Algorithm 在执行mergesort时是否需要将索引作为参数传递？

我在网上看到了许多mergesort的实现，比如传入参数l、m和r，以了解子数组的开始和结束位置。我想知道，如果我们制作子数组的副本并将其传入，那么运行时和空间复杂性是否会保持不变。建议的代码示例如下：

class Solution {

    //mergeSort implementation
    public int[] sortArray(int[] nums) {

        if (nums.length == 1) {
            return nums;
        }

        int arrayLength = nums.length;

        // make copies instead of passing indices
        int[] left = Arrays.copyOfRange(nums, 0, arrayLength/2);
        int[] right = Arrays.copyOfRange(nums, arrayLength/2, arrayLength);

        left = sortArray(left);
        right = sortArray(right);

        return merge(left, right);

    }

    public int[] merge(int[] left,int[] right) {

        int[] merged = new int[left.length + right.length];

        int mergedCounter = 0;
        int i = 0; //leftCounter
        int j = 0; //rightCounter
        while (mergedCounter != left.length + right.length) {
            if (i == left.length) {
                merged[mergedCounter] = right[j];
                mergedCounter++;
                j++;
            } else if (j == right.length) {
                merged[mergedCounter] = left[i];
                mergedCounter++;
                i++;
            } else {
                if (left[i] <= right[j]) {
                    merged[mergedCounter] = left[i];
                    mergedCounter++;
                    i++;
                } else {
                    merged[mergedCounter] = right[j];
                    mergedCounter++;
                    j++;
                }
            }
        }

        return merged;

    }

}

类解决方案{
//合并排序实现
公共int[]sortArray（int[]nums）{
如果（nums.length==1）{
返回nums；
}
int arrayLength=nums.length；
//复制而不是传递索引
int[]left=Arrays.copyOfRange（nums，0，arrayLength/2）；
int[]right=Arrays.copyOfRange（nums，arrayLength/2，arrayLength）；
左=Sortaray（左）；
右=Sortaray（右）；
返回合并（左、右）；
}
公共int[]合并（int[]左，int[]右）{
int[]合并=新int[left.length+right.length]；
int mergedCounter=0；
int i=0；//左计数器
int j=0；//右计数器
while（mergedCounter！=left.length+right.length）{
if（i==左.length）{
合并的[mergedCounter]=右[j]；
mergedCounter++；
j++；
}else if（j==right.length）{
合并的[mergedCounter]=左[i]；
mergedCounter++；
i++；
}否则{
if（left[i]任何额外的复制操作都将增加运行时间。复制子阵列将增加常量的空间需求，但由于“复杂性”忽略常量和/或低阶项，因此空间“复杂性”将保持不变

大多数库使用自底向上的合并排序的一些变体，索引（或指针）是动态更新的，而不是通过递归传递，通常保存在基于编译器优化的寄存器中。自顶向下的合并排序主要用作学习练习

通过基于自底向上合并排序的合并过程或基于自顶向下合并排序的递归级别更改合并方向，可以最小化复制操作

使用C/C++，一种传递数组和索引的方法是通过指针或迭代器，减少每个调用所需的参数数1个参数。
 < P>任何额外的拷贝操作都会增加运行时间。忽略常量和/或低阶项，空间“复杂性”将保持不变

大多数库使用自底向上的合并排序的一些变体，索引（或指针）是动态更新的，而不是通过递归传递，通常保存在基于编译器优化的寄存器中。自顶向下的合并排序主要用作学习练习

通过基于自底向上合并排序的合并过程或基于自顶向下合并排序的递归级别更改合并方向，可以最小化复制操作

用C/C++，传递数组和索引的一种方法是通过指针或迭代器，减少每个调用所需的参数数量1个参数。
 <代码>我相信运行[时间]复杂性没有增加

渐进复杂性可能会保持不变，而常数因子差异很大。

我是否遗漏了一些东西

可维护性/可读性。

我相信运行[时间]复杂性没有增加

渐进复杂性可能保持不变，而常数因子差异很大。

我是否遗漏了一些东西

可维护性/可读性，例如。