更新了java fork/join mergesort以便于复制

我创建了一个完整的、可运行的示例，它再现了没有按mergesort对列表进行实际排序的错误。控制台上打印的是22， 22, 22, 1. 1. 1. -2, -2, -2, 1. 22, -2, 1. 22, -2.因此，mergesort似乎不会影响列表的后半部分，而前半部分只会排序，因为成功调用了insertSort。感谢您的帮助和建议。谢谢大家!

package threadedmergesort;

import java.util.ArrayList;
import java.util.Comparator;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.RecursiveAction;

public class ThreadedMergeSort implements Comparator<Integer>{

    public static void main(String[] args) {
         ArrayList<Integer> toSort = new ArrayList<Integer>();
         toSort.add(1);  
         toSort.add(22);
         toSort.add(-2);
         toSort.add(1);  
         toSort.add(22);
         toSort.add(-2);
         toSort.add(1);  
         toSort.add(22);
         toSort.add(-2);
         toSort.add(1);  
         toSort.add(22);
         toSort.add(-2);
         toSort.add(1);  
         toSort.add(22);
         toSort.add(-2);
         toSort.add(1);  
         toSort.add(22);
         toSort.add(-2);

         ThreadedMergeSort.sort(toSort, 0, toSort.size()-11);
         for (Integer e: toSort){
                System.out.println(e);
                }
    }

    public static void sort (ArrayList<Integer> inputComp){
        sort(inputComp, 0, inputComp.size()-1);
    }
    public static void sort (ArrayList<Integer> inputComp, int low, int high){
        if (high-low< SIZE_LIMIT){
            insertionSort(inputComp, low, high);
            return;
        }
        ArrayList<Integer> temp = new ArrayList(inputComp.size());
        pool.invoke(new SortTask(inputComp, temp, low, high));
        System.out.println("pool.invoke");
    }

    static class SortTask extends RecursiveAction{
        ArrayList<Integer> inputComp;
        ArrayList<Integer> temp;
        int low;
        int high;

        public SortTask(ArrayList<Integer> inputComp, ArrayList<Integer> temp, int low, int high){
            this.inputComp=inputComp;
            this.temp=temp;
            this.low=low;
            this.high=high;
        }

        @Override
        protected void compute(){
            if (high-low<SIZE_LIMIT){
                insertionSort(inputComp, low, high);
                return;
            }
            int middle = (low + high)/2;
            invokeAll(new SortTask(inputComp, temp, low, middle), new SortTask(inputComp, temp, middle+1, high));
            merge(inputComp, temp, low, middle, high);
        }  
    }
        @Override
        public int compare(Integer c1, Integer c2){
        if (c1> c2){
            return -1;
        }
        if (c1 > c2){
            return 1;
        }
        return 0;
    }

    public static void arrayListCopy(ArrayList<Integer> src, int srcPos, ArrayList<Integer> dest, int destPos, int length){
        for (int i = 0; i< length; i++){
            dest.set(destPos+i, src.get(srcPos+i));
        }
    }
    private static void merge(ArrayList<Integer> inputComp1, ArrayList<Integer> inputComp2, int low, int middle, int high){
        ThreadedMergeSort sort = new ThreadedMergeSort();
        if(sort.compare(inputComp1.get(middle), inputComp1.get(middle+1)) <0){
            return;
        }
        arrayListCopy(inputComp1, low, inputComp2, low, middle-low+1);
        int i = low;
        int j = middle+1;
        int k = low;
        while(k < j && j <= high){
            if(sort.compare(inputComp2.get(i),inputComp1.get(j)) <= 0){
                inputComp1.set(k++, inputComp2.get(i++));
            }
            else{
                inputComp1.set(k++,inputComp1.get(j++));
            }
        }
        arrayListCopy(inputComp2, i, inputComp1, k, j-k);
    }

