堆排序算法详解：完全二叉树构建大顶堆与O(n log n)排序实战

堆排序是我个人非常喜欢的一个排序算法，不是因为它的效率在所有场景下都最高，而是因为它背后的数据结构思想——完全二叉树与数组的无缝映射——实在太巧妙了。很多人学排序算法，从冒泡、选择开始，然后到快排、归并，最后接触堆排序，会发现它是“用树形逻辑解决线性存储排序问题”的典型代表。

这篇以“13-堆排序算法”为题的内容，不会像教科书那样堆公式，而是从“为什么需要堆排序”开始，把最大堆的构建、元素下沉、堆排序的完整流程，以及那些面试和工程里容易被问倒的细节，一个个拆开讲。同时我会提供C++和Python两套可直接运行的参考代码，结合我的实际经验，告诉你哪些地方最容易写错，以及堆排序真正的用武之地在哪里。适合正在学数据结构与算法的在校生、准备算法面试的开发者，以及想在实际项目中评估排序方案选型的工程师。

1. 整体设计思路：为什么排序要借助“堆”这种结构

1.1 从选择排序的弱点说起

先回顾一下选择排序的思路：每一轮从未排序区间中找出最小值/最大值，放到有序区间的末尾，重复n-1轮搞定全部元素。这个过程的时间复杂度是O(n²)，瓶颈在哪里？在于“每轮找极值”时，都需要从头到尾扫描一遍剩余元素，这个扫描浪费了大量重复比较。假如有一种办法，能在O(1)或者更快的时间内拿到当前最大值，并且拿到之后删除它、剩下的元素还能继续保持“能快速取到最大值”的性质，那排序的时间复杂度就有了大幅下降的空间。

堆排序的核心思路正是如此：先用给定数组构建一个大顶堆（Max Heap），保证堆顶永远是当前最大值。每次把堆顶元素交换到数组末尾（也就是“取出最大值”），然后把剩余的元素重新调整为一个大顶堆，再次取堆顶……循环下去。整个过程不用额外的复杂数据结构，堆本身就存储在原数组里，并且关键操作——调整堆的过程——能控制在O(log n)的复杂度内，因此堆排序的整体复杂度是O(n log n)。

1.2 完全二叉树与数组的秘密约定

堆是一棵完全二叉树，这意味着它除了最后一层，其他层都是满的，并且最后一层的节点都靠左排列。完全二叉树有一个特别大的好处：可以直接用数组存储，不需要维护任何指针。

如果数组下标从0开始，那么对于下标为 i 的节点：

• 它的左孩子下标是 2*i+1
• 它的右孩子下标是 2*i+2
• 它的父节点下标是 (i-1)/2（整数除法）

这个映射关系是堆排序所有代码的基础。只要记住了这三个公式，任何关于堆的位置计算都不会出错。我一开始学的时候，总是混淆从0开始和从1开始的两种下标体系，后来我自己总结了一句话：从0开始，左孩子是2i+1，右孩子是2i+2；从1开始，左孩子是2i，右孩子是2i+1。 只要实现之前先统一下标约定，代码就不会出现偏移混乱。

1.3 什么场景下优先选堆排序

堆排序在实际工程中的出场率比不上快速排序和内排序中的部分场景，但它在一些特定情况下有不可替代的优势：

• 最坏时间复杂度保证为O(n log n)。快速排序在实现较差的版本下可能退化到O(n²)，而归并排序需要额外O(n)的内存。堆排序在最坏、平均、最好情况下都是O(n log n)，时间性能上没有任何“暗坑”。
• 原地排序，空间复杂度O(1)。虽然归并排序是稳定的O(n log n)算法，但它需要额外的辅助数组，在内存敏感的环境中（比如嵌入式系统、单片机环境）堆排序用起来更踏实。
• 可以只取前k个最大值/最小值。堆排序和“堆”这个数据结构本身最常用的场景是“从海量数据中找Top K”和大规模数据流的中位数，这种场景用完整排序是浪费的，构建一个大小为k的小顶堆即可解决。

当然，堆排序也有明显短板：它是不稳定排序，相同的元素在排序前后相对位置可能改变。如果排序后的稳定性有硬性要求（比如按成绩排序时，同分数的学生要按学号顺序输出），那必须选归并排序或稳定的优化快排，堆排序就不合适了。

2. 核心概念解析：数组如何变成一个“堆”

2.1 大顶堆与小顶堆的判定标准

堆其实是一个完全二叉树，并且满足堆序性（Heap Property）。大顶堆要求每个节点的值都大于等于它的左右孩子的值，也就是父亲≥孩子；那么堆顶自然是全堆的最大值。小顶堆则反过来，父亲≤孩子，堆顶是最小值。

这里有一个容易和经验直觉产生差异的地方：堆只是“部分有序”的结构，并不代表数组是全局有序的。比如大顶堆只保证了父节点比子节点大，但左子节点和右子节点之间的大小没有约束，而且不同子树之间也没有完全排序关系。因此，不能通过一次建堆就得到有序数组，堆排序的过程仍然是一个“反复从堆顶取最大值，并重新调整堆”的循环。

2.2 上滤（Shift Up）与下滤（Shift Down）两个基础动作

堆的各种操作本质上就两个方向的动作：

• 上滤（Shift Up / Swim）：当一个节点值变大，可能破坏父节点≥子节点的关系时，就要和它的父节点比较，若当前节点比父节点大，就交换两者，然后继续向上比较，直到满足堆序或者到达堆顶。上滤一般用于“向堆中插入元素”的操作场景。
• 下滤（Shift Down / Sink）：当一个节点值变小，可能不再满足父节点≥子节点的关系时，就把它和较大的那个子节点比较，若比子节点小则交换，然后继续向下调整，直到叶子节点或者满足堆序。下滤一般用于“删除堆顶”或“建堆”的操作场景。

在堆排序中，最核心的动作是下滤。每次把堆顶元素交换到数组末尾，此时新的堆顶很可能不是最大的，就需要对这个堆顶做下滤操作，让最大的元素重新浮到堆顶。建堆过程也是从最后一个非叶子节点开始，反复执行下滤。

2.3 建堆的时间复杂度为什么是O(n)

初学堆排序的人最容易想当然的问题就是：建堆用上滤插入，把数组元素一个一个插入到一个新的堆结构里，那每个插入调整是O(log n)，一共n个元素，总体复杂度不就是O(n log n)吗？这个推理在逻辑上是通的，但“建堆”完全可以用更高效的方式。

从数组的最后一个非叶子节点开始，对每个节点执行下滤操作，这个从下往上、逐个下滤的过程，整体的时间代价不是O(n log n)，而是O(n)。为什么？

粗略的感觉：下滤的代价取决于这个节点下沉的路径长度，而靠近叶子节点的节点数量多，但它们下沉的高度浅；靠近堆顶的节点数量少，下沉的高度深。把它们的分摊代价加起来，是一个线性级别的结果。用数学公式可以这样大约估算：假设堆是完全二叉树，高度h层。第h-1层的节点最多下沉1步，第h-2层的节点最多下沉2步，依此类推。总的下沉步数求和为：

S = 1×2^(h-2) + 2×2^(h-3) + 3×2^(h-4) + ... + (h-1)×2^0

这个求和结果是2^(h)级别的，而n=2^(h+1)-1，所以S的复杂度是O(n)。这里不用死记公式推导，关键是记住结论：Floyd建堆法（从底向上逐个下滤）是O(n)，堆排序阶段每趟处理是O(log n)，共n趟，因此堆排序的总复杂度为O(n log n)。

2.4 手写堆排序的模块化拆分

在真正写堆排序代码之前，我建议先把问题拆成三个相对独立的函数：

1. buildMaxHeap()：把一个无序数组调整成一个大顶堆
2. maxHeapify()（或者叫sinkDown()）：对指定位置的节点执行下滤调整，维护堆序
3. heapSort()：主流程，先建堆，再反复交换堆顶与末尾，并缩小堆的范围后调整

这种模块化拆分有两个好处：一是每个函数逻辑简单、容易测试和debug；二是面试时向面试官讲解思路，也能表达出清晰的工程化思考方式。我最开始学堆排序时就是一股脑把所有逻辑写在了一个函数里，结果一旦运行结果不对，定位BUG非常痛苦，后来改成这种模块化结构后，问题立刻变得可控很多。

3. 实操过程与核心代码实现

3.1 大顶堆代码实现与每行解释

我用C++先给出一版完整的堆排序（升序用大顶堆），代码里我加了足够详细的注释：

cpp复制#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

// 对以root为根的子树执行下滤调整
// 假设root的左右子树都已经是合法的最大堆
// n表示当前堆的有效元素个数（并非整个数组长度）
void maxHeapify(vector<int>& arr, int n, int root) {
    int largest = root;          // 假设当前根是最大的
    int left = 2 * root + 1;     // 左孩子下标
    int right = 2 * root + 2;    // 右孩子下标

    // 如果左孩子存在且比当前最大值大，更新largest
    if (left < n && arr[left] > arr[largest]) {
        largest = left;
    }
    // 如果右孩子存在且比当前最大值大，更新largest
    if (right < n && arr[right] > arr[largest]) {
        largest = right;
    }

    // 如果最大值不是原本的root，交换并递归向下调整
    if (largest != root) {
        swap(arr[root], arr[largest]);
        maxHeapify(arr, n, largest);
    }
}

// 建堆：从最后一个非叶子节点倒序遍历并下滤
void buildMaxHeap(vector<int>& arr, int n) {
    // 最后一个非叶子节点的下标是 n/2 - 1
    for (int i = n / 2 - 1; i >= 0; --i) {
        maxHeapify(arr, n, i);
    }
}

void heapSort(vector<int>& arr) {
    int n = arr.size();
    // 第一步：建立最大堆
    buildMaxHeap(arr, n);

    // 第二步：重复交换堆顶与堆末尾，并缩小堆范围
    for (int i = n - 1; i > 0; --i) {
        swap(arr[0], arr[i]);   // 将当前最大元素放到数组末尾
        maxHeapify(arr, i, 0);  // 对剩下的 i 个元素重新调整成最大堆
    }
}

int main() {
    vector<int> arr = {4, 10, 3, 5, 1, 2, 8, 7, 6, 9};
    heapSort(arr);
    for (int num : arr) {
        cout << num << " ";
    }
    return 0;
}

有几个关键点我需要专门拎出来讲：

为什么最后一个非叶子节点是 n/2 - 1？ 最后一个元素的下标是n-1，根据父节点公式，它的父节点下标是(n-1-1)/2，也就是n/2-1（整数除法）。既然它后面的节点都是叶子节点，本身没有子树可调整，所以直接从它开始往前遍历并下滤，就能覆盖所有有孩子的节点。

为什么每趟交换之后，调整的是下标0而不是其他节点？ 因为交换后，只有堆顶那个元素是从末尾拿过来的“异常元素”，它的左右子树仍然保持大顶堆结构，所以只需要对根节点执行一次下滤即可。如果用“堆排序只需要每趟调整一次”来对比“普通建堆需要O(n)”，正好体现了堆排序的巧妙之处。

3.2 建堆过程的跟踪与验证

以数组 [4, 10, 3, 5, 1, 2, 8, 7, 6, 9] 为例，n=10，最后一个非叶子节点下标是10/2 - 1 = 4，也就是值为1的节点。检查它的左右孩子，分别是下标9对应数值9，因为9 > 1，所以交换1和9，此时节点4位置变为9，节点9位置变为1，而它已经是叶子节点，不需要再往下调整。接下来处理下标3，值为5，左右孩子下标7和8分别对应7和6，较大的孩子是下标7对应数值7，交换后变为数组 [4, 10, 3, 7, 9, 2, 8, 5, 6, 1]。再处理下标2，值为3，左右孩子下标5和6对应2和8，8最大，交换后为 [4, 10, 8, 7, 9, 2, 3, 5, 6, 1]。下标1，值为10，比孩子7和9都大，无需移动。下标0，值为4，需要和较大孩子（下标1的10）交换，交换后为 [10, 4, 8, 7, 9, 2, 3, 5, 6, 1]，然后需要继续对下标1的子树下滤，因为4小于它的孩子9（较大的那个），所以交换4和9，最终数组变为 [10, 9, 8, 7, 4, 2, 3, 5, 6, 1]。此时已经是合法的大顶堆。

从这个跟踪过程能看出来两件事：第一，建堆不是一次性把所有元素归位，而是从局部子树一层一层往上调整，最终把最大值浮到堆顶；第二，下滤过程是递归的，因为交换到子节点位置后，可能仍然比它的新子节点小，需要继续下沉。

3.3 堆排序主流程的逐步演示

继续用上面的例子，建堆完成后开始排序阶段：

