[Alg]排序算法之插入排序

作者：屎壳郎 miaosg01@163.com

日期：July 2021

版次：初版

简介: 插入排序是排序算法大家族中的一个分支，其原理简单易懂，操作类似于玩扑克，假设你手中的牌已经按你的个人爱好排好序，新抓的一张牌从左到右或从右到左与手中的牌依次比较，找到应该插入的位置，然后插入即可。根据处理的数据结构及操作的不同，又细分为：直接插入排序、shell排序、list排序、地址计算排序等。

1. 直接插入排序

直接插入排序简单明了，不作过多说明，直接列出算法。

算法S：（直接插入排序）

S1[遍历] j=2,3,…,Nj=2,3,\ldots,Nj=2,3,…,N，执行S2到S5，然后结束。
S2[设置i,K,Ri,K,Ri,K,R.] 置i←j−1i\gets j-1i←j−1，K←KjK\gets K_jK←Kj，R←RjR\gets R_jR←Rj。
S3[比较K:KiK:K_iK:Ki.] 如果K≥KiK\geq K_iK≥Ki, 转到S5
S4[移动RiR_iRi，iii减1] 置Ri+1←RiR_{i+1}\gets R_iRi+1←Ri，i←i−1i\gets i-1i←i−1。如果i>0i>0i>0，返回S3。
S5[插入] 置Ri+1←RR_{i+1}\gets RRi+1←R。

从这个算法的内外两个循环嵌套，我们就大约猜出其时间复杂度O(N2)O(N^2)O(N2)，所以它的实际用处不大（是不是很像冒泡排序，地位很尴尬，不讲吧，里面有很多理论知识要说明，讲吧，没甚鸟用！）。但以它为例子来讲讲如何提高精炼一个算法，还是有好多东西可以阐述的。

下面，我们就以直接插入排序算法S为例，找到存在的问题，穷尽我们的能力，对算法S精益求精，看看我们能达到什么高度！

算法S改进1：消除边界条件检查

在直接插入排序算法S执行过程中，第jjj项大约要进行12j{1\over2}j21j次比较和移动操作，整体上要进行(1+2+⋯+N)/2≈N2/4(1+2+\cdots+N)/2\approx N^2/4(1+2+⋯+N)/2≈N2/4次比较和移动操作。在S4步骤中，平均移动数据14N2{1\over4}N^241N2，每次移动操作后都要执行边界条件检查i>0i>0i>0，N2/4N^2/4N2/4次的边界条件检查是很让人脑壳疼，何况还要在编程的时候也小心翼翼的去处理边界条件（一不小心就掉坑里），我们如何彻底消灭它？下面提供两种思路去彻底摒弃边界条件检查。

A：设待排序(R1,R2,…,RN)(R_1,R_2,\ldots,R_N)(R1,R2,…,RN)，我们对这个排列进行改造，在最前面（R1R_1R1之前）插入R0=−∞R_0=-\inftyR0=−∞。这样处理后就可以取消了边界条件检查，因为在K≥KiK\geq K_iK≥Ki的比较中，无论如何都不会越过−∞-\infty−∞；
B：给你排序数据时，不是每次都有机会让你在其前面插值处理，那另一种思路是，假设我们要把RjR_jRj插入到前面已经排好序的序列R1,R2,…,Rj−1R_1,R_2,\ldots,R_{j-1}R1,R2,…,Rj−1中，我们先处理边界，首先和R1R_1R1进行比较，如果Rj<R1R_j<R_1Rj<R1，这说明RjR_jRj应该插入R1R_1R1左面，R1…Rj−1R_1\ldots R_{j-1}R1…Rj−1整体右移一位，把RjR_jRj插入到R1R_1R1的位置，否则R1≤RjR_1\leq R_jR1≤Rj，RjR_jRj肯定插入到R1R_1R1右侧，根本无需边界条件检查。其解决问题的本质是增加了代码量，以空间换时间！

算法S改进2：改进对比—— 二分查找

直接插入排序要进行大约N2/4N^2/4N2/4次的比较操作，我们首先搞明白——进行如此大量的对比操作的目的是什么？

在找东西！

找什么呢？

找RjR_jRj插入位置！

既然明白了事情的本质，那就好办了。查找算法中比O(N2)O(N^2)O(N2)优秀的一抓一大把，高端大气上档次的有之，低调奢华有内涵的有之。我们就选低调奢华有内涵的二分查找，就可以把对比操作由O(N2)O(N^2)O(N2)提高到Nlg⁡(N)N\lg(N)Nlg(N)。OK，又提高了一点。

算法S改进3：改进数据移动—— 两路插入

现在我们来考虑数据移动的问题，每次仅移动一位，平均要移动14N2{1\over4}N^241N2次，我们借鉴上面二分查找的思路，第一项放置在中间，然后向两边移动插入——是为两路插入，这样就可减少一半的数据移动量，约18N2{1\over8}N^281N2。这会引出另一个麻烦，假设你踩的狗屎型号不对，没走狗屎运，第一个为最小项插入了中间，然后所有后续项都要放置在右侧，反之，第一个为最大项，所有后续项插入左侧。为了能够容纳这两种极端情况，需要2N+12N+12N+1的空间来应对。对于喝酸奶都要舔瓶盖的我们来说，这怎么能够容忍！我们先找找问题的根源，如果我们中间插入的为最小值，那右侧尾部空间不够，且不能扩展，而此时左侧一半空间空闲；如果中间插入最大值，头尾出现相反的问题。既然是头尾问题，那无头无尾可好？

OK，用环形数据结构，无头无尾，满足要求。

构建环形数据结构

其实构建环形数据结构并不复杂，我们申请一个数组，指针F指向数组的头部，R指向尾部。假设我们插入的第一个值为P，比P大的值插入，是以F为基点向右扩展；当插入的值小于P时，以R为基准向左扩展。通过改变数据结构，我们只需N+1的空间就可满足两路插入。见图：

数组前后两部分交换（如何旋转一个数组）

应用环形数据结构带来另一个问题，它产生形如(45123)(4\,5\,1\,2\,3)(45123)的数组，我们还要进一步处理，交换前后两部分得到形如(12345)(1\,2\,3\,4\,5)(12345)我们需要的形式。下面介绍一个解决这个问题的算法：设m=2m=2m=2为前部分长度(45)(4\,5)(45)，n=3n=3n=3为后部分长度，我们的目的是交换这前后两部分。首先设定一个变量指定交换位置k←0k\gets0k←0——这是目标地址，我们下一步就应该把x2x_2x2放入kkk指示的位置。我们如何确定的x2x_2x2以及后续循环替代目标的呢？通过下述的数学关系，设s←k+mmodNs\gets k+m\mod Ns←k+mmodN其中N=m+n=5N=m+n=5N=m+n=5，xk←xsx_k\gets x_sxk←xs，k←sk\gets sk←s重复，直到s=0s=0s=0为止。跑一遍演示最能说明问题：

有如下排列(x0,x1∣x2,x3,x4)(x_0,x_1|x_2,x_3,x_4)(x0,x1∣x2,x3,x4)，以竖线为界，要求交换前后两部分：

1、 k←0k\gets 0k←0，取出t←x0t\gets x_0t←x0，确定s←k+mmodN=0+2mod5=2s\gets k+m\mod N=0+2\mod5=2s←k+mmodN=0+2mod5=2，x0←x2x_0\gets x_2x0←x2，k←sk\gets sk←s。第一步完成后结果：(x2,x1∣x2,x3,x4)(x_2,x_1|x_2,x_3,x_4)(x2,x1∣x2,x3,x4)。
2、 k=2k=2k=2，s←2+2mod5=4s\gets2+2\mod5=4s←2+2mod5=4，x2←x4x_2\gets x_4x2←x4，(x2,x1∣x4,x3,x4)(x_2,x_1|x_4,x_3,x_4)(x2,x1∣x4,x3,x4)
3、 k=4k=4k=4，s←4+2mod5=1s\gets4+2\mod5=1s←4+2mod5=1，x4←x1x_4\gets x_1x4←x1，(x2,x1∣x4,x3,x1)(x_2,x_1|x_4,x_3,x_1)(x2,x1∣x4,x3,x1)
4、 k=1k=1k=1，s←1+2mod5=3s\gets1+2\mod5=3s←1+2mod5=3，x1←x3x_1\gets x_3x1←x3，(x2,x3∣x4,x3,x1)(x_2,x_3|x_4,x_3,x_1)(x2,x3∣x4,x3,x1)
5、 k=3k=3k=3，s←3+2mod5=0s\gets3+2\mod5=0s←3+2mod5=0，s=0s=0s=0，x3←t=x0x_3\gets t=x_0x3←t=x0，(x2,x3∣x4,x0,x1)(x_2,x_3|x_4,x_0,x_1)(x2,x3∣x4,x0,x1)

如果mmm和nnn不互质，不能像上面提到的一样，通过一次循环就完成交换。具体见下面算法：

算法X：（旋转数组）

X1[计算最大公约数] 置ddd为mmm和nnn的最大公约数d←gcd(m,n)d\gets gcd(m,n)d←gcd(m,n)，For 0≤j<d0\leq j<d0≤j<d执行后续步骤，然后结束。
X2[初始化] 置t←xjt\gets x_jt←xj，k←jk\gets jk←j，执行X3。
X3[循环替换] s←(k+m)modNs\gets(k+m)\mod Ns←(k+m)modN，如果s≠js\neq js=j，xk←xsx_k\gets x_sxk←xs，k←sk\gets sk←s,重复该步；否则
X4[放置t] xk←tx_k\gets txk←t。

当然，你也可以只旋转其中的部分，但前提是这两部分必须是相连接的，如：(a0,a1,…am−1∣am,…,am+n−1,b0,b1,…,bs)(a_0,a_1,\ldots a_{m-1}|a_m,\ldots,a_{m+n-1},b_0,b_1,\ldots,b_s)(a0,a1,…am−1∣am,…,am+n−1,b0,b1,…,bs)，你可以只旋转数组中的aaa部分，aaa部分是位于头部、尾部或中间都无关紧要。

哇，多么精妙绝伦的算法，让人叹为观止，可见算法的背后的数学是多么重要！！！

难道你一次只吃一个包子——出自电影《功夫熊猫》

我们已经对直接插入排序的方方面面做了剖析，是不是还有改进的余地呢？我突然想起了功夫熊猫上的那句话——难道你一次只吃一个包子？难道你一次只插入一个数据？ 两个两个的插入不是更好吗？先对RjR_jRj和Rj+1R_{j+1}Rj+1进行比较，假设Rj+1>RjR_{j+1}>R_jRj+1>Rj，我们先搜索插入Rj+1R_{j+1}Rj+1，然后继续向前搜索插入RjR_jRj，一趟遍历干掉两个，遍历和对比操作都平均折半，多美妙的事情。那三个一组应该也不是不可以。当然再多点也行，不过它有另外一个名字——归并排序！

2. Shell排序

我们从直接插入排序算法看到，一次只移动一步数据是非常低效的，应该增大数据移动的跨度。那么问题又来了，我们应该移动多大跨度，从而使得移动量最小呢？

下面引入服从一致分布的随机排列，其排序需要的净移动量均值相关数学背景知识：

整体平均净移动量13(N2−1){1\over3}(N^2-1)31(N2−1):

TAOCP 5.2.1-exercise 7
If a1,a2,…,ana_1,a_2,\ldots,a_na1,a2,…,an is a random permutation of {1,2,…,n}\{1,2,\ldots,n\}{1,2,…,n}, what is the average value of ∣a1−1∣+∣a2−2∣+⋯+∣an−n∣|a_1-1|+|a_2-2|+\cdots+|a_n-n|∣a1−1∣+∣a2−2∣+⋯+∣an−n∣?

∣aj−j∣|a_j-j|∣aj−j∣的均值为：（例：∣1−4∣|1-4|∣1−4∣可理解为4在1的位置，排序的目的是把4移动到4的位置，移动距离∣1−4∣=3|1-4|=3∣1−4∣=3，净移动量只考虑理论上需要的移动距离。）
1n(∣1−j∣+∣2−j∣+⋯+∣n−j∣)=1n((j2)+(n−j+12)){1\over n}(|1-j|+|2-j|+\cdots+|n-j|)={1\over n}\left({j\choose2}+{n-j+1\choose2}\right)n1(∣1−j∣+∣2−j∣+⋯+∣n−j∣)=n1((2j)+(2n−j+1))
然后对jjj求和：
1n((n+13)+(n+13))=13(n2−1){1\over n}\left({n+1\choose3}+{n+1\choose3}\right)={1\over3}(n^2-1)n1((3n+1)+(3n+1))=31(n2−1)
要对NNN项数据排序，整体平均移动量约13N2{1\over3}N^231N2，每项的平均移动的距离13N2/N=13N{1\over3}N^2/N= {1\over3}N31N2/N=31N，所以应该增大移动距离，这是增大移动距离的shell排序的理论基础。

shell排序可以看作是增大了距离的直接插入排序，其原理是一样的。

算法D：（shell排序）

设辅助表记录shell排序所需的逐步递减增量表（以下简称步长）ht−1,ht−2,…,h0h_{t-1},h_{t-2},\ldots,h_0ht−1,ht−2,…,h0，这里必须h0=1（这相当于最后一步执行的是直接插入排序）h_0=1（这相当于最后一步执行的是直接插入排序）h0=1（这相当于最后一步执行的是直接插入排序）。

D1.[循环s] 根据设定的增量，for s=t−1,t−1,…,1s=t-1,t-1,\ldots,1s=t−1,t−1,…,1依次执行D2，然后结束。
D2.[循环j] 置h←hsh\gets h_sh←hs，执行D3至D6，for h<j≤Nh<j\leq Nh<j≤N。
D3.[设置i,K,Ri,K,Ri,K,R] 置i←j−hi\gets j-hi←j−h，K←KjK\gets K_jK←Kj，R←RjR\gets R_jR←Rj。
D4.[比较K:KiK:K_iK:Ki] 如果K≥KiK\geq K_iK≥Ki，转至D6。
D5.[移动RiR_iRi，减小iii] 置Ri+h←RiR_{i+h}\gets R_iRi+h←Ri， i←i−hi\gets i-hi←i−h。如果i>0i>0i>0,返回D4.
D6.[RRR插入Ri+hR_{i+h}Ri+h]

步长序列选择

步长序列对shell排序的效率有着至关重要的影响，如何选择才能使shell排序最优化好像还没有从理论上解决这个问题。TAOCP推荐了两个生成方法：

如果N<1000N< 1000N<1000，应用下列方式：h0=1,hs+1=3hs+1h_0=1,h_{s+1}=3h_s+1h0=1,hs+1=3hs+1，直到3ht≥N3h_t\geq N3ht≥N。

如果N≥1000N\geq1000N≥1000:

sss为偶数时，推荐：hs=9⋅2s−9⋅2s/2+1h_s=9\cdot2^s-9\cdot2^{s/2}+1hs=9⋅2s−9⋅2s/2+1
sss为奇数时，推荐：hs=8⋅2s−6⋅2(s+1)/2+1h_s=8\cdot2^s-6\cdot2^{(s+1)/2}+1hs=8⋅2s−6⋅2(s+1)/2+1
最坏的情况时间复杂度O(N4/3)O(N^{4/3})O(N4/3)。
在编程的时候，shell排序的步长不好处理，不同于快速排序，可以从理论上计算出所需stack的最大值。一个折衷的办法是采用链表形式的stack，在需要的时候动态分配，有灵活性的同时丧失了效率。另一种办法是能估算出stack容量。我们下面给出一种估计方法，在N<1000N<1000N<1000时，stack容量选最大值6（按推荐的计算方法6为需要的最大值）。当N≥1000N\geq1000N≥1000时，按如下办法估算：
s=⌈lg⁡(N2)⌉s= \lceil \lg({N\over2})\rceils=⌈lg(2N)⌉

N	估值	实际需要	偏差
1000	9	9	0
2000	10	9	1
6000	12	11	1
24000	14	13	1
120000	16	15	1
720000	19	18	1
5040000	22	21	1
40320000	25	24	1

从上表我们可以看到在INT_MAX取值范围内，偏差都不大于1。在long型范围我没测试。所以按照上面的公式计算shell步长所需要的stack容量是不错的，即没有容量不够，也没有太大造成浪费。

消除边界条件检查

同样，在shell排序中，D5也有i>0i>0i>0的边界条件检查，我们在直接插入排序中介绍了两种消除边界条件检查的方法。因为shell排序是有跨度的插入排序，其对应的第一个元素是变动的。很明显，方法A不能应用，因为只插入一个−∞-\infty−∞，不能阻止越界。方法B是通过优先处理边界条件，但此处的边界的变动，给确定边界带来极大不便。我们必须小心的计算，以找到边界变动的规律。泛泛的说教还是不如举一个简短的小例子。设待排序序列(R1,R2,R3,R4,R5,R6,R7,R8,R9)(R_1,R_2,R_3,R_4,R_5,R_6,R_7,R_8,R_9)(R1,R2,R3,R4,R5,R6,R7,R8,R9)，并设跨度h=3h=3h=3，当我们执行forh<j≤Nfor\, h<j\leq Nforh<j≤N时jjj依次取j=h+1,h+2,…,Nj=h+1,h+2,\ldots,Nj=h+1,h+2,…,N，并以跨度3与前面项对比，我们详细列出对比序列，以便于找到其中的规律:
j=4,R4:R1j=4, R_4:R_1j=4,R4:R1
j=5,R5:R2j=5, R_5:R_2j=5,R5:R2
j=6,R6:R3j=6, R_6:R_3j=6,R6:R3
j=7,R7:R4:R1j=7, R_7:R_4:R_1j=7,R7:R4:R1
j=8,R8:R5:R2j=8, R_8:R_5:R_2j=8,R8:R5:R2
j=9,R9:R6:R3j=9, R_9:R_6:R_3j=9,R9:R6:R3
可以看出，当j=h+1j=h+1j=h+1（R4）时，对应的边界l=1l=1l=1（R1）；当jjj增加1（R5），对应的边界lll也增加1（R2），直到l=hl=hl=h时，重新从1开始。总结如下：

1、初始化：j=h+1j=h+1j=h+1，l=1l=1l=1；
2、当j←j+1j\gets j+1j←j+1时，l←l+1−h[l=h]l\gets l+1-h[l=h]l←l+1−h[l=h]。（[l=h][l=h][l=h]为条件函数，l=hl=hl=h取值为1，l≠hl\neq hl=h取值为0。）
经过改进，shell排序算法可以在实际操作范围内，把对比和数据移动减小到约N7/6N^{7/6}N7/6，随N→∞N\rightarrow\inftyN→∞，该值可降低至N(log⁡N)2N(\log N)^2N(logN)2
通过上面消除边界条件检查优化后，程序运行速度可以加快10%（这不是我说的，是Knuth说的，我不对这句话负责）。

3. List插入排序

通过我们的努力，我们可以用二分查找把对比减少的O(Nlg⁡N)O(N\lg N)O(NlgN)次，增大跨度的shell排序可以把数据移动减少到O(N7/6)O(N^{7/6})O(N7/6)，还有更优的方法吗？当然，如果我们采用单向链表，可以做到不移动数据，每次插入数据只改变两个链接地址。由于链接这种数据结构本省的原因，我们无法减少其14N2{1\over4}N^241N2次的对比。综上，list插入排序要消耗14N2{1\over4}N^241N2次对比，0次移动，2N次改变链接。

算法L：（List插入排序）

设待排序序列(R1,R2,…,RN)(R_1,R_2,\ldots,R_N)(R1,R2,…,RN)包含关键词(K1,…,Kn)(K_1,\ldots,K_n)(K1,…,Kn)和链接(L1,L2,…,Ln)(L_1,L_2,\ldots,L_n)(L1,L2,…,Ln)。L0L_0L0为链表头

L1.[循环jjj] 置L0←N,LN←nullL_0\gets N, L_N\gets nullL0←N,LN←null；forj=N−1,N−1,…,1for\, j=N-1,N-1,\ldots,1forj=N−1,N−1,…,1，执行L2到L5；然后结束。
L2.[设置p,q,Kp,q,Kp,q,K] 置p←L0p\gets L_0p←L0，q←nullq\gets nullq←null，K←KjK\gets K_jK←Kj。K:KpK:K_pK:Kp比较完成，如果有插入操作，应该插入ppp的后面，因为单向链表，已经无法取得ppp后面项的指针，故需要ppp后面跟随一个指针qqq，双向链表(dequeue)则没有这个问题。
L3.[比较K:KpK:K_pK:Kp] 如果K≤KpK\leq K_pK≤Kp，转到L5（我们找到插入位置，转到L5执行插入操作）。
L4.[交替前移] 置q←pq\gets pq←p，p←Lqp\gets L_qp←Lq，如果p≠nullp\neq nullp=null，返回L3。（如果p=nullp=nullp=null，说明已经搜索到链表尾，K为当前最大值，插入链表尾端。）
L5.[插入] 置Lq←jL_q\gets jLq←j，Lj←pL_j\gets pLj←p。

4. 地址计算排序

我们从上面的list插入排序看到，由于链表这种数据结构本身的原因，无法直接访问定位数据，必须通过前一个的链接访问下一个数据，其本质还是依次遍历，比较次数依旧为14N2{1\over4}N^241N2。但我们还是可以通过其它手段来改善，最简单直接的方法是一个链表遍历太长，我们可以把一个链表剁成几段短链表，这种思想即为桶排序，留在分布排序的时候再具体讲。另一种可以把对比提升至N(log⁡N)N(\log N)N(logN)的方法是采用二叉树结构，是两路插入一种更彻底的改进。这个也留在查找部分详细讲解。

我们已经详细讨论了插入排序的方方面面的问题，并对出现的问题给出了具体的解决措施，据此应该能编写出工业级的代码。具体的实现请参考C源代码（相应的改进措施都融合进了源代码中）。