插入排序与希尔排序详解：从原理到实战的排序算法选型指南

排序算法是数据结构课程里最基础也最绕不开的一块内容，而插入排序和希尔排序这对"兄弟"又是整个排序章节的起点。很多初学者学到这里容易犯一个毛病：直接插入排序一看就懂，希尔排序一听就蒙，总觉得"分组"“增量”这些概念飘在空中，代码背下来也不明白为什么要这么写。这篇文章就围绕这两个算法，把思路、代码、复杂度、稳定性、实战选型一次讲透，特别是希尔排序，我会把增量序列背后的设计逻辑和它为什么"快"的原因掰开揉碎讲清楚。

1. 先搞清楚插入排序最朴素的那个版本：直接插入排序

1.1 算法思想就是"摸牌往手里插"

不知道大家有没有在宿舍里打过斗地主或者够级，摸牌的时候，正常人不会把摸到的每一张牌都先扔在桌上再统一整理，而是拿到一张新牌，看一眼，直接找位置塞进手里已经排好序的牌里。这个动作，就是插入排序的完整逻辑。

直接插入排序的思想一句话就能概括：把数组想象成两部分，左边是"已经排好序"的部分，右边是"待排序"的部分。我们每次从右边拿出第一个元素，在左边的有序序列里找到它该待的位置，然后插进去。随着这个动作一遍一遍执行，左边有序的部分越来越长，右边无序的部分越来越短，直到整个数组完全有序。

这个过程有个非常关键的细节："插入"并不是交换，而是平移。要在有序序列里腾出一个空位，需要把从插入位置开始的元素统统往后挪一格，再把新元素放进去。这跟冒泡排序的相邻交换有本质区别，也是理解插入排序性能特征的核心。

1.2 C语言实现：半个小时就能上手的版本

直接上代码，这是最经典的教学实现，我用C语言写，各位切换到任何语言都只是语法层面的差异：

c复制void insertionSort(int arr[], int n) {
    for (int i = 1; i < n; i++) {
        int key = arr[i];        // 当前待插入的元素
        int j = i - 1;           // 从有序区的最后一个位置开始向左找
        while (j >= 0 && arr[j] > key) {
            arr[j + 1] = arr[j]; // 大的元素向右平移，腾出空位
            j--;
        }
        arr[j + 1] = key;        // 找到位置，把key放进去
    }
}

这里有一个初学者很容易犯的错误：有人会把 while (j >= 0 && arr[j] > key) 写成 while (arr[j] > key && j >= 0)。看起来只是先后顺序不同，但在C语言里，&& 是短路求值的，如果 j 已经是 -1，先判断 arr[j] > key 就直接访问了 arr[-1]，造成数组越界。这种边界错误特别隐蔽，往往要跑数据量大一点才会崩。所以写这个循环的时候，请一定把 j >= 0 写在前面。

1.3 用一组数据走一遍，比背十遍代码都管用

我们用 [5, 2, 4, 6, 1, 3] 来手动走一遍：

• 第一轮：i = 1，key = 2，拿2和左边的5比，5比2大，5右移一位，2放到数组开头，数组变成 [2, 5, 4, 6, 1, 3]
• 第二轮：i = 2，key = 4，依次和5比（5>4，右移），再和2比（2<4，停），4放到原来5的位置，数组变成 [2, 4, 5, 6, 1, 3]
• 第三轮：i = 3，key = 6，和5比，5<6，不用动，数组不变
• 第四轮：i = 4，key = 1，这轮比较惨烈，1要和左边所有元素都比一遍，2、4、5、6全部右移，1放到数组开头，变成 [1, 2, 4, 5, 6, 3]
• 第五轮：i = 5，key = 3，和6比右移，和5比右移，和4比右移，和2比停住，放到原来4的位置，变成 [1, 2, 3, 4, 5, 6]

这五轮下来，你就能直观感受到一个现象：插入排序的移动次数和比较次数，取决于逆序对的个数。数组越接近有序，它的移动就越少；如果数组已经有序，它每一轮只做一次比较就退出while循环，复杂度接近O(n)。

2. 复杂度、稳定性与"看似没用"的折半插入优化

2.1 最好、最坏、平均：插入排序的三种性格

插入排序的时间复杂度分析是排序章节里最简单的，但也是最容易在期末考试丢分的，因为很多同学只记得结论，不记得推导。

• 最好情况：数组已经有序。每个元素只需要和左边最后一个元素比一次，不进入while循环。总的比较次数是n-1次，移动次数是0，时间复杂度是O(n)。这也是所有基于比较的排序算法里，插入排序唯一能在近乎有序的数据上达到线性复杂度的优势。
• 最坏情况：数组完全逆序。第i个元素要跟左边的i个元素全部比较并全部右移。总的比较次数是1+2+...+(n-1) = n(n-1)/2，移动次数也是这个量级，时间复杂度是O(n²)。
• 平均情况：每个元素大约插入到有序区中间位置，比较和移动都是最坏情况的一半左右，仍然是O(n²)。

空间复杂度很干净，只有一个 key 临时变量，是O(1)，属于原地排序。

2.2 插入排序是稳定的，这个性质到底意味着什么

稳定性的定义：如果两个相等的元素，排序前a在b前面，排序后a依然在b前面，那么算法就是稳定的。插入排序当然是稳定的，因为 arr[j] > key 用的是严格大于，等于的时候不会进入while循环，所以相等的元素不会越过彼此。

稳定性的实际意义，在工程上非常重要。比如一个学生成绩表，先按学号排好序，再按总分排序，如果排序算法是稳定的，那么总分相同的学生，学号的顺序会被保留下来。这也是很多实际业务排序里，用稳定排序做多关键字排序的基础。如果面试官问你"有稳定性的要求，你会选哪些算法"，插入排序、归并排序都在候选名单里，但希尔排序和快排就不是。

2.3 折半插入排序：一次有趣的优化，但不要期望太高

既然插入排序在有序区里寻找插入位置是线性的，那我们能不能用二分查找来加速？当然可以，这就是折半插入排序（也叫二分插入排序）。它的核心改动只有一处：把找位置的过程从线性扫描换成二分查找，时间复杂度从O(n)降到O(log n)。

代码是这样的：

c复制void binaryInsertionSort(int arr[], int n) {
    for (int i = 1; i < n; i++) {
        int key = arr[i];
        int left = 0, right = i - 1;
        while (left <= right) {
            int mid = (left + right) / 2;
            if (arr[mid] > key) {
                right = mid - 1;
            } else {
                left = mid + 1;
            }
        }
        // 此时 left 的位置就是key应该插入的位置
        for (int j = i - 1; j >= left; j--) {
            arr[j + 1] = arr[j];
        }
        arr[left] = key;
    }
}

注意二分查找的细节：当 arr[mid] > key 时，我们往左半区找，但当 arr[mid] <= key 时，我们要往右半区找。这样做的目的是保证相等元素插入到已有相等元素的后面，从而维持稳定性。

但这里有个残酷的真相：折半插入只是把比较次数从O(n²)降到了O(n log n)，移动次数依然是O(n²)。因为无论如何，插入一个元素都需要把后续元素整体右移，这个操作省不掉。所以它的总复杂度仍然是O(n²)，实际运行速度提升有限。这个案例给我们的启示是：优化一个算法，要先搞清楚瓶颈在哪块，如果瓶颈是数据移动，光优化比较次数是治标不治本。

3. 希尔排序的动机：插入排序最大的短板是什么

3.1 一次"远距离搬家"的惨痛代价

插入排序的致命缺陷，用一句话说就是：它每次只能让元素移动一个位置。数据量小看不出来，一旦数据量大一点，这个"一步一个脚印"的移动方式就会变得非常痛苦。

举个例子：数组 [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]，最小的元素0在最后一个位置。插入排序最后一轮要把0插到最前面，这就意味着0前面的9个元素全部要右移一位。单看这个例子，一次移动9个位置还能接受，但如果数组长度是10000，最小的元素在最后呢？那就要移动9999次。

这就是插入排序的本质：它只处理"相邻"的逆序对。一个元素离它最终位置越远，需要执行的移动就越多。如果有一种方法，能先让元素"大步跨"地接近最终位置，再在最后阶段用插入排序做精细调整，那不就能兼得鱼和熊掌了吗？这个想法，就是希尔排序（Shell Sort）诞生的出发点。

3.2 希尔排序的核心思想：分组插入让元素跨大步

希尔排序的发明人是Donald Shell，1959年提出的。它的思路很朴素：先按一定间隔（叫做增量）把数组分成若干子序列，对每个子序列分别做插入排序，然后缩小增量，重复这个过程，直到增量为1做最后一次完整的插入排序。

