归并排序

和分治思想的第一次相遇

当问题的规模是可以划分的时候，分治的算法往往是很有效的：

不断分割问题的规模，直到子问题的规模足够小便直接求解，之后不断整合子问题的解得到更大规模的解，最后得到完整解。

归并排序就是分治算法的一个简单的例子。

可能有人觉得快速排序也是属于分治算法，但我不这么认为，因为快速排序是先得到大问题的解的一部分，再靠子问题来完成解，

并没有整合子问题这一步，所以硬要说的话，快速排序应该是“治分”算法。

简单图示（是不是有点太简单了）

如何分解？

归并排序把问题划分成两个均匀的子问题——左半区间和右半区间，于是得到递归函数：

[cpp] view plaincopy

1. #define HALF(i) (i >> 1) /// i / 2  
2.   
3. /***************************************** 
4.     函数：归并排序 
5.     说明：对区间[low, high)范围的数据排序 
6. *****************************************/  
7. void mergeSort(int* low, int* high)  
8. {  
9.     int range = high - low; ///区间元素个数  
10.     if(range > 1)   ///对于规模为1的子问题本身已经是解了，所以只处理规模大于1的子问题  
11.     {  
12.         int* mid = HALF(range) + low; ///求出分割点  
13.         ///递归求解子问题  
14.         mergeSort(low, mid);  
15.         mergeSort(mid, high);  
16.         ///再合并两个子问题，这个函数待会儿实现  
17.         merge(low, mid, high);  
18.     }  
19. }  

这里是不能应用尾递归优化的，因为节点信息需要保存，以便解决子问题之后再执行merge（合并子问题）过程。

读者可以思考下对于规模为2的问题为什么不会出现无限递归。

怎么合并？

在合并两个子问题时我们知道子问题对应的区间已经是有序的。所以合并子问题就是合并两组有序元素。

所以我们可以通过比较两区间当前的最小值，得到整个区间的最小值，不断选出最小值便可完成合并（类似选择排序，只不过能在O（1）时间确定最小值）。

整个过程的花费是线性的O（n），n为两区间元素个数和。

不过整个过程需要一个辅助数组来存放不断选出的最小值（总不能占别的元素的位置吧），并且为了效率，先一次性声明足够大的辅助数组供所有合并过程使用：

[cpp] view plaincopy

1. #define HALF(i) (i >> 1) /// i / 2  
2.   
3. int* helper;    ///辅助数组  
4.   
5. /********************************************** 
6.     函数：归并函数 
7.     说明：合并有序区间[low, mid)和[mid, high) 
8.     时间复杂度：O(high - low) 
9. **********************************************/  
10. void merge(int* low, int* mid, int* high)  
11. {  
12.     int* left = low, * right = mid; ///left和right分别是左右区间的遍历指针  
13.     while(true)  
14.     {  
15.         if(*left <= *right)  ///相等时下标小的优先，使得算法稳定  
16.         {  
17.             *(helper++) = *(left++);  
18.             if(left >= mid)  ///左区间已经空了  
19.             {  
20.                 while(right < high) *(helper++) = *(right++);    ///把右区间剩下的复制过去  
21.                 break;  ///跳出循环（外层）  
22.             }  
23.         }  
24.         else  
25.         {  
26.             *(helper++) = *(right++);  
27.             if(right >= high) ///右区间空了  
28.             {  
29.                 while(left < mid) *(helper++) = *(left++); ///把左区间剩下的复制过去  
30.                 break;  ///跳出外层循环  
31.             }  
32.         }  
33.     }  
34.     while(high > low) *(--high) = *(--helper);   ///再复制回来  
35. }  
36.   
37. /***************************************** 
38.     函数：归并排序 
39.     说明：对区间[low, high)范围的数据排序 
40.     时间复杂度：O(nlgn) 
41. *****************************************/  
42. void mergeSortRoutine(int* low, int* high)  
43. {  
44.     int range = high - low; ///区间元素个数  
45.     if(range > 1)   ///对于规模为1的子问题本身已经是解了，所以只处理规模大于1的子问题  
46.     {  
47.         int* mid = HALF(range) + low; ///求出分割点  
48.         ///递归求解子问题  
49.         mergeSortRoutine(low, mid);  
50.         mergeSortRoutine(mid, high);  
51.         ///再合并两个子问题  
52.         merge(low, mid, high);  
53.     }  
54. }  
55.   
56. /**************************************** 
57.     函数：归并排序“外壳” 
58. ****************************************/  
59. void mergeSort(int* low, int* high)  
60. {  
61.     helper = new int[high - low];   ///辅助数组最多也就存输入的元素数  
62.     if(helper != nullptr)  
63.     {  
64.         mergeSortRoutine(low, high);  
65.         delete[] helper;    ///释放内存  
66.     }  
67.     else return;    ///空间不足，没法启动归并排序  
68. }  