第一轮，交换堆顶10和堆末尾元素1，此时数组变成 [1, 9, 8, 7, 4, 2, 3, 5, 6, 10]。当前堆的有效范围是前9个元素，10已经排到了最终位置。接着对下标0（值为1）执行下滤，较大孩子是9，交换，然后再和下标1的新孩子的较大者4交换下滤，处理完以后，堆顶变为9，数组是 [9, 7, 8, 6, 4, 2, 3, 5, 1, 10]。

第二轮，交换9和1，把9放到倒数第二个位置，接下来对前8个元素重新调整……以此类推。直到最后只剩一个元素时，整个数组已经按升序排列。经过完整的事件，最终得到 [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]。

下面用一个简明的表格来展示前几轮的状态：

可以看到，随着调整范围不断缩小，数组后部的有序部分逐渐变长。

3.4 用Python实现堆排序及与C++的差异

Python实现可以借助heapq模块偷懒，但如果你想掌握堆排序本身的原理，我建议还是手动实现一遍。下面是一个递归版本的Python实现：

python复制def max_heapify(arr, n, root):
    largest = root
    left = 2 * root + 1
    right = 2 * root + 2

    if left < n and arr[left] > arr[largest]:
        largest = left
    if right < n and arr[right] > arr[largest]:
        largest = right

    if largest != root:
        arr[root], arr[largest] = arr[largest], arr[root]
        max_heapify(arr, n, largest)