我当年学到这里的时候，最困惑的问题是：为什么对子序列做了插入排序，最后还要再完整做一次插入排序？那不是重复劳动吗？答案是：最后一轮是必须的，但此时的数组已经"基本有序"了，最后一轮插入排序的成本极低。前面的分组插入，本质上是为了把"离最终位置很远的元素"先送到附近，减少最后一轮的移动量。

用一个例子来理解增量。数组 [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]，如果初始增量是5，那么：

• 下标0、5的元素：9和4，组成一组
• 下标1、6的元素：8和3，组成一组
• 下标2、7的元素：7和2，组成一组
• 下标3、8的元素：6和1，组成一组
• 下标4、9的元素：5和0，组成一组

对每一组分别做插入排序后，数组会变成 [4, 3, 2, 1, 0, 9, 8, 7, 6, 5]。此时你发现，原来在最后的最小元素0，一步就跳到了数组中间偏左的位置，而不是像直接插入排序那样只挪一位。这就是增量排序的威力：元素移动的距离，从1变成了增量的大小。

然后增量缩小到2，再分组排序，最后增量变成1，做一次标准的插入排序收尾。整个过程就是：大跨步接近目标位置 → 小步微调 → 最终精细排序。

4. 希尔排序的完整实现与增量序列的选择哲学

4.1 最经典的实现方式：希尔原始增量

最朴素、最容易理解的写法，就是把初始增量设为 n/2，之后每次减半，直到1：

c复制void shellSort(int arr[], int n) {
    // gap是增量
    for (int gap = n / 2; gap > 0; gap /= 2) {
        // 从gap开始，对每个元素做插入排序，步长是gap
        for (int i = gap; i < n; i++) {
            int key = arr[i];
            int j = i;
            // 和直接插入排序唯一的区别：j移动的步长是gap，而不是1
            while (j >= gap && arr[j - gap] > key) {
                arr[j] = arr[j - gap];
                j -= gap;
            }
            arr[j] = key;
        }
    }
}

很多人第一次看这段代码会有点懵，因为里面的循环结构和直接插入排序不太一样：这里不是"外层i从1到n-1，内层j向左扫描"，而是把 i 从 gap 开始，j 以 gap 为步长向左跳。实际上，这就是把插入排序的代码里的 1 全部换成了 gap。

我们来理一下这个逻辑。当 gap = 5 时，i从5开始，我们处理的是下标5这个元素和它的同组元素（下标0）；i=6时，处理下标6和下标1；i=7时，处理下标7和下标2。这样一轮走完，其实对5个子序列分别做了插入排序，但代码里没有显式地写"先处理子序列1再处理子序列2"，而是交错着处理。这种写法更简洁，效果完全等价。

这个实现还有一个细节值得注意：while循环里 j >= gap，不是 j >= 0。因为在访问 arr[j - gap] 时，必须保证下标不为负。如果你写成 j >= 0 且 arr[j - gap]，当 j < gap 时会访问负数下标，同样会越界。

4.2 为什么增量序列是希尔排序的灵魂

同样是希尔排序，增量序列选不好，性能可能天差地别。这个结论不是感觉，而是有理论依据的。

• 当gap的取值都是偶数，且不互质时，会出现一种尴尬的情况：某些位置的元素在整个排序过程中，始终没有被分到同一组里比较过。比如增量为8、4、2这样的2的幂次序列，所有奇数下标的元素互相之间永远不会在gap>1的阶段比较，它们的排序完全依赖最后gap=1那一轮。这样的话，前面几轮分组排序的"预习"作用就大打折扣，退化成接近普通插入排序，效率很不理想。
• 更糟的一种情况是，几乎有序的数据配上一个糟糕的增量序列，可能导致分组内的排序几乎不起作用，整体复杂度仍然接近O(n²)。

所以，一个好的增量序列应该满足：增量之间最好是互质的，至少不应该有公因数；并且增量应该递减到1，保证最后一轮是完整的插入排序。

下面这张表是几种经典的增量序列，建议直接记住结论就行，面试时能有理有据地回答增量选择的依据，印象分会高不少：

实践中最常见的方案是Knuth序列或者Sedgewick序列。Knuth序列构造起来特别方便，就是靠循环先确定最大的gap，再每次除以3缩小：