    private static void insertionSort(ArrayList<Integer> inputComp, int low, int high){
        ThreadedMergeSort sort = new ThreadedMergeSort();
        for(int i = low+1; i<=high; i++){
            int j = i;
            Integer entry = inputComp.get(j);
            while(low<j && sort.compare(entry, inputComp.get(j-1))< 0){
                inputComp.set(j,inputComp.get(j-1));
                --j;
            }
            inputComp.set(j,entry);
        }
    }
    private static final ForkJoinPool pool =  new ForkJoinPool();
    private static final int SIZE_LIMIT = 8;
}

package-threadedmergesort；
导入java.util.ArrayList；
导入java.util.Comparator；
导入java.util.concurrent.ForkJoinPool；
导入java.util.concurrent.RecursiveAction；
公共类ThreadedMergeSort实现了Comparator{
公共静态void main（字符串[]args）{
ArrayList toSort=新的ArrayList（）；
加入（1）；
加入（22）；
toSort.add（-2）；
加入（1）；
加入（22）；
toSort.add（-2）；
加入（1）；
加入（22）；
toSort.add（-2）；
加入（1）；
加入（22）；
toSort.add（-2）；
加入（1）；
加入（22）；
toSort.add（-2）；
加入（1）；
加入（22）；
toSort.add（-2）；
ThreadedMergeSort.sort（toSort，0，toSort.size（）-11）；
for（整数e:toSort）{
系统输出打印ln（e）；
}
}
公共静态无效排序（ArrayList inputComp）{
排序（inputComp，0，inputComp.size（）-1）；
}
公共静态无效排序（ArrayList inputComp、整型低、整型高）{
if（高-低<尺寸限制）{
插入端口（输入复合、低、高）；
返回；
}
ArrayList temp=新的ArrayList（inputComp.size（））；
调用（新的SortTask（inputComp、temp、low、high））；
System.out.println（“pool.invoke”）；
}
静态类SortTask扩展了RecursiveAction{
ArrayList inputComp；
阵列列表温度；
int低；
int高；
公共排序任务（ArrayList inputComp、ArrayList temp、int low、int high）{
这个.inputComp=inputComp；
这个.temp=temp；
这个。低=低；
这个。高=高；
}
@凌驾
受保护的void compute（）{
if（高-低c2）{
返回-1；
}
如果（c1>c2）{
返回1；
}
返回0；
}
公共静态void arrayListCopy（ArrayList src、int srcPos、ArrayList dest、int destPos、int length）{
for（int i=0；i如果（sort.compare（inputComp1.get（middle）、inputComp1.get（middle+1））它正在执行您要求的操作：

ThreadedMergeSort.sort(toSort, 0, toSort.size()-11);

你是说1还是11？
你需要实现你自己的排序方法吗？Arrays.sort和Arrays.parallelSort通常是最好的解决方案。我使用的是ArrayList，所以我不能使用Array.sort。我需要一个ArrayList，这样我就可以简单地动态添加新条目，但谢谢你的建议。在这种情况下，你可以使用Collections.sort或Converyrt list to array，对它进行排序，然后从排序后的数组创建新的列表。我想我可以这样做，但我真的想知道我在这个实现中哪里出错了。我补充说，因为如果大小大于大小限制，它会返回IndexOutOfBoundsException。这可能是我的代码的真正问题。您可以通过删除1来重现这一点1或将其更改为1。前者将返回“起因：java.lang.IndexOutOfBoundsException:索引：15，大小：15”，而后者将返回相同的值，索引和大小为0。您得到的索引越界错误是哪一行？为什么将size_LIMIT设置为8？它被设置为8，以便在大小为8时停止分割，此时它会插入排序并再次开始将列表合并在一起。我不确定在哪里得到错误，但ack traceSetting size-11只是掩盖了您真正的问题，并导致您的列表仅被半排序。真正的问题是构造新的排序任务（inputComp、temp、low、high），在pool.invoke中。可能会更改代码并提出不同的问题。使用size-11意味着您永远不会尝试此构造，因此您的SortTask永远不会被实例化或执行