在Golang的标准库中，container/heap包提供了一套通用的堆操作接口，开发者不需要自己实现堆的底层调整逻辑，只需要让自定义的数据结构实现heap.Interface接口，就可以直接使用堆的插入、删除、初始化等功能。堆是一种特殊的完全二叉树结构，通常分为最小堆和最大堆，最小堆的父节点值小于子节点值，最大堆则相反，在实际开发中常用于优先队列、TopK问题等场景。
heap.Interface接口说明
要使用container/heap包，首先需要了解heap.Interface的定义，它包含三个方法，自定义类型需要实现这三个方法才能完成堆操作：
- Len() int：返回集合中元素的数量
- Less(i, j int) bool：判断索引i的元素是否小于索引j的元素，这个方法决定了堆是最小堆还是最大堆，返回true表示i位置元素优先级更高
- Swap(i, j int)：交换索引i和j位置的元素
- Push(x interface{})：向集合末尾添加一个元素，注意这里的添加是追加到切片末尾，不是堆调整
- Pop() interface{}：移除集合末尾的元素并返回，同样这里的移除只是删除末尾元素，堆调整由heap包的方法完成
实现最小堆示例
下面以实现一个整数最小堆为例，演示完整的实现流程：
1. 定义自定义类型并实现接口
首先定义一个基于切片的类型，然后实现heap.Interface的所有方法：
package main
import (
"container/heap"
"fmt"
)
// 定义IntHeap类型，底层是int切片
type IntHeap []int
// 实现Len方法
func (h IntHeap) Len() int { return len(h) }
// 实现Less方法，i位置元素小于j位置则返回true，构成最小堆
func (h IntHeap) Less(i, j int) bool { return h[i] < h[j] }
// 实现Swap方法
func (h IntHeap) Swap(i, j int) { h[i], h[j] = h[j], h[i] }
// 实现Push方法，向切片末尾追加元素
func (h *IntHeap) Push(x interface{}) {
*h = append(*h, x.(int))
}
// 实现Pop方法，移除切片最后一个元素并返回
func (h *IntHeap) Pop() interface{} {
old := *h
n := len(old)
x := old[n-1]
*h = old[0 : n-1]
return x
}
2. 堆的初始化与操作
定义好类型之后，就可以使用heap包的方法进行堆操作了：
func main() {
// 初始化一个堆，初始元素为2,1,5
h := &IntHeap{2, 1, 5}
// 初始化堆，调整元素位置满足堆结构
heap.Init(h)
// 向堆中插入元素3
heap.Push(h, 3)
// 插入后堆会自动调整，此时堆顶是最小元素
fmt.Printf("当前堆顶元素: %dn", (*h)[0])
// 弹出堆顶元素
min := heap.Pop(h)
fmt.Printf("弹出的堆顶元素: %dn", min)
// 弹出后堆会自动调整，新的堆顶是剩下元素中的最小值
fmt.Printf("新的堆顶元素: %dn", (*h)[0])
// 遍历剩余堆元素
fmt.Print("剩余堆元素: ")
for h.Len() > 0 {
fmt.Printf("%d ", heap.Pop(h))
}
}
上面的代码运行后，会先输出堆顶元素1，弹出后新的堆顶是2，最后遍历输出剩余元素为2 3 5，符合最小堆的特性。
实现最大堆的方法
如果要实现最大堆，只需要修改Less方法的实现逻辑即可，将比较规则改为i位置元素大于j位置元素时返回true：
// 最大堆的Less方法实现
func (h IntHeap) Less(i, j int) bool { return h[i] > h[j] }
这样调整后，堆顶元素就会是切片中的最大值，其他操作逻辑和最小堆完全一致。
自定义结构体堆的实现
实际开发中经常需要对结构体进行排序，比如实现一个任务优先队列，每个任务有优先级和任务内容，按优先级排序：
package main
import (
"container/heap"
"fmt"
)
// 定义任务结构体
type Task struct {
Name string
Priority int
}
// 定义任务堆类型
type TaskHeap []Task
func (h TaskHeap) Len() int { return len(h) }
// 按优先级从高到低排序，优先级数值越大优先级越高
func (h TaskHeap) Less(i, j int) bool { return h[i].Priority > h[j].Priority }
func (h TaskHeap) Swap(i, j int) { h[i], h[j] = h[j], h[i] }
func (h *TaskHeap) Push(x interface{}) {
*h = append(*h, x.(Task))
}
func (h *TaskHeap) Pop() interface{} {
old := *h
n := len(old)
x := old[n-1]
*h = old[0 : n-1]
return x
}
func main() {
tasks := &TaskHeap{
{Name: "写文档", Priority: 1},
{Name: "修Bug", Priority: 3},
{Name: "开发需求", Priority: 2},
}
heap.Init(tasks)
// 插入一个新任务
heap.Push(tasks, Task{Name: "上线部署", Priority: 4})
// 按优先级弹出任务
fmt.Println("任务执行顺序:")
for tasks.Len() > 0 {
task := heap.Pop(tasks).(Task)
fmt.Printf("任务: %s, 优先级: %dn", task.Name, task.Priority)
}
}
运行上述代码，会按照优先级从高到低的顺序输出任务，先执行上线部署，再修Bug，然后开发需求，最后写文档，符合优先队列的逻辑。
注意事项
- 调用
heap.Push和heap.Pop时，必须传入的是指针类型的堆实例，因为这两个方法会修改底层切片的内容 - 如果直接修改底层切片的元素，不会自动触发堆调整，需要手动调用
heap.Fix(h, i)方法来重新调整指定位置的元素 heap.Init方法会将一个无序的切片调整为合法的堆结构，时间复杂度是O(n)，比逐个插入的效率更高
Golangcontainer/heap堆heap_interface修改时间：2026-06-28 01:36:49