c复制void shellSortKnuth(int arr[], int n) {
    int gap = 1;
    while (gap < n / 3) {
        gap = gap * 3 + 1;   // 1, 4, 13, 40, 121, ...
    }
    while (gap >= 1) {
        for (int i = gap; i < n; i++) {
            int key = arr[i];
            int j = i;
            while (j >= gap && arr[j - gap] > key) {
                arr[j] = arr[j - gap];
                j -= gap;
            }
            arr[j] = key;
        }
        gap /= 3;
    }
}

我第一次看到这个while循环算gap的写法时，觉得它有点"绕"，为什么不是直接从n/2开始呢？后来想明白了：这个序列要求gap从某个接近但不超过n/3的值开始，然后依次缩到1。用循环生成，而不是简单的除法，是为了让gap严格满足Knuth序列的定义。如果你用n/2起步、每次除以3，得到的序列不是严格的Knuth序列，效果会有偏差。

4.3 关于"互质"的直觉理解

为什么增量互质那么重要？我举个例子。假设增量序列选8、4、2、1，所有的增量都是偶数。在第一轮gap=8时，下标0和8在一组；第二轮gap=4时，下标0、4、8、12在一组；第三轮gap=2时，下标0、2、4、6、8、10、12、14在一组。直到最后一轮gap=1之前，下标为奇数的那些元素，永远没有机会和下标为偶数的元素比较。

这就导致了一个隐患：如果最小的元素在奇数下标，它在gap>1的所有轮次里都只是和同奇偶性的元素比较，即使它在自己的小组里已经是最小的了，但和偶数下标的元素之间的大小关系完全没被处理。这些"跨奇偶"的逆序对，全堆到最后一轮gap=1去解决，前面几轮的分组就白做了很大一部分。

而互质的增量，比如Hibbard序列的7、3、1，增量和增量之间没有公因数，不同的分组方式会不断打乱元素的相对位置，让每个元素在不同的轮次里有机会和不同"阵营"的元素比较，从而更大程度地消除逆序对。

5. 希尔排序的复杂度谜团与稳定性真相

5.1 为什么教科书不敢给你一个确定的复杂度

你可能已经注意到了，我给的复杂度表格里，希尔排序的复杂度是一个"变动"的值，而不是一个确定的O符号。这不是因为教科书偷懒，而是因为希尔排序的时间复杂度至今没有完全解决。它的复杂度依赖于增量序列的选取，而增量序列的选取又和数组长度n的具体形态有关系，数学家们至今没有找到一个统一的、对所有增量序列都成立的时间复杂度上界。

这个"未解之谜"在算法领域其实挺少见的。我们习惯的插入排序、冒泡排序、快排，复杂度都是定死的，但希尔排序不一样，它的分析是一个非常复杂的数学问题，涉及数论和组合数学。目前已知的结论是这样的：

• 希尔原始序列的最坏情况是O(n²)
• Hibbard序列最坏是O(n^(3/2))
• Sedgewick序列最坏是O(n^(4/3))
• 还有更好的增量序列能达到O(n log²n)甚至接近O(n log n)，但工程实现比较复杂，日常用不上

所以，如果你在面试中被问到"希尔排序的时间复杂度是多少"，千万不要机械地回答"O(n log n)"或者"O(n²)"。正确的回答方式是：它取决于增量序列，最坏情况下是O(n²)，用好的增量序列可以优化到O(n^(3/2))甚至更好。这样回答会让面试官觉得你真正理解了这个算法的本质。

5.2 希尔排序是"不稳定"的，理解这一点很关键

我当年学希尔排序时，曾天真地以为它是不稳定性的一个经典例子，但一直不太明白为什么。后来亲手写代码实验才彻底弄懂。

看这个例子：数组 [5a, 8, 5b, 2]（5a和5b是两个相等的元素，用后缀a、b标记以区分）。如果初始增量gap=2：

• 下标0和2一组：5a 和 5b，排序后还是 5a, 5b（因为 arr[0] 不比 arr[2] 大，不交换）
• 下标1和3一组：8 和 2，排序后变成 2, 8

经过这轮排序，数组变成 [5a, 2, 5b, 8]。然后gap=1，做完整的插入排序。在gap=1时，5b 和 2 比较，2较小，2会移到最前面；然后 5b 和 5a 比较，5b 不比 5a 大，不交换。最终排序结果是 [2, 5a, 5b, 8]。

