hello-algo 堆（Heap）完全指南：完全二叉树数组表示、上浮下沉堆化与跨语言堆操作实践

2026-09-06 15:22:09作者：盛欣凯Ernestine

堆是一种满足特定堆序条件的完全二叉树，也是优先队列、堆排序与“获取最大 k 个元素”等经典算法的底层数据结构。本文基于《Hello 算法》(hello-algo) 仓库中的堆章节文档展开，结合 Python 堆实现源码逐一剖析堆的定义、常用操作效率、数组存储与索引映射、上浮/下沉堆化（sift-up / sift-down）算法、O(n) 高效建堆原理，以及堆的典型应用，帮助读者既会用各语言的内置堆类，也能从零手写一个正确的大顶堆。

1. 堆的基本概念：小顶堆与大顶堆

堆（heap）是一种满足特定条件的完全二叉树，主要可分为两种类型：

小顶堆（min heap）：任意节点的值 $\leq$ 其子节点的值。
大顶堆（max heap）：任意节点的值 $\geq$ 其子节点的值。

堆作为完全二叉树的一个特例，具有以下特性：

最底层节点靠左填充，其他层的节点都被填满。
我们将二叉树的根节点称为“堆顶”，将底层最靠右的节点称为“堆底”。
对于大顶堆（小顶堆），堆顶元素（根节点）的值是最大（最小）的。

这两条性质决定了堆的核心能力：任何时刻都能在 O(1) 时间内访问全局极值（堆顶），同时以 O(log n) 的时间完成插入与删除。

2. 堆的常用操作与时间复杂度

需要指出的是，许多编程语言提供的是优先队列（priority queue），这是一种抽象的数据结构，定义为具有优先级排序的队列。

实际上，堆通常用于实现优先队列，大顶堆相当于元素按从大到小的顺序出队的优先队列。从使用角度来看，我们可以将“优先队列”和“堆”看作等价的数据结构。因此，《Hello 算法》对两者不做特别区分，统一称作“堆”。

堆的常用操作及效率如下（方法名需根据编程语言确定）：

方法名	描述	时间复杂度
`push()`	元素入堆	$O(\log n)$
`pop()`	堆顶元素出堆	$O(\log n)$
`peek()`	访问堆顶元素（对于大 / 小顶堆分别为最大 / 小值）	$O (1)$
`size()`	获取堆的元素数量	$O (1)$
`isEmpty()`	判断堆是否为空	$O (1)$

在实际应用中，我们可以直接使用编程语言提供的堆类（或优先队列类）。类似于排序算法中的“从小到大排列”和“从大到小排列”，可以通过设置一个 flag 或修改 Comparator 实现“小顶堆”与“大顶堆”之间的转换。下面按仓库中各语言代码（codes/python/chapter_heap/heap.py 等）给出主流实现。

2.1 Python：heapq 模块 + flag 取负技巧

Python 的 heapq 模块默认只实现小顶堆，通过“元素取负”即可将大小关系颠倒，实现大顶堆。仓库 heap.py 用 flag 参数统一管理两种堆，入堆 / 出堆 / 访问堆顶时对元素乘上 flag 还原：

import heapq

# 初始化小顶堆
min_heap, flag = [], 1
# 初始化大顶堆
max_heap, flag = [], -1

# Python 的 heapq 模块默认实现小顶堆
# 考虑将“元素取负”后再入堆，这样就可以将大小关系颠倒，从而实现大顶堆
# 在本示例中，flag = 1 时对应小顶堆，flag = -1 时对应大顶堆

# 元素入堆
heapq.heappush(max_heap, flag * 1)
heapq.heappush(max_heap, flag * 3)
heapq.heappush(max_heap, flag * 2)
heapq.heappush(max_heap, flag * 5)
heapq.heappush(max_heap, flag * 4)

# 获取堆顶元素
peek: int = flag * max_heap[0]  # 5

# 堆顶元素出堆
# 出堆元素会形成一个从大到小的序列
val = flag * heapq.heappop(max_heap)  # 5
val = flag * heapq.heappop(max_heap)  # 4
val = flag * heapq.heappop(max_heap)  # 3
val = flag * heapq.heappop(max_heap)  # 2
val = flag * heapq.heappop(max_heap)  # 1

# 获取堆大小
size: int = len(max_heap)

# 判断堆是否为空
is_empty: bool = not max_heap

# 输入列表并建堆
min_heap: list[int] = [1, 3, 2, 5, 4]
heapq.heapify(min_heap)

从源码可以看到，heapq.heapify() 对列表直接建堆（而非逐个 heappush），这是后文 O(n) 建堆的体现。该技巧的局限在于元素必须可取负，因此只适用于数值类型。

2.2 C++：priority_queue + 比较器

C++ 的 priority_queue 模板第三个参数是比较器，greater<int> 得到小顶堆，less<int> 得到大顶堆：

/* 初始化堆 */
// 初始化小顶堆
priority_queue<int, vector<int>, greater<int>> minHeap;
// 初始化大顶堆
priority_queue<int, vector<int>, less<int>> maxHeap;

/* 元素入堆 */
maxHeap.push(1);
maxHeap.push(3);
maxHeap.push(2);
maxHeap.push(5);
maxHeap.push(4);

/* 获取堆顶元素 */
int peek = maxHeap.top(); // 5

/* 堆顶元素出堆 */
// 出堆元素会形成一个从大到小的序列
maxHeap.pop(); // 5
maxHeap.pop(); // 4
maxHeap.pop(); // 3
maxHeap.pop(); // 2
maxHeap.pop(); // 1

/* 获取堆大小 */
int size = maxHeap.size();

/* 判断堆是否为空 */
bool isEmpty = maxHeap.empty();

/* 输入列表并建堆 */
vector<int> input{1, 3, 2, 5, 4};
priority_queue<int, vector<int>, greater<int>> minHeap(input.begin(), input.end());

2.3 Java：PriorityQueue + Comparator

Java 默认提供小顶堆，通过 lambda 表达式修改 Comparator 即可转为大顶堆：

/* 初始化堆 */
// 初始化小顶堆
Queue<Integer> minHeap = new PriorityQueue<>();
// 初始化大顶堆（使用 lambda 表达式修改 Comparator 即可）
Queue<Integer> maxHeap = new PriorityQueue<>((a, b) -> b - a);

/* 元素入堆 */
maxHeap.offer(1);
maxHeap.offer(3);
maxHeap.offer(2);
maxHeap.offer(5);
maxHeap.offer(4);

/* 获取堆顶元素 */
int peek = maxHeap.peek(); // 5

/* 堆顶元素出堆 */
// 出堆元素会形成一个从大到小的序列
peek = maxHeap.poll(); // 5
peek = maxHeap.poll(); // 4
peek = maxHeap.poll(); // 3
peek = maxHeap.poll(); // 2
peek = maxHeap.poll(); // 1

/* 获取堆大小 */
int size = maxHeap.size();

/* 判断堆是否为空 */
boolean isEmpty = maxHeap.isEmpty();

/* 输入列表并建堆 */
minHeap = new PriorityQueue<>(Arrays.asList(1, 3, 2, 5, 4));

Kotlin 与 Java 用法几乎一致，只是改用 SAM 转换语法初始化大顶堆：

/* 初始化堆 */
// 初始化小顶堆
var minHeap = PriorityQueue<Int>()
// 初始化大顶堆（使用 lambda 表达式修改 Comparator 即可）
val maxHeap = PriorityQueue { a: Int, b: Int -> b - a }

/* 元素入堆 */
maxHeap.offer(1)
maxHeap.offer(3)
maxHeap.offer(2)
maxHeap.offer(5)
maxHeap.offer(4)

/* 获取堆顶元素 */
var peek = maxHeap.peek() // 5

/* 堆顶元素出堆 */
peek = maxHeap.poll() // 5
peek = maxHeap.poll() // 4
peek = maxHeap.poll() // 3
peek = maxHeap.poll() // 2
peek = maxHeap.poll() // 1

/* 获取堆大小 */
val size = maxHeap.size

/* 判断堆是否为空 */
val isEmpty = maxHeap.isEmpty()

/* 输入列表并建堆 */
minHeap = PriorityQueue(mutableListOf(1, 3, 2, 5, 4))

2.4 C# 与 Swift：基于 Comparer 的优先队列

C# 的 PriorityQueue<TElement, TPriority> 将“元素”与“优先级”分离，通过 Comparer.Create 传 lambda 实现大顶堆：

