基本排序算法之希尔排序

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

直接插入排序算法的时间复杂度为O($n^2$)，但若排序序列为“正序”时，其时间复杂度可提高至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 时，算法变为直接插入排序，这就保证了数据一定会被全部排序。

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

实现

Python实现：

def shellSort(lyst: list)->None:
    n = len(lyst)
    dk=n>>1
    while(dk>=1):
        for i in range(dk,n):
            if(lyst[i]<lyst[i-dk]):
                tmp = lyst[i]
                j = i-dk
                while(j>=0):
                    if tmp <lyst[j]: lyst[j+dk] = lyst[j]
                    else :break
                    j-=dk
                lyst[j+dk] = tmp
        dk>>=1
    return lyst
                
lyst = [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($n^2$)。本文中，以n/2为步长的最坏时间复杂度为O($n^2$)。
空间： 仅使用了常数个辅助单元，因而空间复杂度为o(1)。
稳定性： 当相同关键字的记录被划分到不同的子表时，可能会改变它们之间的相对顺序，因而是不稳定的。
适用性： 希尔排序算法仅适用于线性表为顺序存储的情况。

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