Question

我正在尝试实现对短于一定长度的子数组使用插入排序的quickSort。我已经编写了这段代码，但问题是它适用于高达400,000个整数的记录，但我需要让它运行5000,000个整数数组。它让我很难找到为什么我得到StackOverflow错误。

public int[] quickSort2(int[] arrayOfIntegers, int startIndex, int endIndex) {
    if (startIndex < endIndex) {
        if (endIndex - startIndex < INSERTION_SORT_THRESHOLD) {
            InsertionSort(arrayOfIntegers, startIndex, endIndex);
        } else {
            int pivotIndex = partition2(arrayOfIntegers, startIndex, endIndex);
            quickSort2(arrayOfIntegers, startIndex, pivotIndex - 1);
            quickSort2(arrayOfIntegers, pivotIndex + 1, endIndex);
        }
    }
    return arrayOfIntegers;
}

插入排序如下所示：

public int[] InsertionSort(int[] arrayOfNumbers, int startIndex, int endIndex) {
    for (int i = startIndex + 1; i <= endIndex; i++) {
        int key = arrayOfNumbers[i];
        int pointer = i - 1;
        while (pointer >= startIndex && arrayOfNumbers[pointer] > key) {
            arrayOfNumbers[pointer + 1] = arrayOfNumbers[pointer];
            pointer -= 1;
        }
        arrayOfNumbers[pointer + 1] = key;
    }
    return arrayOfNumbers;
}

QuickSort分区是：

private int partition2(int[] arrayOfIntegers, int start, int end) {
    int pivot = arrayOfIntegers[end];
    int pointer = start - 1;
    for (int i = start; i <= end - 1; i++) {
        if (arrayOfIntegers[i] <= pivot) {
            pointer += 1;
            int temporaryStorage = arrayOfIntegers[i];
            arrayOfIntegers[i] = arrayOfIntegers[pointer];
            arrayOfIntegers[pointer] = temporaryStorage;
        }
    }
    arrayOfIntegers[end] = arrayOfIntegers[pointer + 1];
    arrayOfIntegers[pointer + 1] = pivot;
    return (pointer + 1);
}

此外，当我编码在大小为5000,000的整数数组上运行QuickSort并使用长度为3,6,9等的子数组来对整个数组进行排序时，它不会给我“StackOverflow”错误。有人可以帮忙吗

Answer 1

您正确获取了Stackoverflow，因为您的实现使用了递归。您可以使用quickSort2方法调用quickSort2，这会增加每次调用的堆栈。由于堆栈无法无限增长，因此您将获得Stackoverflow。

如果将阈值增加到3,6,9（依此类推），您将获得显着减少的递归（调用quickSort2）。这就是为什么在这种情况下你没有获得Stackoverflow的原因。但它只是你的阵列大小的问题。如果它足够大，你无论如何都会获得Stackoverflow。

解决方案是消除代码中的递归。消除递归不仅可以避免Stackoverflow，还可以提高代码的速度，因为与迭代相比，递归速度要慢得多（在Java中）。

有关详细信息，请参阅http://www.geeksforgeeks.org/iterative-quick-sort/或Google iterative quicksort。

QuickSort修改实现以使用插入排序来实现短子阵列

1 个答案: