排序算法（二）-- 归并排序

归并排序

归并排序算法使用分治策略

1. 分治法

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

分治模式在每一层递归上有三个步骤：

• 分解： 将原来问题分解为一系列子问题
• 解决： 递归地解各子问题。若子问题足够小，则直接求解
• 合并： 将子问题合并成原问题的解。 

归并排序算法完全依照了上述模式，直观的操作如下：

• 分解： 将n个元素分成各含n/2个元素的子序列
• 解决： 用合并排序算法对两个子序列递归的排序
• 合并： 合并两个已排序的子序列以得到排序结果。

在对子序列排序时，其长度为一时递归结束。单个元素被认为是排好序的。

合并排序的关键步骤在于合并两个已排序的子序列，引入作为合并的辅助过程 Merge(A,p,q,r), 其中A为数组，p,q,r是下标，满足 p<=q<r, 该过程假设子数组A[p...q]和A[q+1...r]是已经排好序的， 将它们合并成一个已经排好序的子数组代替当前子数组A[p...r].

Merge过程的时间代价为O(n),n=r-p+1是待合并元素的个数。

算法的基本步骤如图：

算法实现的伪代码如图：

通过MergeSort对其排序

其算法实现：

void Merge(int A[], int p, int q, int r)
{
	int n1 = q-p+1;		// 计算子数组A[p .. q]的长度
	int n2 = r-q;		// 计算字数组A[q+1 .. r]的长度

	int* L = new int[n1+1];     // 创建数组L（left）长度为(n1+1)
	int* R = new int[n2+1];		// 创建数组R（right）长度为(n2+1)

	// 将子数组A[p .. q]复制到L[1 .. n1]中去
	for(int i = 0; i < n1; i++)
	{
		L[i] = A[p+i];
	}
	// 将子数组A[q+1 .. r]复制到 R[1 .. n2]中去
	for(int j=0; j < n2; j++)
	{
		R[j] = A[q+j+1];
	}

	//将哨兵置于L和R的末尾
	L[n1] = 1000;
	R[n2] = 1000;

	// 这里要注意，与原书不同，C++的程序数组从[0]开始
	int i = 0;
	int j = 0;

	/* for循环每一轮迭代开始，子数组A[p .. k-1]包含了L[1..n1+1]和
	R[1 .. n2+1]中的k-p个最小的元素。并且是排好序的。此外， L[i]和R[j]
	是各自所在的数组中未被复制回数组A中的最小元素
	*/
	for(int k = p; k <= r; k++)
	{
		if(L[i] <= R[j])
		{
			A[k] = L[i];
			i++;
		}
		else
		{
			A[k] = R[j];
			j++;
		}
	}
}

// 对子数组A[p .. r]排序
/* 注： 排序中数组表示以C++为标准
	调用函数：MergeSort(A ,0,n-1);
*/
void MergeSort(int A[], int p, int r)
{
	/*
	如果p>=r ,则该子数组中至多只有一个元素。则是已经排好序的
	否则，分解步骤计算出一个下标q,将A[p .. r]分成A[p .. q]和
	A[q+1 .. r].
	*/
	int q;
	if(p <r)
	{
		q = (p+r)/2;
		MergeSort(A,p,q);
		MergeSort(A,q+1,r);
		Merge(A,p,q,r);
	}
}

（晕死，代码片不能保存，说含有敏感词汇，这里面那个词比较敏感啊？）

排序结果：

下图给出了n为2的幂时，自底向上的操作。

可以看出，递归排序比插入排序浪费空间。因为要申请一个和排序数组大小相同的数组空间，但是归并排序在性能上是优于插入排序的，它的时间复杂度远低于插入排序。