归并排序

和分治思想的第一次相遇

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

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

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

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

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

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

如何分解？

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

[cpp] view plaincopy

1. #define MID(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 = MID(range) + low; ///求出分割点  
13.         ///递归求解子问题  
14.         mergeSort(low, mid);  
15.         mergeSort(mid, high);  
16.         merge(low, mid, high);   ///再合并两个子问题，这个函数待会儿实现  
17.     }  
18. }  

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

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

怎么合并？

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

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

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

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

[cpp] view plaincopy

1. #define MID(i) (i >> 1) /// i / 2  
2.   
3. int* helper;    ///辅助数组  
4.   
5. /********************************************** 
6.     函数：归并函数 
7.     说明：合并有序区间[low, mid)和[mid, high) 
8.           left为左区间的遍历指针 
9.           right为右区间的遍历指针 
10.           helper为局部变量覆盖全局声明 
11.           这样做是为了减少代码行数 
12.     时间复杂度：O(high - low) 
13. **********************************************/  
14. void merge(int* low, int* mid, int* high, int* left, int* right, int* helper)  
15. {  
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.     while(high > low) *(--high) = *(--helper);   ///再复制回来  
38. }  
39.   
40. /***************************************** 
41.     函数：归并排序 
42.     说明：对区间[low, high)范围的数据排序 
43.     时间复杂度：O(nlgn) 
44. *****************************************/  
45. void mergeSortRoutine(int* low, int* high)  
46. {  
47.     int range = high - low; ///区间元素个数  
48.     if(range > 1)   ///对于规模为1的子问题本身已经是解了，所以只处理规模大于1的子问题  
49.     {  
50.         int* mid = MID(range) + low; ///求出分割点  
51.         ///递归求解子问题  
52.         mergeSortRoutine(low, mid);  
53.         mergeSortRoutine(mid, high);  
54.         merge(low, mid, high, low, mid, helper);   ///再合并两个子问题  
55.     }  
56. }  
57.   
58. /**************************************** 
59.     函数：归并排序“外壳” 
60. ****************************************/  
61. void mergeSort(int* low, int* high)  
62. {  
63.     helper = new int[high - low];   ///辅助数组最多也就存输入的元素数  
64.     if(helper != nullptr)  
65.     {  
66.         mergeSortRoutine(low, high);  
67.         delete[] helper;    ///释放内存  
68.     }  
69.     else return;    ///空间不足，没法启动归并排序  
70. }  

时间复杂度

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

优化

关于归并排序的优化还是挺多的，这里先来讲一种很不错的优化：

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

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

[cpp] view plaincopy

1. /********************************************** 
2.     函数：优化版归并函数 
3.     说明：合并有序区间[low, mid)和[mid, high) 
4.           left为左区间的遍历指针 
5.           right为右区间的遍历指针 
6.           helper为局部变量覆盖全局声明 
7.           这样做是为了减少代码行数 
8.     时间复杂度：O(high - low) 
9. **********************************************/  
10. void merge(int* low, int* mid, int* high, int* left, int* right, int* helper)  
11. {  
12.     while(true)  
13.     {  
14.         if(*left <= *right)  ///相等时下标小的优先，使得算法稳定  
15.         {  
16.             *(helper++) = *(left++);  
17.             if(left >= mid)  break; ///左区间扫描完直接跳出外层循环，此时右区间剩下来的元素本来就处于正确位置  
18.         }  
19.         else  
20.         {  
21.             *(helper++) = *(right++);  
22.             if(right >= high) ///右区间空了  
23.             {  
24.                 while(left < mid) *(helper++) = *(left++); ///把左区间剩下的复制过去  
25.                 break;  ///跳出外层循环  
26.             }  
27.         }  
28.     }  
29.     while(right > low) *(--right) = *(--helper);   ///再复制回来，不过要跳过右区间剩下的元素  
30. }  

这样不仅使代码更加简短，并且在很多时候会使程序加速。

同理可以应用于左区间原本就处于正确位置的元素，最终得到：

[cpp] view plaincopy

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

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

减少的“倒腾”次数的期望

即下面cnt的平均值：

[cpp] view plaincopy

1. int cnt = 0;    ///计数器  
2.   
3. void merge(int* low, int* mid, int* high, int* right, int* helper)  
4. {  
5.     while(*low <= *right)  
6.     {  
7.         cnt++;  ///左边多一个元素不用参与复制  
8.         if(++low >= mid)  
9.         {  
10.             cnt += high - right;    ///右边都不用参加  
11.             return;  
12.         }  
13.     }  
14.     int* left = low;  
15.     *(helper++) = *(right++);  
16.     if(right >= high)  
17.         while(left < mid) *(helper++) = *(left++);  
18.     else while(true)  
19.         {  
20.             if(*left <= *right)  
21.             {  
22.                 *(helper++) = *(left++);  
23.                 if(left >= mid)  
24.                 {  
25.                     cnt += high - right;    ///右边不用参加复制的元素个数  
26.                     break;  
27.                 }  
28.             }  
29.             else  
30.             {  
31.                 *(helper++) = *(right++);  
32.                 if(right >= high)  
33.                 {  
34.                     while(left < mid) *(helper++) = *(left++);  
35.                     break;  
36.                 }  
37.             }  
38.         }  
39.     while(right > low) *(--right) = *(--helper);   ///再复制回来，不过要跳过右区间剩下的元素  
40. }  

当左右区间元素个数均为 k/2时，左区间不用参与复制的元素个数为 i 的条件为前 i 小的元素都被分在了左边，并且第 i + 1大元素被分在了右边，但第k/2大元素要单独考虑。

右边不用参与复制的元素个数和左区间是一样的，因为是对称的。于是得到下面的级数：

下面是我的测试数据（元素互异且随机排列）：

可以看出这项优化平均减少O（n）次多余的操作。

使叶子“变粗”

同样归并排序也可以用插入排序来优化，同样也是因为对于小规模的数据插入排序常数小的缘故。并且由于引进插入排序我们知道叶子宽度一定大于1，因此可以简化归并函数：

[cpp] view plaincopy

1. #define FACTOR 10    ///叶子宽度  
2. #define MID(i) (i >> 1) /// i / 2  
3.   
4. int* helper;    ///辅助数组  
5.   
6. /********************************************** 
7.     函数：优化版归并函数 
8.     说明：合并有序区间[low, mid)和[mid, high) 
9.           right为右区间的遍历指针 
10.           helper为局部变量覆盖全局声明 
11.           这样做是为了减少代码行数 
12.     时间复杂度：O(high - low) 
13. **********************************************/  
14. void merge(int* low, int* mid, int* high, int* right, int* helper)  
15. {  
16.     ///收缩左边界，不再考虑左区间原本位于正确位置的元素  
17.     while(*low <= *right)  
18.     {  
19.         if(++low >= mid)  
20.             return;  ///如果左区间的元素全部在正确位置，那么右区间也是如此，直接返回  
21.     }  
22.     int* left = low;    ///设置左区间遍历指针  
23.     *(helper++) = *(right++);   ///别浪费上面循环失败的比较结果。。。  
24.     ///因为叶子大于1，所以之前那两句就不用了。  
25.     while(true)  
26.     {  
27.         if(*left <= *right)  ///相等时下标小的优先，使得算法稳定  
28.         {  
29.             *(helper++) = *(left++);  
30.             if(left >= mid) break; ///左区间扫描完直接跳出外层循环，此时右区间剩下来的元素本来就处于正确位置  
31.         }  
32.         else  
33.         {  
34.             *(helper++) = *(right++);  
35.             if(right >= high) ///右区间空了  
36.             {  
37.                 while(left < mid) *(helper++) = *(left++); ///把左区间剩下的复制过去  
38.                 break;  ///跳出外层循环  
39.             }  
40.         }  
41.     }  
42.     while(right > low) *(--right) = *(--helper);   ///再复制回来，不过要跳过右区间剩下的元素  
43. }  
44.   
45. /************************************* 
46.     函数：优化版插入排序 
47.     说明：对区间[low, high)的数据排序 
48.     时间复杂度：O(n + inverse) 
49. *************************************/  
50. static void improvedInsertionSort(int* low , int* high)  
51. {  
52.     for(int* cur = low; ++cur < high; )     ///实际是从第二个元素开始插入，因为第一个已经有序了  
53.     {  
54.         int tmp = *cur; ///临时保存要插入的值  
55.         int* destPos = cur;     ///记录当前要插入的元素的正确安放位置，这里初始化为本来的位置  
56.         ///把第一次测试单独提出来  
57.         if(*(--destPos) > tmp)  
58.         {  
59.             do  
60.             {  
61.                 *(destPos + 1) = *destPos;  
62.             }while(--destPos >= low && *destPos > tmp);     ///测试上一个是否是目标位置  
63.             *(destPos + 1) = tmp;   ///最后一次测试失败使得destIndex比实际小1  
64.         }  
65.     }  
66. }  
67.   
68. /***************************************** 
69.     函数：归并排序 
70.     说明：对区间[low, high)范围的数据排序 
71.     时间复杂度：O(nlgn) 
72. *****************************************/  
73. void mergeSortRoutine(int* low, int* high)  
74. {  
75.     int range = high - low; ///区间元素个数  
76.     if(range > FACTOR)   ///对于规模为1的子问题本身已经是解了，所以只处理规模大于1的子问题  
77.     {  
78.         int* mid = MID(range) + low; ///求出分割点  
79.         ///递归求解子问题  
80.         mergeSortRoutine(low, mid);  
81.         mergeSortRoutine(mid, high);  
82.         merge(low, mid, high, mid, helper);   ///再合并两个子问题  
83.     }  
84.     else improvedInsertionSort(low, high);  
85. }  
86.   
87. /**************************************** 
88.     函数：归并排序“外壳” 
89. ****************************************/  
90. void mergeSort(int* low, int* high)  
91. {  
92.     helper = new int[high - low];   ///辅助数组最多也就存输入的元素数  
93.     if(helper != nullptr)  
94.     {  
95.         mergeSortRoutine(low, high);  
96.         delete[] helper;    ///释放内存  
97.     }  
98.     else return;    ///空间不足，没法启动归并排序  
99. }  

