Java中合并排序的实现问题

我正在学习算法课程，正在学习合并排序。我们的教授建议我们尝试实现书中提供的伪代码

我使用Integer.MAX_值作为sentinel值是否正确 对整数数组排序（用于合并中的第8行和第9行） 方法（下面是伪代码）

对于Merge-Sort伪代码方法的第2行，像我一样使用Math.ceil（）在Java中编写代码是否正确？（编辑：实际上是地板，我更新了代码以反映这一点。）

如果你看到任何其他错误，请告诉我

这是本书为合并排序提供的伪代码。

下面是我用Java编写的代码：

public void mergeSort(int[] arrNums, int p, int r) {
    if (p < r) {
        int q = (p + r) / 2;
        mergeSort(arrNums, p, q);
        mergeSort(arrNums, q + 1, r);
        merge(arrNums, p, q, r);
    }
}

public void merge(int[] arrNums, int p, int q, int r) {
    int nOne = q - p + 1;
    int nTwo = r - q;

    int[] arrLeft = new int[nOne + 1];
    int[] arrRight = new int[nTwo + 1];

    for (int i = 0; i < nOne; i++) {
        arrLeft[i] = arrNums[p + i - 1];
    }

    for (int j = 0; j < nTwo; j++) {
        arrRight[j] = arrNums[q + j];
    }

    arrLeft[nOne] = Integer.MAX_VALUE;
    arrRight[nTwo] = Integer.MAX_VALUE;

    // Tracks arrLeft index
    int i = 0;

    // Tracks arrRight index
    int j = 0;

    for (int k = p; k < r; k++) {
        if (arrLeft[i] <= arrRight[j]) {
            arrNums[k] = arrLeft[i];
            i++;
        } else {
            arrNums[k] = arrRight[j];
            j++;
        }
    }
}

public void合并排序（int[]arrNums，int p，int r）{
if（p如果（arrlefit[i]是
merge
方法中
循环的最后一个
，变量
k
应该从
p-1
开始：

for (int k = p - 1; k < r; k++) {
    if (arrLeft[i] <= arrRight[j]) {
        arrNums[k] = arrLeft[i];
        i++;
    } else {
        arrNums[k] = arrRight[j];
        j++;
    }
}

for（int k=p-1；k如果（arrlef[i]我几天前实现了它，如果有人会感兴趣

private static void mergeSort(double[] arr, int start, int end){
    if(start < end){
        int mid = ( start + end ) / 2;
        mergeSort(arr, start, mid);
        mergeSort(arr, mid + 1, end);
        Merge(arr, start, mid, end);
    }
}


private static void Merge(double[] arr, int start, int mid, int end){

    double[] leftArray = new double[mid - start + 2];
    double[] rightArray = new double[end - mid + 1];
    for(int i = start; i <= mid; i++ )
        leftArray[i - start] = arr[i];
    for (int i = mid + 1; i <= end; i++ )
        rightArray[i - mid - 1] = arr[i];

    leftArray[mid - start + 1] = Double.POSITIVE_INFINITY;
    rightArray[end - mid] = Double.POSITIVE_INFINITY;

    int leftIndex = 0, rightIndex = 0;

    for (int k = start; k <= end; k++){
        if(leftArray[leftIndex] <= rightArray[rightIndex])
            arr[k] = leftArray[leftIndex++];
        else
            arr[k] = rightArray[rightIndex++];
    }   
}

private static void mergeSort（双[]arr，int start，int end）{
如果（开始<结束）{
int mid=（开始+结束）/2；
合并排序（arr、start、mid）；
合并排序（arr、mid+1、end）；
合并（arr、开始、中间、结束）；
}
}
私有静态无效合并（双[]arr，int start，int mid，int end）{
double[]leftArray=新的double[mid-start+2]；
double[]rightArray=新的double[end-mid+1]；
对于（int i=start；i），在伪代码中不是
ceil
，它是
floor
。如果对整数进行运算，这是隐含的。使用无穷大的另一种方法是检查左数组或右数组是否没有更多变量，然后将另一个数组的剩余部分哑到主数组中。@ShadyAtef“哑剩余部分？？”你是说“dump”吗？@ajb，是的..这是真的。在大多数库中，自下而上合并排序的变体更常见。Wiki有一些简单的示例，用于数组和链接列表的自上而下和自下而上合并排序..通常会一次性分配相同（或1/2）的工作数组原始数组的大小和合并方向与迭代过程交替，或者在自顶向下合并排序的情况下与递归级别交替（这避免了不必要的数据复制）。