算法之归并排序

归并排序是分治法（divide-and-conquer）的经典案例。

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

分解（Divide）：将原问题分解成一系列子问题；

解决（Conquer）：递归地解各子问题。若子问题足够小，则直接求解；

合并（Combine）：将子问题的结果合并成原问题的解。

归并排序（merge-sort）算法完全依照了上述模式，具体的操作细节如下图：

合并的程序伪代码如下：

其中A表示待排序的数组，两个待合并的区间L和R分别为[p,q]和[q+1,r]

L[n1+1] = INT_MAX和R[n2+1] = INT_MAX是为了设置“哨兵”表示算法边界

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] = INT_MAX
     R[n2+1] = INT_MAX
     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

比如对数组（4,5,7,8,1,2,3,6）进行归并排序，其MERGE过程如下图所示：

（注：上图来自http://www.cnblogs.com/chengxiao/p/6194356.html）

完整的归并排序调用MERGE子程序
MERGE-SORT(A,p,r)
  if p < r
     q=floor((p+r)/2)
     MERGE-SORT(A,p,q)
     MERGE-SORT(A,q+1，r)
     MERGE(A,p,q,r)

C++代码如下：

同时，MERGE过程已被改写，不再使用哨兵元素，而是在一旦数组L或R中的所有元素都被赋值回数组A后，就立刻停止，再将另一个数组中余下的元素复制回数组A中。

#include<iostream>
#include<stdlib.h>
using namespace std;

void merge(int a[],int begin,int mid,int end){
	int *result=(int *)malloc((end-begin+1)*sizeof(int));//中间数组用于存储归并序列 
	int i=begin;//第一个子区间是[begin,mid] 
	int j=mid+1;//第二个子区间是[mid+1,end] 
	int k=0;//中间数组同步下标 
	while(i<=mid && j<=end){
		if(a[i]<=a[j]){
			result[k++]=a[i++];
		}
		else{
			result[k++]=a[j++];
		}
	}
	
	while(i<=mid){
		result[k++]=a[i++];
	}
	
	while(j<=end){
		result[k++]=a[j++];
	}
	
	for(i=0;i<k;i++){//中间数组向原数组赋值 
		a[begin+i]=result[i];
	}
	
	free(result);
} 

//从小到大排序
void MergeSort_up(int a[],int begin,int end){
	if(a==NULL || begin>=end ) return;//一定要=号表示边界条件 
	int mid=(begin+end)/2;
	MergeSort_up(a,begin,mid);//先递归分区间 
	MergeSort_up(a,mid+1,end);
	merge(a,begin,mid,end);//再合并排序 
}

        尽管合并排序的最坏情况运行时间为O(nlgn)，插入排序的最坏情况运行时间为O(n²)，但插入排序中的常数因子使得它在n较小时，运行得要快一些。因此，在合并排序算法中，当子问题足够小时，采用插入排序就比较合适了。

void MergeSort_insertion(int *a, int p, int r)
{
	if ((r-p)>=50) // 小于50个数据的数组进行插入排序
	{
		int q = (p+r)/2;
		MergeSort_insertion(a, p, q);
		MergeSort_insertion(a, q+1, r);
		merge(a, p, q, r);
	}else
	{
		InsertionSort(a+p, r-p+1);
	}
}

其中MergeSort_insertion和原MergeSort_up的算法运行时间比较为：

（注：上述数据来自https://blog.csdn.net/left_la/article/details/8656953）