归并排序（Merge Sort）

1.归并排序（Merge Sort）基本原理：

　　它的原理是假设初始序列有n个记录，则可以看成是n个有序的子序列，每个子序列的长度为1，然后两两合并，得到n/2个长度为2或1的有序子序列；再两两归并，… … ，如此重复，直至得到一个长度为n的有序序列为止，这两排序方法就称为归并排序。

　　

public class MergeSort {
    
    public static void mergeSort(int[] arr) {
        mSort(arr, 0, arr.length-1);
    }

    /*
     * 递归分治
     * @param arr 待排数组
     * @param left 左指针
     * @param right 右指针
     */
    public static void mSort(int[] arr, int left, int right) {
        if(left >= right)
            return ;
        int mid = (left + right) / 2;
        
        mSort(arr, left, mid); //递归排序左边
        mSort(arr, mid+1, right); //递归排序右边
        merge(arr, left, mid, right); //合并
    }
    
    /*
     * 合并两个有序数组
     * @param arr 待合并数组
     * @param left 左指针
     * @param mid 中间指针
     * @param right 右指针
     */
    public static void merge(int[] arr, int left, int mid, int right) {
        //[left, mid] [mid+1, right]
        int[] temp = new int[right - left + 1]; //中间数组
        
        int i = left;
        int j = mid + 1;
        int k = 0;
        while(i <= mid && j <= right) {
            if(arr[i] <= arr[j]) {
                temp[k++] = arr[i++];
            }
            else {
                temp[k++] = arr[j++];
            }
        }
        
        while(i <= mid) {
            temp[k++] = arr[i++];
        }
        
        while(j <= right) {
            temp[k++] = arr[j++];
        }
        
        for(int p=0; p<temp.length; p++) {
            arr[left + p] = temp[p];
        }
        
    }
}

　　栗子1：

　　下列排序算法中(D)排序在一趟结束后不一定能选出一个元素放在其最终位置上

 　　  A.选择

　　　B.冒泡

　　　C.堆排序

　　　D.归并

　解释：A，选择排序每次选择一个元素放在其最终位置，直道序列有序为止

　　　　B，冒泡排序每一趟都将子序列中最小的元素放在子序列的首位，也就是元素的最终位置

　　　　C，堆排序，以最小堆为例，堆顶元素是所有元素中最小的，可以一次性放在最终位置

 　　

　　栗子2：

　　现有1G数据需要排序，计算资源只有1G内存可用，下列排序方法中最可能出现性能问题的是__D__。

　　A.选择

　　B.冒泡

　　C.堆排序

　　D.归并

　　E.插入

　　栗子3：

　　下述几种排序方法中，要求内存最大的是（）D

　　A.快速排序

　　B.插入排序

　　C.选择排序

　　D.归并排序

　　解释：

　　这个题要求的是空间复杂度。

　　冒泡排序,简单选择排序,堆排序,直接插入排序,希尔排序的空间复杂度为O(1),因为需要一个临时变量来交换元素位置,(另外遍历序列时自然少不了用一个变量来做索引)

　　快速排序空间复杂度为O(logn)~O(n)(因为递归调用了) ,

　　归并排序空间复杂是O(n),需要一个大小为n的临时数组.

　　基数排序的空间复杂是O(n),桶排序的空间复杂度不确定