C快速排序功能不断崩溃

时间:2016-02-26 22:56:51

标签: c function quicksort

我正在为学校做的任务的一部分涉及构建快速排序来对数组进行排序。我很确定我把它关闭了,但无论什么时候我打电话,它都会崩溃我

void quickSort(double * array, unsigned int size, int start, int stop)
{
    int swapIndex = start;
    int pivot = start;
    double temp;
    if (size > 1)
    {
        for (int i = pivot + 1; i < stop; ++i)
        {
            if (array[pivot] > array[i])
            {
                ++swapIndex;
                temp = array[i];
                array[i] = array[swapIndex];
                array[swapIndex] = temp;
            }
        }
        temp = array[swapIndex];
        array[swapIndex] = array[pivot];
        array[pivot] = temp;
        quickSort(array, size, start, swapIndex);
        quickSort(array, size, swapIndex, size);
    }
}

http://pastebin.com/Ccv4KP3j

1 个答案:

答案 0 :(得分:0)

N.B。此答案基于截至2016年2月27日的pastebin链接

首先,您的函数具有错误的返回类型 - quicksort就地工作,这意味着它不会创建任何新数组;它会对传递给它的数组进行排序。它将完美地用作void函数。

请记住,在C中,数组只能通过引用传递,即每次递归调用quicksort都会处理完全相同的数组。

你的快速排序应该是这样的:

double arr[] = {12, -2, 4, 5, 2, 1};
quicksort(arr, 0, 5);
// arr is now sorted

int i;
for (i=0; i<6; i++){
    printf("%f, ", arr[i]);
}
printf("\n");
// prints "-2, 1, 2, 4, 5, 12"

为了清楚起见,我建议编写一个函数void doubleSwap(double *a, double* b)来处理所有元素交换,而不会弄乱你的代码。

代码导致堆栈溢出的原因有两个:

  1. 初始if后卫需要检查开始和结束是否有所不同 不止一个,不仅仅是因为它们不同。

  2. 'swapIndex'变量始终与数据透视表单元格重叠,从而产生 由于枢轴值在变形之前变得混乱 整个数组被处理。可以通过将pivot设置为来修复此问题 stop - 1

  3. 以下是我的代码版本的pastebin,但在查看之前,请尝试使用一堆printf来自行调试。

    另请注意,您不必将整个数组传递给qsort - 您可以将quickSort(array, swapIndex, stop)替换为quickSort(array + swapIndex, 0, stop - swapIndex),这样您就可以完全删除start,因为它始终为零

    void doubleSwap(double *a, double*b){
        double temp = *a;
        *a = *b;
        *b = temp;
    }
    
    void quickSort(double * array, int start, int stop)
    {
        int pivot = stop - 1;
        int swapIndex = start;
        int i;
    
        if (start < stop - 1) {
            for (i = start; i < stop; i++) {
                if (array[i] < array[pivot]){
                    doubleSwap(array + swapIndex, array + i);
                    swapIndex++;
                }
            }
    
            // Note that `array + swapIndex` is equivalent to `&(array[swapIndex])`
            doubleSwap(array + swapIndex, array + pivot);
    
            fprintf(stderr, "swapIndex = %d start = %d stop = %d\n", swapIndex, start, stop);
            for (i = 0; i< NELEMS; i++){
                fprintf(stderr, "%3f, ", array[i]);
            }
            fprintf(stderr, "\n");
    
            quickSort(array, start, swapIndex);
            quickSort(array, swapIndex, stop);
        }
    }