我写了一封信 quickSort 方法，我使用该方法尝试对已接近排序的数组进行排序-反向排序。因此，快速排序尝试按升序排序，而数组几乎已按降序排序：

private static void switchPlaces(int[] a, int i, int j) {
        int temp = a[i];
        a[i] = a[j];
        a[j] = temp;
    }

    public static void quickSort(int[] a, int low, int high)  {
        int i = low;
        int j = high;
        int pivot = a[low];

        while (i <= j) {

            while (a[i] < pivot) {
                i++;
            }
            while (a[j] > pivot) {
                j--;
            }

            if (i <= j) {
                switchPlaces(a, i, j);
                i++;
                j--;
            }
        }

        if (low < j) {
            quickSort(a, low, j);
        }
        if (i < high) {
            quickSort(a, i, high);
        }
    }

我使用我的自定义方法生成这样一个数组-20%的元素比它们以前的元素大。
但是当我打开qucksort时 100,000 长数组i get stackoverflow错误：

int[] a = generateArray(100_000);

quickSort(a, 0 , a.length - 1); //stackoverflow

不会发生的事情 1,000,000 长数组：

int[] a = generateArray(1_000_000);

quickSort(a, 0 , a.length - 1); //quickly works: all elements inside a are sorted

之后 1_000_000 排序：
a 一开始 100_000 排序：
a 一开始 1_000_000 排序：

我不明白为什么它适用于较大的数组，但不适用于较小的数组。
编辑：

public static void main(String[] args) {
        int[] a = generateArray(1_000_000);
        quickSort(a, 0 , a.length - 1);
        System.out.println();
    }

    public static int[] generateArray(int N) {
        Random random = new Random();
        int max = 1_000_000;
        int[] result = new int[N];

        int prev =  max - random.nextInt(100);
        result[0] = prev;
        for (int i = 1; i < N; i++) {
            boolean toSort = random.nextInt(10) < 8;

            int number;
            if (toSort) {
                number = Math.max(0, prev - random(5, 10));
                prev = number;
            } else {
                number = prev + random(5, 10);
            }

            result[i] = number;
        }

        return result;
    }