- 归并方法
- 自顶向下的归并排序
- 实现
- 性能分析
- 优化：切换到插入排序
- 自底向上的归并排序
归并方法
“归并”操作是将两个有序的数组合并成一个更大的有序数组，归并排序就是基于这一操作，先递归地将一个数组分成两半分别排序，然后将排序结果归并起来。
归并的代码如下：
private static void merge(Comparable[] a, int lo, int mid, int hi) {
int i = lo, j = mid + 1;
for (int k = lo; k <= hi; k++) {
aux[k] = a[k];
}
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[i], aux[j])) {
a[k] = aux[i++];
} else {
a[k] = aux[j++];
}
}
}这种归并方法用了一个辅助数组aux[]，在归并时，先将待归并的元素复制到辅助数组，然后将子数组a[lo..mid]和a[mid+1..hi]归并成一个有序的数组，同时将数组归并回a[]。i，j分别指向左右两个子数组的待归并元素，执行时如果左半边数组用尽，则取右半边元素，右指针加1，如果右半边数组用尽，则取左半边元素，左指针加1，如果两边数组都没用尽，则通过指针各取一个元素比较大小，将小的元素归并回原数组，同时对应的指针加1。
这个归并方法能够将两个子数组排序，然后就可以通过它将整个数组排序。
归并排序的代码实现有自顶向下和自底向上两种。
自顶向下的归并排序
实现
public class Merge {
private static Comparable[] aux;
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);
}
public static void sort(Comparable[] a) {
aux = new Comparable[a.length];
sort(a, 0, a.length - 1);
}
}其中aux为归并所需的辅助数组，在排序开始前初始化。sort(Comparable[] a, int lo, int hi)方法递归地调用自己，将一个大的数组不断地分为左右两部分，并最终进行归并。将一个长度16的数组排序的轨迹如下图：
要将a[0..15]排序， sortO方法会调用自己将a[0..7]排序，再在其中调用自己将a[0..3]和a[0..1]排序。在将a[0]和a[1]分别排序之后，终于才会开始将a[0]和a[1]归并。第二次归并是a[2]和a[3]，然后是a[0..1]和a[2..3]，以此类推。从这段轨迹可以看到， sort()方法的作用其实在于安排多次merge()方法调用的正确顺序。
所以这种方式在不断地将数组分割然后排序，所以也称自顶向下的归并。
性能分析
关系归并排序算法的性能，还是从比较和访问数组的次数来分析。
下面的树状图直观地表示了归并排序的执行过程，每个结点都表示一个sort()方法通过merge()方法归并而成的子数组。对于长度为N的数组，这颗二叉树的高度为lgN，在经过层层归并的过程中，每一层都最多需要N次比较，比如将a[0..7]和a[8..15]归并为a[0..15]时，16个元素都会经过一次比较被放回原数组，然后再往下层走，不管需要几次归并，处理的元素都是16个，既16次比较。每层N次比较，则一共NlgN次比较。
所以归并排序的增长数量级为NlgN级别的，这相比之前的选择、插入排序的平方级别，要快太多了。
将1万条随机整数进行排序时，插入排序与归并排序的速度对比如下：
Insertion, 0.868 s
Merge, 0.018 s优化：切换到插入排序
上面的归并排序代码还可以继续优化，优化的方式之一便是在小规模数组时，切换到插入排序。因为当递归分割到最下面几层的子数组时，子数组的规模已经非常小了，继续递归只会使方法的调用过于频繁。用不同的方法处理小规模问题能改进大多数递归算法的性能，在小规模问题上，插入排序或者选择排序可能比归并排序更快，而且这样做可以有效减少递归的深度，减少方法调用的开销。
public class MergeOptimize {
private static int CUTOFF = 20;
private static void sort(Comparable[] src, Comparable[] dst, int lo, int hi) {
if (hi <= lo + CUTOFF) {
insertionSort(dst, lo, hi);
return;
}
int mid = lo + (hi - lo) / 2;
sort(src, dst, lo, mid);
sort(src, dst, mid + 1, hi);
merge(src, dst, lo, mid, hi);
}
...
}在数组规模小于20的时候，改用插入排序。
用10万条随机整数来检验优化后的效果：
Merge, 0.305 s
MergeOptimize, 0.199 s自底向上的归并排序
自底向上的归并排序区别于自顶向上排序方法的地方在于，后者将一个大问题分割成小问题分别解决，然后用所有小问题的答案来解决整个大问题，属于分治思想的典型应用；而自底向上的归并排序则是直接从最小规模的数组开始归并，不断得到规模更大的数组，最终得以将整个数组排序。比如依次进行1-1,2-2,4-4归并，子数组的大小不断翻倍。
public class MergeBU {
private static Comparable[] aux;
public static void sort(Comparable[] a) {
int N = a.length;
aux = new Comparable[N];
for (int sz = 1; sz < N; sz = sz + sz) {
for (int lo = 0; lo < N - sz; lo += sz + sz) {
merge(a, lo, lo + sz - 1, Math.min(lo + sz + sz - 1, N - 1));
}
}
}
...
}自底向上的归并排序的增长数量级仍然是NlgN级别的，因为其原理仍然是基于归并的。在实际运行时，可能由于少了函数递归调用的开销，比自顶向下的归并排序还能更快，如下为10万条随机整数的测试结果：
Merge, 0.279
MergeBU, 0.172