Java 合并排序实现/在递归调用中或合并时怀疑错误

非常感谢您对这一混乱局面的任何帮助。这里的任务是对不同于零的整数数组进行排序。我想我犯了两个我无法解决的错误

第一：我想我在递归调用时犯了一个错误。合并时，边界似乎设置错误

第二：我还认为排序过程也有一些错误

    static void mergeSort(int[] init, int lower, int upper) {
    if (lower < upper) {

        int mid = (lower + upper) / 2;
        mergeSort(init, lower, mid);
        mergeSort(init, mid+1, upper);
        merge(init, lower, mid, upper);
    }
}

static void merge(int[] init, int lower, int mid, int upper) {
    int length1 = mid - lower;      //length of first subarray
    int length2 = upper - mid;      //length of second subarray

    int[] leftArray = new int[length1+1];     //creating left subArray
    int[] rightArray = new int[length2+1];    //creating right subArray

    for (int i = 0; i < length1; i++) {       //copying positions from left partition to left subArray
        leftArray[i] = init[lower + i];
    }

    for (int i = 0; i < length2; i++) {       //copying positions from right partition to right subArray
        rightArray[i] = init[mid+i];
    }

    int i = 0;                                //sorting
    int j = 0;
    for (int k = lower; k < upper; k++) {
        if (leftArray[i] <= rightArray[j]) {
            init[k] = leftArray[i];
            i++;
        } else {
            init[k] = rightArray[j];
            j++;
        }
    }
}

静态void合并排序（int[]init、int-lower、int-upper）{
if（下部<上部）{
int mid=（下+上）/2；
合并排序（初始、较低、中间）；
合并排序（初始，中间+1，上部）；
合并（初始、下部、中部、上部）；
}
}
静态无效合并（int[]init，int-lower，int-mid，int-upper）{
int length1=mid-lower；//第一个子数组的长度
int length2=中上部；//第二个子阵列的长度
int[]leftArray=new int[length1+1]；//创建左子数组
int[]rightArray=new int[length2+1]；//创建右子数组
对于（int i=0；i如果（leftArray[i]这不是使用静态方法逐步执行合并排序的推荐方法：

public static void mergeSort(int[] init, int arrayLength) {
    if (arrayLength < 2) {
        return;
    }
    int mid = arrayLength / 2;
    int[] left = new int[mid];
    int[] right = new int[arrayLength - mid];
 
    for (int i = 0; i < mid; i++) {
        left[i] = init[i];
    }
    for (int i = mid; i < arrayLength; i++) {
        right[i - mid] = init[i];
    }
    mergeSort(left, mid);
    mergeSort(right, arrayLength - mid);
 
    merge(init, left, right, mid, arrayLength - mid);
}

public static void merge(
  int[] init, int[] left, int[] right, int leftLength, int rightLength) {
 
    int i = 0, j = 0, k = 0;
    while (i < leftLength && j < rightLength) {
        if (left[i] <= right[j]) {
            init[k++] = left[i++];
        }
        else {
            init[k++] = right[j++];
        }
    }
    while (i < leftLength) {
        init[k++] = left[i++];
    }
    while (j < rightLength) {
        init[k++] = right[j++];
    }
}

publicstaticvoidmergesort（int[]init，int-arraylelength）{
if（排列长度<2）{
返回；
}
int mid=阵列长度/2；
int[]左=新int[mid]；
int[]right=新的int[arrayLength-mid]；
对于（int i=0；i