时间复杂度

上面的归并排序的时间复杂度是很好分析的，最多有lgn层问题，每层均花费O(n)所以是O（nlgn），并且最坏和最好情况都是差不多的，下面是我拍的算法导论上的分析图示：

优化

方案一：使叶子“变粗”

也就是小规模的子问题直接用插入排序来解决，因为插入排序的常数优势使得它面对小规模的数据时是有优势的：

[cpp] view plaincopy

1. #define HALF(i) (i >> 1)    ///i / 2  
2. #define FACTOR 16   ///叶子宽度  
3.   
4. /************************************* 
5.     函数：优化版插入排序 
6.     说明：对区间[low, high)的数据排序 
7.     时间复杂度：O(n + inverse) 
8. *************************************/  
9. void insertionSort(int* low , int* high)  
10. {  
11.     for(int* cur = low; ++cur < high; )     ///实际是从第二个元素开始插入，因为第一个已经有序了  
12.     {  
13.         int tmp = *cur; ///临时保存要插入的值  
14.         int* destPos = cur;     ///记录当前要插入的元素的正确安放位置，这里初始化为本来的位置  
15.         ///把第一次测试单独提出来  
16.         if(*(--destPos) > tmp)  
17.         {  
18.             do  
19.             {  
20.                 *(destPos + 1) = *destPos;  
21.             }while(--destPos >= low && *destPos > tmp);     ///测试上一个是否是目标位置  
22.             *(destPos + 1) = tmp;   ///最后一次测试失败使得destIndex比实际小1  
23.         }  
24.     }  
25. }  
26.   
27. /***************************************** 
28.     函数：归并排序 
29.     说明：对区间[low, high)范围的数据排序 
30.     时间复杂度：O(nlgn) 
31. *****************************************/  
32. void mergeSortRoutine(int* low, int* high)  
33. {  
34.     int range = high - low; ///区间元素个数  
35.     if(range > FACTOR)   ///对于规模小于FACTOR的子问题用插入排序求解  
36.     {  
37.         int* mid = HALF(range) + low; ///求出分割点  
38.         ///递归求解子问题  
39.         mergeSortRoutine(low, mid);  
40.         mergeSortRoutine(mid, high);  
41.         ///再合并两个子问题  
42.         merge(low, mid, high);  
43.     }  
44.     else insertionSort(low, high);  
45. }  

规模的阀值在10左右都不错。

方案二：避免不必要的复制

在原始的归并函数中左右区间的元素都会按大小全部复制到辅助数组中去，之后再一一复制回来。这一过程是没错，不过却没有考虑那些原本就处于正确位置的元素。

比如当左区间空了的时候，此刻右区间剩下的元素还需要再复制到辅助数组中吗？答案是不需要的，因为它们本来就已经在正确位置了。

同理可以应用于左区间原本就处于正确位置的元素。

还有当右区间空了的时候左区间的元素其实是可以直接移到右区间的，于是得到优化代码：

[cpp] view plaincopy

1. /********************************************** 
2.     函数：优化版归并函数 
3.     说明：合并有序区间[low, mid)和[mid, high) 
4.     时间复杂度：O(high - low) 
5. **********************************************/  
6. void merge(int* low, int* mid, int* high)  
7. {  
8.     ///收缩左边界，不再考虑左区间原本位于正确位置的元素  
9.     while(*low <= *mid)  
10.         if(++low >= mid) return;  ///如果左区间的元素全部在正确位置，那么右区间也是如此，直接返回  
11.     int* left = low, * right = mid;     ///left和right分别是左右区间的遍历指针  
12.     *(helper++) = *(right++);   ///别浪费上面循环失败的比较结果。。。  
13.     if(right >= high) ///右区间空了  
14.         while(mid > left) *(--right) = *(--mid); ///把左区间剩下的直接复制到右区间  
15.     else while(true)  
16.         {  
17.             if(*left <= *right)  ///相等时下标小的优先，使得算法稳定  
18.             {  
19.                 *(helper++) = *(left++);  
20.                 if(left >= mid)  break; ///左区间扫描完直接跳出外层循环，此时右区间剩下来的元素本来就处于正确位置  
21.             }  
22.             else  
23.             {  
24.                 *(helper++) = *(right++);  
25.                 if(right >= high) ///右区间空了  
26.                 {  
27.                     while(mid > left) *(--right) = *(--mid); ///把左区间剩下的直接复制到右区间  
28.                     break;  ///跳出外层循环  
29.                 }  
30.             }  
31.         }  
32.     while(right > low) *(--right) = *(--helper);   ///再复制回来，不过要跳过右区间剩下的元素  
33. }  

虽然在最坏情况下和原始的归并函数一样，但是大部分情况还是有优化的，特别是当数组原本有序时，每层只需简单遍历O(n/2)个元素，比快速排序更高效。

计算表明这项优化平均减少O（n）次多余的操作。

方案三：从自顶向下变为自底向上

上面递归版的归并排序的分解步骤是通过划分父问题才得到子问题，但其实子问题是可以被我们直接找到的，因为一个子问题的标识是一个区间，而区间是由左右端点的数字确定的。

所以我们可以直接计算出我们目前想得到的子问题的区间：

[cpp] view plaincopy

1. #define FACTOR 16   ///叶子宽度  
2. #define FIRST_GAP 32    ///第一次步长，为叶子宽度的两倍  
3. #define HALF(i) (i >> 1) ///i / 2  
4. #define NEXT_GAP(i) (i <<= 1)    ///下一个步长  
5. /***************************************************** 
6.     函数：自底向上版归并排序 
7.     说明：对区间[low, high)范围的数据排序 
8.     时间复杂度：O(nlgn) 
9. ******************************************************/  
10. void mergeSortRoutine(int* low, int* high)  
11. {  
12.     int* left, * mid, * right;  ///一个问题区间的标识  
13.     ///先用插入排序优化  
14.     for(left = low, right = low + FACTOR; right < high; left = right, right += FACTOR)  
15.         insertionSort(left, right);  
16.     insertionSort(left, high);  
17.     ///手动计算问题区间  
18.     for(int gap = FIRST_GAP; HALF(gap) < range; NEXT_GAP(gap))  
19.     {  
20.         for(left = low, mid = low + HALF(gap), right = low + gap; right < high; left = right, right += gap, mid += gap)  
21.             merge(left, mid, right);  
22.         if(mid < high) merge(left, mid, high);  
23.     }  
24. }  

最终的方案：完全不用来回复制，换一个角度看数据

为什么非得把临时放在辅助数组里的数据又一一复制回去呢，换一个视角，直接把辅助数组和原数组的角色对换一下不就好了：

[cpp] view plaincopy

1. int* helper;    ///辅助数组  
2.   
3. #define FACTOR 8    ///叶子的宽度  
4. #define BIGER_FACTOR 16     ///更大的叶子宽度  
5. #define HALF(i) (i >> 1) ///i / 2  
6. #define NEXT_GAP(i) (i <<= 1)    ///下一个步长  
7.   
8. /********************************************** 
9.     函数：归并函数 
10.     说明：合并有序区间[low, mid)和[mid, high) 
11.     时间复杂度：O(high - low) 
12. **********************************************/  
13. void merge(int* low, int* mid, int* high)  
14. {  
15.     int* left = low, * right = mid;  
16.     while(true)  
17.     {  
18.         if(*left <= *right)  ///相等时下标小的优先，使得算法稳定  
19.         {  
20.             *(helper++) = *(left++);  
21.             if(left >= mid)  
22.             {  
23.                 while(right < high) *(helper++) = *(right++);  
24.                 break;  
25.             }  
26.         }  
27.         else  
28.         {  
29.             *(helper++) = *(right++);  
30.             if(right >= high) ///右区间空了  
31.             {  
32.                 while(left < mid) *(helper++) = *(left++); ///把左区间剩下的直接复制到右区间  
33.                 break;  ///跳出外层循环  
34.             }  
35.         }  
36.     }  
37.     ///并不复制回去  
38. }  
39.   
40. /************************************* 
41.     函数：优化版插入排序 
42.     说明：对区间[low, high)的数据排序 
43.     时间复杂度：O(n + inverse) 
44. *************************************/  
45. static void insertionSort(int* low , int* high)  
46. {  
47.     for(int* cur = low; ++cur < high; )     ///实际是从第二个元素开始插入，因为第一个已经有序了  
48.     {  
49.         int tmp = *cur; ///临时保存要插入的值  
50.         int* destPos = cur;     ///记录当前要插入的元素的正确安放位置，这里初始化为本来的位置  
51.         ///把第一次测试单独提出来  
52.         if(*(--destPos) > tmp)  
53.         {  
54.             do  
55.             {  
56.                 *(destPos + 1) = *destPos;  
57.             }while(--destPos >= low && *destPos > tmp);     ///测试上一个是否是目标位置  
58.             *(destPos + 1) = tmp;   ///最后一次测试失败使得destIndex比实际小1  
59.         }  
60.     }  
61. }  
62.   
63. /***************************************************** 
64.     函数：自底向上版归并排序 
65.     说明：对区间[low, high)范围的数据排序 
66.           range为数据个数 
67.           [lowOfHelper, highOfHelper)为辅助数组的范围 
68.     时间复杂度：O(nlgn) 
69. ******************************************************/  
70. void mergeSortRoutine(int* low, int* high, int range, int* lowOfHelper, int* highOfHelper)  
71. {  
72.     int* left, * mid, * right;  ///一个问题区间的标识  
73.     int firstGap = 8;  
74.     int layer = 0;  ///看步长8处于问题的第几层  
75.     while(NEXT_GAP(firstGap) < range) layer++;  ///层数加1  
76.     int factor = layer % 2 ? FACTOR : BIGER_FACTOR;     ///选择正确的因子  
77.     ///先用插入排序优化，有两个优化步长8和16看是处于问题的奇数层还是偶数层  
78.     for(left = low, right = low + factor; right < high; left = right, right += factor)  
79.         insertionSort(left, right);  
80.     insertionSort(left, high);  
81.     ///手动计算问题区间  
82.     for(int gap = NEXT_GAP(factor); HALF(gap) < range; NEXT_GAP(gap))  
83.     {  
84.         for(left = low, mid = low + HALF(gap), right = low + gap; right < high; left = right, right += gap, mid += gap)  
85.             merge(left, mid, right);  
86.         if(mid < high) merge(left, mid, high);  
87.         else while(left < high) *(helper++) = *(left++);  
88.         ///交换两数组的标识，“换一个角度”看数组  
89.         swap(low, lowOfHelper);  
90.         swap(high, highOfHelper);  
91.         ///重新设置辅助数组，必须放在最后面，使得最后退出循环时helper指向真正的辅助数组以便释放空间  
92.         helper = lowOfHelper;  
93.     }  
94. }  
95.   
96. /**************************************** 
97.     函数：归并排序“外壳” 
98. ****************************************/  
99. void mergeSort(int* low, int* high)  
100. {  
101.     int range = high - low;  
102.     helper = new int[range];   ///辅助数组最多也就存输入的元素数  
103.     if(helper != nullptr)  
104.     {  
105.         mergeSortRoutine(low, high, range, helper, helper + range);  
106.         delete[] helper;    ///释放内存  
107.     }  
108.     else return;    ///空间不足，没法启动归并排序  
109. }  

这样一来效率是十分接近快速排序的，并且还是稳定排序！不过对空间需求比较大。

来看和快速排序的效率比较：