[Alg]排序算法之归并排序

[Alg]排序算法之归并排序

作者：屎壳郎 miaosg01@163.com

日期：Aug 2021

版次：初版

---

简介： 归并排序是一类在任何情况下都能保证$N\lg (N)$的排序算法，它在数据量比较小时体现的不明显，但在大数据量时优势明显。归并排序在外部排序中尤其重要，由于受到外部存储条件的限制，归并排序几乎是唯一选择。

1、两路归并

设有两个有序的序列1 4 6 8与2 3 5 7，我们比较头部两个较小的项，然后输出最小者，然后重复这个步骤直到两个序列都清空。
$$|\genfrac{}{}{0ex}{}{\underline{1}}{\underline{2}}\genfrac{}{}{0ex}{}{4}{3}\genfrac{}{}{0ex}{}{6}{5}\genfrac{}{}{0ex}{}{8}{7}$$
$$1|\genfrac{}{}{0ex}{}{\underline{4}}{\underline{2}}\genfrac{}{}{0ex}{}{6}{3}\genfrac{}{}{0ex}{}{8}{5}\genfrac{}{}{0ex}{}{}{7}$$
$$12|\genfrac{}{}{0ex}{}{\underline{4}}{\underline{3}}\genfrac{}{}{0ex}{}{6}{5}\genfrac{}{}{0ex}{}{8}{7}$$

当有一个序列耗尽时，需要特别处理，详细算法描述如下：

算法 M：（两路归并）

两个非空的已排好序的序列$x_1\le x_2\le \cdots \le x_m$和$y_1\le y_2\le \cdots \le y_n$ 归并为一个有序序列$(z_1\le z_2\le \cdots \le z_{m+n})$。

• M1.[初始化] 置$i\leftarrow 1$，$j\leftarrow 1$，$k\leftarrow 1$。
• M2.[比较] 如果$x_i\le y_j$，转至M3，否则转至M5。
• M3.[输出$x_i$] 置$z_k\leftarrow x_i$，$k\leftarrow k+1$，$i\leftarrow i+1$。如果$i\le m$，返回M2。
• M4.[整体输出$y_j,\dots ,y_n$] 置$(z_k,\dots ,z_{m+n})\leftarrow (y_j,\dots ,y_n)$。
• M5.[输出$y_j$] 置$z_k\leftarrow y_j$，$k\leftarrow k+1$，$j\leftarrow j+1$。如果$j\le n$，返回M2。
• M6.[整体输出$x_i,\dots ,x_m$] 置$(z_k,\dots ,z_{m+n})\leftarrow (x_i,\dots ,x_m)$，并结束。

为使得代码更加简洁，我们可以设置$x_{m+1}\leftarrow \infty$，$ y_{n+1}\gets\infty$，这样我们就不用特别处理一个序列先耗尽的情况。在《[Alg]排序算法之插入排序》介绍直接插入排序算法时，为了提高效率，介绍了一种一次插入两个或更多项的改进措施，其实这就是归并排序的思想。同样，如果只归并一个数据项，也就是插入排序了，可以把它看作是归并排序的一个特例。

上面这个算法在$m\approx n$时是相当高效的，但是当$m>>n$或$m<<n$时，就要进行大量冗余的比较，使得算法性能相当低下。下面介绍一个专门应对这种情况的算法。

考虑$A(2,9)$与$B(1,3,4,5,6,7,8,10,11,12)$归并，$m=2<<n=10$的情况，归并结果放入$C$中。假设 $A$在$B$中的分布是均匀一致的，那$A$中的两个数$(2,9)$应该把$B$分成三段，那插入位置就是$B$的$\frac{1}{3}$和$\frac{2}{3}$的位置，那我们就选取这些位置作为起点来确定比较的基点是合理的。这有点类似于shell排序和Batcher排序，增大插入和交换的跨度，我们在这采用的方法更优秀，第一，确定最合理的比较基点，第二，并以此基点圈定范围采用二叉搜索加速进度。采用如下方法确定位置:

$t\leftarrow \lfloor \lg (n/m)\rfloor =2$，则第一个比较基点即为$n+1-2^t=10+1-4=7$即$B_7=8<9$，然后用二叉法在 { B 7 , B 8 , B 9 , B 10 } \{B_7,B_8,B_9,B_{10}\} {B7​,B8​,B9​,B10​}中确定位置，输出$C(-,-,-,-,-,-,-,8,9,10,11,12)$。

剩余$A(2)$与$B(1,3,4,5,6,7,8)$归并：$t\leftarrow \lfloor \lg (7/1)\rfloor =2$，确定位置$n+1-2^t=7+1-4=4$，$B_4=5>2$，输出 { B 4 , B 5 , B 6 , B 7 } \{B_4,B_5,B_6,B_7\} {B4​,B5​,B6​,B7​}至$C(-,-,-,-,5,6,7,8,9,10,11,12)$。

剩余$A(2)$与$B(1,3,4)$归并：$t\leftarrow \lfloor \lg (3/1)\rfloor =1$，确定位置$3+1-2=2$，$B_2=3>2$，输出 { B 2 , B 3 } \{B_2,B_3\} {B2​,B3​}至$C(-,-,3,4,5,6,7,8,9,10,11,12)$。

至此只剩$A(2)$，$B(1)$，$t\leftarrow 0$，唯一选择$n+1-2^0=1+1-1=1$归并。

总结算法如下：

算法H：（二叉归并）

设两个有序序列$A_1,\dots ,A_m$，$B_1,\dots ,B_n$。

• H1.[初始化] 如果$m$或$n$为0，结束；否则，如果$m>n$，置$t\leftarrow \lfloor \lg (m/n)\rfloor$ 并跳转至H4。如果$n>m$，置$t\leftarrow \lfloor \lg (n/m)\rfloor$。
• H2.[比较$A_m:B_{n+1-2^t}$] 如果$A_m<B_{n+1-2^t}$，输出$(B_{n+1-2^t},\dots ,B_n)$，置$n\leftarrow n-2^t$，并返回H1。
• H3.[二叉查找]应用二叉查找$(B_{n+1-2^t},\dots ,B_n)$，确定$k$为满足$B_k<A_m$条件的最大值，则输出$B_{k+1},\dots B_n$和$A_m$，并置$m\leftarrow m-1$，$n\leftarrow k$。返回H1。
• H4.[比较$B_n:A_{m+1-2^t}$] (H4和H5与H2 H3执行的操作一样，只是交换了$m$、$n$的角色）如果$B_n<A_{m+1-2^t}$，输出$(A_{m+1-2^t},\dots ,A_m)$，置$m\leftarrow m-2^t$，并返回H1。
• H5.[二叉查找]应用二叉查找$(A_{m+1-2^t},\dots ,A_m)$，确定$k$为满足$A_k<B_n$条件的最大值，则输出$A_{k+1},\dots A_m$和$B_n$，并置$n\leftarrow n-1$，$m\leftarrow k$。返回H1。

这个算法对m（假设$m<<n$）均匀分布一致分布在$m+n$中的情况特别高效。它融合了二叉和归并两方面的优势。

2、自然分段的两路归并排序

上面讲了归并两个序列，要求序列在归并前就排好序，下面讲解利用归并思想进行排序。自然分段的归并排序就是利用序列自然形成的上升段和下降段归并，采用上面提到的归并方法形成更大的升段和降段，并最终完成排序。

采用两头点蜡的方法，从左端取升段从右侧取降段进行一次归并，并把结果放置到另外的$N$空间，我们给它起个名字DEST，后面好进行描述，原来的空间命名为ORIG。
$$ORIG\underrightarrow{59}|\underrightarrow{18}|2|\overleftarrow{64}|\overleftarrow{73}$$

首先归并左侧$59$与右侧的$73$，输出空间为：
$$DEST\underrightarrow{3579}|-----$$

接着归并左侧$18$与右侧$64$，输出空间为：
$$DEST\underrightarrow{3579}|-|\overleftarrow{8641}$$

最后归并$2$:
$$DEST\underrightarrow{3579}|2|\overleftarrow{8641}$$

然后进行空间反转，从DEST向ORIG归并输出：
$$ORIG\underrightarrow{13456789}|\overleftarrow{2}$$

再次反转空间，ORIG向DEST输出：
$$DEST\underrightarrow{123456789}$$

详细的算法描述如下：

算法N：（自然分段两路归并排序）

设记录$R_1,R_2,\dots ,R_N$，其对应的键值$K_1,K_2,\dots ,K_N$。需要额外的$N$空间。

• N1.[初始化] 置$s\leftarrow 0$。（输出空间切换）
• N2.[准备遍历] 如果$s=0$，置$i\leftarrow 1$，$j\leftarrow N$，$k\leftarrow N+1$，$l\leftarrow 2N$。如果$s=1$，置$i\leftarrow N+1$，$j\leftarrow 2N$，$k\leftarrow 1$，$l\leftarrow N$。并置$d\leftarrow 1$，$f\leftarrow 1$。（$d$与换边相关，头向尾接收数据时$d=1$，尾向头时$d=-1$）
• N3.[比较$K_i:K_j$] 如果$K_i>K_j$，跳转至N8。如果$i=j$，置$R_k\leftarrow R_i$，并跳转至N13.
• N4.[输出$R_i$] 置$R_k\leftarrow R_i$，$k\leftarrow k+d$。
• N5.[是否段尾？] $i\leftarrow i+1$。如果$K_{i-1}\le K_i$，转至N3。
• N6.[输出$R_j$] 置$R_k\leftarrow R_j$，$k\leftarrow k+d$。
• N7.[是否段尾？] $j\leftarrow j-1$。如果$K_{j+1}\le K_j$，转至N6；否则跳转至N12。
• N8.[输出$R_j$] 置$R_k\leftarrow R_j$，$k\leftarrow k+d$。
• N9.[是否段尾？] $j\leftarrow j-1$，如果$K_{j+1}\le K_j$，跳转至N3。
• N10.[输出$R_i$] 置$R_k\leftarrow R_i$，$k\leftarrow k+d$。
• N11.[是否段尾？] $i\leftarrow i+1$，如果$K_{i-1}\le K_i$，返回N10.
• N12.[切换输出方向] 置$f\leftarrow 0$，$d\leftarrow -d$,交换$k\leftrightarrow l$。返回N3。
• N13.[切换输出空间] 如果$f=0$，置$s\leftarrow 1-s$并返回N2。否则$f=1$，结束。（$f$控制着算法结束，在最后一趟归并阶段N2设置$f=1$，运行过程中不发生换边N12，说明完成归并，在N13推出。

从概率上来看，$K_i>K_j$与$K_i<K_j$各占$1/2$的概率，每趟遍历归并操作，段减少一半（两两合并），所以总的遍历次数为$\lg (\frac{1}{2}N)=\lg N-1$，每次遍历都要移动$N$个数据，复杂度$O(N\lg (N))$。

3、人工分段的两路归并排序

上面提到，自然分段依赖于假设所有记录服从一致分布，$K_i>K_j$与$K_i<K_j$各占$1/2$的概率。当待排序的序列中存在大量的升序段或降序段时，该算法处理的速度非常快。但是段太多时，主循环运行大量的分段测试语句，这拖慢了主循环。下面引入一种不依赖于自然分段的归并排序算法。我们人为的进行分段，先从1开始，然后2，4，8，…，k次遍历后分段长度为$2^k$。虽然人为分段长度为2的指数倍，同样能处理$N$不是2的指数倍的情况，后面讲解具体如何实现。

人工分段与自然分段没有什么本质上的区别，所以基本上程序也一样，只是在分段检测时的条件改变了。

算法S：（人工分段归并排序）

• S1.[初始化] 置$s\leftarrow 0$，$p\leftarrow 1$。
• S2.[准备遍历] 如果$s=0$，置$i\leftarrow 1$，$j\leftarrow N$，$k\leftarrow N+1$，$l\leftarrow 2N=1$。如果$s=1$，置$i\leftarrow N+1$，$j\leftarrow 2N$，$k\leftarrow 0$，$l\leftarrow N=1$。并置$d\leftarrow 1$，$q\leftarrow p$，$r\leftarrow p$。
• S3.[比较$K_i:K_j$] 如果$K_i>K_j$，跳转至S8。
• S4.[输出$R_i$] $k\leftarrow k+d$，$R_k\leftarrow R_i$
• S5.[是否段尾？] $i\leftarrow i+1$，$q\leftarrow q-1$。如果$q>0$，返回S3。
• S6.[输出$R_j$] $k\leftarrow k+d$，如果$k=l$，跳转至S13；否则置$R_k\leftarrow R_j$。
• S7.[是否段尾？] $j\leftarrow j-1$，$r\leftarrow r-1$。如果$r>0$，返回S6；否则转至S12。
• S8.[输出$R_j$] $k\leftarrow k+d$，$R_k\leftarrow R_j$。
• S9.[是否段尾？] $j\leftarrow j-1$，$r\leftarrow r-1$。如果$r>0$，返回S3。
• S10.[输出$R_i$] $k\leftarrow k+d$。如果$k=l$，转至S13；否则置$R_k\leftarrow R_i$。
• S11.[是否段尾？] $i\leftarrow i+1$，$q\leftarrow q-1$。如果$q>0$，返回S10。
• S12.[切换输出方向] 置$q\leftarrow p$，$r\leftarrow p$，$d\leftarrow -d$，交换$k\leftrightarrow l$。如果$j-i<p$，返回S10。否则返回S3。
• S13.[切换输出空间] 置$p\leftarrow p+p$。如果$p<n$，置$s\leftarrow 1-s$并返回S2。否则，结束。

现在我们详细解释人工分段归并如何解决$N$不是$2p$的倍数的情况：

在最后阶段，总是位于中间有一个$<2p$的序列，设长度为$t$，当$0\le t<p$时，在S12中$j-i<p$会跳转至S10，把它和一个空序列归并。

如果剩余一个长度$p$的序列和长度为$t<p$的序列，会有以下情况：$x_1\le x_2\le \dots \le x_p|y_t\ge \dots y_1$。如果$x_p\le y_t$，左侧首先耗尽，处理右侧，当右侧处理完成时，有条件$k=l$成立，跳转S13转换输出空间。如果$x_p>y_t$右侧先耗尽后$K_j=x_p$为最大值，剩余的$x_i,x_{i+1},\dots ,x_{p-1}$依次输出，直到满足S6中$k=l$跳转至S13。所以在任何情况下，上述程序都能圆满运行。

也可以像在快速排序中采取的办法一样优化，快排在末尾阶段采用直接插入排序来避免快排的低效。也可以采用同样的办法来加速人工分段的归并排序，只是放在开始阶段（归并排序像是直接插入排序的反操作）。可以把16个或32个（2的指数倍）排好序，然后再归并。

虽然人工分段减小了主循环中的分段检测，但机械的分段也丧失了自然分段中的一个优势，在自然分段中，如果存在$m$段，归并后可能会出现$<\frac{m}{2}$的情况，见下面的例子：

初始序列存在8个段，经一次趟归并后应该还有4个段，但实际上只存在2个段，有两个消失了。这就是自然分段的优势，不过这种情况的出现是不可预期的。
$$26|410|814|1216|1511|137|93|51$$
$$1256781314|1615121110943$$

4、链表归并排序

上面讨论的归并排序都需要$2N$的空间，下面介绍链表排序，虽然它也需要额外的链间空间，但省去了移动数据操作。这个算法需要$N+2$的额外空间，$N$用来存放链接地址，2个空间用来作为两个链接的表头。

首先让两个表头分别指向$L_0\leftarrow 1$和$L_{N+1}\leftarrow 2$，链接地址$L_i\leftarrow -(i+2)$，这样一个数组就被分成了两个链表，$L_0$串起索引地址为奇数的数组项$R_1,R_3,R_5,\dots$；$L_{N+1}$串起数组偶数项。负号作为分段的标志。这种把数组索引地址作为链接的方法我们在《排列与反序》中也应用过，不妨称为相对链接（对应于绝对地址指针），这是链表技术在顺序存储中聪明的应用。

还是以$(5,9,1,8,2,6,4,7,3)$为例说明。经过上面的处理，有如下结构

整理后两个链表：

第一趟遍历，依次比较归并$p$和$q$所指向的两个链表。因为不好理解，下图给出了第一趟遍历归并的每一步操作图示，请参照算法，一步一步对照。红、蓝分别代便了两个链表分段重组过程。

第一趟遍历完成后，所形成的新结构：

算法L：（链表归并排序）

• L1.[准备两个链表] 置$L_0\leftarrow 1$，$L_{N+1}\leftarrow 2$，$L_i\leftarrow -(i+2)$for$1\le i\le N-2$，并置$L_{N-1}\leftarrow L_N\leftarrow 0$。
• L2.[准备遍历] 置$s\leftarrow 0$，$t\leftarrow N+1$，$p\leftarrow L_s$，$q\leftarrow L_t$。如果$q=0$，算法结束。
• L3.[比较$K_p:K_q$] 如果$K_p>K_q$，转至L6。
• L4.[前进p] 置$|L_s|\leftarrow p$，$s\leftarrow p$，$p\leftarrow L_p$。如果$p>0$，返回L3。
• L5.[完成剩余链表] 置$L_s\leftarrow p$，$s\leftarrow t$。然后置$t\leftarrow q$，$q\leftarrow L_q$重复直到$q\le 0$，转至L8。
• L6.[前进q] 置$|L_s|\leftarrow q$，$s\leftarrow q$，$q\leftarrow L_q$。如果$q>0$，返回L3。
• L7.[完成生于链表] 置$L_s\leftarrow p$，$s\leftarrow t$。然后$t\leftarrow p$，$p\leftarrow L_p$重复直到$p\le 0$。
• L8.[遍历是否结束？] 置$p\leftarrow -p$，$q\leftarrow -q$。如果$q=0$，置$|L_s|\leftarrow p$，$|L_t|\leftarrow 0$，并返回L2。否则返回L3。

这个算法要比上面提到的自然分段、人工分段的归并排序快约$10\%$到$20\%$。上面的方法是采用了两路归并，进一步考虑，如果分成三个链表，采用三路归并效果会如何呢？回想在《[Alg]排序算法之选择排序》中提到的堆排序也有同样的问题，如果堆排序中，也选择三分会如何呢？上面提到，两路归并，一趟段数减少一半，那三路合并就是原来的$\frac{1}{3}$，故运行的趟数${\log }_{3}N$，复杂度为 $(N{\log }_{3}N)$，堆排序也是如此。虽然复杂度稍有提高，但多了好多$\Theta (N)$项。

链表归并排序还顺便把数组排列的逆求出来了（注意逆序和反序的区别）。例如$(2,3,1)$，其逆为：$(3,1,2)$
$$\left(\genfrac{}{}{0ex}{}{2}{1}\genfrac{}{}{0ex}{}{3}{2}\genfrac{}{}{0ex}{}{1}{3}\right)\Rightarrow \left(\genfrac{}{}{0ex}{}{1}{3}\genfrac{}{}{0ex}{}{2}{1}\genfrac{}{}{0ex}{}{3}{2}\right)$$

$$\left(\genfrac{}{}{0ex}{}{2}{R_1}\genfrac{}{}{0ex}{}{3}{R_2}\genfrac{}{}{0ex}{}{1}{R_3}\right)$$

排好序后有：
$$HEAD\to R_3\to R_1\to R_2$$
可见链接地址即为$(2,3,1)$的逆$(3,1,2)$。