def build_max_heap(arr):
    n = len(arr)
    for i in range(n // 2 - 1, -1, -1):
        max_heapify(arr, n, i)

def heap_sort(arr):
    n = len(arr)
    build_max_heap(arr)
    for i in range(n - 1, 0, -1):
        arr[0], arr[i] = arr[i], arr[0]
        max_heapify(arr, i, 0)

if __name__ == "__main__":
    test = [4, 10, 3, 5, 1, 2, 8, 7, 6, 9]
    heap_sort(test)
    print(test)

C++和Python的差别主要在于：不需要刻意处理深拷贝问题；数组下标从0开始；递归函数返回不需要显式return。但有一个注意事项：Python递归深度默认1000层。堆的下滤递归深度理论上等于堆的高度，也就是log2(n)，对绝大多数输入都没问题，但如果测试数据超过2^1000这种不切实际的情况，不需要考虑这个边界。

如果想避免递归，可以改成迭代版本的max_heapify，对工程应用更友好，也降低了一点点函数调用开销：

python复制def max_heapify_iter(arr, n, root):
    while True:
        largest = root
        left = 2 * root + 1
        right = 2 * root + 2
        if left < n and arr[left] > arr[largest]:
            largest = left
        if right < n and arr[right] > arr[largest]:
            largest = right
        if largest == root:
            break
        arr[root], arr[largest] = arr[largest], arr[root]
        root = largest

很多初学者没有意识到递归改迭代的关键：把递归参数更新为新的节点下标root = largest，然后用循环替代函数自身调用。这里的break条件等价于递归版里的if largest == root: return。

3.5 堆排序的完整复杂度与稳定性分析

先给出一张总结表：

关于“最好情况为什么不是O(n)”，很多人存在误解。即使输入数组已经有序，堆排序依然需要先建堆，在建堆完成后也不能立刻判定可以结束，因为堆结构并不是全序结构，必须经过完整的交换-下滤流程。因此堆排序在所有情况下的比较次数都接近n log n量级，这一点和快排不同，快排在最好情况下（比如每次划分都很均衡）能跑出比平均情况更好的常数，但堆排序基本没有这种“输入友好”的场景。

稳定性方面举例来说，假设数组为 [5a, 5b, 3]，下标从左到右对应两个5的顺序为先a后b。建堆时，如果某个比较和交换使得5b越过5a，那么排序后5b就可能出现在5a前面，破坏了相等元素的相对顺序。这也是为什么堆排序不适合用于“多关键字排序”之类的场景。

4. 常见问题与坑点避坑指南

4.1 下标边界问题和最隐蔽的“一颗老鼠屎”BUG

堆排序最常见的运行错误就是数组越界访问。回顾核心公式：left = 2i+1, right = 2i+2。如果i是最后一个非叶子节点，left和right一定存在于数组范围内；但问题经常出在循环终止条件上。

假如你在buildMaxHeap里错误地把循环写成了for (int i = n/2; i >= 0; --i)，看起来只多了一个下标，但下标n/2可能已经是一个叶子节点，调用maxHeapify后，left或right算出超过n的下标。虽然比较逻辑里有left < n的守卫，不会出现段错误，但多做一次无意义的调用，并且如果后续代码误用了超出n范围的下标，就会读到未定义数据。反方向也可能出错，如果循环写成for (int i = n/2 - 1; i > 0; --i)，就漏掉了下标0这个堆顶的处理，最后建出来的堆一定是不合法的，排序结果完全错误。

我调试过几回，发现处理堆排序数组越界问题最好的方法是：在一开始就确定自己的下标约定是左孩子 = 2*root + 1，并且在所有地方都使用< n而不是<= n-1来做边界判断，保持风格统一，能减少很多无意识的错误。

4.2 交换之后忘记缩小堆的范围

堆排序主循环中，每交换一次堆顶和最末尾元素，下一步需要对“剩余的堆”做调整。这个剩余范围是动态变化的。如果错误地一直固定用整个数组长度n来调整，就会把已经放到数组末尾的排好序元素再次拉回到堆里参与比较，最终导致整个数组乱成一团。

一种避免出错的经验是：在主循环中使用变量heapSize来跟踪当前堆的大小。初始heapSize = n，每轮先swap(arr[0], arr[heapSize-1])，然后heapSize--，再对arr[0]下滤（传heapSize）。显式维护heapSize远比每轮计算i-1来得直观，尤其当代码要扩展成“从堆中删除任意元素”等功能时，这个变量必不可少。

4.3 递归下滤与性能陷阱

当数据规模很大的时候，递归带来的函数调用开销可能会成为性能瓶颈。虽然堆排序整体操作次数在几十万级别时通常感觉不出来，但在嵌入式环境或者高频调用场景下，我仍然推荐将下滤实现为循环。循环版本的性能通常比递归版本高出明显比例，且避免了爆栈风险。

下面是C++迭代版本的maxHeapify：

cpp复制void maxHeapifyIter(vector<int>& arr, int n, int root) {
    while (true) {
        int largest = root;
        int left = 2 * root + 1;
        int right = 2 * root + 2;
        if (left < n && arr[left] > arr[largest]) largest = left;
        if (right < n && arr[right] > arr[largest]) largest = right;
        if (largest == root) break;
        swap(arr[root], arr[largest]);
        root = largest;
    }
}

这个迭代版本的思路和递归版本完全一致，只是把递归调用转换为在循环内更新root。

4.4 用Python实现最容易踩的坑：反直觉的负下标

Python的列表支持负下标，所以如果不小心写出了range(n, -1, -1)或者下标访问时用了负数而不自知，代码可能不报错，但逻辑已经错了。比如在max_heapify里如果忘了检查left < n，当left正好等于n时，arr[n]会直接报IndexError，这是好的，能及时暴露问题；但如果因为某些计算，left等于n-1、n-2等正常范围内，就不会报错。最危险的反而是循环变量范围错误导致一直无法访问某个元素，这时程序不会异常退出，但输出结果始终不对。

我在写Python版堆排序时吃过一次亏：用的数组是随机生成的，排序后输出发现开头前几个元素没排对，后来打印每次交换后的数组才发现问题出在循环条件上，有一轮堆调整从未被执行。从此以后我学乖了，任何堆排序核心算法输出不对时，第一件事就是在每个循环点打印出当前数组的状态，然后和手推的理想状态比对，一般几个回合内就能锁定错误位置。

4.5 手写堆排序在一些变形题目中的扩展

堆排序本身算法题不怎么复杂，但面试官很喜欢在堆上做扩展。比如：

• 寻找Top K大的数：维护一个大小为K的小顶堆，遍历数据时若元素大于堆顶，则替换堆顶并做下滤调整。空间复杂度O(K)，时间复杂度O(n log K)。这个思路比“先全部排序取前K个”高效得多。
• 合并K个有序链表：用一个小顶堆保存K个链表的当前节点，每次取最小节点并放入结果链表，然后从它所在的链表取出下一个节点继续堆化。堆的大小始终为K，总时间复杂度O(n log K)。
• 数据流的中位数：用一个大顶堆存较小的一半数，小顶堆存较大的一半数，每来一个新元素，先与堆顶比较决定去哪个堆，然后调整两个堆的大小差距不超过1，取中位数就是其中一个堆顶。

这些变体题目本质都是“动态维护前K大/前K小元素”，核心动作就是堆的插入删除和堆化，理解了堆排序的下滤操作，这些题目会容易很多。

5. 工程场景中的考量与实践总结

5.1 堆排序与快速排序、归并排序的取舍

在通用排序库中，绝大多数编程语言的内置sort不会采用堆排序。C++的std::sort通常使用Introspective Sort（内省排序）——先使用快速排序，当递归深度过深则换用堆排序来保证最坏情况下的复杂度；Python的sort底层是Timsort（一种稳定自适应归并排序）。这说明了语言设计者的取舍：排序算法是否稳定、是否能利用输入数据的已有顺序、常数因子是否足够低，往往比理论复杂度更重要。

堆排序的常数因子相对偏大，原因是它对内存的访问模式是跳跃式的（从下标i跳到2*i+1），不像快排那样顺序读写缓存友好，所以在处理规模较大的数组时，实际运行时长通常略慢于优化良好的快排。但如果遇到极端输入（例如基本有序的数组且快排采用固定基准时），快排可能退化到O(n²)，此时堆排序的“不掉链子”特性就体现出价值。

5.2 堆排序在有限内存与流式场景中的优势

假设需要在嵌入式设备中，对内存占用1MB以内的几十万个16位整数完成排序，同时又不能消耗额外的数组空间。在这个约束下，堆排序是最合理的方案之一。

再考虑一个流式场景：网络网关每秒收到大量数据包，需要实时找出最近一分钟的Top100大流量IP。如果把流式数据全部存下来再做全排序，内存和时间都无法承受；正确做法用一个容量为100的小顶堆，新到数据先判最大还是堆外，然后进行堆调整。这个方法本质上是“堆排序思想的在线版本”，它帮助我们只关注感兴趣的前K个目标，而无需关心全局有序。

5.3 我自己做排序对比时的一些实际经验

我在一次排序算法性能比较测试中，用随机生成的100万个整数分别运行堆排序、快速排序和归并排序，在Release模式下，堆排序耗时大约是快速排序的1.5倍左右，归并排序因为需要额外分配内存也略慢于快排。但是当测试数据改成完全逆序时，采用普通固定基准的快速排序明显变慢，且递归深度显著增加；而堆排序的耗时基本持平。这个实验让我更坚定了一个观点：堆排序最大的价值不是快，而是稳。

此外，对于多关键字排序、对象排序等真实业务场景，我一般不会直接用堆排序，因为对象的内存占用较大，交换开销不可忽略，这种情况下归并排序的稳定性和顺序归并特性更加合适。堆排序最舒服的舞台，就是数值型标量的大规模排序、嵌入式系统内置缓冲区排序，以及算法题中海量数据的TopK相关问题。

5.4 给新手的学习建议与一个自查清单

从零开始学习堆排序的同学，不用急着一次性写完整代码，建议按下面这个顺序递进：

1. 先手动完成“在数组中定位父子节点”的小练习：给出任意数组下标，计算父节点和两个子节点，反复练习到不加思考就能推算。
2. 只实现一个maxHeapify函数，随机构造一棵“左右子树都已经满足堆序、只有根节点不合格”的数组，用代码把它调整成大顶堆。
3. 借用第二步的函数，完成完整的buildMaxHeap，知道为什么要从最后一个非叶子节点倒序遍历。
4. 最后实现主循环swap + shrink + heapify，跑通排序。

如果你写完代码，结果不对，可以用下面这个自查清单排查：

这套清单帮我解决过很多次自己代码异常的问题，也帮身边同学排查过错漏。如果按照这个顺序学，边练边手推一个数组的过程，会比单纯看文章自己感觉“懂了但不会写”高效得多。

从我个人实际教学和刷题的经历来看，堆排序作为排序算法专场的第13个主题，它的价值不只是学会一种排序方法，更是借这个机会真正理解“堆”这种数据结构的操作方式。下滤、上滤、建堆、取极值、调整堆范围，这几板斧学会之后，再去学优先队列、Top K问题、Dijkstra最短路径算法，你会发现它们是相通的。回头再看堆排序，它的代码量不大，每一行都值得反复推敲，弄懂它算是在数据结构与算法这条路上打通了一个很重要的关节。