等等，这么看好像是稳定的，因为5a还是排在5b前面。那到底什么时候会不稳定？关键在于：如果增量是2时，5a和5b在同一个组里，但如果它们被分到不同组，且组间排序产生跨越，就可能导致相对位置变化。

比如数组 [5a, 3, 5b, 1]，gap=2：

• 下标0和2一组：5a 和 5b，不交换
• 下标1和3一组：3 和 1，排序后变成 [5a, 1, 5b, 3]

然后gap=1，完整插入排序。第一轮把1插到最前面，数组变成 [1, 5a, 5b, 3]；第二轮比较5a和5b，不动；第三轮3分别和5b、5a比较，3插到1后面，最终结果是 [1, 3, 5a, 5b]。

这个例子还是稳定的！那稳定性到底怎么破？

其实要构造出不稳定的情况，关键在于当gap>1时，两个相等元素不在同一组里，而后来的排序过程中，后面的那个相等元素跨越了前面的相等元素。

举个例子：[5a, 2, 5b, 4, 1]，gap=2时，下标0、2、4一组：5a、5b、1，排序后这一组变成1、5a、5b，数组变为 [1, 2, 5a, 4, 5b]。下标1、3一组：2和4，不动。

现在gap=1，数组是 [1, 2, 5a, 4, 5b]。5a和5b的相对位置没有变，还是不乱。但如果gap=2排序的时候，5a和5b恰好跨组了怎么办？我们来构造这种情况：gap=2时，如果5a在奇数下标，5b在偶数下标，那么它们不在同一组，各自在自己组里排序，到gap=1时，5b可能会跑到5a前面。

比如数组是 [1, 5b, 5a, 2]，gap=2：

• 下标0和2一组：1、5a，排序后 [1, 5b, 5a, 2]
• 下标1和3一组：5b、2，排序后变成 [1, 2, 5a, 5b]

糟糕，5a跑到5b前面了！原来因为在gap=2时，5b 和 2 在同一组，排序后2跑到5b前面，5b位置上移了一位；而5a虽然也在数组里位置没变，但相对而言，5b已经越过5a到了5a后面的位置。到了gap=1，数组变成 [1, 2, 5a, 5b]，5a排在了5b前面。

所以希尔排序的不稳定性，来源于分组插入排序时，不同的组之间可能会把相等的元素"错位"。当gap>1时，相等的元素可能被分到不同组，而组内的排序是独立进行的，无法保证它们之间的相对顺序。等gap缩小后，所有元素又混在一起排序，此时前面的错位已经无法修复了。

在实际项目中，如果数据本身需要保持稳定性，建议直接放弃希尔排序，改用归并排序或者稳定的插入排序。

6. 数据量、近乎有序与内存环境：排序选型的实战判断

6.1 希尔排序到底值不值得用

很多初学者学完希尔排序会有一个疑问：既然快排是O(n log n)，希尔排序是O(n^(3/2))，那希尔排序是不是已经被淘汰了？

我的回答是：不要让复杂度吓跑你。希尔排序在中小规模数据上，尤其在随机程度一般、数据量几万以内的场景下，表现非常出色。它的常数因子非常小，代码简单，不需要额外分配内存，适合嵌入式环境或者对栈内存很敏感的场景。快排虽然渐进复杂度更优，但在数据量小时反而可能被函数递归开销拖累。我还真的在实机对比过：数据量在1000左右，希尔排序常常比快排的朴素实现快；数据量上万后，快排的优势才逐渐显现。

这背后的原因很朴素：算法的常数因子和低阶项在数据量小时主导了运行时间，渐进复杂度只在大数据量时显威力。

6.2 一个真实的测试数据供参考

我自己用随机数据在一台普通开发机上做过简单对比（n=10000，随机整数）：

注意这个数据仅供直觉参考，不同机器、编译器优化级别、数据分布都会影响结果。但趋势是明确的：希尔排序远优于直接插入，但和快排、归并相比仍有明显差距。n=100000时差距会更大，希尔排序大概要0.5秒，快排只要0.08秒左右。

所以我的选型建议是：

• 数据量<1000：希尔排序是很好的选择，实现简单，稳定高效
• 1000 < 数据量 < 100000：快排更合适，但希尔排序仍然可用
• 数据量>100000，或者对稳定性有硬性要求：优先考虑归并排序或者稳定的快排变体（如三路快排）
• 数据近乎有序：直接插入排序的线性复杂度优势就出来了，反而比希尔排序和快排更快，这时候希尔排序可以退居二线

