研磨算法：排序之归并排序
标签（空格分隔）： 研磨算法
理解归并排序
归并排序（MERGE-SORT）是利用归并的思想实现的排序方法，该算法是分治（divide-and-conquer）的经典应用
简单来说就是将一个要排序的数组，先递归地将其分成两半，两半分别排序，然后归并起来。
分治模型
我们将整个数组递归地进行分割，不断二分，直到分隔为独立的元素。如
[8,4,5,7,1,3,6,2]
分为 [8,4,5,7] [1,3,6,2]
分为 [8,4] [5,7] [1,3] [6,2]
分为 [8] [4] [5] [7] [1] [3] [6] [2]然后对于最小的子问题，即每个独立元素，不断向上两两合并。
[8] [4] [5] [7] [1] [3] [6] [2]
合并 [4,8] [5,7] [1,3] [2,6]
合并 [8,4,5,7] [1,3,6,2]
合并 [1,2,3,4,5,6,7,8]可以看到这种结构很像一棵完全二叉树，本文的归并排序我们采用递归去实现（也可采用迭代的方式去实现）。分阶段可以理解为就是递归拆分子序列的过程，递归深度为log2n。
分
对于分来说，没有什么难点，我们使用递归的形式。
治
对于治来说，我们需要将两个已经有序的子序列合并成一个有序序列，我们先将所有元素复制到一个辅助数组中，将辅助数组分隔成两个待合并的数组。然后比较两个待合并数组的采用如下策略：
1. 在两个待合并数组中的头结点放置两个指针，并比较元素
2. 将小的那个放回的原数组中，并移动指针到下一个
2. 继续比较，直到某一边取尽，然后取另一边的元素
比如上图中的最后一次合并，要将[4,5,7,8]和[1,2,3,6]两个已经有序的子序列，合并为最终序列[1,2,3,4,5,6,7,8]，来看下实现步骤。
1. [4,5,7,8] [1,2,3,6] 比较4，1 得到 [1]
2. [4,5,7,8] [1,2,3,6] 比较4，2 得到 [1,2]
3. [4,5,7,8] [1,2,3,6] 比较4，3 得到 [1,2,3]
4. [4,5,7,8] [1,2,3,6] 比较4，6 得到 [1,2,3,4]
5. [4,5,7,8] [1,2,3,6] 比较5，6 得到 [1,2,3,4,5]
6. [4,5,7,8] [1,2,3,6] 比较7，6 得到 [1,2,3,4,5,6]
7. [4,5,7,8] [1,2,3,6] 取7 得到 [1,2,3,4,5,6,7]
8. [4,5,7,8] [1,2,3,6] 取8 得到 [1,2,3,4,5,6,7,8]代码演示
对于复杂代码的书写，我们一般遵循一个原则，即：先写主干，再写各个小方法。
对于该算法，我们先写出主干函数mergeSort，然后再写sort，再写merge方法
package sort;
import java.util.Arrays;
/**
* Created by japson on 4/18/2018.
*/
public class MergeSort {
// 归并所需的辅助数组
private static int[] temp;
public static void main(String[] args) {
int[] a = {9,8,7,6,5,4,3,2,1};
sort(a);
System.out.println(Arrays.toString(a));
}
// 一般我们都使用一个参数的方法，在其内部再重载
public static void sort(int[] a) {
// 为临时数组等长赋值
temp = new int[a.length];
sort(a,0,a.length-1);
}
// 排序算法，主要是递归
public static void sort(int[] a,int lo,int hi) {
// 递归的边界条件 注意 <=
if (hi <= lo) return;
int mid = (lo + hi)/2;
sort(a,lo,mid); // 左边归并排序，使得左子序列有序
sort(a,mid+1,hi); // 右边归并排序，使得右子序列有序
merge(a,lo,mid,hi); // 将两个有序子数组合并操作
}
// 归并算法 使用两个指针，从开头和中间扫描比较，将较小的复制的原数组中
private static void merge(int[] a, int lo, int mid, int hi) {
int i = lo; // 左序列指针
int j = mid + 1; // 右序列指针
// 必须是k=hi，因为hi是8，而一共是第9个
for (int k = lo ; k <= hi ; k++) {
temp[k] = a[k];
}
// 赋值回a数组
for (int k = lo ; k <= hi ; k++) {
if (i > mid) {
a[k] = temp[j];
j ++;
} else if (j > hi) {
a[k] = temp[i];
i++;
} else if (temp[i] > temp[j]) {
a[k] = temp[j];
j++;
} else {
a[k] = temp[i];
i++;
}
}
}
}算法分析
归并排序是稳定排序，它也是一种十分高效的排序，能利用完全二叉树特性的排序一般性能都不会太差。
java中Arrays.sort()采用了一种名为TimSort的排序算法，就是归并排序的优化版本。
每次合并操作的平均时间复杂度为O(n)，而完全二叉树的深度为|log2n|。总的平均时间复杂度为O(nlogn)。而且，归并排序的最好，最坏，平均时间复杂度均为O(nlogn)。