两个并归排序为什么在测试的时候时间相差那么大?求解!

  1. 第一个时间花费较多的递归排序
    java
    public static void binxG(int [] arr,int len,int right){
     if((right - len <= 0) || right < 0 || (arr == null)){
         return;
     }
     else{
         int mid = len + (right-len) / 2;
         //求中点分界
         binxG(arr,len,mid);
         //左递归划分求左边最后有序
         binxG(arr,mid+1,right);
         //右递归划分求右边最后有序
         youX(arr,len,mid,right);
         //求最后子数组有序
     }
    
    }
public static void youX(int [] arr,int len,int mid,int right){
    //将参数数组分成两边依次求两边的小数方法新创建的数组中
    int r = mid + 1;
    //标记右边子数组开始下标
    int l = len;
    //标记左边子数组开始下标
    int [] z = new int[right - len + 1];
    //创建数组用于存储排序好的元素,最后复制回原数组
    for(int i = 0;i <=right;){
        //交替 将最小的元素放到最前面
        if(r <= right && l <= mid) {
            if (arr[r] < arr[l])
                z[i++] = arr[r++];
            else
                z[i++] = arr[l++];
        }
        //右边子数组遍历完了,将左边剩下的元素放到数组中
        while(r > right && l <= mid)   z[i++] = arr[l++];
        //左边子数组遍历完了,将右边剩下的元素放到数组中
        while(l > mid && r <= right)     z[i++] = arr[r++];
        if(r >right && l >mid)      i++;
    }
    System.arraycopy(z, 0, arr, len, right-len+1);
}

2. 第二个并归排序花费时间较少
public static void binG(int [] arr,int len,int right){
        //测试程序,并归排序
        if((arr == null) || (right - len <= 0) || (right < 0))
            //错误信息或停止信息是退出
            return;
        else{
            int center = len + ((right - len) >> 1);
            //求中点
            binG(arr,len,center);
            //左并归
            binG(arr,center+1,right);
            //右并归
            merge(arr,len,right,center);
            //二分比较排序,子数组
        }
    }


    public static void merge(int []arr,int p,int q,int cen){
        //确定两个子数组的大小
        int n1 = (cen-p+1);
        int n2 = (q-cen);
        //开辟两个子数组
        int [] z1 = new int[n1];
        int [] z2 = new int[n2];
        //为子数组赋值
        for(int i = 0; i < n1; i++){
            z1[i] = arr[p + i];
        }
        for(int i = 0; i < n2; i++){
            z2[i] = arr[cen + i +1];
        }
        int i = 0;
        int j = 0;
        //开始排序两个子数组
        for(int k = p; k <= q; k++){
            if(j == n2){
                //如果第二个子数组排完了,就将第一个子数组后的所有元素插入数组中
                arr[k] = z1[i++];
                continue;
            }
            if(i == n1){
                //如果第一个子数组排完了,就将第二个子数组后的所有元素插入数组中
                arr[k] = z2[j++];
                continue;
            }
            if(z1[i] <= z2[j]){
                //设置排序条件,判断是插入第一个子数组还是插入第二个子数组
                arr[k] = z1[i++];
            }
            else{
                arr[k] = z2[j++];
            }
        }
    }


  1. 为什么这两个并归排序在测试次数越来越大的时候他们的时间差也越来越大?我觉得这都是并归的思想,但这个时间差. . .求解啊!