归并排序

分治法：分治法是将原问题分解成n个规模较小而结构与原问题相似的子问题，然后递归地解决这些子问题，然后再合并其结果，就得到原问题的解。

归并排序就采用了分治策略，首先将n个元素分成各含n/2个元素的子序列（2个子序列），使用归并排序法对两个子序列递归的排序，最后合并两个已排序的子序列得到最终结果。

归并排序的关键在于合并两个已排序的子序列，还是以扑克牌为例。假设有两堆牌面朝上的扑克牌，每一堆都是已排序的，最小的牌在最上面，最终结果是要将两堆牌合并成一个排好序的牌面朝下的扑克牌。基本步骤是选取两堆牌中最顶上两张牌中较小的一张，将其取出后面朝下的摆放在桌子上，重复这个步骤，知道某一堆牌为空为止，最后将一堆中剩余的牌面朝上的牌放置在牌面朝下的牌上。

合并步骤的伪代码如下：

MERGE(A, p, q, r)
    n1 <-- q - p + 1
    n2 <-- r - q
    create arrays L[1..n1] and R[1..n2]
    for i <-- 1 to n1
        do L[i] <-- A[p+i-1]
    for j <-- 1 to n2
        do R[j] <-- A[q+j]
    i <-- 1
    j <-- 1
    for k <-- p to r
        do if L[i] <= R[j]
            then A[k] <-- L[i]
                i <-- i + 1
            else A[k] <-- R[j]
                j <-- j + 1

例如：
A _ _ _ _ _ _ _ _
L 2 4 5 7  R 1 2 3 6

(a)
A 1 _ _ _ _ _ _ _
L 2 4 5 7  R 2 3 6

(b)
A 1 2 _ _ _ _ _ _
L 4 5 7     R 2 3 6

(c)
A 1 2 2 _ _ _ _ _
L 4 5 7     R 3 6

(d)
A 1 2 2 3 _ _ _ _
L 4 5 7     R 6

(e)
A 1 2 2 3 4 _ _ _
L 5 7        R 6

(f)
A 1 2 2 3 4 5 _ _
L 7           R 6

(h)
A 1 2 2 3 4 5 6 _
L 7           R

(i)
A 1 2 2 3 4 5 6 7
L              R

合并过程c代码如下：

void merge(int A[], int p, int q, int r)
{
	int i, j, k;

	int n1 = q - p + 1;
	int n2 = r - q;

	int L[n1];
	int R[n2];

	for (i = 0; i < n1; i++) {
		L[i] = A[p+i];
	}

	for (j = 0; j < n2; j++) {
		R[j] = A[q+1+j];
	}

	i = j = 0;
	for (k = p; i < n1 && j < n2; k++) {
		if (L[i] <= R[j]) {
			A[k] = L[i++];
		} else {
			A[k] = R[j++];
		}
	}

	for (; i < n1; i++, k++) {
		A[k] = L[i];
	}

	for (; j < n2; j++, k++) {
		A[k] = R[j];
	}
}

解释一下上面的代码，变量p, q, r是数组A的下标，p是起始下标，r是结束下标，q是中间下标，相当于q将数组A分成了两个子数组。首先计算出两个子数组的长度为n1和n2，然后创建了两个子数组L和R，表示left和right，两个for循环将数组中A中到数据复制到子数组L和R中，再一个for循环合并数组L和R中的数据到数组A中，最后如果L或R有剩余的数据直接复制到数组A中，这就是整个归并程序的合并过程。

以上只是一个合并过程，下面的MERGE-SORT过程对子数组A[p..r]进行排序，如果p>=r，则说明该子数组中只有一个元素，当然是已排序的，否则分解子数组，直到只有一个元素为止，伪代码如下：

MERGE-SORT(A, p, r)
    if p < r
        then q <-- (p+r) / 2
            MERGE-SORT(A, p, q)
            MERGE-SORT(A, q+1, r)
            MERGE(A, p, q, r)

c代码如下：

void merge_sort(int A[], int p, int r)
{
	int q;

	if (p < r) {
		q = (p + r) / 2;
		merge_sort(A, p, q);
		merge_sort(A, q+1, r);
		merge(A, p, q, r);
	}
}

归并排序可由下图形象表示：
              1 2 2 3 4 5 6 7
                   /            \
        2 4 5 7             1 2 3 6
           /   \                   /   \
     2 5       4 7       1 3       2 6
      /  \        /  \        /  \       /  \
    5    2    4    7    1    3    2    6

归并排序完整代码如下：

#include <stdio.h>

void dump(int a[], int len)
{
	int i;

	for (i = 0; i < len; i++) {
		printf("%3d", a[i]);
	}
	printf("\n");
}

void merge(int A[], int p, int q, int r)
{
	int i, j, k;

	int n1 = q - p + 1;
	int n2 = r - q;

	int L[n1];
	int R[n2];

	for (i = 0; i < n1; i++) {
		L[i] = A[p+i];
	}

	for (j = 0; j < n2; j++) {
		R[j] = A[q+1+j];
	}

	i = j = 0;
	for (k = p; i < n1 && j < n2; k++) {
		if (L[i] <= R[j]) {
			A[k] = L[i++];
		} else {
			A[k] = R[j++];
		}
	}

	for (; i < n1; i++, k++) {
		A[k] = L[i];
	}

	for (; j < n2; j++, k++) {
		A[k] = R[j];
	}
}

void merge_sort(int A[], int p, int r)
{
	int q;

	if (p < r) {
		q = (p + r) / 2;
		merge_sort(A, p, q);
		merge_sort(A, q+1, r);
		merge(A, p, q, r);
	}
}

int main(void)
{
	int a[] = {3, 1, 0, 4, 6, 2, 9, 8, 7, 5};

	int len = sizeof(a) / sizeof(a[0]);

	dump(a, len);

	merge_sort(a, 0, len-1);

	dump(a, len);

	return 0;
}

执行结果为：
  3  1  0  4  6  2  9  8  7  5
  0  1  2  3  4  5  6  7  8  9