数据结构和算法 归并排序

原理：

是创建在归并操作上的一种有效的排序算法，效率为O(nlog n)（大O符号）。1945年由约翰·冯·诺伊曼首次提出。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用，且各层分治递归可以同时进行。

• 分割：递归地把当前序列平均分割成两半。
• 集成：在保持元素顺序的同时将上一步得到的子序列集成到一起（归并）。

递归法（Top-down）

1. 申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列
2. 设定两个指针，最初位置分别为两个已经排序序列的起始位置
3. 比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置
4. 重复步骤3直到某一指针到达序列尾
5. 将另一序列剩下的所有元素直接复制到合并序列尾

迭代法（Bottom-up）

原理如下（假设序列共有n个元素）：

1. 将序列每相邻两个数字进行归并操作，形成(n/2)个序列，排序后每个序列包含两/一个元素
2. 若此时序列数不是1个则将上述序列再次归并，形成 ceil(n/4)个序列，每个序列包含四/三个元素
3. 重复步骤2，直到所有元素排序完毕，即序列数为1

图解：

 

代码实现：

代码git地址

https://github.com/baochunhai/data-structure-algorithms.git

public class MergeSort {
    public static void main(String[] args) {

        int[] arr =SortUtil.randomArr(5);

        SortUtil.printArr(arr);
//        process(arr,0,arr.length-1);
        mergeSort(arr);
        SortUtil.printArr(arr);
    }

    /**
     * 递归版本
     * @param arr
     * @param L
     * @param R
     */
    private static void process(int[] arr,int L,int R){
        if(L==R){
            return;
        }
        int mid = L + ((R-L)>>1);
        // 左边变有序
        process(arr,L,mid);
        // 右边变有序
        process(arr,mid+1,R);
        // 整体变有序
        merge(arr,L,mid,R);
    }

    /**
     * 非递归版本
     * @param arr
     */
    private static void mergeSort(int[] arr) {
        if (arr == null || arr.length < 2) {
            return;
        }
        int N = arr.length;
        int mergeSize = 1;
        while (mergeSize < N) {
            int L = 0;
            while (L < N) {
                int mid = L + mergeSize - 1;
                if (mid >= N) {
                    break;
                }
                // 分组后，最后不够一组,则选小的为右边界
                int R = Math.min(mid + mergeSize, N - 1);
                merge(arr, L, mid, R);
                L = R + 1;
            }
            mergeSize <<= 1;
        }


    }

    private static void merge(int[] arr,int L,int M,int R) {
        int[] help = new int[R - L + 1];
        int i = 0;
        int p1 = L;
        int p2 = M + 1;
        while (p1 <= M && p2 <= R) {
            if (arr[p1] <= arr[p2]) {
                help[i++] = arr[p1++];
            } else{
                help[i++] = arr[p2++];
            }
        }
        // 左边没越界,右边越界
        while (p1 <= M) {
            help[i++] = arr[p1++];
        }
        // 右边没越界,左边越界
        while (p2 <= R) {
            help[i++] = arr[p2++];
        }
        for (i = 0; i < help.length; i++) {
            arr[L + i] = help[i];
        }
    }
}

时间复杂度分析：

比较操作的次数介于 (nlog n)/2和 nlog n-n+1。 赋值操作的次数是（2nlog n)。归并算法的空间复杂度为：O (n)

 

稳定性：

       稳定。算法中优先将左子序列中的数优先放到辅助数组，保证了排序的稳定性。