Java：归并排序的两种普通实现

不多bb，直接百度百科：

该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列。即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。归并排序是一种稳定的排序方法。一般用于总体无序，各子项相对有序的数列。

稳定的排序，即相等的元素顺序不会改变，就是输入他俩啥循序，最终结果他俩还是那顺序。

步骤

• 申请空间（arr)，使其大小为两个已经排序序列arr1，arr2的和，用以存放合并后的序列。
• 定义俩指针，初始化指向两个已排序序列的起始位置。
• 依次向后挪动指针，哪个大就往arr里塞，直到一方被掏空，另一方全部合并到arr末尾。

方案一

先创建两个临时数组，装载数组的两部分，然后进行merge。

    public static void mergeSort(int[] arr){
        int len = arr.length;
        if(len >1){
            //处理前一半
            int[] firstArr = new int[len/2];
            //System.arraycopy(arr,0,firstArr,0,len/2);

            //拷贝前一半进辅助数组firstArr
            for(int i = 0;i<len/2;i++){
                firstArr[i] = arr[i];
            }
            mergeSort(firstArr);
            //处理另一半
            int secondArrLen = len-len/2;
            int[] secondArr = new int[secondArrLen];
            //拷贝后一半进辅助数组secondArr
            for(int i = 0;i<secondArrLen;i++){
                secondArr[i] = arr[i+len/2];
            }
            mergeSort(secondArr);
            //合并两个结果
            merge(firstArr,secondArr,arr);
        }
    }
    private static void merge(int[] firstArr, int[] secondArr, int[] arr) {
        int curr1 = 0;
        int curr2 = 0;
        int curr3 = 0;
        //两个数组都还有元素的时候，把更小的插入到arr中
        while(curr1<firstArr.length&& curr2<secondArr.length){
            if(firstArr[curr1]<secondArr[curr2]){
                arr[curr3++] = firstArr[curr1++];
            }else{
                arr[curr3++] = secondArr[curr2++];
            }
        }
        //此时secondArr已经空了，直接把firstArr的后面的全部填充到arr中
        while(curr1<firstArr.length){
            arr[curr3++] = firstArr[curr1++];
        }
        while(curr2<secondArr.length){
            arr[curr3++] = secondArr[curr2++];
        }
    }

方案二

先对初始数组的两部分排序，再归并到临时数组中，最后赋值到原始数组里。

    public static void mergeSort(int[]arr){
        int low = 0;
        int high = arr.length-1;
        mergeSort1(arr,low,high);
    }

    private static void mergeSort1(int[] arr, int low, int high) {
        if(low<high){
            int mid = (low+high)>>1;
            mergeSort1(arr,low,mid);
            mergeSort1(arr,mid+1,high);
            merge(arr,low,mid,high);
        }

    }
    // [low,mid] + [mid+1,high]
    private static void merge(int[] arr, int low, int mid, int high) {
        int[] temp = new int[arr.length];

        int p1 = low;
        int p2 = mid+1;
        int p3 = low;
		//两个数组都还有元素的时候，把更小的插入到temp中
        while(p1<=mid&& p2<=high){
            if(arr[p1]<=arr[p2]){
                temp[p3++] = arr[p1++];
            }else{
                temp[p3++] = arr[p2++];
            }
        }
        //此时p2已经空了，直接把p1的后面的全部填充到temp中
        while(p1<= mid) {
            temp[p3++] = arr[p1++];
        }
        while(p2<=high){
            temp[p3++] = arr[p2++];
        }
        for(int i = low;i<=high;i++){
            arr[i] = temp[i];
        }
    }

归并排序复杂度

归并排序的复杂度为O（nlogn），优于选择排序，冒泡排序和插入排序。

---

参考：归并排序