浅入浅出数据结构（21）——合并排序

　　在讲解合并排序以前，咱们先来想想下面这个问题如何解决：

　　有两个数组A和B，它们都已各自按照从小到大的顺序排好了数据，如今咱们要把它们合并为一个数组C，且要求C也是按从小到大的顺序排好，请问该怎么作？

　　这个问题很是容易解决，咱们将A、B和C都视为队列，而后不断比较A和B的首部，取出其中更小的数据出队，而后将该数据插入队列C，若A或B有一方为空了，则将另外一方数据顺序出队再插入C便可：

int i=0,j=0,z=0;
while(i<a_size && j<b_size)
{
    if(a[i]<b[j])
       c[z++]=a[i++];
    else
       c[z++]=b[j++];
}
while(i<a_size)
    c[z++]=a[i++];
while(j<b_size)
    c[z++]=b[j++];

　　显然，上述问题的解决很是简单，时间复杂度为O(N)，N为总数据量。也就是说，若是咱们有两个已排好序的数组，那么咱们就能够快速地将它们合并起来，而这，就是合并排序的根本思想。

　　回顾快速排序，能够看出快速排序的作法其实就是：选取枢纽，将小于枢纽的元素组成一个子数组，大于枢纽的元素组成一个子数组，只要这两个子数组排好序，整个数组就能排好序，至于两个子数组怎么排好序，递归实现。

　　合并排序的作法与快速排序有些相似，只是“过程”反了过来：将原数组对半分为两个子数组，只要这两个子数组排好序，我就能将它们经过合并（上述问题的解法）来获得有序的原数组，至于怎么获得两个排好序的子数组，递归实现。

　　用伪代码来表示合并排序的过程，就是这样：

void MergeSort(int *src,unsigned int left,unsigned int right)
{
   if(left<right)
   {
     /*将原数组一分为二*/
     unsigned int center= (left+right)/2;
     /*经过递归实现子数组的排序*/
     MergeSort(src,0,center);
     MergeSort(src,center+1,right);

     /*伪代码：将子数组合并*/
   }
}

　　有了伪代码后，剩下的工做就是将伪代码中的“空”填上去。

　　上述伪代码有两个“空”，一个是实现递归的基准情形，这个“空”很好填，由于根本不用填，为何呢？由于只要数组大小大于1，咱们就一直划分下去，那么最终划分获得的子数组将会只有1个数据，此时这个子数组必为“有序”，也就是说递归的基准情形必然存在。

　　另外一个“空”则是实现子数组的合并，这个“空”咱们能够参考本文一开始提出的问题的解法，可是该解法须要用到一个额外的数组C，且最终的有序数据都放进了C里面，该怎么办呢？思路很简单也很直接，那就是：既然你要一个额外数组，那我就给你一个额外数组tempArr，有序数据在tempArr里面，而我但愿它们在原数组里面，那我就将tempArr里的数据复制回来：

        /*将子数组合并到tempArr*/

        unsigned int i=left,j=center+1,z=left; //注意，i,j,z的初始化和范围都要有所变化
        while(i<=center&&j<=right)
        {
            if(src[i]<src[j])
                tempArr[z++]=src[i++];
            else
                tempArr[z++]=src[j++];
        }
        while(i<=center)
            tempArr[z++]=src[i++];
        while(j<=right)
            tempArr[z++]=src[j++];
        
        /*将tempArr的数据拷贝到原数组中*/
        for (z = left;z <= right;++z)
            src[z] = tempArr[z];

 

 

 　　将上面的代码填入到伪代码中，并将伪代码的参数稍加修改，便有了以下合并排序：

void MSort(int *src, int *tempArr, unsigned int left, unsigned int right)
{
    if (left < right)
    {
        /*将原数组一分为二*/
        unsigned int center = (left + right) / 2;
        
        /*递归实现子数组排序*/
        MSort(src, tempArr, left, center);
        MSort(src, tempArr, center + 1, right);
        
        /*将子数组合并到tempArr*/
        unsigned int i=left,j=center+1,z=left;
        while(i<=center&&j<=right)
        {
            if(src[i]<src[j])
                tempArr[z++]=src[i++];
            else
                tempArr[z++]=src[j++];
        }
        while(i<=center)
            tempArr[z++]=src[i++];
        while(j<=right)
            tempArr[z++]=src[j++];
        
        /*将tempArr的数据拷贝到原数组中*/
        for (int i = left;i <= right;++i)
            src[i] = tempArr[i];
    }
}

　　为了方便调用，咱们再实现一个小接口：

void MergeSort(int *src, unsigned int size)
{
    int *tempArr = (int *)malloc(sizeof(int)*size);
    MSort(src, tempArr, 0, size - 1);
    free(tempArr);
}

　　

　　至此，合并排序就实现完毕了，其占用的空间显然比快速排序等算法要多出一倍，那么其时间复杂度如何呢？咱们就来简单的算算看。

　　首先，咱们假设进行合并排序的数组大小为N且为2的幂，T(N)表示对其排序耗费的时间，那么就有：

　　1.T(1)=1

　　2.T(N)=2*T(N/2)+2N（两个N分别为合并耗费时间和拷贝回原数组所耗费的时间）

　　将2式左右除以N，得：

　　T(N)/N=T(N/2)/(N/2)+2

　　递推该式，得：

　　T(N/2)/(N/2)=T(N/4)/(N/4)+2

　　T(N/4)/(N/4)=T(N/8)/(N/8)+2

　　……
　　T(2)/2=T(1)/1+2

　　将上述全部式子左侧相加且右侧相加，得：

　　T(N)/N+T(N/2)/(N/2)+T(N/4)/(N/4)+……+T(2)/2=T(N/2)/(N/2)+T(N/4)/(N/4)+……+T(1)/1+2*logN

　　化简，得：

　　T(N)/N=T(1)/1+2*logN，即T(N)=N+2*N*logN=O(N*logN)

　　这个时间复杂度与快速排序的平均时间复杂度相同，比快速排序的最坏状况要好得多，可是在实际应用中快速排序要比合并排序优先考虑，缘由在于合并排序须要更多的内存空间，而且从tempArr拷贝数据回原数组也是一项花费巨大的工做。