Question

我正在测试它的各种分布，当反向（降序）排序数组作为输入时，我得到分段错误。有时它甚至对于反向排序的阵列也能很好地工作，并且有时我得到分段错误错误，特别是在大的反向排序阵列（> 100000）上。是因为非常深的递归调用，那么递归调用深度的限制是什么，它取决于哪些因素以及在编写递归程序时需要注意什么预防措施。

int partation(double *a, int lower, int upper) {
    int i = lower, j = upper;
    double t = a[lower], temp;
    while (i <= j) {
        while (i <= upper && a[i] <= t)
            i++;
        while (a[j] > t)
            j--;
        if (i <= j) {
            temp = a[i];
            a[i] = a[j];
            a[j] = temp;
        }
    }
    temp = a[lower];
    a[lower] = a[j];
    a[j] = temp;
    return j;
}

void quick_sort(double *a, int lower, int upper) {
    int j;
    if (lower >= upper)
        return;
    else {
        j = partation(a, lower, upper);
        quick_sort(a, lower, j - 1);
        quick_sort(a, j + 1, upper);
    }
}

Answer 1

由于堆栈溢出，您有分段错误。

反向排序数组是分区方案的最坏情况：您在n-1元素数组上递归n次。

您可以尝试改进分区方案以避免这种病态情况，但有一种方法可以避免quick_sort函数中的深度递归：在较小的一半上递归，在较大的一半上循环。病理情况将非常缓慢但不再崩溃。

以下是代码：

#include <stdio.h>
#include <time.h>

int partition(double *a, int lower, int upper) {
    /* assuming lower < upper */
    int i = lower, j = upper;
    double t = a[lower], temp;
    while (i <= j) {
        while (i <= upper && a[i] <= t)
            i++;
        while (a[j] > t)
            j--;
        if (i < j) {
            temp = a[i];
            a[i] = a[j];
            a[j] = temp;
        }
    }
    temp = a[lower];
    a[lower] = a[j];
    a[j] = temp;
    return j;
}

void quick_sort(double *a, int lower, int upper) {
    while (lower < upper) {
        int j = partition(a, lower, upper);
        if (j - lower < upper - j) {
            if (lower < j - 1) {
                quick_sort(a, lower, j - 1);
            }
            lower = j + 1;
        } else {
            if (j + 1 < upper) {
                quick_sort(a, j + 1, upper);
            }
            upper = j - 1;
        }
    }
}

int main(void) {
    double a[65536];
    for (int n = 2; n <= (int)(sizeof(a) / sizeof(*a)); n += n) {
        for (int i = 0; i < n; i++) {
            a[i] = n - i;
        }
        clock_t t = clock();
        quick_sort(a, 0, n - 1);
        t = clock() - t;
        for (int i = 1; i < n; i++) {
            if (a[i - 1] > a[i]) {
                printf("out of order at %d: %f > %f\n", i - 1, a[i - 1], a[i]);
                return 1;
            }
        }
        printf("a[%d] sorted in %.3f msec\n", n, (double)t * 1000.0 / CLOCKS_PER_SEC);
    }
    return 0;
}

输出：

a[2] sorted in 0.002 msec
a[4] sorted in 0.001 msec
a[8] sorted in 0.001 msec
a[16] sorted in 0.001 msec
a[32] sorted in 0.000 msec
a[64] sorted in 0.002 msec
a[128] sorted in 0.006 msec
a[256] sorted in 0.021 msec
a[512] sorted in 0.074 msec
a[1024] sorted in 0.287 msec
a[2048] sorted in 1.185 msec
a[4096] sorted in 5.104 msec
a[8192] sorted in 19.497 msec
a[16384] sorted in 78.140 msec
a[32768] sorted in 297.297 msec
a[65536] sorted in 1175.032 msec

关于你的第二个问题，在编写递归程序时，它依赖于哪些因素以及需要采取哪些预防措施？没有明确的答案：

堆栈空间的限制（如果存在这样的概念）是特定于实现的，不同的系统具有非常不同的限制：从小型嵌入式系统上的几千字节到大型系统上的几兆字节。
递归数千次是有风险的，因此定义具有自动存储的大型数组也是如此。在上面的代码中，我定义了一个64K双精度数组，它在现代通用计算机上不是问题，但在小型数字传感器上可能太多了。 递归较小的一半方法的最大递归级别受 log（N）的限制，16只有N=65536，应该是适用于所有系统。

Answer 2

是的，分割是因为递归太深。

当您在函数中快速排序反向数组时，t函数中的partation始终是该领域中的最大值或最小值，因为您总是使用{{1} }作为t的值。这意味着当数组反转时，a[lower]的返回值将始终等于partation或'lower'。这会导致（上 - 下）递归的总数，并且肯定会导致错误。要避免这种情况，请使用upper和upper之间的随机值，而不是始终使用lower作为a[lower]的值

当反向排序数组作为输入给出时，为什么我会出现分段错误？

2 个答案: