归并算法

回到我们玩扑克牌的例子，假设桌子上有两对牌面朝上的牌，每堆都已经排好序，最小的牌在最上面。我们希望把这两堆牌合并成单一的排好序的输出堆，牌面朝下的放在桌子上。我们的基本步骤包括在牌面朝上的两堆牌的顶上顶上的两张牌中选取小的一张，将该牌从堆中移开并牌面朝下地将该牌放置到输出堆。重复这个步骤，直到一个输出堆为空，这时，我们呢只是拿起剩余的输入堆并牌面朝下的将该堆放置到输出堆。因为我们只是比较顶上的两张牌，所以计算上每个基本步骤需要常量时间。

    下面的伪代码中，A是一个数组，形式类似于：{2, 4, 5, 7, 1, 2, 3, 6}，可以看出两边都是排好序的。p q r 是数组的下标，并且p<=q<r

     伪代码中我们呢为了避免在每一个基本步骤必须检查是否有堆为空，在每个堆的底部放置一张哨兵牌，它包含了一个特殊的值，用于简化代码。这里，我们使用∞作为哨兵牌。伪代码如下：

	MERGE(A,p,q,r)
	   n1=q-p+1
	   n2=r-q
	   let L[1..n1+1] and R[1..n2+1] be new arrays
	   for i=1 to n1
	       L[i]=A[p+i-1]
	   for j=1 to n2
	   	   R[J]=A[q+j]
	   L[n1+1]=∞
	   R[n2+1]=∞
	   i=1
	   j=1
	   for k=p to r
	       if L[i]<=R[j]
	    		 A[k]=L[i]
	             i=i+1
	       else A[k]=R[j]
	    		j=j+1

附上我的java实现，不好看，但意思一致：

/**
	 * 
	 * @param A
	 *            一个数组 两段分别有序如：24571236
	 * @param p
	 *            起始下标
	 * @param q
	 *            中间下标
	 * @param r
	 *            结束下标
	 */
	public static void merge(int[] A, int p, int q, int r) {
		int n1 = q - p + 1; // 左长度
		int n2 = r - q; // 右长度

		int[] L = new int[n1 + 1];
		int[] R = new int[n2 + 1];

		for (int i = 0; i < n1; i++) {
			L[i] = A[p + i];
		}
		for (int j = 0; j < n2; j++) {
			R[j] = A[q + j + 1];
		}
		L[n1] = Integer.MAX_VALUE;
		R[n2] = Integer.MAX_VALUE;
		int i = 0;
		int j = 0;
		for (int k = p; k <= r; k++) {
			if (L[i] != Integer.MAX_VALUE && R[j] != Integer.MAX_VALUE) {
				if (L[i] >= R[j]) {
					A[k] = R[j];
					j++;
				} else {
					A[k] = L[i];
					i++;
				}
			} else if (L[i] != Integer.MAX_VALUE) {
				A[k] = L[i];
				i++;
			} else if (R[j] != Integer.MAX_VALUE) {
				A[k] = R[j];
				j++;
			} else {
				// 不做处理
			}
		}

	}

那么这里有人会说，你上哪找两边都排好序的队列去，这方法应用范围太小了，事实真的如此吗，我再给一段代码，多了不解释，看懂了你就会了：

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