Java实现归并排序

//合并两个有序表
    static void Merge(int[] arr,int low,int mid,int high){
        //申请一个辅助数组，长度为当前递归数组长度
        int[] temp=new int[high-low+1];
        //初始化辅助数组的指针，以及要排序数组的左右两个子表的初始指针
        int i=0,p1=low,p2=mid+1;
        //两个子表指针没有越界
        while (p1<=mid&p2<=high){
            //把两个子表当前位置中关键字较小赋值给辅助数组
            if (arr[p1]<arr[p2]){
                temp[i++]=arr[p1++];
            }else {
                temp[i++]=arr[p2++];
            }
        }
        //在右半子表排好序时，左半子表还没排好序时
        while (p1<=mid){
            //把剩余元素依次赋值
            temp[i++]=arr[p1++];
        }
        //在左半子表排好序时，右半子表还没排好序时
        while (p2<=high){
            temp[i++]=arr[p2++];
        }
        for (int j=0;j<temp.length;j++){
            arr[low+j]=temp[j];
        }
    }

	//归并方法2
    static void Merge2(int[]arr ,int low ,int mid ,int high){
        //这里要申请与初始arr长度一样的辅助数组，因为我们要先把元素全部放入数组，所以随着low越大，就会造成数组溢出
        int[] temp=new int[arr.length];
        int i,j,k;
        for (k=low;k<=high;k++){
            temp[k]=arr[k];
        }
        //从辅助数组中的两个子表当前位置元素比较，较小值放入arr[k]
        for (i=low,j=mid+1,k=i;i<=mid&&j<=high;k++){
            if (temp[i]<temp[j])
                arr[k]=temp[i++];
            else{
                arr[k]=temp[j++];
            }
        }
        //把剩余元素放入arr中
        while (i<=mid) arr[k++]=temp[i++];
        while (j<=high) arr[k++]=temp[j++];
    }
	
    static void MergeSort(int[] arr,int low,int high){
        if(low<high){
            //从中间划分两个子序列
            int mid=(high+low)>>1;
            //对左子表进行递归排序
            MergeSort(arr,low,mid);
            //对右子表进行递归归并
            MergeSort(arr,mid+1,high);
            //归并
            Merge(arr,low,mid,high);
        }
    }

    public static void main(String[] args) {
        int[] arr1=new int[]{5315,13156,648,123,64,3154,615,32,616,848,211};
        int[] arr=new int[]{998857732,995773975,986263711,970050582,978672815,946770900,884642435,885254231,830140516,917959651,768122842,937296273,546931356,861262547,764532283,965184299,918973856,915272981,830623614,728999048,693597252,631219735,884688278,984427390,714012242,537616843,536343860,521612397,659978110,445747969,433183457,641532230,480363996,586696306,31693639,805374069,303753633,215386675,261627544,604354651,733048764,393354006,631784130,241316335,427529125,111935818,698504118,109686701,64838842,353487181,82447697,177571868,691252458,230964510,453463919,340316511,280992325,13701823,77481420,544069623,544526209,193715454,157540946,427514727,292446044,782703840,219297819,151485185,256184773,570872277,695760794,738644784,784607555,433518449,440403918,281397572,493886311,970466103,738026287,819959858,119093579,411203381,306242389,84356804,42607214,462370265,294497342,70309112,158982405,513023688,740856884,784337461,17092337,633020080,387052570,421701576,298738196,54807658,472147510,169670404};
        MergeSort(arr,0,arr.length-1);
        MergeSort(arr1,0,arr1.length-1);
        System.out.println(Arrays.toString(arr));
        System.out.println(Arrays.toString(arr1));
    }

空间效率：辅助空间需要n个单元，所以算法空间复杂度为O(n)
时间效率：每次归并的时间复杂度为O(n)，共需进行log2n趟归并，所以算法时间复杂度为O(nlog2n)
算法比较稳定