严蔚敏数据结构排序全解：九大排序算法复杂度与稳定性

“严蔚敏数据结构排序汇总”这个话题，我相信很多人在期末考试、考研复习、软考准备甚至面试前刷题时都翻过。严蔚敏那本《数据结构（C语言版）》第十章把直接插入排序、折半插入、希尔排序、冒泡、快排、简单选择、堆排、归并排序、基数排序全串了一遍，教材代码写得严谨，但初学者往往“看得懂每一步，合上书一片空白”。这篇文章我按自己的学习和使用经验，把这些排序重新整理一遍——每种排序的核心思路、书上代码为什么这么写、复杂度怎么推、到底什么时候用，以及我在真实项目和刷题中踩过的坑。内容适合正在啃这本书的学生，也适合想快速把排序体系捡起来的人。

1. 先搞清楚严蔚敏教材里排序章节的编排逻辑

1.1 九种排序不是平铺的，背后有四条技术线

很多人翻开第十章就从直接插入排序开始背，背完一个忘一个。我建议先看目录结构：插入排序（直接插入、折半插入、希尔）、交换排序（冒泡、快速）、选择排序（简单选择、堆）、归并排序、基数排序。这其实是四条完全不同的技术思路——插入类是在“已经有序的部分”中找位置放新元素；交换类是通过相邻或间隔元素的比较交换把逆序对纠正过来；选择类是每趟从剩余元素中挑出极值放到正确位置；归并是假设左右两半各自有序再合并；基数排序干脆不比较大小，而是按位数分配收集。教材把这几种排序放在同一章，本质是想告诉我们：同一个问题，从不同角度切入会得到复杂度差异巨大的方案。

我的建议是不要按照教材顺序线性阅读，而是把“比较排序”和“非比较排序”先分开。比较排序的理论下界是 O(n log n)，所以任何基于比较的排序，平均复杂度都不可能突破这个天花板；基数排序走的是另一条路，用关键字位数来换取时间，这才做到 O(d(n+r))。理解这个分层之后，再看希尔排序为什么能突破 O(n²)、快排为什么不稳定、堆排为什么是选择排序的优化版，视野会清楚很多。

1.2 前置数据结构：顺序表、记录、哨兵的概念别跳过

严蔚敏教材里内部排序全部建立在“顺序表”存储结构上，代码开头通常是这样：

c复制#define MAXSIZE 20
typedef int KeyType;
typedef struct {
    KeyType key;
    // 其他数据项
} RedType;
typedef struct {
    RedType r[MAXSIZE + 1]; // r[0] 留作哨兵或暂存
    int length;
} SqList;

这里最容易被忽略的就是 r[0] 这个位置。很多初学者会奇怪为什么数组从下标 1 开始存数据，白白浪费一个位置。这个设计有两个原因：一是排序代码里的位置计算公式、循环边界写起来更直观，第 i 个元素的左右孩子正好是 2i 和 2i+1，这在堆排序里尤其重要；二是 r[0] 在插入排序中充当“哨兵”，每次插入前先把待插入元素暂存在 r[0]，这样内层循环判断“是否越界”时就不再需要额外检查下标是否到了 0，代码少一个条件，执行速度也能快一点。

学习这部分时我强烈建议用一两个简单的序列自己人肉跑一遍，比如 {49, 38, 65, 97, 76, 13, 27}，严格按照教材代码的写法画哨兵、画移动箭头。不要嫌这个过程笨，我能把堆排序调明白就是因为先手写了三遍建堆过程图。

2. 插入类排序：直接插入、折半插入、希尔排序

2.1 直接插入排序：像整理扑克牌，哨兵写法是精髓

直接插入排序的思路一句话就能讲清楚：把待排序序列分成两部分，左边是已经有序的序列，右边是待插入元素；每次从头开始把右边第一个元素插入到左边合适位置。它的直观类比就是打扑克牌时，摸到一张新牌然后把它插到手里已经排好序的牌中。

教材代码的逻辑是这样的：

c复制void InsertSort(SqList &L) {
    for (int i = 2; i <= L.length; i++) {
        if (L.r[i].key < L.r[i - 1].key) {
            L.r[0] = L.r[i];          // 暂存待插入记录
            int j;
            for (j = i - 1; L.r[0].key < L.r[j].key; --j)
                L.r[j + 1] = L.r[j];  // 记录后移
            L.r[j + 1] = L.r[0];      // 插入到正确位置
        }
    }
}

这段代码需要抠三个细节。第一，外循环从 i=2 开始，因为只有一个元素时天然有序。第二，if 判断用来优化——如果当前元素已经比前面最大的元素大，说明位置正确，省掉一次不必要的搬移。第三，内层循环把 L.r[0].key < L.r[j].key 作为继续后移的条件，当 j 一路减小到 0 时，L.r[0].key < L.r[0].key 明显为假，循环自动终止，因此不需要额外判断 j 是否越界，这就是哨兵的价值所在。

复杂度上面，最好情况是序列本来就接近有序，每趟只需比较一次，总时间 O(n)；最坏情况是逆序，比较和移动次数都达到最大值，O(n²)；平均情况也是 O(n²)。由于相同关键字的元素在插入过程中不会跨越彼此（严格从左往右插入，相等时停止后移），直接插入排序是稳定的。适用场景就是“数量小且基本有序”，实际工程中很多排序库在小片段上都会切到插入排序，原因后面讲快排时会提到。

2.2 折半插入排序：比较次数少了，移动次数一分没省

折半插入排序是直接插入排序的改进版，改进思路是：前面那部分已经有序，为什么还要从后往前一个个比较？直接二分查找插入位置不就行了。查找位置的时间从 O(i) 降到 O(log i)，总的比较次数从 O(n²) 降到 O(n log n)。听着很美，但是注意——找到位置之后，仍然要把位置之后的所有元素全部后移一位，移动次数依然是 O(n²)，所以总的时间复杂度并没有发生量级变化，还是 O(n²)。

教材里提这个算法，我认为更多是为了强化“折半查找”在有序表上的应用，顺便打破一些学生的幻觉：优化某个环节不代表整体复杂度就能跟着降，算法分析要看所有操作的加权总和。如果你在复习时想在这里多花时间，可以重点关注它为什么稳定（相等元素插到已有相等元素的后面）、为什么只适用于顺序表（链表没法随机访问也就没法二分）这两点。

2.3 希尔排序：分组插入如何突破 O(n²) 的天花板

希尔排序是插入排序的一次重大突破，它的核心动作是“跳跃式插入”。先把序列按某个增量 d 分成若干子序列，对每个子序列做直接插入排序，然后缩小 d，重复这个过程，直到 d=1 做最后一次完整的插入排序。

为什么这样能变快？关键在于插入排序有一个特性：序列越接近有序，效率越高。希尔排序前期用大的增量让元素快速跳到距离它最终位置不远的地方，然后再逐步细化排序，每一轮都在为下一轮创造“接近有序”的有利局面，最后一次 d=1 时虽然要做一次完整的插入排序，但此时的序列已经几乎有序，比较和移动次数都非常小。这个过程在最坏情况下依然能保持比 O(n²) 更好的性能，教材中给出的经验复杂度大约在 O(n^1.3) 左右，具体值依赖增量序列的选取。

增量序列的选择非常关键。严蔚敏教材采用的是希尔本人提出的增量序列 d = ⌊d/2⌋，d 初始为 ⌊n/2⌋，比如 n=8 时增量序列是 4、2、1。这个序列实现简单，但存在一个弱点：某些元素可能在相邻两轮之间只移动一位，导致最后一轮负担过重。实际研究中有人用 Hibbard 增量序列 1, 3, 7, 15...，也有人用 Sedgewick 增量序列，性能更好。至于不稳定性，可以这样理解：分组后，相同的元素可能被分到不同的组，各自在组内完成插入，相对顺序可能被打乱。希尔排序也是教材中第一个不稳定的排序，这种细节在考试里常以判断题出现。

如果要写代码，本质上就是三层循环套直接插入排序思路，我把教材代码拆成“按增量分组”的写法，方便理解：

c复制void ShellInsert(SqList &L, int dk) {
    for (int i = dk + 1; i <= L.length; i++) {
        if (L.r[i].key < L.r[i - dk].key) {
            L.r[0] = L.r[i]; // 暂存
            int j;
            for (j = i - dk; j > 0 && L.r[0].key < L.r[j].key; j -= dk)
                L.r[j + dk] = L.r[j];
            L.r[j + dk] = L.r[0];
        }
    }
}
void ShellSort(SqList &L, int dlta[], int t) {
    for (int k = 0; k < t; k++)
        ShellInsert(L, dlta[k]);
}

注意这个写法里我把 j 的范围判断 j > 0 加回去了，因为分组插入时每次跳跃 dk 个位置，如果沿用原来的纯哨兵写法，L.r[0] 只能保证下标 0 处是当前待插入元素，无法阻止 j 跳到负数下标，所以这里必须老老实实检查边界。这也是教材上一个容易让读者困惑的地方——同样的插入逻辑，在直接插入排序里可以用哨兵省略边界检查，在希尔排序里却不能依赖。真正理解了 r[0] 哨兵的边界保护原理，就不容易在这里踩坑。

3. 交换类排序：冒泡排序和快速排序

3.1 冒泡排序：每趟把最大值“冒”到最后面

冒泡排序的想法很朴素：从前往后两两比较相邻元素，如果顺序反了就交换，这样最大元素就会像气泡一样浮到序列末尾；然后对前面未排好的部分重复。教材代码通常这样组织：

c复制void BubbleSort(SqList &L) {
    for (int i = 1; i < L.length; i++) {
        bool flag = false;
        for (int j = 1; j <= L.length - i; j++) {
            if (L.r[j].key > L.r[j + 1].key) {
                RedType temp = L.r[j];
                L.r[j] = L.r[j + 1];
                L.r[j + 1] = temp;
                flag = true;
            }
        }
        if (!flag) break; // 本轮没有交换，说明已有序
    }
}

加入 flag 标记是本算法最重要的优化：如果某一趟遍历结束后一次交换都没有发生，说明所有元素都已到位，可以提前终止。这在序列几乎有序时非常有效，例如一个已经有序的数组，只需一趟扫描即可确认终止，时间复杂度降到 O(n)。你没看错，这比很多“稳定但呆板”的实现快得多，而这正是我多次在线上业务代码里看到同事用冒泡排序，却因为没加 flag 标记导致性能白白翻倍的地方。

冒泡是稳定的，因为只有 > 时才交换，相等的元素不会越过彼此。最坏和平均复杂度都是 O(n²)，空间复杂度 O(1)。它最大的价值是“实现简单、不容易写错、稳定”，所以在少量数据的教学、简单工具脚本里常见。刷题时不建议用它处理 n 大于几千的数组，尤其是逆序数据，那会让你真切体验到什么是“等得花儿都谢了”。

3.2 快速排序：划分枢纽，递归分治

快排在绝大多数场景下是内部排序的首选，原因是平均时间 O(n log n)，而且常数因子很小。它由 Hoare 在 1962 年提出，思想是：从序列中选一个“枢纽”，把比它小的元素放到它左边，比它大的放到右边，再对左右两部分递归地重复这个过程。教材的 Partition 函数用得非常紧凑：

c复制int Partition(SqList &L, int low, int high) {
    L.r[0] = L.r[low];            // 用子表的第一个记录作枢纽记录
    KeyType pivotkey = L.r[low].key;
    while (low < high) {
        while (low < high && L.r[high].key >= pivotkey) --high;
        L.r[low] = L.r[high];     // 比枢纽小的移到低端
        while (low < high && L.r[low].key <= pivotkey) ++low;
        L.r[high] = L.r[low];     // 比枢纽大的移到高端
    }
    L.r[low] = L.r[0];            // 枢纽记录到位
    return low;
}
void QSort(SqList &L, int low, int high) {
    if (low < high) {
        int pivotloc = Partition(L, low, high);
        QSort(L, low, pivotloc - 1);
        QSort(L, pivotloc + 1, high);
    }
}

这段代码的每一步都是在 “填坑”：先用 r[0] 把 low 位置的枢纽值拿出去，low 位置空出来；然后从右边找比枢纽小的值填到 low；再从左边找比枢纽大的值填到 high；循环往复，最后把枢纽值放回去。这个实现方式既省了额外空间，又避免了频繁交换。我第一次理解这段代码时有一个坎——为什么内层两个 while 都要带 low < high，少了会怎样。后果其实很严重，可能 low 越过 high，数组越界，或者把已经填好的位置再覆盖掉。所以这个双端交替填坑结构，是快排书写的核心考点，建议多画几次图。

快排为什么不稳定？看这个例子：[3a, 3b, 2]，选 3a 作枢纽，2 比枢纽小被移到最前面，3b 位置不变，排完结果可能是 [2, 3b, 3a]，3a 和 3b 的先后关系就变了。因为 Partition 过程会大跨度移动元素，相同关键字的相对位置无法保证。

枢纽的选择对快排影响巨大。如果输入序列已经基本有序，每次选第一个元素当枢纽，会导致两个子序列严重不平衡（比如左边为空），递归深度退化成 n，时间复杂度退化为 O(n²)。教材会在“改进”部分提到选中间位置或随机选枢纽。工程上还常用三数取中法——取 low、mid、high 三个位置的值，以它们的中位数作枢纽。不要小看这一步，我在线上分析过一个排序耗时过长的 case，原始数据是“按时间戳逆序写入但需要按主键排序”的场景，用裸快排就踩了最坏情况的坑；改成随机枢纽后，耗时从几千毫秒降到几十毫秒，差距非常夸张。

3.3 快排的工程优化细节：递归栈和区域切换

快排的空间复杂度不是 O(1)，而是 O(log n)——这是因为递归调用需要系统栈来保存现场。最坏情况下递归深度 O(n)，空间复杂度 O(n)，所以对于数据量特别大、系统栈比较紧张的场景，要注意爆栈风险。工程上常见的处理方式：一是改用“尾递归”优化，减少一半的递归层次；二是当子序列长度小于某个阈值（比如 10~20）时，改用插入排序完成收尾。插入排序在小规模数据上的常数极小，而快排到后期反复递归产生的开销反而更大，所以“小段切插入排序”能获得非常可观的提速。C++ STL 里的 sort 就采用了类似思想的 introsort：先走快排，如果递归深度超过阈值则切到堆排序保证 O(n log n) 的最坏复杂度，小片段再切插入排序优化，这就是一个教科书排序走向工程化的典型样本。

Partition 函数本身也可以单独抽象出来使用，比如“求无序数组中第 K 小的元素”，每趟 Partition 后判断枢纽位置是否等于 K，不等于就只递归一侧，平均 O(n) 时间解决，这就是快速选择算法。很多同学学完快排只是会背代码，真正拉开差距的恰恰是这种“把排序过程拆成可复用组件”的意识。

4. 选择类排序：简单选择排序与堆排序

4.1 简单选择排序：固定比较，交换次数很少

简单选择排序的思路一句话：每趟从未排序部分选出最小的元素，和未排序部分的第一个元素交换。它的代码实现比较简单，核心是双重循环，但有个显著的复杂性特征：无论输入数据是否有序，比较次数始终是 n(n-1)/2，因此最好、最坏、平均时间复杂度都是 O(n²)。交换次数则是 O(n) 级别，最坏也只需要 n-1 次交换，这在“移动代价远大于比较代价”的场景中反而有优势，比如元素结构很大但关键字很小时。

简单选择排序不稳定，举一个容易忽略的例子：[5, 5, 1]，第一趟选出 1，和第一个 5 交换，序列变成 [1, 5, 5]，两个 5 的相对顺序没有变化；但如果第一趟选择到的是第二个 5 呢？实际算法永远是选最小元素和第一位交换，所以例子需要构造跨多个相同值的情况，比如 [2, 2, 1, 2]，第一趟把 1 换到前面，第一个 2 被换到末尾？不对——这里最小元素 1 在位置 3，它与位置 1 的 2 交换，交换后 2a 走到位置 3，2b 在位置 2，2c 在位置 4，三个 2 中 2a 落到了 2b 后面，因此不稳定。这类小例子最好自己手推几遍，考试时很容易被拿来判断稳定性。

4.2 堆排序：借助完全二叉树找最值

教材把堆排序放在选择排序大类里，因为它本质是“每趟选择一个最值放到正确位置”，只是用了一个比线性扫描高效得多的数据结构——大顶堆（或小顶堆）。堆是一棵完全二叉树，在顺序表中的存储规则是：下标 i 的节点的左孩子是 2i，右孩子是 2i+1，父节点是 i/2。大顶堆要求每个节点都不小于它的孩子，所以堆顶是整个序列的最大值。排序过程可以拆成三个关键阶段。

第一个阶段，建初始堆。从最后一个非叶子节点开始往前逐个调整，最后一个非叶子节点的下标是 n/2。调整函数如下，也叫“下沉”：

c复制void HeapAdjust(SqList &L, int s, int m) {
    RedType rc = L.r[s];
    for (int j = 2 * s; j <= m; j *= 2) {
        if (j < m && L.r[j].key < L.r[j + 1].key)
            ++j;          // 让 j 指向较大的孩子
        if (rc.key >= L.r[j].key)
            break;        // 父节点已经不小于孩子，调整结束
        L.r[s] = L.r[j];  // 大孩子上移
        s = j;            // 继续往下一层
    }
    L.r[s] = rc;
}

这段代码为什么这么难记？因为它在循环里不断 “下沉” 被掏空的节点。刚开始我总是试图用一个临时变量同时保存父节点和孩子节点，结果绕来绕去。后来我发现正确的理解方式是：先把堆顶元素暂存到 rc，把它当作一个“空洞”，每轮把更大的孩子提到空洞位置，然后空洞下移一层，直到找到 rc 真正能放的位置。把这个过程想象成“在二叉树上挖洞填洞”，代码就顺了。

第二个阶段，交换堆顶与末尾元素。堆排序每一趟把堆顶最大值交换到当前范围的最后位置，然后把堆的范围缩小 1，再对堆顶执行一次 HeapAdjust。重复 n-1 次后序列完成升序排序，因此大顶堆排出来是升序，小顶堆排出来是降序，这个细节经常有人弄反。

第三个阶段是复杂度与稳定性的判断。建堆过程整体 O(n)，之后 n-1 次堆调整，每次调整代价 O(log n)，总复杂度 O(n log n)。无论输入数据是否有序，堆排序总能保持这个量级，这是它相对快排的一大优势——没有明显的最坏退化。但堆排序的常数因子比快排大，实际运行往往不如快排快，这是“理论复杂度相同但常数不同”的典型案例。堆排序不稳定，因为堆调整过程中父子节点间的远距离移动可能改变相等元素的相对顺序。

4.3 堆排序的应用：TopK 与优先队列

堆排序在实际应用中很多时候不作为完整排序工具出现，而是以“优先队列”的形态解决问题。最经典的就是 TopK：在海量数据中找最大的 K 个数。用容量为 K 的小顶堆作为容器，遍历数据时，如果当前元素比堆顶大，就弹出堆顶、把当前元素插入堆。这样做的时间复杂度是 O(n log K)，如果 n 很大而 K 很小，这是一个巨大的优势。另外一个高频场景是“合并 K 个有序链表”——每次从 K 个链表头中取最小节点，用一个最小堆维护候选集合，代码复杂度可控且高效。

这类题目在面试中常作为堆的考察载体，本质就是在问“你会不会把一个无序数组建成 O(n) 的堆，以及会不会在 O(log n) 内完成一次调整”。王卓老师的 PPT 和多个考研网课都把 HeapAdjust 的“s”和“m”边界讲得很细，建议你边看边亲手用无符号数组推演一次。我在复习初期曾因为背错边界条件，导致某次模拟笔试题里堆排序结果差一位没排完，后来彻底弄懂了下标语义，才算真正稳定拿分。

5. 归并排序与基数排序：稳定排序里的两种不同思路

5.1 二路归并排序：先拆到底，再两两合并

归并排序和前面所有排序的思路都不太一样——它假设两个子序列已经各自有序，然后在线性时间内把它们合并成一个有序序列。那怎么让子序列有序？递归地把序列拆成单个元素，单元素天然有序，然后再逐层合并回来。这就是分治思想的典型应用，严蔚敏教材里的归并排序虽然代码较长，但核心合并步骤很简单：

c复制void Merge(RedType R[], RedType T[], int low, int mid, int high) {
    int i = low, j = mid + 1, k = low;
    while (i <= mid && j <= high) {
        if (R[i].key <= R[j].key)
            T[k++] = R[i++];
        else
            T[k++] = R[j++];
    }
    while (i <= mid) T[k++] = R[i++];
    while (j <= high) T[k++] = R[j++];
}

合并两个有序数组的过程用的是双指针：两个指针分别指向两个子序列的开头，每轮比较一次，把较小的放入结果数组，然后指针后移。if (R[i].key <= R[j].key) 这个等号是归并排序能保持稳定的关键——当左右相等时先取左侧元素，这样相等关键字的相对顺序不会被破坏。

归并排序的时间复杂度稳定在 O(n log n)，不会像快排那样被输入数据影响；代价是需要 O(n) 的额外辅助数组。递归深度是 log n，所以它也可以用于链表排序——因为链表不需要随机访问，只要递归拆成前后两半再合并即可。甚至在外部排序（数据量大到内存放不下）时，归并也是基础框架。综合来看，如果你需要“稳定 + 大数据量 + 时间可控”的组合，归并排序几乎是优先选择。实际工程中的 Java 对象数组排序 TimSort，其本质就是归并+插入的混合改进版。

5.2 基数排序：不比较大小，通过分配与收集完成排序

基数排序和前八种基于比较的排序完全不同。比如一批三位数，先按个位数字分配到 10 个桶里，然后按桶的顺序收集回来；再按十位重复，最后按百位重复。从最低位开始处理（LSD）能得到稳定排序，因为后面的高位分配不会破坏前面低位已经排好的稳定顺序。时间复杂度是 O(d(n+r))，其中 d 是关键字的位数，r 是基数（十进制就是 10）。当 r 和 d 都不大时，它可以做到线性时间排序，比 nlogn 更快，这也是唯一能突破比较排序理论下界的方式，代价是需要额外的 O(n+r) 空间。

基数排序也有明显局限：它只适合关键字结构可以分解为若干“位”的数据，比如整数、短字符串。对浮点数、复杂对象，很难找到合理的“位”划分。实际业务中对“字符串排序”，如果字符串长度差异较大，字典树配合深度优先遍历往往更合适；如果长度一致且基数小，基数排序则相当高效。教材里讲基数排序时使用的链式队列分配法，逻辑较绕，考试时更常考的是“手推一趟分配与收集过程”，所以你可以先把轮次推演练熟，代码实现可以放到第二优先级。

6. 横向对比与选型：八大排序复杂度、稳定性、适用场景一览

6.1 核心指标速查表

整理一张表格，把九种排序的关键特性放在一起，方便备考复习和面试前速记：

这张表里的每一项都值得单独追问一句“为什么”。比如为什么折半插入的最好复杂度只影响比较次数，移动次数仍为 O(n²)，所以整体是 O(n²)？为什么快排的平均和最坏差这么多，而堆排和归并基本不受输入影响？一旦你能把表格里每个数字都讲出背后的执行过程原因，才说明排序真的入门了。考试中“给出一组数据，问什么排序过程长什么样”也是高频题，建议每种算法都用手工模拟一两轮，形成肌肉记忆。

6.2 根据业务场景如何选型

实际工程中出现“数组需要排序”时，大多数语言的标准库已经提供了混合排序实现，自己造轮子的机会不多。但理解选型逻辑依然很重要：当数据量很小（几十到几百）时，直接插入排序简单有效；当数据基本有序时，插入排序和带标记的冒泡排序都有 O(n) 的潜力；当数据量大且不要求稳定时，快排通常是默认首选；当要求“最坏情况也不退化”时，堆排或归并更稳妥；当要求稳定且数据量较大时，归并排序是合规选择；当关键字结构适合分解时，基数排序可能带来意外的线性复杂度；当内存极度紧张时，堆排序或快排的原地特性很重要。

我在一个实际项目中曾遇到每月跑一次的报表任务，输入是几十万行日志，需要按用户 ID 排序聚合。一开始我用裸快排，运行时间可以接受；后来数据源顺序发生变化，出现大量逆序片段，快排频繁退化，任务开始超时。换成堆排序后运行时间不再波动，代价是平均比顺数据下的快排慢了一些，但换来的是“最坏也可控”的稳定性。这个取舍过程让我意识到，所谓“最优排序”不存在，只有“最适合当前输入特征与约束”的排序。

6.3 教材之外的 408 考点和八股延伸

如果你在准备考研 408 或数据结构期末考试，排序章节的出题方向其实很固定。第一类是给定初始序列要求写出每趟排序结果，这是所有算法都必须掌握的。第二类是判断排序方法的稳定性与复杂度，容易混淆的点是：快排和堆排不稳定、简单选择不稳定、希尔不稳定、归并稳定、基数稳定、插入和冒泡稳定。第三类是问“什么情况下快排最慢”“为什么堆排不适合小数据”这类原理题，回答时需要从递归划分、常数因子等角度展开。

另外一个高频考点是“链式存储下的排序选择”。数组排序中大量使用随机访问（折半插入、堆排序、快排的 Partition 都需要），一旦变成单链表，这些算法会失去效率；插入排序和归并排序则天然适合链表，因为它们的核心操作是“插入”“合并”，只需要修改指针就能完成。这也是为什么王道和严蔚敏教材都强调，外部排序要基于归并，内存排序则默认用顺序表。理解存储结构与算法操作的匹配关系，比背一堆“适用场景”更不容易被考题绕进去。

7. 实验与避坑：亲手写一遍排序的正确姿势

7.1 建议的动手实验方案

我整理这套排序时，给自己定过一个“排序实验验收流程”，现在分享给你。第一步，写一个工具函数生成几种测试数据：完全随机、升序、降序、大量重复元素、少量近乎有序。第二步，为每种排序实现对应函数，每一个函数在 n=10 的小数据上先打印每一趟排序结果，用人工方式和手推过程对比。第三步，在 n=10000 以上的大数据上测试耗时，验证复杂度是否符合预期。第四步，设计一个包含唯一 ID 的“记录”结构，确保相同 key 的元素有先后标记，用来验证稳定性判断。

如果只是“看懂了”就想往下走，后面写 AVL 树、B+ 树时很容易因为基础不牢而返工。排序几乎是数据结构教材里最适合用来建立“算法正确性感觉”的一章——你写的代码对不对，立刻就能跑出来验证；运行时间如果异常，立刻能反推是复杂度出了问题还是实现上隐藏了 O(n²) 的操作。这种反馈循环对编程能力的提升是真的快。

7.2 常见坑位与排查方向

第一个坑是下标边界。 严蔚敏教材代码里数组从 1 开始存，但如果你自己写测试数据时从 0 开始，或者把 for (int j = 2 * s; j <= m; j *= 2) 写成 j < m，堆调整就会漏掉最后一个节点。排查方法是打印每一趟建堆结束后数组的全部内容，和手推对比，很快能定位是哪一段丢元素。

第二个坑是快排的递归死循环。 如果枢纽值恰好是当前区间最大值或最小值，Partition 返回的 low 可能等于 high 或者落在端点，此时如果没有正确排除枢纽位置，QSort(L, low, pivotloc - 1) 和 QSort(L, pivotloc + 1, high) 可能有一个区间为空，这是正常的，但如果递归条件写成了 if (low <= high) 或者递归新区间包含了 pivotloc 本身，就可能永远无法收敛。遇到递归过深或内存溢出时，优先检查递归区间是否单调缩小。

第三个坑是归并排序的合并区间不连续。 递归归并时 mid 的计算方式如果写成 (low + high) / 2，在 low 和 high 很大时可能整数溢出，要写成 low + (high - low) / 2。合并时漏掉尾部剩余元素也很常见，忘了写最后两个 while 循环就会导致元素莫名丢失。我在辅导大一学生实验课时发现，这个坑的概率几乎有一半。

第四个坑是稳定性验证方法不对。 想验证某种排序稳不稳定，不能只看输出结果是否有序，必须给相同 key 的记录编码，例如用 (value, id) 的结构体，排序完成后检查 value 相同的元素 id 是否保持输入顺序。很多教材习题说“简单选择排序不稳定”，很多学生拿一个没有重复元素的序列验证半天，当然什么都看不出来。

第五个坑是测试数据太温柔。 很多同学测试时只用随机小数数组，排完一看没报错就收工，结果退化场景一个都没测到。快速排序在降序输入上最容易暴露最坏 O(n²) 的问题；插入排序在几乎有序的数据上才有最好表现；堆排序如果只测 n 小于 10 的数据，调整过程反映不出来“下沉”多层的复杂度差异。建议准备一份测试矩阵，至少包含 n=0、n=1、n=2、n=10000 的随机数据、降序数据、大量重复数据，四种组合跑一遍才算完整。

7.3 我的一些个人心得

排序这章我前后翻过好几遍，自己敲过、讲过、也在生产环境里排查过排序问题，有一个感受特别深：不要试图硬背代码，一定要为每个排序找到让你“通”的那个比喻或者图式。直接插入是理牌，快排是挑一个基准然后左右分队，堆排是拿完全二叉树当自动选最大值的机器，归并是先拆到底再拼回去。代码是这些思想的具体表达，思想通了代码顺手就能写出来。

另外，如果做题总错“某趟之后序列是什么”，我建议不要只看文字，拿一张草稿纸画出每一轮下标变化。尤其是快排的填坑过程、堆排的建堆过程、归并的合并过程，画上三遍，各种边界就刻在脑子里了。很多考 408 的同学最后悔的就是排序章节过于依赖“看懂了”而没有“亲手推演”，导致考场上时间一紧张就手抖出错，这个成本真的不值得。

复习时可以把“八大排序”当成一把尺子：先用最简单的直接插入排序建立插入类直觉，再用快排理解分治和递归，再用堆排理解完全二叉树与数组的映射，最后用归并理解稳定与外部排序的衔接。四类思想都打通之后，你会发现后续学习哈希、树、图时很多思维方式是共通的。排序不是一个孤立的章节，它其实是整本数据结构里“算法设计思想最密集的一章”。