快速排序算法StackOverflowError

[qq_35899288]

class Quick{
public void quickSort(int[] arr,int start,int end){
int i=start;
int j=end;
int key=arr[i];
boolean bl=true;
while(i<j){
if(bl){
if(key>arr[j]){
arr[i++]=arr[j];
bl=!bl;
}
else j--;
}
else{
if(key<arr[i]){
arr[j--]=arr[i];
bl=!bl;
}
else i++;
}
}
arr[i]=key;
if(start<i-1) quickSort(arr,start,i-1);
if(i+1<end) quickSort(arr,i+1,end);
}
}

这个随机生成80万个数字没有问题，800万个就提示StackOverflowError，提示问题出现在if(i+1<end) quickSort(arr,i+1,end);

[pan__yy]

800w已经超出了栈的存储范围，将数组声明成全局变量就会存在堆内存，堆内存大很多

[sky_08_06_02]

[bree06]

将递归改为循环, 数据量大了递归就是死

[bree06]

将JVM内存设置大一点就行, 我这边拿递归测试1个亿的数据是没问题的. 然后做了一个改版将递归转为循环, 你可以测试一下.

public class Quick {
    static Random random = new Random();

    public static void main(String[] args) {
        Quick quick = new Quick();
        int[] array = new int[100000000];
        int r = array.length << 1;
        for (int i = 0; i < array.length; i++) {
            array[i] = random.nextInt(r);
        }
        int[] array_new = array.clone();
        long start = System.currentTimeMillis();
        quick.quickSort(array, 0, array.length - 1);
        System.out.println("quickSort: " + (System.currentTimeMillis() - start));

        start = System.currentTimeMillis();
        quick.quickSortNode(array_new);
        System.out.println("quickSortNode: " + (System.currentTimeMillis() - start));
    }

    public void quickSort(int[] arr, int start, int end) {
        int i = start;
        int j = end;
        int key = arr[i];
        boolean bl = true;
        while (i < j) {
            if (bl) {
                if (key > arr[j]) {
                    arr[i++] = arr[j];
                    bl = !bl;
                } else j--;
            } else {
                if (key < arr[i]) {
                    arr[j--] = arr[i];
                    bl = !bl;
                } else i++;
            }
        }
        arr[i] = key;
        if (start < i - 1) quickSort(arr, start, i - 1);
        if (i + 1 < end) quickSort(arr, i + 1, end);
    }

    // 改版快速排序, 将递归改为循环
    public void quickSortNode(int[] arr) {
        int len = arr.length, p = 0;
        int[][] r = new int[arr.length > 100 ? 100 : arr.length][];
        r[p++] = new int[]{0, len - 1};
        do {
            int[] point = r[--p];
            if (point[0] >= point[1]) continue;
            int key = arr[point[0]], i = point[0], j = point[1], left = i, right = j;
            boolean bl = true;
            while (i < j) {
                if (bl) {
                    if (key > arr[j]) {
                        arr[i++] = arr[j];
                        bl = !bl;
                    } else j--;
                } else {
                    if (key < arr[i]) {
                        arr[j--] = arr[i];
                        bl = !bl;
                    } else i++;
                }
            }
            arr[i] = key;
            if (left < i - 1) r[p++] = new int[]{left, i - 1};
            if (i + 1 < right) r[p++] = new int[]{i + 1, right};
        } while (p > 0);
    }
}

这是测试1亿数据用时. 递归略快. quickSort: 10416 quickSortNode: 11876