/* 初始化堆 */
// 初始化小顶堆
PriorityQueue<int, int> minHeap = new();
// 初始化大顶堆（使用 lambda 表达式修改 Comparer 即可）
PriorityQueue<int, int> maxHeap = new(Comparer<int>.Create((x, y) => y.CompareTo(x)));

/* 元素入堆 */
maxHeap.Enqueue(1, 1);
maxHeap.Enqueue(3, 3);
maxHeap.Enqueue(2, 2);
maxHeap.Enqueue(5, 5);
maxHeap.Enqueue(4, 4);

/* 获取堆顶元素 */
int peek = maxHeap.Peek(); // 5

/* 堆顶元素出堆 */
peek = maxHeap.Dequeue(); // 5
peek = maxHeap.Dequeue(); // 4
peek = maxHeap.Dequeue(); // 3
peek = maxHeap.Dequeue(); // 2
peek = maxHeap.Dequeue(); // 1

/* 获取堆大小 */
int size = maxHeap.Count;

/* 判断堆是否为空 */
bool isEmpty = maxHeap.Count == 0;

/* 输入列表并建堆 */
minHeap = new PriorityQueue<int, int>([(1, 1), (3, 3), (2, 2), (5, 5), (4, 4)]);

Swift 需要引入 swift-collections 包，其 Heap 类型同时支持最大堆与最小堆：

/* 初始化堆 */
var heap = Heap<Int>()

/* 元素入堆 */
heap.insert(1)
heap.insert(3)
heap.insert(2)
heap.insert(5)
heap.insert(4)

/* 获取堆顶元素 */
var peek = heap.max()!

/* 堆顶元素出堆 */
peek = heap.removeMax() // 5
peek = heap.removeMax() // 4
peek = heap.removeMax() // 3
peek = heap.removeMax() // 2
peek = heap.removeMax() // 1

/* 获取堆大小 */
let size = heap.count

/* 判断堆是否为空 */
let isEmpty = heap.isEmpty

/* 输入列表并建堆 */
let heap2 = Heap([1, 3, 2, 5, 4])

2.5 Go：实现 heap.Interface 自定义堆

Go 标准库只提供堆算法框架，需要自行实现 heap.Interface（同时满足 sort.Interface）。仓库中的 heap.go 展示了完整的整数大顶堆写法，关键在于 Less 的比较方向——改成小于号即得到小顶堆：

// Go 语言中可以通过实现 heap.Interface 来构建整数大顶堆
type intHeap []any

// Push heap.Interface 的方法，实现推入元素到堆
func (h *intHeap) Push(x any) {
    // Push 和 Pop 使用 pointer receiver 作为参数
    // 因为它们不仅会对切片的内容进行调整，还会修改切片的长度。
    *h = append(*h, x.(int))
}

// Pop heap.Interface 的方法，实现弹出堆顶元素
func (h *intHeap) Pop() any {
    // 待出堆元素存放在最后
    last := (*h)[len(*h)-1]
    *h = (*h)[:len(*h)-1]
    return last
}

// Len sort.Interface 的方法
func (h *intHeap) Len() int {
    return len(*h)
}

// Less sort.Interface 的方法
func (h *intHeap) Less(i, j int) bool {
    // 如果实现小顶堆，则需要调整为小于号
    return (*h)[i].(int) > (*h)[j].(int)
}

// Swap sort.Interface 的方法
func (h *intHeap) Swap(i, j int) {
    (*h)[i], (*h)[j] = (*h)[j], (*h)[i]
}

// Top 获取堆顶元素
func (h *intHeap) Top() any {
    return (*h)[0]
}

func TestHeap(t *testing.T) {
    // 初始化大顶堆
    maxHeap := &intHeap{}
    heap.Init(maxHeap)
    // 元素入堆
    heap.Push(maxHeap, 1)
    heap.Push(maxHeap, 3)
    heap.Push(maxHeap, 2)
    heap.Push(maxHeap, 4)
    heap.Push(maxHeap, 5)

    top := maxHeap.Top() // 获取堆顶元素
    heap.Pop(maxHeap) // 5
    heap.Pop(maxHeap) // 4
    heap.Pop(maxHeap) // 3
    heap.Pop(maxHeap) // 2
    heap.Pop(maxHeap) // 1

    size := len(*maxHeap)  // 获取堆大小
    isEmpty := len(*maxHeap) == 0
    _ = top; _ = size; _ = isEmpty
}

