基本排序算法之希尔排序

希尔排序是一种插入排序。

直接插入排序算法的时间复杂度为O(n2n^2n2)，但若排序序列为“正序”时，其时间复杂度可提高至O(n)。由此可见，直接插入排序更适合基本有序的排序表和数据量不大的排序表。希尔排序正是基于这两点分析对直接插入排序进行改进而得来的，又称缩小增量排序。以其设计者希尔（Donald Shell）的名字命名，该算法由 1959 年公布。

算法思想

我们举个例子来描述算法流程（以下摘自维基百科）：

假设有这样一组数 {13, 14, 94, 33, 82, 25, 59, 94, 65, 23, 45, 27, 73, 25, 39, 10}，如果我们以步长为 5 开始进行排序：

13 14 94 33 82
25 59 94 65 23
45 27 73 25 39
10

然后我们对每列进行直接插入排序：

10 14 73 25 23
13 27 94 33 39
25 59 94 65 82
45

将上述四行数字，依序接在一起时我们得到：{10, 14, 73, 25, 23, 13, 27, 94, 33, 39, 25, 59, 94, 65, 82, 45}，然后再以 3 为步长：

10 14 73
25 23 13
27 94 33
39 25 59
94 65 82
45

排序之后变为：

10 14 13
25 23 33
27 25 59
39 65 73
45 94 82
94

最后以 1 为步长进行直接插入排序（此时就是简单的插入排序了）。

可想而知，步长的选择是希尔排序的重要部分。算法最开始以一定的步长进行排序，然后会继续以更小的步长进行排序，最终算法以步长为 1 进行排序。当步长为 1 时，算法变为直接插入排序，这就保证了数据一定会被全部排序。

到目前为止，尚未求得一个最好的增量序列，希尔提出的方法是d1=n/2d_1=n/2d1=n/2，di+1=「di/2」d_{i+1}=「d_i/2」di+1=「di/2」，并且最后一个增量等于1。

实现

Python实现：

def shellSort(lyst: list)->None:n = len(lyst)dk=n>>1while(dk>=1):for i in range(dk,n):if(lyst[i]<lyst[i-dk]):tmp = lyst[i]j = i-dkwhile(j>=0):if tmp <lyst[j]: lyst[j+dk] = lyst[j]else :breakj-=dklyst[j+dk] = tmpdk>>=1return lystlyst = [9,7,6,32,1]
print(shellSort(lyst))

C++实现：

#include <iostream>
#include <vector>
#include <queue>
using namespace std;
vector<int> shellSort(vector<int>& lyst){int n = lyst.size();for(int dk=n>>1;dk>=1;dk>>=1){for(int i =dk;i<n;i++){if(lyst[i]<lyst[i-dk]){int tmp = lyst[i];int j = i-dk;for(;j>=0 and tmp<lyst[j];j-=dk){lyst[j+dk] =lyst[j];}lyst[j+dk]=tmp;}}}return lyst;}int main() {vector<int> test = {1,3,2,4};vector<int> res;res = shellSort(test);for(int i =0;i<res.size();i++)cout<<res[i]<<" ";return 0;
}

算法分析

时间： 步长序列的不同，会导致最坏的时间复杂度情况的不同，这涉及了数学上尚未解决的难题，所以时间复杂度分析比较困难。记住就行了。当n在某个特定范围内，希尔排序的时间复杂度约为o(n2n^2n2)。本文中，以n/2为步长的最坏时间复杂度为O(n2n^2n2)。
空间： 仅使用了常数个辅助单元，因而空间复杂度为o(1)。
稳定性： 当相同关键字的记录被划分到不同的子表时，可能会改变它们之间的相对顺序，因而是不稳定的。
适用性： 希尔排序算法仅适用于线性表为顺序存储的情况。

参考链接：https://cuijiahua.com/blog/2017/12/algorithm_3.html