在讲解合并排序之前，我们先来想一想下面这个问题如何解决：
有两个数组A和B，它们都已各自按照从小到大的顺序排好了数据，现在我们要把它们合并为一个数组C，且要求C也是按从小到大的顺序排好，请问该怎么做？
这个问题非常容易解决，我们将A、B和C都视为队列，然后不断比较A和B的首部，取出其中更小的数据出队，然后将该数据插入队列C，若A或B有一方为空了，则将另一方数据顺序出队再插入C即可：
int i=,j=,z=;
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)/;
/*通过递归实现子数组的排序*/
MergeSort(src,,center);
MergeSort(src,center+,right);
/*伪代码：将子数组合并*/
}
}
有了伪代码后，剩下的工作就是将伪代码中的“空”填上去。
上述伪代码有两个“空”，一个是实现递归的基准情形，这个“空”很好填，因为根本不用填，为什么呢？因为只要数组大小大于1，我们就一直划分下去，那么最终划分得到的子数组将会只有1个数据，此时这个子数组必为“有序”，也就是说递归的基准情形必然存在。
另一个“空”则是实现子数组的合并，这个“空”我们可以参考本文一开始提出的问题的解法，但是该解法需要用到一个额外的数组C，且最终的有序数据都放进了C里面，该怎么办呢？思路很简单也很直接，那就是：既然你要一个额外数组，那我就给你一个额外数组tempArr，有序数据在tempArr里面，而我希望它们在原数组里面，那我就将tempArr里的数据复制回来：
/*将子数组合并到tempArr*/
unsigned int i=left,j=center+,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) / ; /*递归实现子数组排序*/
MSort(src, tempArr, left, center);
MSort(src, tempArr, center + , right); /*将子数组合并到tempArr*/
unsigned int i=left,j=center+,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, , size - );
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拷贝数据回原数组也是一项花费巨大的工作。