基于java的递归合并排序

我正在练习关于合并排序的算法。我在合并排序上构建了一个java程序。我认为我的代码中有一些逻辑错误

这是我的输出：

    Array length = 6
     value of q 2
    value of q 1
    value of q 0
9 1073741823 left end -----m(0,0,1)
6 1073741823 right end -----m(0,0,1)
remaining element left
6 9 0 0 0 0 -------------------
9 6 1073741823 left end -----m(0,1,2)
5 1073741823 right end -----m(0,1,2)
remaining element left
5 9 6 0 0 0 -------------------
value of q 4
value of q 3
0 1073741823 left end -----m(3,3,4)
8 1073741823 right end -----m(3,3,4)
remaining element right
5 9 6 0 8 0 -------------------
0 8 1073741823 left end -----m(3,4,5)
2 1073741823 right end -----m(3,4,5)
remaining element left
5 9 6 0 2 8 -------------------
9 6 5 1073741823 left end -----m(0,2,5)
0 8 2 1073741823 right end -----m(0,2,5
remaining element left
0 8 2 9 6 5 -------------------
0 8 2 9 6 5

这是我的代码：

public class MergeSort{
    private int[] digits;
    private  static int[] dummy;
    private  int length;

    public static void main(String[] args) {
        int [] digits = {9,6,5,0,8,2};
        System.out.println("Array length = "+digits.length);
        MergeSort ms = new MergeSort();
        ms.sort(digits);


        for(int a :dummy){
            System.out.print(a+" ");
        }
    }
    void sort(int [] digits){
        this.digits=digits;
        length=digits.length;
        dummy= new int[length];
        mergesort(0,length-1);
    }

    void mergesort(int p,int r){
        int q;
        if(p < r){
            q = (p + r) / 2;

            System.out.println("value of q "+q);
            mergesort(p,q);
            mergesort(q+1,r);
            merge(p,q,r);
            System.out.println("-------------------");
        }
    }

    void merge(int p,int q,int r){
        int i,j,k;
        int n1=q-p+1;
        int n2 =r-q;
        int [] left = new int[n1+1];
        int [] right = new int[n2+1];
        int [] arr=new int[n1+n2];
        for(i = 0; i<n1;i++){
            left[i]= digits[p+i];
            //System.out.print(left[i]+" ");
        }

        for(j = 0; j < n2; j++){
            right[j]= digits[q+j+1];
            //System.out.print(left[j]+" ");
        }
        left[n1] = Integer.MAX_VALUE / 2;
        right[n2] = Integer.MAX_VALUE / 2;

        for(i = 0; i < left.length; i++){
            System.out.print(left[i] + " ");
        }
        System.out.println("left end -----m("+p+","+q+","+r+")");
        for(j = 0; j < right.length; j++){
            System.out.print(right[j]+" ");
        }
        System.out.println("right end -----m("+p+","+q+","+r+")");

        i=0;
        j=0;
        for(k = p; k < r; k++){  
        if(left[i]<right[j]){
            dummy[k]=left[i];
            i++;
        }

        else {
             dummy[k] = right[j];
             j++;
        } 
    }

    while(i<n1)
        dummy[k]=left[i];
        i++;
        k++;
        System.out.println("remaining element left");
    }

    while(j<n2){
        dummy[k]=right[j];
        j++;
        k++;
        System.out.println("remaining element right");
    }

        for(int a: dummy){
            System.out.print(a+" ");
        }
    }
}

公共类合并排序{
私有int[]位；
私有静态int[]虚拟；
私有整数长度；
公共静态void main（字符串[]args）{
int[]位={9,6,5,0,8,2}；
System.out.println（“数组长度=+位数.length”）；
MergeSort ms=新的MergeSort（）；
ms.sort（数字）；
for（int a：虚拟）{
系统输出打印（a+“”）；
}
}
无效排序（int[]位）{
这个。数字=数字；
长度=位数。长度；
虚拟=新整数[长度]；
合并排序（0，长度为1）；
}
无效合并排序（整数p，整数r）{
int-q；
if（p对于（i=0；i要使合并排序起作用，它需要将预览的结果进行较小的计算，并将其用于下一阶段的计算，但您的结果存储在虚拟内存中，该内存永远不会用作下一次计算的源，而仅用作存储。我建议使合并和合并排序函数返回值，这样可读性更高，更清晰如果你愿意，re是我的版本

public class MergeSort {

public static void main(String ...args){
    int[]array = {9,6,5,0,8,2};
    String sortedResultToPrint = Arrays.toString(sort(array));
    System.out.println(sortedResultToPrint);
}
public static int[] sort(int[] array) {
    int[] result = mergSort(array, 0, array.length-1);
    return result;
}

private static int[] mergSort(int[] array, int start, int end) {
    int[] result = null;
    if (start < end) {
        int midle = (start + end) / 2;
        int[] left = mergSort(array, start, midle);
        int[] right = mergSort(array, midle + 1, end);
        result = merge(left, right);
    } else {
        result = new int[]{array[start]};
    }
    return result;
}

private static int[] merge(int[] left, int[] right) {
    int[] result = new int[left.length + right.length];

    int leftPtr = 0;
    int rightPtr = 0;
    for (int i = 0; i < result.length; i++) {
        // Copyed all the left part only right remains
        if (leftPtr >= left.length) {
            result[i] = right[rightPtr++];
        }

        // Copyed all the right part only left remains
        else if (rightPtr >= right.length) {
            result[i] = left[leftPtr++];
        }

        //Right is smaller than left
        else if (right[rightPtr] < left[leftPtr]) {
            result[i] = right[rightPtr++];
        }

        // Left is smaller than right
        else {
            result[i] = left[leftPtr++];
        }

    }
    return result;
}

公共类合并排序{
公共静态void main（字符串…参数）{
int[]数组={9,6,5,0,8,2}；
String sortedResultTopPrint=Arrays.toString（sort（array））；
System.out.println（SortedResultTopPrint）；
}
公共静态int[]排序（int[]数组）{
int[]result=mergSort（数组，0，array.length-1）；
返回结果；
}
私有静态int[]mergSort（int[]数组，int开始，int结束）{
int[]结果=null；
如果（开始<结束）{
int midle=（开始+结束）/2；
int[]left=mergSort（数组、开始、中间）；
int[]right=mergSort（数组，中间+1，结束）；
结果=合并（左、右）；
}否则{
结果=新的int[]{array[start]}；
}
返回结果；
}
私有静态int[]合并（int[]左，int[]右）{
int[]结果=新int[left.length+right.length]；
int leftPtr=0；
int rightpr=0；
for（int i=0；i=left.length）{
结果[i]=右[rightPtr++]；
}
//复制了所有右侧部分，只剩下左侧部分
else if（righptr>=right.length）{
结果[i]=左[leftPtr++]；
}
//右边比左边小
else if（右[rightPtr]<左[leftPtr]）{
结果[i]=右[rightPtr++]；
}
//左比右小
否则{
结果[i]=左[leftPtr++]；
}
}
返回结果；
}

}
请设置问题和代码的格式（请使用正确的缩进）。现在查看正确设置格式的代码：）