最简单易懂的归并排序

(一) 归并排序
归并排序（Merge Sort）：归并排序的核心思想还是蛮简单的。如果要排序一个数组，我们先把数组从中间分成前后两部分，然后对前后两部分分别排序，再将排好序的两部分合并在一起，这样整个数组就都有序了。

归并排序使用的就是分治思想，分治，顾名思义，就是分而治之，将一个大问题分解成小的子问题来来解决。小的子问题解决了，大问题也就解决了。
分治算法一般都是用递归来实现的。分治是一种解决问题的处理思想，递归是一种编程技巧。

1. 如何用递归代码来实现归并排序 。
   递推公式：
   merge_sort(p…r) = merge(merge_sort(p…q), merge_sort(q+1…r))

终止条件：
p >= r 不用再继续分解
merge_sort(p…r) 表示，给下标从 p 到 r 之间的数组排序，我们将这个排序问题转化为了两个子问题，merge_sort(p…q)和merge_sort(q+1…r),其中下标q等于p和r的中间位置，也就是(p+r)/2.当下标从p到q和从q+1到r这两个子数组都排好序之后，我们再将两个有序的子数组合并在一起，这样下标从p到r之间的数据也就排好序了。

归并排序算法伪代码：
// 归并排序算法, A 是数组，n 表示数组大小
merge_sort(A, n) {
merge_sort_c(A, 0, n-1)
}

// 递归调用函数
merge_sort_c(A, p, r) {
// 递归终止条件
if p >= r then return

// 取 p 到 r 之间的中间位置 q
q = (p+r) / 2
// 分治递归
merge_sort_c(A, p, q)
merge_sort_c(A, q+1, r)
// 将 A[p…q] 和 A[q+1…r] 合并为 A[p…r]
merge(A[p…r], A[p…q], A[q+1…r])
}

如图所示，我们申请一个临时数组 tmp，大小与 A[p…r] 相同。我们用两个游标 i 和 j，分别指向 A[p…q] 和A[q+1…r] 的第一个元素。比较这两个元素 A[i] 和 A[j]，如果 A[i]<=A[j]，我们就把 A[i] 放入到临时数组 tmp，并且 i 后移一位，否则将 A[j] 放入到数组 tmp，j 后移一位。

merge() 函数写成伪代码如下：

merge(A[p…r], A[p…q], A[q+1…r]) {
var i := p，j := q+1，k := 0 // 初始化变量 i, j, k
var tmp := new array[0…r-p] // 申请一个大小跟 A[p…r] 一样的临时数组
while i<=q AND j<=r do {
if A[i] <= A[j] {
tmp[k++] = A[i++] // i++ 等于 i:=i+1
} else {
tmp[k++] = A[j++]
}
}

// 判断哪个子数组中有剩余的数据
var start := i，end := q
if j<=r then start := j, end:=r

// 将剩余的数据拷贝到临时数组 tmp
while start <= end do {
tmp[k++] = A[start++]
}

// 将 tmp 中的数组拷贝回 A[p…r]
for i:=0 to r-p do {
A[p+i] = tmp[i]
}
}
2) 归并排序的性能分析：
第一：归并排序是稳定的排序算法
第二：归并排序的时间复杂度是O(nlogn)
第三：归并排序的空间复杂度是O(n)