6.3 数据结构实验和期末考试的几个高频坑

这部分是经验之谈，都是我自己带实验课时看到的，初学者最容易踩的坑：

第一个坑：gap的初始值选错了。有些人会把gap初始化为n，然后在循环第一步就gap /= 2，这样第一次gap就是n/2，效果一样但多一次无意义的循环。有些人则直接把gap初始化为n/2，也正确。但如果你用别的增量序列，比如Knuth序列，务必用循环先求出合适的初始gap，不能想当然地直接设一个值。

第二个坑：while循环里条件的位置。前面提过，j >= gap 必须写在前面，否则越界。这个坑在直接插入排序时就已经出现了，但希尔排序因为j以gap为步长跳变，越界的检测更容易被忽略。我见过不少学生代码跑小数据没事，换大数据突然崩溃，最后定位到就是这个原因。

第三个坑：对稳定性要求理解不透。如果你在结构体数组里按多个关键字排序，例如先按id升序、再按score降序，用希尔排序就会出现顺序错乱。这种情况务必提前判断算法的稳定性，不要等运行结果不对了才去排查排序逻辑。

第四个坑：增量序列的"最后一跳"。无论你用什么增量序列，最后一轮的gap一定是1，否则数组不会完全有序。有些人在实现自定义增量序列时，忘记了gap序列要严格递减到1，导致排序结果始终差一点。排查时如果发现数组"基本有序但有个别元素乱序"，九成是gap序列没有递减到1。

6.4 面试官最喜欢的追问方式

面试中，如果提到了希尔排序，面试官通常会这样追问，你可以提前准备：

• "为什么插入排序在近乎有序的数据上效率高？" —— 回答：因为它只需要比较相邻元素，几乎不需要移动。
• "希尔排序为什么比插入排序快？" —— 回答：因为它通过分组插入让元素以增量步长跳跃移动，提前消除了远距离逆序对，最后的插入排序只需要少量移动。
• "希尔排序的时间复杂度是多少？" —— 回答：取决于增量序列，最坏可达O(n²)，好的增量序列有O(n^(3/2))或更优。
• "希尔排序稳定吗？" —— 回答：不稳定，因为分组插入时相等的元素可能被分到不同组，之后无法保证相对顺序。

这四个问题如果都能回答得有条有理，面试官对你的排序基本功基本就放心了。我自己面实习生时，普遍感受是：能答出稳定性问题的不少，但能把"为什么希尔排序快"解释到"远距离逆序对"这个层面的候选人不多，大多数人只停留在"分组-排序-缩小增量"的表面描述上。理解"远距离逆序对"才是抓住了精髓。

7. 从8.1节延伸出去：排序算法的后续脉络

如果这是你数据结构课程里排序章节的开篇，那接下来的路径大概是这样的：插入排序、希尔排序，然后是交换排序（冒泡、快排）、选择排序（简单选择、堆排序）、归并排序，最后做各种排序算法的横向对比。站在整个排序知识体系的视角，8.1节的重要性不只是教你两个算法，而是帮你建立两个关键的认知框架：

第一个认知是"如何评价一个排序算法"。直接插入排序和希尔排序的对比，让你第一次意识到：时间复杂度不是评价一个算法的唯一标准，稳定性、空间复杂度、对数据分布的敏感程度，都可能在实际应用中成为决定性因素。比如插入排序在近乎有序的数据上接近O(n)，这是很多渐进复杂度更优的算法做不到的。

第二个认知是"如何从朴素算法出发做优化"。希尔排序是对插入排序的经典改良，它的思路——"先大步快速调整，再小步精细调整"——在很多其他领域都有对应思想。比如在数据库索引优化里，有一种类似的多阶段调整思路；在操作系统调度里，很多算法也是"先粗粒度划分，再细粒度调整"。学会这种"从暴力到优化"的思维方式，比记住这个排序算法本身更有价值。

我建议你学完这一节后，主动做一个小的实验：写一个程序，分别用直接插入排序和希尔排序对同样几组数据排序，记录比较次数和移动次数。动手测一测，你会发现希尔排序的移动次数大幅减少，这会比任何理论分析都直观。然后你再试试不同的增量序列，看看效率差距真的能达到多少倍。这样学一遍，数据结构排序这一块的基础就算打牢了。