Question

Hy伙计，

我在c ++中使用quicksort遇到了一些麻烦。在最坏的情况下，有一个排序的数组（有增长或减少的值）我得到一个堆栈溢出数组〜900元素。尾递归是我找到的解决方案，但我可能不会在这里做，因为我没有做任何改进：

void quickSort(int *array, int start, int end){
    //elementary state
    if (start + 1 > end){
        return;
    }

    //partitioning, retuns position of pivotelemnt
    int wall = partitioning(array, start, end);

    //recursion
    quickSort(array, start, wall-1);
    //tail recursion?
    return quickSort(array, wall + 1, end);
}//quickSort

关注this Wikipedia article我刚刚将回复添加到我上次调用quickSort作为第一个示例。我不认为这是做任何事情......

编辑：

int partitioning(int *array, int start, int end){

    //partitioningborder
    int wall = start;

    for (int i = wall; i < end; ++i){
        if (array[i] <= array[end]){

            //swap an element if needed
            int swap = array[i];
            array[i] = array[wall];
            array[wall] = swap;

            //increment the partitioningborder
            wall++;
        }//if
    }//for

    //place pivotelement
    int swap = array[end];
    array[end] = array[wall];
        array[wall] = swap;

        return wall;
}//partitioning

Answer 1

为了避免堆栈溢出，代码需要比较分区大小（wall-start）和（end-wall），递归较小的分区，然后循环回来查看较大的分区。它不是真正的尾递归。像这样：

void quickSort(int *array, int start, int end){
    while(start < end){
        wall = partition(...);   // wall = index to pivot
        // recurse on smaller part, loop on larger part
        if((wall - start) <= (end - wall)){
            quickSort(a, start, wall-1);
            start = wall+1;
        } else {
            quickSort(a, wall+1, end);
            end = wall-1;
        }
    }
}

如果使用Hoare类型分区方案，墙或墙+ 1可能指向枢轴值。您可以添加一个检入分区，以便返回的索引始终指向数据透视值（而不是有时在数据透视值之前指向1）。

带尾递归的C ++快速排序

1 个答案: