归并排序(Merge Sort)_mergesort-CSDN博客

本文链接：https://blog.csdn.net/sysu_arui/article/details/7989046

归并排序维基百科：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版）