归并排序维基百科：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[n];
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[n];
b = new int[n];//辅助空间
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[n];
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版）
