归并排序(Merge Sort)

归并排序维基百科：http://zh.wikipedia.org/wiki/归并排序

归并排序（Merge Sort，又称合并排序）是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。

归并操作(merge)，也叫归并算法，指的是将两个已经排序的序列合并成一个序列的操作。归并排序算法依赖归并操作。

1、递归算法

算法思想：

把待排序序列分成两段，然后对两段各自进行归并排序，最后把这两段的排序结果组合在一起。

(1)递归实现1

#include <cstdlib>
#include <iostream>

using namespace std;

/*
递归算法
对a[left,right]进行归并排序
*/
template<class T>
void mergeSort(T* a, int left, int right)
{
if(left < right)
{
int mid = (left + right)/2; //devide
mergeSort(a,left,mid);      //conquer
mergeSort(a,mid+1,right);   //conquer
merge(a,left,mid,right);    //combine
}
}

/*
将有序段a[left,mid]和a[mid+1,right]合并为升序
*/
template<class T>
void merge(T* a, int left, int mid, int right)
{
int len1 = mid - left + 1;
int len2 = right - mid;

T* b = new T[len1];
T* c = new T[len2];
//copy
for(int i=0; i<len1; i++)
{
b[i] = a[left + i];
}
for(int j=0; j<len2; j++)
{
c[j] = a[mid + j + 1];
}
int i = 0;
int j = 0;
int k = left;
while(i < len1 && j < len2)
{
if(b[i] <= c[j])
{
a[k++] = b[i++];
}
else
{
a[k++] = c[j++];
}
}
while(i < len1)
{
a[k++] = b[i++];
}
while(j < len2)
{
a[k++] = c[j++];
}
delete[] b;
delete[] c;
}

int main(int argc, char *argv[])
{
int n;
int* a = NULL;

while(cin>>n && n>0)
{
a = new int
;
for(int i=0; i<n; i++)
{
cin>>a[i];
}
mergeSort(a,0,n-1);
for(int i=0; i<n; i++)
{
cout<<a[i]<<" ";
}
cout<<endl<<endl;
delete [] a;
}

system("PAUSE");
return EXIT_SUCCESS;
}

该递归算法实现中，merge()函数里面空间复杂度为O(n)，虽然单次递归调用所需的最大辅助空间为O(n)，但是有lgn层递归调用。所以该算法的空间复杂度为O(nlgn)。下面给出的第2种递归实现，做了一点改善，算法空间复杂度为O(n)。

(2)递归实现2

#include <cstdlib>
#include <cstdio>
#include <iostream>

using namespace std;

/*
递归算法
对a[left,right]进行归并排序
*/
template<class T>
void mergeSort(T* a, T* b, int low, int high)
{
if(low < high)
{
int mid = (low + high)/2;		//devide
mergeSort(a, b, low, mid);		//conquer
mergeSort(a, b, mid+1, high);	//conquer
merge(a, b, low, mid, high);  	//combine
}
}

/*
将有序段a[low,mid]和a[mid+1,high]合并为升序
b[]为辅助数组
*/
template<class T>
void merge(T* a, T* b, int low, int mid, int high)
{
memcpy(b + low, a + low, (high - low + 1)*sizeof(T));
int i,j,k;

for(i=low, j=mid+1, k=low; i <= mid && j <= high; k++)
{
if(b[i] <= b[j])
{
a[k] = b[i++];
}
else
{
a[k] = b[j++];
}
}
while(i <= mid)
{
a[k++] = b[i++];
}
while(j <= high)
{
a[k++] = b[j++];
}
}

int main(int argc, char *argv[])
{
int n;
int* a = NULL;
int* b = NULL;

while(cin>>n && n>0)
{
a = new int
;
b = new int
;//辅助空间
for(int i=0; i<n; i++)
{
cin>>a[i];
}
mergeSort(a, b, 0, n-1);
for(int i=0; i<n; i++)
{
cout<<a[i]<<" ";
}
cout<<endl<<endl;
delete [] a;
delete [] b;
}

system("PAUSE");
return EXIT_SUCCESS;
}

2、迭代算法



根据递归算法，我们很容易把代码改为非递归，只需根据归并段的大小逐段进行归并，实现如下。

#include <cstdlib>
#include <iostream>

using namespace std;

/*将有序段a[low,mid]和a[mid+1,high]合并为升序
*存入数组b
*/
template<class T>
void merge(T* a, T* b, int low, int mid, int high)
{
int beg1 = low;
int end1 = mid;
int beg2 = mid + 1;
int end2 = high;
int k = low;

while(beg1 <= end1 && beg2 <= end2)
{
if(a[beg1] <= a[beg2])
{
b[k++] = a[beg1++];
}
else
{
b[k++] = a[beg2++];
}
}
if(beg1 <= end1)
{
for(int i=beg1; i<=end1; i++)
{
b[k++] = a[i];
}
}
else
{
for(int i=beg2; i<=end2; i++)
{
b[k++] = a[i];
}
}
}

/*将数组a分段两两归并
*a为数组首地址，size为数组大小
seg为段的大小 ，初始值为1
b[]为临时数组
*/
template<class T>
void mergePass(T* a, T* b, int seg, int size)
{
int seg_start = 0;
while(seg_start <= size - 2*seg)//注意临界点
{
merge(a, b, seg_start, seg_start + seg - 1, seg_start + 2*seg - 1);
seg_start += 2*seg;		//下一个归并段的起始位置
}
//剩余长度小于两个归并段长度，但大于一个归并段长度
if(seg_start + seg < size)
{
merge(a, b, seg_start, seg_start + seg - 1, size - 1);
}
else//剩余长度小于等于一个归并段长度
{
for(int i=seg_start; i<size; i++)
{
b[i] = a[i];
}
}
}

/*迭代算法
*将数组a归并排序
*a为数组首地址，size为数组大小
*/
template<class T>
void mergeSort(T* a, int size)
{
int seg = 1;//归并段的初始长度为1
T* temp = new T[size];
while(seg < size)
{
mergePass(a, temp, seg, size);
seg += seg;//归并段增大1倍
mergePass(temp, a, seg, size);
seg += seg;//归并段增大1倍
}
delete [] temp;
}

int main(int argc, char *argv[])
{
int n;
int* a = NULL;

while(cin>>n && n>0)
{
a = new int
;
for(int i=0; i<n; i++)
{
cin>>a[i];
}
mergeSort(a,n);
for(int i=0; i<n; i++)
{
cout<<a[i]<<" ";
}
cout<<endl<<endl;
delete [] a;
}

system("PAUSE");
return EXIT_SUCCESS;
}

3、测试用例

测试用例：(input中一行为一个test case，行首元素为该tese case 中所含元素)

input:

3 3 2 1

10 1 3 7 8 20 12 19 80 34 5

output:

1 2 3

1 3 5 7 8 12 19 20 34 80

4、算法复杂度分析

(1)对于输入规模为n，归并两个子序列的函数merge()的复杂度为Θ(n)

(2)算法递归式为:T(n) = 2T(n/2)+cn (n>1)

(3)构造递归树，得递归树的深度为lgn

(4)递归树每一层的复杂度为cn,算法总的复杂度为cnlgn即Θ(nlgn)
参考资料：

[1]算法导论（第2版）

[2]王晓东 计算机算法设计与分析（第3版）