Question

我实现了一个递归的快速排序，但是我收到了stackoverflow并且不确定错误所在：（

我从10-50开始排序100万个。

我的作品尺寸不到100万，如10万等。

public Quicksort(int NUM_TESTS, int NUM_ELEMENTS){
    num_tests = NUM_TESTS;
    num_elements = NUM_ELEMENTS;
}

private void start(){
    for (int i = 0; i < num_tests; i++){
        int[] d1 = dataGeneration(num_elements);
        qSortRecursive(d1,0,d1.length-1);
    }
}

public static void main(String args[]){
    Quicksort q = new Quicksort(1,1000000);
    q.start();    
}

private int[] dataGeneration(int n) {
    int[] d1 = new int[n];
    for (int i = 0; i < n; i++){
        d1[i] = (int)(Math.random() * ((50 - 10) + 1) + 10);
    }
    return d1;
}

private void qSortRecursive(int[] data, int left, int right){
    if(left < right){
        int pivot = partition(data,left,right);
        qSortRecursive(data,left,pivot-1);
        qSortRecursive(data,pivot+1,right);
    }
}

private int partition(int[] data, int left, int right){
    int pivot = left ;
    left++;
    while (left <= right){
        while (left <= right && data[left] <= data[pivot]) {
            left++;
        }

        while (left <= right && data[right] >= data[pivot]){
            right--;
        }

        if (left < right){
            swap(data,left,right);
            left++;
            right--;
        }          
    }

    if (data[right] <= data[pivot]){
        if (data[right] != data[pivot]){
            swap(data,right,pivot);
        }
        pivot = right;
    } 

    return pivot;
}

private void swap(int[] data, int i, int j){
    int temp = data[i];
    data[i] = data[j];
    data[j] = temp;
}

Answer 1

    private void qSortRecursive(int[] data, int left, int right){
    while (left < right){
        int pivot = partition(data,left,right);
        if (pivot - left < right - pivot){
            qSortRecursive(data, left, pivot - 1);
            left = pivot + 1;
        } else {
            qSortRecursive(data, pivot + 1, right);
            right = pivot - 1;
        }
    }

通过减少递归次数来执行尾调用解决了我的问题，感谢大家的帮助:)。

Answer 2

您可以尝试在不递归的情况下重写算法。好吧，你通过添加自己的堆栈来删除递归，在这种情况下，你可以拥有整个内存，而不仅仅是堆栈的大小。

类似于：http://alienryderflex.com/quicksort/

Quicksort递归 - StackOverFlow

2 个答案: