为什么我的快速排序实现了堆栈溢出失败?

时间:2017-09-09 16:34:17

标签: java algorithm quicksort forkjoinpool

我需要编写一个算法来对一个集合进行排序,超过10,000个元素。 所以我写了一个forkjoin快速排序...... 但是当输入变大时,代码就会崩溃。 首先,我使用的测试用例是一个随机列表,工具可以处理。 然后,我只是尝试一些极端情况,就像一个有序的数字。代码失败。 我检查代码,但不知道为什么。

这是下面的代码:

public class ForkJoinSort {
    private static int THRESHOLD = 1000;
    private static ForkJoinPool pool = new ForkJoinPool();

    public static <T extends Comparable<T>> void quickSortFJ(List<T> rawList) {
        pool.invoke(new QuickSort<>(rawList));
    }

    static class QuickSort<T extends Comparable<T>> extends RecursiveAction {
        List<T> rawList;
        int lo;
        int hi;

        QuickSort(List<T> rawList) {
            this.rawList = rawList;
            this.lo = 0;
            this.hi = rawList.size() - 1;
        }

        QuickSort(List<T> rawList, int lo, int hi) {
            this.rawList = rawList;
            this.lo = lo;
            this.hi = hi;
        }

        @Override
        protected void compute() {
            if (hi > lo && hi - lo >= THRESHOLD) {
                int pivot = partition(rawList, lo, hi);
                invokeAll(new QuickSort<>(rawList, lo, pivot - 1),
                        new QuickSort<>(rawList, pivot + 1, hi));
            } else {
                quickSort(rawList, lo, hi);
            }
        }
    }

    private static <T extends Comparable<T>> int partition(List<T> rawList, int lo, int hi) {
        T key = rawList.get(hi);
        int index = lo;
        for (int i=lo; i<hi; i++) {
            if (rawList.get(i).compareTo(key) > 0) {
                swap(rawList, index, i);
                index ++;
            }
        }

        swap(rawList, index, hi);

        return index;
    }

    private static <T extends Comparable<T>> void swap(List<T> rawList, int left, int right) {
        if (left != right) {
            T temp = rawList.get(left);
            rawList.set(left, rawList.get(right));
            rawList.set(right, temp);
        }
    }

    public static <T extends Comparable<T>> void quickSort(List<T> rawList, int lo, int hi) {
        if (lo < hi) {
            int pivot = partition(rawList, lo, hi);
            quickSort(rawList, lo, pivot-1);
            quickSort(rawList, pivot+1, hi);
        }
    }
}

测试用例失败:

List<Long> longTwoList = new ArrayList<>();
for (long i=0; i!=17000; i++) {
   longTwoList.add(i);
}

ForkJoinSort.quickSortFJ(longTwoList);//failed
ForkJoinSort.quickSort(longTwoList, 0, longTwoList.size()-1);//falied

与这个问题相当混淆。谢谢你的回复。

0 个答案:

没有答案