Question

我正在尝试计算混合quickSort-insertSort的运行时间。但是，当呈现更大的数组（〜500k元素）时，出现java.lang.StackOverflowError。我能以某种方式克服这个问题吗？不使用递归不是一种选择。

代码如下：

public class QuickSort2 {

private static void swap(int[] arr, int x, int y){
       int temp = arr[x];
       arr[x] = arr[y];
       arr[y] = temp;
    }

private static int partition(int[] arr, int lo, int hi){
    int pivot = arr[hi];
    int index = lo - 1;
    for(int i = lo; i < hi; i++){
        if(arr[i] < pivot){
            index++;
            swap(arr, index, i);
        }
    }
    swap(arr, index + 1, hi);
    return index + 1;
} 

public static void quickSort(int[] arr, int lo, int hi){
    if(lo < hi && hi-lo > 10){
        int q = partition(arr, lo, hi);
        quickSort(arr,lo,q-1);
        quickSort(arr,q+1,hi);
        }else{
            InsertionSort.insertSort(arr);
        }    
    }
}

，还有insertSort：

public class InsertionSort {

static void insertSort(int[] arr){
    int n = arr.length;
    for (int j = 1; j < n; j++){
        int key = arr[j];
        int i = j-1;
        while ((i >= 0) && (arr[i] > key)){
            arr[i+1] = arr[i];
            i--;
        }
        arr[i+1] = key;
    }         
}

发生错误的行：

quickSort(arr,lo,q-1);
quickSort(arr,q+1,hi);

以及调用代码：

public class RunningTime {

public static void main(String[] args) {
    int[] arr = ReadTest.readToArray("int500k");
    int lo = 0;
    int hi = arr.length - 1;

    long startTime = System.currentTimeMillis();
    QuickSort2.quickSort(arr, lo, hi);
    long stopTime = System.currentTimeMillis();
    long elapsedTime = stopTime - startTime;
    System.out.println("Running time: " + elapsedTime);
    System.out.println("Array is sorted: " + isSorted(arr));
}

}

Answer 1

您应该将插入排序限制为仅对数组的子集起作用。

除此之外，我的代码没有其他问题。

文件int500k是否已排序？如果是这样，这是快速排序的最坏情况，这意味着递归深度将达到50万个级别。

要解决此问题，您可以例如随机选择枢轴而不是arr[hi]。

混合QuickSort +插入排序java.lang.StackOverflowError

1 个答案: