Java QuickSort修改了实现，对短子数组使用插入排序

我正在尝试实现快速排序，对短于某个长度的子数组使用插入排序。我已经写了这段代码，但问题是它适用于高达400000个整数的记录，但我需要使它运行于5000000个整数数组。这让我很难找到为什么会出现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[]quickSort2（int[]arrayOfIntegers、int startIndex、int endIndex）{
if（开始索引<结束索引）{
if（endIndex-startIndex<插入\排序\阈值）{
插入排序（ArrayFintegers、startIndex、endIndex）；
}否则{
int pivotIndex=partition2（arrayOfIntegers、startIndex、endIndex）；
quickSort2（ArrayFintegers、startIndex、pivotIndex-1）；
quickSort2（ArrayFintegers，pivotIndex+1，endIndex）；
}
}
返回数组查找器；
}

插入排序如下所示：

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;
}

public int[]InsertionSort（int[]arrayOfNumbers，int startIndex，int endIndex）{
对于（int i=startIndex+1；i=startIndex&&arrayOfNumbers[pointer]>键）{
ArrayOfNumber[指针+1]=ArrayOfNumber[指针]；
指针-=1；
}
ArrayOfNumber[指针+1]=键；
}
返回arrayOfNumber；
}

快速排序分区是：

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);
}

private int partition2（int[]arrayOfIntegers，int start，int end）{
int pivot=arrayOfIntegers[end]；
int指针=start-1；
对于（int i=start；i，由于实现使用递归，因此正确地获得堆栈溢出。从
quickSort2
方法中调用
quickSort2
，该方法将在每次调用时增加堆栈。由于堆栈不能无限增长，因此获得堆栈溢出

如果将阈值增加到3、6、9（等等），递归（调用
quickSort2
）将显著减少。这就是为什么在这种情况下不会出现Stackoverflow。但这只是数组大小的问题。如果它足够大，无论如何都会出现Stackoverflow

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

有关更多信息，请参见例如或谷歌
迭代快速排序
这意味着什么？-
“使用长度为3、6、9的子数组”
。在何处使用这些大小？几乎是重复的-