2.6 Rust：BinaryHeap + Reverse 反转包装

Rust 的 BinaryHeap 默认是大顶堆；要实现小顶堆，需要用 std::cmp::Reverse 包装元素以反转比较结果：

use std::collections::BinaryHeap;
use std::cmp::Reverse;

/* 初始化堆 */
// 初始化小顶堆
let mut min_heap = BinaryHeap::<Reverse<i32>>::new();
// 初始化大顶堆
let mut max_heap = BinaryHeap::new();

/* 元素入堆 */
max_heap.push(1);
max_heap.push(3);
max_heap.push(2);
max_heap.push(5);
max_heap.push(4);

/* 获取堆顶元素 */
let peek = max_heap.peek().unwrap(); // 5

/* 堆顶元素出堆 */
// 出堆元素会形成一个从大到小的序列
let peek = max_heap.pop().unwrap(); // 5
let peek = max_heap.pop().unwrap(); // 4
let peek = max_heap.pop().unwrap(); // 3
let peek = max_heap.pop().unwrap(); // 2
let peek = max_heap.pop().unwrap(); // 1

/* 获取堆大小 */
let size = max_heap.len();

/* 判断堆是否为空 */
let is_empty = max_heap.is_empty();

/* 输入列表并建堆 */
let min_heap = BinaryHeap::from(vec![Reverse(1), Reverse(3), Reverse(2), Reverse(5), Reverse(4)]);

2.7 无内置堆的生态：JS、TS、Dart、Ruby、C

值得注意的是，JavaScript、TypeScript、Dart、Ruby、C 的标准库均未提供内置 Heap 类（仓库对应代码文件中即标注了这一点）。在这些语言中，要么引入第三方堆库，要么参考下一节的数组实现思路自行编码——这正是学习堆内部结构的价值所在。

3. 堆的存储与表示：数组加索引映射

下面进入核心部分：不看标准库黑盒，自己实现一个堆。下文实现的是大顶堆（仓库 my_heap.py 中的 MaxHeap 类）。若要将其转换为小顶堆，只需将所有大小逻辑判断进行逆转（例如，将 $\geq$ 替换为 $\leq$ ）。

3.1 为什么用数组存储堆

“二叉树”章节讲过，完全二叉树非常适合用数组来表示。由于堆正是一种完全二叉树，因此我们将采用数组来存储堆。

当使用数组表示二叉树时，元素代表节点值，索引代表节点在二叉树中的位置，节点指针通过索引映射公式来实现。给定索引 $i$ ：

左子节点索引： $2 i + 1$
右子节点索引： $2 i + 2$
父节点索引： $(i - 1) / 2$ （向下整除）

当索引越界时，表示空节点或节点不存在。

这正是堆与一般二叉树的重要区别：堆的“完全二叉树”形态使得父子关系可以纯算术推导，无需任何指针字段，缓存友好且空间开销极小。仓库源码将映射公式封装为三个方法，见 my_heap.py#L25-L35：

def left(self, i: int) -> int:
    """获取左子节点的索引"""
    return 2 * i + 1

def right(self, i: int) -> int:
    """获取右子节点的索引"""
    return 2 * i + 2

def parent(self, i: int) -> int:
    """获取父节点的索引"""
    return (i - 1) // 2  # 向下整除

3.2 访问堆顶元素：O(1)

堆顶元素即为二叉树的根节点，也就是列表的首个元素。源码 my_heap.py#L49-L51：

def peek(self) -> int:
    """访问堆顶元素"""
    return self.max_heap[0]

同理，size() 返回 len(self.max_heap)，is_empty() 判断 size() == 0，均为 O(1) 操作。

3.3 元素入堆：从底至顶堆化（sift-up）

给定元素 val，我们首先将其添加到堆底。添加之后，由于 val 可能大于堆中其他元素，堆的成立条件可能已被破坏，因此需要修复从插入节点到根节点的路径上的各个节点，这个操作被称为堆化（heapify）。

考虑从入堆节点开始，从底至顶执行堆化：比较插入节点与其父节点的值，如果插入节点更大，则交换两者；然后继续循环，从底至顶修复路径上的各个节点，直至越过根节点或遇到无须交换的节点时结束。（文档原稿配有 9 帧逐步动画，位于 docs/chapter_heap/heap.assets/heap_push_step1.png 至 heap_push_step9.png。）

