《算法》2.2归并排序

1原地归并的抽象方法

实现：

/**
* 将a[lo...mid]和a[mid+1...hi]归并
* @param a 数组
* @param lo lo
* @param mid mid
* @param hi hi
*/
public static void merge(Comparable[] a, int lo, int mid, int hi) {
    int i = lo, j = mid + 1;
    //将a[lo...hi]复制到aux[lo...hi]
    for (int k = lo; k <= hi; k++) {
        aux[k] = a[k];
    }
    //归并回到a[lo...hi]
    for (int k = lo; k <= hi; k++) {
        if (i > mid) {//左半边用尽
            a[k] = aux[j++];
        } else if (j > hi) {//右半边用尽
            a[k] = aux[i++];
        } else if (less(aux[j], aux[i])) {//比较两个
            a[k] = aux[j++];
        } else {
            a[k] = aux[i++];
        }
    }
}

2自顶向下的归并排序

基于原地归并的抽象实现的一种递归归并，

应用了高效算法设计中的分治思想的最典型的一个例子

实现：

/**
 * 自顶向下的归并排序（递归实现）
 * @Author: AZhu
 * @Date: 2021/2/15 14:29
 */
public class Merge extends Sorting {

    private static Comparable[] aux;//归并所需的辅助数组

    /**
     * 将数组a[]排序
     * @param a 数组
     */
    public static void sort(Comparable[] a) {
        aux = new Comparable[a.length];//一次性分配空间
        sort(a, 0, a.length - 1);
    }

    /**
     * 递归将数组a[lo...hi]排序
     * @param a
     * @param lo
     * @param hi
     */
    private static void sort(Comparable[] a, int lo, int hi) {
        if (hi <= lo) {
            return;
        }
        int mid = lo + (hi - lo) / 2;
        sort(a, lo, mid);//将左半边排序
        sort(a, mid + 1, hi);//将右半边排序
        merge(a, lo, mid, hi);//归并
    }
}

性能分析：

• 递归调用sort()方法的作用实际上是安排多次merge()方法调用的正确顺序。
• 对于长度为N的任意数组，自顶向下的归并排序
  • 需要1/2NlgN至NlgN次比较
  • 最多需要访问数组6NlgN次
• 优点：能够保证将任意长度为N的数组排序所需时间和NlgN成正比。
• 缺点：所需的额外空间和N成正比。

优化：

• 对小规模的子数组使用插入排序

  使用插入排序处理小规模的子数组（比如长度小于15）一般可以将归并排序的运行时间缩短10%~15%

• 测试数组是否已经有序

  添加一个判断方法，如果a[mid]小于等于a[mid+1]，我们就认为数组已经是有序的并跳过merge()方法。

  如此可以将任意有序的子数组的运行时间变成线性的了。

• 不将元素复制到辅助数组

  节省将数组元素复制到用于归并的辅助数组所用的时间（但空间不行）

3自底向上的归并排序

先归并那些微型数组，再成对归并得到子数组，

如此这般，直到将整个数组归并在一起。

比标准的递归方法所需要的代码量更少。

实现：

/**
 * 自底向上的归并排序（非递归实现）
 * @Author: AZhu
 * @Date: 2021/2/15 14:49
 */
public class MergeBU extends Sorting {

    private static Comparable[] aux;//归并所需的辅助数组

    /**
     * 将数组a[]排序
     * @param a 数组
     */
    public static void sort(Comparable[] a) {
        //进行lgN次两两归并
        int N = a.length;
        aux = new Comparable[N];
        for (int sz = 1; sz < N; sz = sz + sz) {//sz子数组的大小
            for (int lo = 0; lo < N - sz; lo += sz + sz) {//lo:子数组索引
                merge(a, lo, lo + sz - 1, Math.min(lo + sz + sz - 1, N - 1));
            }
        }
    }
}

性能分析：

• 对于长度为N的任意数组，自底向上的归并排序
  • 需要1/2NlgN至NlgN次比较
  • 最多需要访问数组6NlgN次

4两种归并排序的比较

• 当数组长度为2的幂时，两种排序算法所用的比较次数和数组访问次数相同，只是顺序不同。
• 自底向上的归并排序算法比较适合用链表组织的数据。
• 两种排序算法的实现方式实现任何分治类的算法都很自然。

5总结

一个命题：

• 没有任何基于比较算法能够保证使用少于lg(N!) ~ NlgN次比较将长度为N的数组排序。

另一个命题：

• 归并排序是一种渐进最优的基于比较排序的算法。

归并排序的局限性：

• 归并排序的空间复杂度不是最优的
• 在实践中不一定会遇到最坏的情况
• 除了比较，算法的其他操作（例如访问数组）也可能很重要
• 不进行比较也能将某些数据排序