云海天狼堆是数据结构与算法里一个非常“拧巴”的存在。它长着一副二叉树的样子，底层却用数组存；它的逻辑结构看上去整整齐齐，实际排序时交换起来却跳来跳去。很多初学者学到“树”这一章还能勉强跟上，一到“堆排序、建堆”就开始发懵，面试时一让手写堆排序就卡壳，本质上就是因为没有把“树”和“数组”这两条线索串起来。
这篇文章我打算用一套完整的思路来拆解：先弄清楚树的基础概念分布，再盯着“完全二叉树”这一个形态，把堆的定义、数组存储、上浮下沉、建堆、堆排序全部串成一条线。看完之后你会发现，堆排序并不是需要“背下来”的算法，而是只要理解了三个关键操作，写代码就是顺水推舟的事。适合正在学数据结构的学生、准备算法面试的开发者，以及工作中需要用优先级队列处理任务调度、TopK、定时器这些场景的工程师。
1. 树的基础认知：堆的三层根基
很多人学堆的时候直接跳到“大顶堆小顶堆”，结果对堆为什么长成那样没有概念。实际上，堆是长在二叉树这棵大树上的一个特殊分支。要想把堆吃透，得先把树的地基打牢。
1.1 树的定义与核心术语
树是一种非线性的数据结构，它由 n（n≥0）个有限节点组成。n=0 时叫空树，n>0 时，树里有一个根节点，其他节点可以通过边连接到彼此，形成层次关系。树的形态很像实际生活里的组织结构：总经理下面有部门总监，每个总监下面还有主管。这种“一对多”的关系，正是树这种数据结构存在的意义。
树里有一批必须记住的术语：
- 节点（Node）：树的基本单位，一个节点可以存一个数据元素。
- 根节点（Root）：没有父节点的节点，一棵树只有唯一一个根。
- 父节点与子节点：相连的两个节点中，上层的是父节点，下层的是子节点。
- 叶子节点（Leaf）：没有子节点的节点，也叫终端节点。
- 节点的度（Degree）：一个节点拥有子节点的个数，比如一个节点有3个子节点，那它的度就是3。树的度是这棵树中所有节点度的最大值。
- 树的深度（Depth）/ 高度（Height）：从根节点开始，根为第1层，根的子节点为第2层，依次往下。最大层数就是树的深度。
- 兄弟节点：同一个父节点下面的所有子节点互为兄弟。
看下面这棵简单的树结构。
code复制 A
/ \
B C
/ \ / \
D E F G
- A 是根节点。
- B、C 是 A 的子节点，D、E 是 B 的子节点。
- D、E 互称兄弟节点。
- D、E、F、G 都是叶子节点。
- 树的深度是 3。
- B 的度是 2，C 的度是 2，A 的度也是 2，所以这棵树的度是 2。
树结构在实际工程项目中太常见了。文件系统就是典型的树形结构，根目录下面有子目录，子目录下面还有文件。DOM 树、语法树、路由表，都是树的具体应用。如果把树理解透彻，后面看 B 树、B+树、红黑树这些高级话题会轻松很多。
1.2 二叉树、满二叉树与完全二叉树
在所有树结构里，用得最多的一定是二叉树。二叉树的定义很简单：每个节点最多只有两个子节点的树。正是这个“最多两个”的约束，让二叉树可以用很优雅的方式存储，也衍生出一堆非常高效的算法。
二叉树有两个重要性质需要记住：
- 在二叉树的第 i 层上，最多有 2^(i-1) 个节点（i≥1）。
- 深度为 k 的二叉树最多有 2^k - 1 个节点。
这两个性质可以自己推演一下，验证一遍比背下来牢靠得多。
在二叉树里，有两种特殊的形态，堆跟它们关系极其密切。
第一种是满二叉树（Full Binary Tree）。每一层的节点数都达到最大值，也就是说深度为 k 的满二叉树一定有 2^k - 1 个节点。从形状上看，每一层都被填满了，没有任何空缺。满二叉树非常“对称”，但实际场景中这种结构太苛刻了，很难刚好凑齐那么多节点。
第二种是完全二叉树（Complete Binary Tree）。完全二叉树的定义要严格区分于满二叉树：它要求除最后一层外，每一层都必须填满，最后一层可以不满，但所有叶子节点必须集中在左侧连续排列，不能有空隙。
完全二叉树的实际形状就是“从左到右连续填充”的。可以这样理解：一棵完全二叉树的节点编号和同等深度满二叉树的节点编号完全一致，不会有任何一个位置是“本该有节点却空了”的。
完全二叉树的重要性在于，它让“用数组存储树”成为可能。普通二叉树用数组存会遇到大量空洞，浪费空间；但完全二叉树没有空洞，每个数组位置都对应一个有效节点。
1.3 树的存储方式：链式还是数组
树可以用两种方式存储：链式存储和顺序存储。
链式存储很好理解，每个节点包含数据域和两个指针域，分别指向左孩子和右孩子。结构体大概长这样：
c复制typedef struct TreeNode {
int val;
struct TreeNode *left;
struct TreeNode *right;
} TreeNode;
链式存储的优点是直观，处理子树关系方便；缺点是每个节点都要消耗指针空间，而且对于满二叉树这种形态，指针密度过大，内存利用率不高。
顺序存储则是把树的节点按层依次存入数组。对于完全二叉树，这种存储方式特别合适，因为节点在数组中的下标可以直接通过数学公式算出父子关系。
假设数组下标从 0 开始，对于下标为 i 的节点：
- 左孩子的下标是 2 * i + 1
- 右孩子的下标是 2 * i + 2
- 父节点的下标是 (i - 1) / 2（向下取整）
这个公式就是堆的底层基础。你不需要在任何节点里存储指针，只需要知道当前节点的数组下标，就能用 O(1) 的时间找到它的孩子和父亲。
顺序存储对于普通二叉树来说会有浪费，因为有些位置可能没有节点，数组空洞会导致空间利用率下降。但完全二叉树完美避开了这个问题，因为其节点本身就是连续填充的，数组下标没有任何空洞。堆选择用数组存储，不是随意决定的，而是因为堆本身就是完全二叉树，天然适合这种紧凑的内存布局。
需要模型API调用？ 免费领10W Token，多模型网关一键接入 Claude、DeepSeek 等主流模型。
2. 堆的核心概念与存储设计
堆在树的基础上加了两个额外约束：形态上必须是完全二叉树，值上必须满足堆序性。这一下就让它的定位非常清晰。
2.1 堆序性：大顶堆和小顶堆到底在堆什么
堆的定义可以这样概括：堆是一个完全二叉树，并且树中每个节点的值都不大于（或不小于）其父节点的值。
大顶堆（Max Heap）要求每个节点的值都大于等于其孩子节点的值。因此堆顶元素一定是整个堆里最大的值。反过来说，小顶堆（Min Heap）要求每个节点的值都小于等于其孩子节点的值，堆顶一定是最小值。
注意，堆序性只约束了父子和祖孙之间的相对大小，并不约束兄弟节点之间的关系。大顶堆左边的孩子不一定比右边的孩子大，两个兄弟之间谁大谁小是完全随意的。这一点经常有人搞混，以为大顶堆一定是一个严格降序排列的完全二叉树，这是不对的。
大顶堆里找最大值时间复杂度是 O(1)，就是直接读堆顶。往堆里插入一个新节点、删除堆顶节点，时间复杂度都是 O(log n)，因为每次操作之后需要沿着树的路径做调整，这条路径的长度就是树的高度 log₂n。
堆序性的意义在于：它把“全序关系”压缩成了“局部关系”，用更低的维护成本换来了对极值的高效访问。世界并不是有序的，你和所有同学不要求按身高排成一条线，只要体育老师能快速找到最高的那个人，就能完成排队。堆干的正是这件事：不去维护整个序列的全局有序，只维护一个“堆顶即极值”的局部约束。
2.2 用数组存储堆，下标关系是灵魂
堆底层用数组存储，这一点已经反复强调。直接用图来看一个典型的大顶堆。
code复制 90
/ \
70 60
/ \ / \
40 30 20 10
这棵树的数组存储为：
code复制[90, 70, 60, 40, 30, 20, 10]
下标索引关系：
| 节点下标 i | 左孩子下标 2i+1 | 右孩子下标 2i+2 | 父节点下标 (i-1)/2 |
|---|---|---|---|
| 0 | 1 | 2 | 无 |
| 1 | 3 | 4 | 0 |
| 2 | 5 | 6 | 0 |
| 3 | 无 | 无 | 1 |
这种存储方式有一个非常大的好处：它天然支持“随机访问任意节点的子节点和父节点”，不需要任何指针，只需要乘法和加法运算。在计算机底层，数组的访问是连续内存的偏移计算，缓存友好性极高，性能比链式结构好很多。堆排序之所以被选为经典排序算法，一个重要原因就是它的局部性原理非常好，所有数据都在一个连续数组里。
在实际工程代码里，有两种下标习惯：从 0 开始和从 1 开始。从 0 开始的公式是 2i+1、2i+2、(i-1)/2；从 1 开始的公式是 2i、2i+1、i/2。从 1 开始的好处是可以直接用位运算 i/2 找到父节点，且不需要处理 i=0 时的边界问题；代价是数组第 0 个位置必须空出来。C、C++、Java 的风格通常从 0 开始，而部分 Lua、Python 的算法实现里有人喜欢从 1 开始。两种情况都要能熟练切换，否则看别人的代码容易一头雾水。
2.3 堆的应用场景：并不只是排序
堆排序只是堆的众多应用之一。在真实系统中，堆的使用频率比很多人想象的高得多。
优先级队列是最直接的堆应用。操作系统中的任务调度、网络请求的优先级处理、搜索算法里的 Dijkstra 最短路，底层都依赖一个最小堆来快速取出当前优先级最高的元素。Java 的 PriorityQueue、Python 的 heapq 模块，内部就是堆实现。
TopK 问题是堆的另一大经典应用。在海量数据里找出最大的 K 个数，不需要全部排序，只需维护一个大小为 K 的小顶堆。遍历数据时，如果当前元素比堆顶大，就替换堆顶并调整堆；最终堆里剩下的 K 个元素就是整个数据集里最大的 K 个。这个思路在日志分析、推荐系统、排行榜场景中处处可见。
定时器也会用到堆。很多网络框架的定时器管理，比如 nginx、libuv，内部都用最小堆来管理定时事件，堆顶就是最近要触发的定时器，每次只需检查堆顶事件是否到期，效率极高。
哈夫曼树、表达式树这些树结构也在编译原理和文件压缩领域频繁出现。所以别以为“学树和堆”只是为了考试，它直接决定了你对系统底层设计的理解深度。
3. 建堆：上浮与下沉，两种完全不同的思路
现在到了全篇最关键的部分：怎么把一个无序数组变成堆。这一步是理解堆排序的前提，也是面试中最常考的点。很多人一听“建堆”就紧张，其实核心操作只有两个：上浮（sift up）和下沉（sift down）。这两个操作的名字很形象，就是一个节点往上冒，一个节点往下沉。
3.1 上浮操作：用于插入场景
上浮操作的场景是：已经有一个合法的堆，现在向堆尾插入一个新元素，这个新元素可能会破坏堆序性，需要不断向上调整。比方说大顶堆里，你插入一个非常大的值，它跑到堆尾之后，它的父节点如果比它小，就得交换，再继续往上看，直到找到正确位置。
伪代码如下：
code复制sift_up(heap, i):
while i > 0 and heap[parent(i)] < heap[i]:
swap(heap[parent(i)], heap[i])
i = parent(i)
插入一个新元素的时间复杂度是 O(log n)，因为每上升一层，问题规模就减半。插入操作的整体流程是：将新元素追加到数组末尾，然后执行上浮操作。
上浮操作理解起来直观，但建堆时如果用“逐个插入”的方式，也就是从空堆开始，每次向堆尾插入一个元素并上浮，总的时间复杂度是 O(n log n)。因为插入 n 个元素，每个插入要 O(log n)。这个复杂度不能说差，但在建堆这个场景，还有更优的做法。
3.2 下沉操作：更复杂的调整逻辑
下沉操作的场景是：某个节点的值比它的孩子节点小（在大顶堆里），它破坏了堆序性，需要不断向下调整。找到左右孩子中较大的那个，如果父亲比它小，就交换，然后继续往这个孩子的位置下沉，直到叶子节点。
伪代码如下：
code复制sift_down(heap, n, i):
while true:
largest = i
left = 2 * i + 1
right = 2 * i + 2
if left < n and heap[left] > heap[largest]:
largest = left
if right < n and heap[right] > heap[largest]:
largest = right
if largest == i:
break
swap(heap[i], heap[largest])
i = largest
注意，下沉的时候要比较的就是左右孩子和当前节点三者里的最大值，找到后把最大值换上来。如果父亲本来就是最大的，就不用动了，直接跳出。
下沉操作最经典的应用场景就是建堆。给一个无序数组建堆的聪明做法是：从最后一个非叶子节点开始，逐个往前对所有内部节点执行下沉操作，而不是从叶子节点开始下沉。这样能做到 O(n) 的时间复杂度建堆。
为什么从最后一个非叶子节点开始？因为叶子节点没有孩子，它天然就是满足堆序性的（没有孩子来跟它比较）。你不需要对叶子节点做任何调整，只需要从最后一个非叶子节点开始逐个处理。
最后一个非叶子节点的下标怎么求？对于数组长度为 n 的完全二叉树，最后一个叶子节点的下标是 n-1，它的父节点下标就是 (n-1-1)/2 = n/2 - 1。所以从 n/2 - 1 这个下标开始，依次减 1 循环到 0 即可。
3.3 建堆为什么是 O(n)：数学推导
这里有一个在面试中经常出现的坑，需要仔细拆开讲。很多人以为“对 n 个节点做下沉，每次 O(log n)，所以建堆是 O(n log n)”，但这个结论是错误的。原因在于，不是每个节点都需要下沉 O(log n) 次，大多数节点根本不需要下沉很多次，因为它们本身就在接近叶子节点的位置。
来看一个满二叉树，高度为 h。第 i 层的节点个数是 2^i。第 i 层的节点最多需要下沉 h-i 次。总下沉次数 S 为：
S = 0 * 2^h + 1 * 2^(h-1) + 2 * 2^(h-2) + ... + h * 2^0
（第 h 层叶子节点下沉 0 次，第 h-1 层节点最多下沉 1 次，依此类推）
这个级数收敛于 2n，精确一点就是 S = 2^(h+1) - h - 2。当 h 很大时，S 趋近于 2 * (2^h) - h，而 n = 2^(h+1) - 1，所以 S < 2n。也就是说，总的调整次数是 O(n) 级别的，而不是 O(n log n)。
换个方式理解：越靠近根节点的节点数量越少，需要下沉的层数越深；越靠近叶子的节点数量越多，但它们基本不需要调整。这种“大头在下层，下层工作量小；上层工作量大，但节点少”的分布，使得总和仍然是线性的。
这个推导值得反复看几遍，因为它是面试里常见的追问点。能说清“为什么下沉建堆是 O(n)，而上浮建堆是 O(n log n)”，面试官一般就会认可你对堆的理解深度。
3.4 建堆的完整代码示例
下面给出用 C 语言实现的无序数组建堆代码。
c复制#include <stdio.h>
void swap(int *a, int *b) {
int tmp = *a;
*a = *b;
*b = tmp;
}
void sift_down(int arr[], int n, int i) {
while (1) {
int largest = i;
int left = 2 * i + 1;
int right = 2 * i + 2;
if (left < n && arr[left] > arr[largest]) {
largest = left;
}
if (right < n && arr[right] > arr[largest]) {
largest = right;
}
if (largest == i) {
break;
}
swap(&arr[i], &arr[largest]);
i = largest;
}
}
void build_heap(int arr[], int n) {
for (int i = n / 2 - 1; i >= 0; i--) {
sift_down(arr, n, i);
}
}
这段代码里最需要注意的是边界条件。下沉过程中要判断 left < n 和 right < n，防止访问数组越界。因为数组长度不一定是 2^k - 1，最后一层的节点可能只有少数几个，左孩子存在但右孩子不存在的场景很常见。
测试一下，对数组 [4, 10, 3, 5, 1] 建大顶堆：
code复制初始数组: [4, 10, 3, 5, 1]
n = 5, n/2 - 1 = 1
从 i=1 开始:
arr[1]=10, 左孩子 arr[3]=5, 右孩子 arr[4]=1, 10 已经是最大的，不交换。
i=0:
arr[0]=4, 左孩子 arr[1]=10, 右孩子 arr[2]=3, 最大的是 10，交换 arr[0] 和 arr[1]。
[10, 4, 3, 5, 1]
现在 i=1，继续下沉:
arr[1]=4, 左孩子 arr[3]=5, 右孩子 arr[4]=1, 最大的是 5，交换 arr[1] 和 arr[3]。
[10, 5, 3, 4, 1]
继续 i=3，arr[3]=4, 左孩子 arr[7] 越界，右孩子 arr[8] 越界，退出。
最终堆数组: [10, 5, 3, 4, 1]
建堆完成后，arr[0] 就是最大值 10，完全符合大顶堆的要求。
4. 堆排序：从建堆到完全有序
堆排序的思想非常精巧：既然堆顶一定是全堆最大（或最小）的元素，那就每次把堆顶取出来，然后把剩余部分重新调整成堆，继续取堆顶。这样反复取出的序列自然就是有序排列的。
4.1 堆排序的三步走
堆排序整体分为三个阶段。
第一步，建堆。通过下沉操作把无序数组调整成大顶堆。
第二步，交换堆顶与当前未排序区间的最后一个元素。交换之后，数组中最大的元素就固定到了末尾正确的位置。
第三步，缩小堆的大小，对剩余部分重新执行一次下沉操作，把新的堆顶调整到正确的位置。注意此时堆的末尾已经有序，不再参与堆的调整。
重复第二步和第三步，直到堆的大小缩小到 1，全部排序完成。
这里的核心技巧是“不额外开辟空间”：建堆用的是原数组，交换也是在原数组内部进行，空间复杂度是 O(1)。这是一个原地排序算法。
4.2 完整堆排序实现
以 C 语言为例：
c复制void heap_sort(int arr[], int n) {
// 第一步：建堆
for (int i = n / 2 - 1; i >= 0; i--) {
sift_down(arr, n, i);
}
// 第二步+第三步：依次取出堆顶
for (int i = n - 1; i > 0; i--) {
// 将堆顶最大的元素交换到数组末尾
swap(&arr[0], &arr[i]);
// 对剩余的 i 个元素重新调整为大顶堆
sift_down(arr, i, 0);
}
}
对数组 [4, 10, 3, 5, 1] 执行堆排序的过程：
code复制建堆后: [10, 5, 3, 4, 1]
轮次 1: 交换 arr[0]=10 和 arr[4]=1 -> [1, 5, 3, 4, 10]
对前 4 个元素下沉:
[5, 1, 3, 4, 10] -> 继续下沉
[5, 4, 3, 1, 10]
轮次 2: 交换 arr[0]=5 和 arr[3]=1 -> [1, 4, 3, 5, 10]
对前 3 个元素下沉:
[4, 1, 3, 5, 10]
轮次 3: 交换 arr[0]=4 和 arr[2]=3 -> [3, 1, 4, 5, 10]
对前 2 个元素下沉:
[3, 1, 4, 5, 10]
轮次 4: 交换 arr[0]=3 和 arr[1]=1 -> [1, 3, 4, 5, 10]
最终结果: [1, 3, 4, 5, 10]
注意，每轮交换之后，数组末尾的部分就已经是升序排列的了。堆排序利用大顶堆可以原地实现升序排序；如果用小顶堆，则可以原地实现降序排序。
4.3 堆排序的复杂度与稳定性分析
堆排序的时间复杂度在最好、最坏、平均情况下都是 O(n log n)，因为它总是要做 n 次选堆顶操作，每次调整是 O(log n)，再加上建堆的 O(n)。不管输入数据已经是顺序的、逆序的还是随机的，堆排序都一视同仁地执行同样多的比较和交换。
空间复杂度是 O(1)，因为它是在原数组上操作的。
但堆排序有一个显著缺点：不稳定。稳定性是排序算法的重要属性，意思是两个值相等的元素，排序后它们的相对顺序不能改变。堆排序的交换操作是跳跃式的，它会将堆顶元素直接换到数组末尾，完全可能把两个相同值的元素的相对位置颠倒。
举个例子，数组 [3a, 30, 3b, 1, 2]，其中 3a 和 3b 的值相同，但用不同标记区分。建堆后 3a 可能被换到堆顶，再被换到数组末尾，等轮到 3b 时，3b 被换到 3a 的后面，两个相同值的相对顺序已经无法保证和初始顺序一致。
如果对稳定性有要求，应该选择归并排序等稳定排序算法。但在优先级队列、TopK 这些场景中，我们只关心极值，不关心稳定顺序，堆就是最佳选择。
4.4 为什么平常排序不常用堆排序
看到这里，有人可能会问：堆排序时间复杂度是 O(n log n)，空间复杂度 O(1)，理论上和快排一样优秀，为什么实际系统里排序一般都用快排而不是堆排序？
其中一个重要原因是缓存局部性。堆排序的交换模式是跳跃式的，它频繁地访问相距较远的数组元素，这对 CPU 缓存很不友好。而快速排序是分治式地局部操作，每一轮只处理当前分区的一段连续子数组，访问局部性更好。在现代计算机体系里，缓存命中率对性能的影响很大，快排的常数因子比堆排序小得多。实际测试时，同样数量级的数据，快排通常比堆排序快一倍以上。
另一个原因是稳定性。堆排序天然不稳定，而快排通过适当优化也可以实现稳定版本（虽然代价较大）。在大多数语言的标准库中，排序算法默认会优先保证稳定性和良好的平均性能，所以 C++ 的 std::sort 采用 Introsort（快排+堆排混用），Java 的 Arrays.sort 对基本类型采用双轴快排，对对象类型采用 TimSort。
但这不代表堆排序没有价值。它最大的价值在于“求极值”而不是“排序”。当你不关心全局顺序，只关心最大或最小的几个元素时，堆的优势非常明显。
5. 常见问题与排查技巧实录
讲了这么多理论，落地到实际写代码和学习过程中，有几个高频问题必须拿出来单独说说。这些问题我见过太多人踩坑了。
5.1 数组越界：左右孩子下标计算的边界陷阱
用数组实现堆的第一大坑就是越界。在 sift_down 里，每轮循环都要判断 left < n 和 right < n，这两个条件缺一不可。尤其是最后一个非叶子节点，它可能有左孩子没有右孩子，也可能左右孩子都没有。如果不对右孩子做越界检查，直接访问一个不存在的下标，程序会读取无意义的内存数据，导致排序结果错乱甚至直接崩溃。
在 C 语言里，这种错误甚至不会立刻报错，因为 C 语言不检查数组边界，它会静默地读取越界内容，然后把垃圾数据当成右孩子的值参与比较，最终排序结果看似合理实则完全错误。遇到这种情况，排查的手段是打印每一步的数组状态，重点检查交换操作后堆的结构是否依然合法。
5.2 从 0 和从 1 开始的下标混乱
很多人读不同文章时被下标公式弄晕。记住一个核心原则：无论从 0 开始还是从 1 开始，只要父子关系公式统一，算法逻辑就完全一致。不要在一段代码里混用两种体系。
一段很常见的错误是：建堆循环写成 for (int i = n/2; i >= 0; i--)，这里的 n/2 恰好是数组最后一个元素的下标，而不是最后一个非叶子节点的下标。正确的起点是 n/2 - 1。这里差一个下标，建堆结果就不正确。
从 1 开始的写法里，数组第 0 个位置要么留空，要么放一个哨兵元素，不要真的去参与堆操作。初学者最容易犯的错就是“从 0 开始建公式，然后套一个从 1 开始的代码模板”，结果越写越乱。
5.3 稳定性误区：堆排序到底为什么不行
有一个很经典的误解，认为“只要在值相同时比较下标，堆排序就可以稳定”。这个想法表面上有道理，实际不可行，因为堆排序的交换不是相邻交换，它会将一个元素直接跳跃到另一个位置，这个过程无法保证相同的值保持相对顺序。
如果在排序时强行给每个元素附加一个原始下标作为次要比较键，确实可以让堆排序变得稳定，但这会额外消耗 O(n) 的空间，而且比较逻辑变得复杂。这已经完全偏离了堆排序“原地排序”的设计初衷。
5.4 用堆解决 TopK 问题的正确姿势
TopK 问题用堆解决的核心是：求最大 K 个元素，维护小顶堆；求最小 K 个元素，维护大顶堆。原理是让堆顶成为“门槛”，任何比堆顶更符合条件的新元素都可以把堆顶淘汰出局。
伪代码如下：
code复制top_k(nums, k):
build_min_heap(empty heap of size k)
for num in nums:
if heap.size < k:
heap.push(num)
else if num > heap.top():
heap.pop()
heap.push(num)
return heap
这里的小顶堆保证堆顶永远是堆里最小的那个数。当有更大的数进来时，淘汰掉最小的，堆里就始终保存着当前见过的最大的 K 个数。最终堆顶就是这个 TopK 序列的门槛值。
这个方案最大的优势是内存占用 O(k)，时间复杂度 O(n log k)。当成千上万的数据大到无法全部装入内存时（比如海量日志、用户行为数据），只能依赖这种一次遍历就能算出来的流式方案。
5.5 实验报告和面试：怎么把堆讲清楚
对于正在做“数据结构实验报告”或者准备算法面试的同学，我有几条具体的建议。
写实验报告时，不要只贴代码，要配合一张“建堆过程图”。把无序数组的初始形态画成完全二叉树，然后画出第一次下沉后、第二次下沉后的树形结构，每一步在哪个节点发生交换标注清楚。配图比一百行文字都直观。报告中需要写明你选择的存储方式是顺序存储还是链式存储、为什么选择这种方式、建堆的时间复杂度如何推导、堆排序是否稳定，这些要点都覆盖了，报告质量基本就是优秀档。
面试时被问到“手写堆排序”，可以先用三个关键词概括思路：下沉、建堆、交换。然后说明“从最后一个非叶子节点开始下沉建堆”，再写代码。面试官问“建堆复杂度多少”，回答 O(n) 并给出层级求和推导。问到“堆排序稳定吗”，回答不稳定，并解释原因，同时补充一句“所以实际工程中如果需要稳定排序会选归并或 TimSort”。这三个问题都能答上来，堆相关的面试题基本就稳了。
6. 避坑经验与扩展方向
文章最后再分享一点我在实际项目里的体会。堆这个数据结构，工作后用到的频率比我想象中高得多。我做过后台任务调度系统，定时器用最小堆管理待执行任务，每次只需要检查堆顶事件是否到期，逻辑非常简单；做过日志平台的 TopK 统计，用固定大小的最小堆从海量访问记录里实时找出热门接口，内存占用非常稳定。每次用到堆的时候，都会庆幸当年认真推导过 O(n) 建堆的过程，因为底层原理清楚了，上层的应用就只是套模板而已。
有一条经验值得特别记下来：写堆相关代码，先写 sift_down，再基于 sift_down 写建堆和排序。所有堆操作的复杂问题都是因为 sift_down 里的边界条件写错，只要这一步严格验证过，后面的建堆和排序基本不会出错。我自己习惯先用一个随机小数组跑几遍，打印出建堆后的数组，肉眼确认堆顶是最大值、每个父节点都大于等于子节点，再开始跑排序。这个习惯帮我省下过很多排查时间。
最后想说的是，数据结构这块内容，靠死记硬背撑不了多久。树和堆的真正价值在于它教会你“不同形态的约束带来不同的效率体验”——完全二叉树约束了形态，于是数组存储成为可能；堆序性约束了父子大小关系，于是极值访问只需要 O(1)。理解了这些设计取舍，你面对任何一个新数据结构时，都会有底气去拆解它的优缺点，而不是等着别人告诉你它有什么用。
如果这篇文章帮到了你，我建议你把建堆、下沉、堆排序这三段代码自己在编辑器里敲三遍，手写顺了，才是真正掌握。