如果你写过 JavaScript，可能见过类似这样的代码：
const queue = [];
queue.push(task);
queue.sort((a, b) => a.time - b.time);
const next = queue.shift();
比如实现一个定时任务队列、消息队列、优先级队列。
刚开始这样写没问题，但是任务越来越多时：
- 每次插入都需要排序
- 每次取任务都需要移动数组元素
- 时间复杂度越来越高
有没有一种数据结构，可以：
- 快速插入任务
- 快速找到优先级最高的任务
- 不需要每次重新排序？
答案就是：堆（Heap）
Go 标准库已经帮我们实现了一套堆：
container/heap
今天我们就通过源码，看看 Go 是如何实现堆的。
什么是堆？
堆是一种特殊的完全二叉树。
它满足一个规则：
对于小顶堆，父节点永远小于子节点：
1
/ \
3 5
/ \
8 10
根节点永远是最小值。
对于大顶堆，父节点永远大于子节点：
10
/ \
8 5
/ \
3 1
根节点永远是最大值。
很多场景都会使用堆：
- 定时任务调度
- Top K 问题
- 优先队列
堆为什么适合用数组存储？
很多初学者会想：
二叉树不是应该用 Node 节点 + left/right 指针吗？
例如：
class Node {
value;
left;
right;
}
但是堆一般不用这种方式。
Go 的 heap 使用数组：
例如：
[]int{1,3,5,8,10}
对应：
1
/ \
3 5
/ \
8 10
数组：
index:
0 1 2 3 4
1 3 5 8 10
为什么可以？
因为完全二叉树非常规律。
假设节点下标：
父节点:
i
左孩子:
2*i + 1
右孩子:
2*i + 2
例如：
节点：
index=1
value=3
左孩子索引为：
2*1+1=3
对应：
8
右孩子索引为：
2*1+2=4
对应：
10
所以：
堆本质就是一个按照规则排列的数组。
Go heap 的核心设计
打开源码：
src/container/heap/heap.go
可以看到：
type Interface interface {
sort.Interface
Push(x any)
Pop() any
}
这里非常 Go。
Go 没有：
Heap<T>
这种泛型容器设计。
它使用接口 + 组合的方式设计堆。
接口（interface）负责定义“能力”，组合（composition）负责复用已有能力。Go 不依赖传统面向对象的继承，而是通过这两种方式实现代码复用和扩展。
通过 Interface 接口定义堆需要实现的方法，组合 sort.Interface 接口，复用排序的能力。
heap.Interface 继承了什么？
看：
type Interface interface {
sort.Interface
Push(x any)
Pop() any
}
因为 sort.Interface 接口定义：
type Interface interface {
Len() int
Less(i,j int) bool
Swap(i,j int)
}
所以完整接口：
实际上要求实现：
Len()
Less()
Swap()
Push()
Pop()
也就是：
| 方法 | 作用 |
|---|---|
| Len | 数组长度 |
| Less | 比较大小 |
| Swap | 交换元素 |
| Push | 添加元素 |
| Pop | 删除元素 |
为什么 Go 不直接实现 int 堆？
比如：
Heap([]int)
为什么不这样？
因为不同场景比较规则不同。
例如：
任务队列：
type Task struct {
Name string
Time int
}
可能按照：
Time
排序。
排行榜：
Score
排序。
文件：
Size
排序。
所以 Go 只实现堆算法而把元素比较规则交给开发者。
以上就是 Go 语言中堆的接口设计。
实现一个小顶堆
例如：
任务：
type Task struct {
Name string
Priority int
}
优先级越小越先执行。
实现：
type TaskHeap []*Task
需要实现 heap.Interface 接口中定义的 5 个方法。
Len
func (h TaskHeap) Len() int {
return len(h)
}
告诉 heap：
有多少元素。
Less
重点：
func (h TaskHeap) Less(i,j int) bool {
return h[i].Priority < h[j].Priority
}
Less 方法决定谁在前面。
这里：
true
表示：
i 应该排在 j 前面。
Swap
func (h TaskHeap) Swap(i,j int){
h[i],h[j]=h[j],h[i]
}
交换元素。
Push
func (h *TaskHeap) Push(x any){
*h=append(*h,x.(*Task))
}
注意：
这里为什么是指针？
因为：
append 可能改变 slice (切片)地址。
Pop
func (h *TaskHeap) Pop() any{
old:=*h
n:=len(old)
item:=old[n-1]
*h=old[:n-1]
return item
}
注意这里删除的是最后一个元素。
为什么？
因为 heap 内部删除时不会直接删除根节点。
具体后面会讲。
heap.Push 源码分析
使用：
heap.Push(h,item)
heap.Push 在 Go 标准库中的源码如下：
func Push(h Interface, x any) {
h.Push(x)
up(h, h.Len()-1)
}
两个动作：
第一步
添加元素到数组末尾。
例如：
原来：
2
/ \
5 8
数组：
[2,5,8]
加入：
1
先放最后：
[2,5,8,1]
现在：
2
/ \
5 8
/
1
违反小顶堆规则。
第二步：上浮
调用 up() 函数。
在 Go 语言标准库中，up() 函数源码：
func up(h Interface, j int) {
for {
i := (j - 1) / 2 // parent
if i == j || !h.Less(j, i) {
break
}
h.Swap(i, j)
j = i
}
}
重点来了。
上浮算法（up()）分析
假设：
2
/ \
5 8
/
1
index:
[2,5,8,1]
0 1 2 3
新节点：
index=3
计算父节点：
公式：
(parent)
(i-1)/2
所以：
(3-1)/2
=1
父节点：
5
比较：
1 < 5
交换：
2
/ \
1 8
/
5
继续：
index：
1
父节点：
(1-1)/2
=0
比较：
1 < 2
交换：
1
/ \
2 8
/
5
完成。
上浮不断地将比父节点小的子节点交换到父节点位置完成堆化。
heap.Pop 源码分析
heap.Pop 方法在 Go 标准库中的源码实现为：
func Pop(h Interface) any {
n := h.Len() - 1
h.Swap(0, n)
down(h, 0, n)
return h.Pop()
}
heap.Pop 方法的设计很巧妙。他不是直接删除 index 为 0 的元素，而是将 index 为 0 的元素与最后一个元素交换位置。
然后调用 down() (下沉算法)恢复堆的性质。
最后调用用户实现的 h.Pop() 方法，移除并返回末尾元素。
在 javascript 中，删除堆顶可以使用 shift() 方法:
const arr = [1, 3, 5, 8, 10];
const result = arr.shift();
shift() 会删除第一个元素，并将后面的元素向前移动。
但是在 Go 中，通过交换收尾元素，然后删除尾部元素，实现删除堆顶元素，避免了将所有元素整体向前搬移。
这也是堆能够高效删除堆顶的原因。
下沉算法（down()）分析
在 Go 语言标准库中，down() 函数源码：
func down(h Interface, i0, n int) bool {
i := i0
for {
j1 := 2*i + 1
if j1 >= n || j1 < 0 { // j1 < 0 after int overflow
break
}
j := j1 // left child
if j2 := j1 + 1; j2 < n && h.Less(j2, j1) {
j = j2 // = 2*i + 2 // right child
}
if !h.Less(j, i) {
break
}
h.Swap(i, j)
i = j
}
return i > i0
}
核心是不断让父节点和更小的孩子交换。
heap.Init 源码分析
heap.Init 方法的作用是建堆，把一段乱序数据原地整理成合法的堆。
heap.Init 方法在 Go 标准库中的源码为：
func Init(h Interface) {
// heapify
n := h.Len()
for i := n/2 - 1; i >= 0; i-- {
down(h, i, n)
}
}
从源码中可以看到，heap.Init 方法是从 i = n/2 - 1 开始，从大到小，倒着执行下层算法建堆。
堆是用数组存的完全二叉树，节点 i 的孩子在下标 2i+1 和 2i+2。所以：
节点
i有孩子 ⟺2i+1 <= n-1⟺i <= (n-2)/2
而整数运算下 (n-2)/2 == n/2 - 1，所以 n/2 - 1 就是最后一个有孩子的节点。
下标 n/2 ~ n-1 的那些节点全是叶子（一个孩子都没有）。
heap.Init 方法是从 i = n/2 - 1 开始，从大到小，倒着执行下层算法建堆，跳过了叶子节点。
为什么跳过叶子？ 因为叶子天然就是合法的堆（单节点堆没有父子关系要检查），对它们调 down 纯属浪费。
container/heap 源码设计思想总结
读完源码，可以发现 Go 的堆实现非常简洁。
核心只有三个东西：
1. 数组模拟完全二叉树
parent=(i-1)/2
left=2*i+1
right=2*i+2
2. 两个核心算法
上浮算法 up() 和 下沉算法 down() ，维护堆的性质。
3. 接口实现算法复用
Go 不关心：
你存什么。
可以是：
int
也可以：
Task
只需要告诉它：
Less()
如何比较。
总结
用一句话理解 Go 的堆：
Go 的 container/heap 本质是：利用数组模拟完全二叉树，通过 Less 定义优先级，再使用上浮(up)和下沉(down)算法维护堆结构。
