不确定为什么Java合并排序算法偶尔会失败

算法有时有效，有时无效。我正在使用这里找到的JUnit测试

谢谢你的帮助

Java代码

包裹分拣；
公共类合并排序{
公共静态int[]排序（int[]A）{
mergeSortHelper（A，新整数[A.length]，0，A.length-1）；
返回A；
}
私有静态void合并器（int[]A，int[]helper，int p，int r）{
if（p
while（j我修改了代码：）以通过测试，但我不确定它是否是100%安全的代码。使用它的风险自负

package sorting;

public class MergeSort {

    public static int[] sort(int[] A) {
        mergeSortHelper(A, new int[A.length], 0, A.length - 1);
        return A;
    }

    private static void mergeSortHelper(int[] A, int[] helper, int p, int r) {
        if (p < r) {
            int mid = (p + r)/2;
            mergeSortHelper(A, helper, p, mid);
            mergeSortHelper(A, helper, mid + 1, r);
            merge(A, helper, p, mid, r);
        }
    }

    private static void merge(int A[], int[] helper, int p, int q, int r) {
        for (int i = p; i <= r; i++) {
            helper[i] = A[i];
        }

        int j = p;
        int k = q + 1;
        int count = 0;

        while (j <= q && k <= r) {
            if (helper[j] < helper[k]) {
                A[p+count] = helper[j++]; 
            } else {
                A[p+count] = helper[k++];
            }

            count++;
        }

        while (j <= q) {
            A[p+count++] = helper[j++];            
        }

        while (k <= r) {
            A[p+count++] = helper[k++];            
        }
    }
}

包裹分拣；
公共类合并排序{
公共静态int[]排序（int[]A）{
mergeSortHelper（A，新整数[A.length]，0，A.length-1）；
返回A；
}
私有静态void合并器（int[]A，int[]helper，int p，int r）{
if（p
导入java.util.ArrayList；
导入java.util.List

公共final类MergeSort实现可运行的排序{

private List<Integer> list;
private List<Integer> temp = new ArrayList<Integer> ();
private long time = 0;
private boolean sortCompleted = false;

public MergeSort(List<Integer> item) {
    this.list = item;
    initializeTempList();
}   

public void run() {
    sort();
    System.out.println(this.toString());
}

private void initializeTempList() {
    for(int i=0; i<list.size(); i++) {
        temp.add(0);
    }
}
/*
 * Merge Sort Algorithm O(N*LOGN)
 */
public void sort() {
    long starttime = System.nanoTime();
    mergePartition(0, list.size()-1);
    long endtime = System.nanoTime();
    time = endtime - starttime;
    sortCompleted = true;
}

private void mergePartition(int low, int high) {

    if (low == high) return;
    else {
        int mid = (low + high) / 2;
        mergePartition(low, mid);
        mergePartition(mid+1, high);
        merge(low, mid+1, high);
    }
}

private void merge(int lowPtr, int midPtr, int highPtr) {
    int ci = 0;
    int ai = lowPtr;
    int mid = midPtr - 1;
    int bi = highPtr - ai + 1;

    while (lowPtr <= mid && midPtr <= highPtr) {
        if (list.get(lowPtr) < list.get(midPtr)) {
            temp.set(ci++, list.get(lowPtr++));
        }
        else {
            temp.set(ci++, list.get(midPtr++));
        }
    }

    /*
     * copy remaining sorted elements
     */
    while (lowPtr <= mid) {
        temp.set(ci++, list.get(lowPtr++));
    }

    /*
     * copy remaining sorted elements
     */
    while (midPtr <= highPtr) {
        temp.set(ci++, list.get(midPtr++));
    }

    /*
     * replace original elements with sorted elements
     */
     copy(ai, bi, temp);
}

private void copy(int from, int num, List<Integer> arrTemp) {
    for(int i=0; i<num; i++){
        list.set(from+i, arrTemp.get(i));
    }
}

public long getTime() {
    return time;
}

public String toString() {
    return "Merge sort is completed in " + getTime() + " nanoseconds";
}

private void swap(int x, int y) {
    int tmp = list.get(x);
    list.set(x, list.get(y));
    list.set(y, tmp);
}

public void reversedList() {
    int idx = list.size()/2;
    int high = list.size()-1;
    for(int low=0; low<idx; low++) {
        swap(low, high--);
    }
} 

public boolean isSortCompleted() {
    return sortCompleted;
}   

私有列表；
private List temp=new ArrayList（）；
私人长时间=0；
私有布尔值sortCompleted=false；
公共合并排序（列表项）{
this.list=项目；
初始化模板（）；
}   
公开募捐{
排序（）；
System.out.println（this.toString（））；
}
私有void initializeTempList（）{
对于（int i=0；如果正在使用什么数据？随机生成的数组，我将发布JUnit测试
    while (j <= q) {
        A[p+count] = A[j++];
        count++;
    }

    while (k <= r) {
        A[p+count] = A[k++];
        count++;
    }

    while (j <= q) {
        A[p+count] = helper[j++];
        count++;
    }

    while (k <= r) {
        A[p+count] = helper[k++];
        count++;
    }

package sorting;

public class MergeSort {

    public static int[] sort(int[] A) {
        mergeSortHelper(A, new int[A.length], 0, A.length - 1);
        return A;
    }

    private static void mergeSortHelper(int[] A, int[] helper, int p, int r) {
        if (p < r) {
            int mid = (p + r)/2;
            mergeSortHelper(A, helper, p, mid);
            mergeSortHelper(A, helper, mid + 1, r);
            merge(A, helper, p, mid, r);
        }
    }

    private static void merge(int A[], int[] helper, int p, int q, int r) {
        for (int i = p; i <= r; i++) {
            helper[i] = A[i];
        }

        int j = p;
        int k = q + 1;
        int count = 0;

        while (j <= q && k <= r) {
            if (helper[j] < helper[k]) {
                A[p+count] = helper[j++]; 
            } else {
                A[p+count] = helper[k++];
            }

            count++;
        }

        while (j <= q) {
            A[p+count++] = helper[j++];            
        }

        while (k <= r) {
            A[p+count++] = helper[k++];            
        }
    }
}

diff --git a/src/sorting/MergeSort.java b/src/sorting/MergeSort.java
index 0f5c8e4..dbf6689 100644
--- a/src/sorting/MergeSort.java
+++ b/src/sorting/MergeSort.java
@@ -35,7 +35,7 @@
         int count = 0;

         while (j <= q && k <= r) {
-            if (helper[j] <= helper[k]) {
+            if (helper[j] < helper[k]) {
                 A[p+count] = helper[j++]; 
             } else {
                 A[p+count] = helper[k++];
@@ -45,13 +45,11 @@
         }

         while (j <= q) {
-            A[p+count] = A[j++];
-            count++;
+            A[p+count++] = helper[j++];            
         }

         while (k <= r) {
-            A[p+count] = A[k++];
-            count++;
+            A[p+count++] = helper[k++];            
         }
     }
 }
\ No newline at end of file

private List<Integer> list;
private List<Integer> temp = new ArrayList<Integer> ();
private long time = 0;
private boolean sortCompleted = false;

public MergeSort(List<Integer> item) {
    this.list = item;
    initializeTempList();
}   

public void run() {
    sort();
    System.out.println(this.toString());
}

private void initializeTempList() {
    for(int i=0; i<list.size(); i++) {
        temp.add(0);
    }
}
/*
 * Merge Sort Algorithm O(N*LOGN)
 */
public void sort() {
    long starttime = System.nanoTime();
    mergePartition(0, list.size()-1);
    long endtime = System.nanoTime();
    time = endtime - starttime;
    sortCompleted = true;
}

private void mergePartition(int low, int high) {

    if (low == high) return;
    else {
        int mid = (low + high) / 2;
        mergePartition(low, mid);
        mergePartition(mid+1, high);
        merge(low, mid+1, high);
    }
}

private void merge(int lowPtr, int midPtr, int highPtr) {
    int ci = 0;
    int ai = lowPtr;
    int mid = midPtr - 1;
    int bi = highPtr - ai + 1;

    while (lowPtr <= mid && midPtr <= highPtr) {
        if (list.get(lowPtr) < list.get(midPtr)) {
            temp.set(ci++, list.get(lowPtr++));
        }
        else {
            temp.set(ci++, list.get(midPtr++));
        }
    }

    /*
     * copy remaining sorted elements
     */
    while (lowPtr <= mid) {
        temp.set(ci++, list.get(lowPtr++));
    }

    /*
     * copy remaining sorted elements
     */
    while (midPtr <= highPtr) {
        temp.set(ci++, list.get(midPtr++));
    }

    /*
     * replace original elements with sorted elements
     */
     copy(ai, bi, temp);
}

private void copy(int from, int num, List<Integer> arrTemp) {
    for(int i=0; i<num; i++){
        list.set(from+i, arrTemp.get(i));
    }
}

public long getTime() {
    return time;
}

public String toString() {
    return "Merge sort is completed in " + getTime() + " nanoseconds";
}

private void swap(int x, int y) {
    int tmp = list.get(x);
    list.set(x, list.get(y));
    list.set(y, tmp);
}

public void reversedList() {
    int idx = list.size()/2;
    int high = list.size()-1;
    for(int low=0; low<idx; low++) {
        swap(low, high--);
    }
} 

public boolean isSortCompleted() {
    return sortCompleted;
}