自底向上的归并排序

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

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

[cpp] view plaincopy

1. #define MID(i) (i >> 1) /// i / 2  
2. #define NEXT_GAP(i) (i <<= 1)    ///下一个步长  
3.   
4. int* helper;    ///辅助数组  
5.   
6. /********************************************** 
7.     函数：优化版归并函数 
8.     说明：合并有序区间[low, mid)和[mid, high) 
9.           right为右区间的遍历指针 
10.           helper为局部变量覆盖全局声明 
11.           这样做是为了减少代码行数 
12.     时间复杂度：O(high - low) 
13. **********************************************/  
14. void merge(int* low, int* mid, int* high, int* right, int* helper)  
15. {  
16.     ///收缩左边界，不再考虑左区间原本位于正确位置的元素  
17.     while(*low <= *right)  if(++low >= mid)  return;  ///如果左区间的元素全部在正确位置，那么右区间也是如此，直接返回  
18.     int* left = low;    ///设置左区间遍历指针  
19.     *(helper++) = *(right++);   ///别浪费上面循环失败的比较结果。。。  
20.     if(right >= high) ///右区间空了  
21.         while(left < mid) *(helper++) = *(left++); ///把左区间剩下的复制过去  
22.     else while(true)  
23.         {  
24.             if(*left <= *right)  ///相等时下标小的优先，使得算法稳定  
25.             {  
26.                 *(helper++) = *(left++);  
27.                 if(left >= mid) break; ///左区间扫描完直接跳出外层循环，此时右区间剩下来的元素本来就处于正确位置  
28.             }  
29.             else  
30.             {  
31.                 *(helper++) = *(right++);  
32.                 if(right >= high) ///右区间空了  
33.                 {  
34.                     while(left < mid) *(helper++) = *(left++); ///把左区间剩下的复制过去  
35.                     break;  ///跳出外层循环  
36.                 }  
37.             }  
38.         }  
39.     while(right > low) *(--right) = *(--helper);   ///再复制回来，不过要跳过右区间剩下的元素  
40. }  
41.   
42. /************************************************ 
43.     函数：自底向上版归并排序 
44.     说明：对区间[low, low + range)范围的数据排序 
45.     时间复杂度：O(nlgn) 
46. ************************************************/  
47. void mergeSortRoutine(int* low, int* high, int range)  
48. {  
49.     for(int gap = 2; MID(gap) < range; NEXT_GAP(gap))  
50.         for(int* right = low + gap, * mid = low + MID(gap); mid < high; right += gap, mid += gap)  
51.             merge(right - gap, mid, right > high ? high : right, mid, helper);  
52. }  
53.   
54. /**************************************** 
55.     函数：归并排序“外壳” 
56. ****************************************/  
57. void mergeSort(int* low, int* high)  
58. {  
59.     helper = new int[high - low];   ///辅助数组最多也就存输入的元素数  
60.     if(helper != nullptr)  
61.     {  
62.         mergeSortRoutine(low, high, high - low);  
63.         delete[] helper;    ///释放内存  
64.     }  
65.     else return;    ///空间不足，没法启动归并排序  
66. }  

不过不知道为什么在我电脑上递归版反而更快，真是奇怪。

后记

如果内容有误或有什么提议请在下面评论，谢谢。