设节点总数为 $n$ ，则树的高度为 $O(\log n)$ 。由此可知，堆化操作的循环轮数最多为 $O(\log n)$ ，元素入堆操作的时间复杂度为 $O(\log n)$ 。

源码见 my_heap.py#L53-L71，push 只做两件事：追加节点 + 调用 sift_up：

def push(self, val: int):
    """元素入堆"""
    # 添加节点
    self.max_heap.append(val)
    # 从底至顶堆化
    self.sift_up(self.size() - 1)

def sift_up(self, i: int):
    """从节点 i 开始，从底至顶堆化"""
    while True:
        # 获取节点 i 的父节点
        p = self.parent(i)
        # 当“越过根节点”或“节点无须修复”时，结束堆化
        if p < 0 or self.max_heap[i] <= self.max_heap[p]:
            break
        # 交换两节点
        self.swap(i, p)
        # 循环向上堆化
        i = p

两个终止条件值得注意：p < 0 表示已经越过根节点（根节点没有父节点）；self.max_heap[i] <= self.max_heap[p] 表示父子关系合法、无需再交换。小顶堆版本只需把比较方向反转即可。

3.4 堆顶元素出堆：从顶至底堆化（sift-down）

堆顶元素是二叉树的根节点，即列表首元素。如果我们直接从列表中删除首元素，那么二叉树中所有节点的索引都会发生变化，这将使得后续使用堆化进行修复变得困难。为了尽量减少元素索引的变动，采用以下三步：

交换堆顶元素与堆底元素（交换根节点与最右叶节点）。
交换完成后，将堆底从列表中删除（注意，由于已经交换，因此实际上删除的是原来的堆顶元素）。
从根节点开始，从顶至底执行堆化。

“从顶至底堆化”的操作方向与“从底至顶堆化”相反：将根节点的值与其两个子节点的值进行比较，找出最大的子节点并与根节点交换，然后循环执行此操作，直到越过叶节点或遇到无须交换的节点时结束。

源码见 my_heap.py#L73-L102：

def pop(self) -> int:
    """元素出堆"""
    # 判空处理
    if self.is_empty():
        raise IndexError("堆为空")
    # 交换根节点与最右叶节点（交换首元素与尾元素）
    self.swap(0, self.size() - 1)
    # 删除节点
    val = self.max_heap.pop()
    # 从顶至底堆化
    self.sift_down(0)
    # 返回堆顶元素
    return val

def sift_down(self, i: int):
    """从节点 i 开始，从顶至底堆化"""
    while True:
        # 判断节点 i, l, r 中值最大的节点，记为 ma
        l, r, ma = self.left(i), self.right(i), i
        if l < self.size() and self.max_heap[l] > self.max_heap[ma]:
            ma = l
        if r < self.size() and self.max_heap[r] > self.max_heap[ma]:
            ma = r
        # 若节点 i 最大或索引 l, r 越界，则无须继续堆化，跳出
        if ma == i:
            break
        # 交换两节点
        self.swap(i, ma)
        # 循环向下堆化
        i = ma

pop 中“先交换、再删除”的顺序是关键细节：先 swap(0, size-1) 让原堆顶元素落到尾部，再用 list.pop() 删除它，这样只有根节点位置被新元素破坏，只需从根开始下沉修复一次即可。sift_down 中通过 l < self.size() / r < self.size() 显式检查子节点越界，保证处理不完整子树（最底层只靠左填充）时不会越界；用 ma 记录三者中的最大值，ma == i 时说明当前节点已经是最大、堆序恢复，提前终止。

与元素入堆操作相似，堆顶元素出堆操作的时间复杂度也为 $O(\log n)$ 。

MaxHeap 的完整行为可以在 my_heap.py#L110-L137 的 Driver Code 中直接观察：建堆 → peek → push → pop → size → is_empty，并借助 modules 包中的 print_heap 工具把堆按二叉树形态打印出来，便于核对堆化结果。

4. 高效建堆：O(n) 而非 O(n log n)

“输入列表并建堆”有两种做法，对应 my_heap.py#L17-L23 的构造方法：

def __init__(self, nums: list[int]):
    """构造方法，根据输入列表建堆"""
    # 将列表元素原封不动添加进堆
    self.max_heap = nums
    # 堆化除叶节点以外的其他所有节点
    for i in range(self.parent(self.size() - 1), -1, -1):
        self.sift_down(i)

其原理见建堆操作文档：

借助入堆操作实现：创建空堆后逐个执行“入堆”，每个元素 O(log n)，总计 $O(n \log n)$ 。
遍历堆化实现（上表代码）：先把列表原封不动放进堆（此时堆性质尚未满足），再倒序遍历，对每个非叶节点执行“从顶至底堆化”。倒序保证堆化某个节点时，它之下的子树已是合法子堆。叶节点没有子节点，天然就是合法子堆，无须堆化，因此遍历从“最后一个节点的父节点”开始。

复杂度推导：若按“节点数 $n / 2$ × 最大下沉深度 $\log n$ ”估算得 $O(n \log n)$ ，但这忽略了“底层节点远多于顶层节点”的事实。对高度为 $h$ 的完美二叉树，按“各层节点数 × 该层节点高度”求和 $T(h) = 2^0 h + 2^1 (h-1) + \cdots + 2^{h-1}$ ，错位相减后可化简为 $T(h) = 2^{h+1} - h - 2 = O(2^h) = O(n)$ 。因此，输入列表并建堆的时间复杂度为 O(n)，非常高效——heapq.heapify()、C++ priority_queue 的迭代器构造函数、Java new PriorityQueue<>(list) 走的都是这条 O(n) 路径。

5. 堆的常见应用

优先队列：堆通常作为实现优先队列的首选数据结构，其入队和出队操作的时间复杂度均为 $O(\log n)$ ，而建堆操作为 $O (n)$ ，这些操作都非常高效。
堆排序：给定一组数据，可以先建堆，再不断执行元素出堆操作得到有序序列；实践中通常会用更优雅的原地堆排序实现，详见堆排序章节。
获取最大的 k 个元素：经典问题，例如选择热度前 10 的新闻作为微博热搜，选取销量前 10 的商品等。

仓库给出了一个基于堆的标准解法 top_k.py：维护一个大小为 k 的小顶堆，让堆中始终保留“当前见过的最大 k 个元素”，堆顶即第 k 大的阈值：

def top_k_heap(nums: list[int], k: int) -> list[int]:
    """基于堆查找数组中最大的 k 个元素"""
    # 初始化小顶堆
    heap = []
    # 将数组的前 k 个元素入堆
    for i in range(k):
        heapq.heappush(heap, nums[i])
    # 从第 k+1 个元素开始，保持堆的长度为 k
    for i in range(k, len(nums)):
        # 若当前元素大于堆顶元素，则将堆顶元素出堆、当前元素入堆
        if nums[i] > heap[0]:
            heapq.heappop(heap)
            heapq.heappush(heap, nums[i])
    return heap

# Driver Code
nums = [1, 7, 6, 3, 2]
k = 3
res = top_k_heap(nums, k)

以 nums = [1, 7, 6, 3, 2]、k = 3 为例，最终堆中保留 [3, 7, 6]（即最大的 3 个元素）。该算法只需一次遍历，若数据以流式形式到达也无需保存全部元素，空间复杂度为 O(k)，这正是堆（优先队列）在实际工程中不可替代的原因。

6. 小结与延伸阅读

堆是“完全二叉树 + 堆序条件”的数据结构，用数组存储后父子节点关系完全由索引公式 $2 i + 1$ / $2 i + 2$ / $(i - 1) / / 2$ 决定，无需指针。
入堆 = 追加到尾部 + 从底至顶堆化（sift-up）；出堆 = 首尾交换 + 删尾 + 从顶至底堆化（sift-down），二者均为 $O(\log n)$ ；peek / size / isEmpty 均为 O(1)。
整表建堆通过“原封入列 + 倒序遍历下沉堆化”达到 O(n)。
各语言内置支持程度不一：Python heapq（小顶堆，取负转大顶堆）、C++ priority_queue、Java/Kotlin PriorityQueue、C# PriorityQueue、Go container/heap、Rust BinaryHeap、Swift swift-collections；JS/TS/Dart/Ruby/C 无内置实现。
延伸阅读：建堆操作、Top K 问题、堆排序，以及多语言代码目录 codes/python/chapter_heap/（其他语言可在 codes/ 下按 chapter_heap 目录名查找）。