Question

美好的一天我试图使用10000个数字的快速排序，但它给我堆栈溢出错误。它适用于随机数，但它不具有降序和升序数。

＆＃39; 谢谢

void quickSort(long* array, long start, long last)
{
    if (start < last)
    {
        int p = partition(array, start, last);
        quickSort(array, start, p-1);
        quickSort(array, p + 1, last);
    }
}
int partition(long* array, long start, long last)//first partition
{
    int j = start + 1;
    for (long i = start + 1;i <= last;i++)
    {
        if (array[i] < array[start])
        {
            swap(array[i], array[j]);
            j++;
        }           

    }
    swap(array[start], array[j - 1]);
    return j - 1;
}
'

Answer 1

对于已排序的元素，您可以通过选择三个元素array[start]，array[last]和array[(start + last + 1)/2]的中位数作为透视值来避免此问题。

int median_of_3(long* array, long start, long last)
{
    long a = (start + last + 1)/2, b = start, c = last;
    if (array[c] < array[a]) swap(array[c], array[a]);
    if (array[b] < array[a]) swap(array[b], array[a]);
    if (array[c] < array[b]) swap(array[c], array[b]);
    return partition(array, start, last);
}

避免大堆栈深度的另一个策略是计算哪个分区较小，并递归调用较小的分区。然后可以将另一个分区优化为循环（尾递归优化）。

void quickSort(long* array, long start, long last)
{
    if (start >= last) return;

    int p = median_of_3(array, start, last);
    int next_start[2] = { start, p + 1 };
    int next_last[2] = { p - 1, last };
    bool i = p > (start + last)/2;
    quickSort(array, next_start[i], next_last[i]);
    /*
     * If the compiler does not optimize the tail call below into
     * a loop, it is easy to do the optimization manually.
     */
    quickSort(array, next_start[!i], next_last[!i]);
}

Introspection也可用于避免大堆栈深度。您可以跟踪递归调用深度，如果它过于深入＆＃34;，则可以安全地进入不同的排序策略，例如合并排序或堆排序。这是std::sort目前使用的行为。

void introSortImpl(long* array, long start, long last, int depth)
{
    if (--depth == 0) {
        heapSort(array, start, last);
        return;
    }

    if (start >= last) return;

    int p = median_of_3(array, start, last);
    int next_start[2] = { start, p + 1 };
    int next_last[2] = { p - 1, last };
    bool i = p > (start + last)/2;
    introSortImpl(array, next_start[i], next_last[i], depth);
    introSortImpl(array, next_start[!i], next_last[!i], depth);
}

void introspectionSort(long* array, long start, long last)
{
    introSortImpl(array, start, last, log2(start - last) * 3);
}

Answer 2

代码没问题但你的编译器使用堆栈的效率非常低。你只需要提高预留的堆栈金额。它更多地发生在调试配置文件中，而不是仅仅因为编译器保留大堆栈块来检查堆栈是否在执行过程中被破坏而发生。

Answer 3

Lomuto分区方案的示例，如quicksort，在较小的分区上使用递归，更新l或r，然后循环返回以将较大的分区拆分为两个分区，重复该过程。最坏情况的堆栈空间是O（log2（n）），它应该避免堆栈溢出。最坏的情况时间复杂度仍为O（n ^ 2）（取决于如何实现分区）。

有些人将此示例称为半递归。它不是尾递归的一个例子，因为尾递归意味着递归函数在调用自身后才会返回。原始问题示例中的第二个调用是尾调用。

void quicksort(int * tab, int l, int r)
{
   int q;
   while(l < r)
   {
      q = partition(tab, l, r);
      if(q - l < r - q) {     // recurse into the smaller partition
         quicksort(tab, l, q - 1);
         l = q + 1;
      } else {
         quicksort(tab, q + 1, r);
         r = q - 1;
      }
   }                          // loop on the larger partition
}

QUICK SORT堆栈溢出c ++大数字

3 个答案: