归并排序及其优化

归并排序

基本概念

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

算法步骤

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

迭代法（Bottom-up）
1. 原理如下（假设序列共有 n个元素）：
2. 将序列每相邻两个数字进行归并操作，形成 $ceil(n/2)$个序列，排序后每个序列包含两/一个元素
3. 若此时序列数不是1个则将上述序列再次归并，形成 $ceil(n/4)$个序列，每个序列包含四/三个元素
4. 重复步骤2，直到所有元素排序完毕，即序列数为1

二者比较
测试来看 迭代法比递归法要快一点，原因在于递归多了入栈和出栈的操作，优化后二者差距缩小，主要在于递归的merge操作是更高的层次上的，相比而言迭代的merge优化操作没有在递归中的起到的作用大。但是即便如此，迭代的算法依旧快那么一点。

图示

对一个随机点的链表进行排序

复杂度分析

数据结构 数组
最坏时间复杂度 O(n\log n)
最优时间复杂度 O(n\log n)
平均时间复杂度 O(n\log n)
空间复杂度 O(n)

代码实现

递归版

package SortingAdvance.MergeSort;

import java.util.Arrays;

/**
 * @ Description: 归并排序 普通递归版 时间复杂度O(nlogn)
 * @ Date: Created in 11:42 2018/7/29
 * @ Author: Anthony_Duan
 */
public class MergeSortRecursion {

    //不允许实例
    private MergeSortRecursion(){}

    /**
     * 将arr[l...mid]和arr[mid+1...r]两部分进行归并
     */
    private static void merge(Comparable[] arr, int l, int mid, int r) {

        //拷贝数组，[l,r+1)
        Comparable[] aux = Arrays.copyOfRange(arr, l, r + 1);

        // i是左半部分的索引，j是右半部分的索引，j的歧视索引为mid+1
        int i = l, j = mid + 1;
        //k是比较后得到的较小的元素将要放入原数组的索引 注意k是索引原数组的，i，j是索引拷贝后数组的
        for (int k = l; k <=r ; k++) {
            //如果左半部分的已经全部放到原数组了，将右半部分数组全部依次放入原数组
            if (i > mid) {
                arr[k] = aux[j-l];
                j++;
            }
            //如果右半部分的已经全部放到原数组了，将左半部分数组全部依次放入原数组
            else if (j > r) {
                arr[k] = aux[i-l];
                i++;
            }
            //如果左半部分取出的元素比较小，那么将左半部分索引取出的元素放入原数组 然后左半部分索引加一
            else if (aux[i - l].compareTo(aux[j - l]) < 0) {
                arr[k] = aux[i-l];
                i++;
            }
            //右半部分取出的元素比较小，那么将右半部分索引取出的元素放入元素放入数组，然后右半部分索引加一
            else {
                arr[k] = aux[j-l];
                j++;
            }
        }
    }


    // 递归使用归并排序,对arr[l...r]的范围进行排序
    private static void sort(Comparable[] arr, int l, int r) {
        if (l >= r) {
            return;
        }

        int mid = l + (r - l) / 2;
        sort(arr, l, mid);
        sort(arr, mid + 1, r);
        merge(arr, l, mid, r);
    }

    public static void sort(Comparable[] arr) {
        int n = arr.length;
        sort(arr,0,n-1);
    }
    // 测试MergeSort
    public static void main(String[] args) {

        // Merge Sort是O(nlogn)复杂度的算法
        // 可以在1秒之内轻松处理100万数量级的数据
        // 注意：不要轻易尝试使用SelectionSort, InsertionSort或者BubbleSort处理100万级的数据
        // 否则，你就见识了O(n^2)的算法和O(nlogn)算法的本质差异：）
        int N = 1000000;
        Integer[] arr = SortTestHelper.generateRandomArray(N, 0, 100000);
        SortTestHelper.testSort("SortingAdvance.MergeSortRecursion.MergeSortRecursion", arr);

        return;
    }
}

迭代版

package SortingAdvance.MergeSort;

import java.util.Arrays;

/**
 * @ Description: 归并排序 普通迭代版 时间复杂度O(nlogn)
 * @ Date: Created in 12:08 2018/7/29
 * @ Author: Anthony_Duan
 */
public class MergeSortIteration {

    private MergeSortIteration(){}

    private static void merge(Comparable[] arr, int l, int mid, int r) {
        Comparable[] aux = Arrays.copyOfRange(arr, l, r + 1);

        int i = l, j = mid + 1;
        for (int k = l; k <=r ; k++) {
            if (i > mid) {
                arr[k] = aux[j-l];
                j++;
            } else if (j > r) {
                arr[k] = aux[i - l];
                i++;
            } else if (aux[i-l].compareTo(aux[j-l]) < 0) {
                arr[k] = aux[i - l];
                i++;
            }else {
                arr[k] = aux[j - l];
                j++;
            }
        }
    }

    public static void sort(Comparable[] arr) {
        int n = arr.length;

        /**
         * 迭代的方式是指底而上，递归是自顶向下
         * sz 是每次左右部分中元素的个数
         * 外层循环控制分组
         * 内层循环控制归并
         */
        for (int sz = 1; sz < n; sz *= 2) {
            for (int i = 0; i < n - sz; i += sz + sz ) {
                merge(arr,i,i+sz-1,Math.min(i+sz+sz-1,n-1));
            }
        }
    }

    // 测试 MergeSort BU
    public static void main(String[] args) {

        // MergeSortIteration 也是一个O(nlogn)复杂度的算法，虽然只使用两重for循环
        // 所以，MergeSortIteration也可以在1秒之内轻松处理100万数量级的数据
        // 注意：不要轻易根据循环层数来判断算法的复杂度，MergeSortIteration就是一个反例
        int N = 1000000;
        Integer[] arr = SortTestHelper.generateRandomArray(N, 0, 100000);
        SortTestHelper.testSort("SortingAdvance.MergeSort.MergeSortIteration", arr);

        return;
    }

}

优化策略

策略1：对于arr[mid] <= arr[mid+1]的情况,不进行merge
策略2：对于小数组, 使用插入排序优化

递归优化版

package SortingAdvance.MergeSort;

import java.util.Arrays;

/**
 * @ Description: 归并排序递归优化版  时间复杂度 O(nlogn)
 * @ Date: Created in 12:49 2018/7/29
 * @ Author: Anthony_Duan
 */
public class MergeSortRecursionAdvance {


    // 我们的算法类不允许产生任何实例
    private MergeSortRecursionAdvance(){}

    // 将arr[l...mid]和arr[mid+1...r]两部分进行归并
    private static void merge(Comparable[] arr, int l, int mid, int r) {

        Comparable[] aux = Arrays.copyOfRange(arr, l, r+1);

        // 初始化，i指向左半部分的起始索引位置l；j指向右半部分起始索引位置mid+1
        int i = l, j = mid+1;
        for( int k = l ; k <= r; k ++ ){

            if( i > mid ){  // 如果左半部分元素已经全部处理完毕
                arr[k] = aux[j-l]; j ++;
            }
            else if( j > r ){   // 如果右半部分元素已经全部处理完毕
                arr[k] = aux[i-l]; i ++;
            }
            else if( aux[i-l].compareTo(aux[j-l]) < 0 ){  // 左半部分所指元素 < 右半部分所指元素
                arr[k] = aux[i-l]; i ++;
            }
            else{  // 左半部分所指元素 >= 右半部分所指元素
                arr[k] = aux[j-l]; j ++;
            }
        }
    }


    private static void sort(Comparable[] arr, int l, int r) {

        //优化2： 对于小规模数组，说那个插入排序
        if (r -l <=15) {
            InsertionSortAdvance.sort(arr, l, r);
            return;
        }

        int mid = (l + r) / 2;
        sort(arr, l, mid);
        sort(arr, mid + 1, r);


        //优化1：对于arr[mid]<= arr[mid+1]的情况，不进行merge
        // 对于近乎有序的数组非常有效，但是对于一般情况，有一定的性能损失
        if (arr[mid].compareTo(arr[mid + 1]) > 0) {
            merge(arr, l, mid, r);
        }
    }

    public static void sort(Comparable[] arr) {
        int n = arr.length;
        sort(arr, 0, n - 1);
    }


    public static void main(String[] args) {
        int N = 1000000;
        Integer[] arr = SortTestHelper.generateRandomArray(N, 0, 100000);
        SortTestHelper.testSort("SortingAdvance.MergeSort.MergeSortRecursionAdvance", arr);

        return;
    }
}

迭代优化版

package SortingAdvance.MergeSort;


import SortingBasic.InsertionSort.InsertionSort;

import java.util.Arrays;

/**
 * @ Description: 归并排序迭代优化版  时间复杂度O(nlogn)
 * @ Date: Created in 13:04 2018/7/29
 * @ Author: Anthony_Duan
 */
public class MergeSortIterationAdvance {

    // 我们的算法类不允许产生任何实例
    private MergeSortIterationAdvance(){}

    // 将arr[l...mid]和arr[mid+1...r]两部分进行归并
    private static void merge(Comparable[] arr, int l, int mid, int r) {

        Comparable[] aux = Arrays.copyOfRange(arr, l, r+1);

        // 初始化，i指向左半部分的起始索引位置l；j指向右半部分起始索引位置mid+1
        int i = l, j = mid+1;
        for( int k = l ; k <= r; k ++ ){

            if( i > mid ){  // 如果左半部分元素已经全部处理完毕
                arr[k] = aux[j-l]; j ++;
            }
            else if( j > r ){   // 如果右半部分元素已经全部处理完毕
                arr[k] = aux[i-l]; i ++;
            }
            else if( aux[i-l].compareTo(aux[j-l]) < 0 ){  // 左半部分所指元素 < 右半部分所指元素
                arr[k] = aux[i-l]; i ++;
            }
            else{  // 左半部分所指元素 >= 右半部分所指元素
                arr[k] = aux[j-l]; j ++;
            }
        }
    }

    public static void sort(Comparable[] arr){

        int n = arr.length;

        // 对于小数组, 使用插入排序优化
        for( int i = 0 ; i < n ; i += 16 ) {
            InsertionSortAdvance.sort(arr, i, Math.min(i+15, n-1) );
        }

        for( int sz = 16; sz < n ; sz += sz ) {
            for( int i = 0 ; i < n - sz ; i += sz+sz )
                // 对于arr[mid] <= arr[mid+1]的情况,不进行merge
            {
                if( arr[i+sz-1].compareTo(arr[i+sz]) > 0 ) {
                    merge(arr, i, i+sz-1, Math.min(i+sz+sz-1,n-1) );
                }
            }
        }

    }

    public static void main(String[] args) {

        int N = 1000000;
        Integer[] arr = SortTestHelper.generateRandomArray(N, 0, 100000);
        SortTestHelper.testSort("SortingAdvance.MergeSort.MergeSortIterationAdvance", arr);

        return;
    }


}