前言
堆是数据结构里一个很典型的例子:逻辑上它是一棵完全二叉树,物理上却只用一个数组就能存下。也正因为如此,它的插入、删除都只需要沿着一条路径调整,代码量不大,但每一步的下标关系都值得想清楚。
本文将按照"先看懂结构,再动手实现"的顺序展开:先说明堆的定义和数组存储方式,再给出结构定义与接口,然后逐个实现初始化、插入、删除等操作,最后分析两种建堆方式的时间复杂度,并整理几处初学者容易混淆的地方。
本文代码统一实现大堆,使用 C 语言,从基本原理逐步讲解到完整可运行的实现。
1. 堆的概念与结构
1.1 什么是堆?
把一组数据按照完全二叉树的顺序存入一维数组,如果每个父结点与其孩子都满足同一种大小关系,就可以构成堆。
| 类型 | 父子结点的关系 | 堆顶特点 |
|---|---|---|
| 大堆,也叫大根堆、最大堆 | 父结点的值不小于孩子结点 | 根结点是整个堆的最大值 |
| 小堆,也叫小根堆、最小堆 | 父结点的值不大于孩子结点 | 根结点是整个堆的最小值 |
设数组为 a,元素个数为 n。对于每个合法下标 i,只要相应孩子存在,大堆就要求:
text
a[i] >= a[2*i + 1] // 有左孩子时
a[i] >= a[2*i + 2] // 有右孩子时
小堆把上面的两个 >= 都改为 <=。相等的元素也符合堆的性质。
堆有两个需要同时满足的条件:
- 结构上是完全二叉树:最后一层可以不满,但结点必须从左到右连续排列;上面的各层都是满的。
- 数值上满足统一的父子大小关系:大堆始终是父结点不小于孩子,小堆则相反。
例如,下面是一棵大堆:
text
90
/ \
70 80
/ \ /
20 60 50
对应数组是 [90, 70, 80, 20, 60, 50]。可以看到,堆只约束父子之间的大小关系,兄弟之间不要求有序,整个数组也不要求有序。不能仅凭根结点最大,就认定一棵完全二叉树是大堆,还需要检查每一组父子关系。
1.2 完全二叉树与数组下标
按照从上到下、从左到右的顺序,从 0 开始编号,完全二叉树就能连续存入数组。
text
树上的下标: 数组中的位置:
0 下标:0 1 2 3 4 5
/ \ 数据:90 70 80 20 60 50
1 2
/ \ /
3 4 5
对于下标为 i 的结点:
| 关系 | 下标公式 | 存在条件 |
|---|---|---|
| 父结点 | (i - 1) / 2,整数除法 |
i > 0 |
| 左孩子 | 2 * i + 1 |
2 * i + 1 < n |
| 右孩子 | 2 * i + 2 |
2 * i + 2 < n |
例如,下标 1 的左右孩子是 3、4;下标 5 的父结点是 (5 - 1) / 2 = 2。根结点下标为 0,没有父结点,不能对它套用父结点公式来判断是否存在父亲。
记住:逻辑结构是完全二叉树,物理存储是数组。后面的调整算法不需要左右孩子指针,只需要这些下标公式。
2. 堆的结构定义及接口
2.1 结构定义
实现堆需要使用动态内存管理、断言和布尔类型等功能,先包含以下头文件:
c
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <assert.h>
#include <string.h>
接下来定义堆的结构,使用动态数组保存数据:
c
typedef int HPDataType;
typedef struct Heap
{
HPDataType* a; // 指向存储数据的动态数组
int size; // 当前有效元素个数
int capacity; // 数组当前能够容纳的元素个数
} HP;
size 和 capacity 的含义不同。例如,申请了 8 个元素的空间,只放入 5 个元素时,size 是 5,capacity 是 8,只有下标 [0, size) 中的数据属于堆。
2.2 接口总览
堆的基本操作及辅助函数声明如下:
c
void HPInit(HP* php); // 初始化空堆
void HPInitArray(HP* php, HPDataType* a, int n); // 复制数组并建堆
void HPDestroy(HP* php); // 销毁堆
void HPPush(HP* php, HPDataType x); // 插入元素
HPDataType HPTop(HP* php); // 读取堆顶
void HPPop(HP* php); // 删除堆顶
bool HPEmpty(HP* php); // 判断是否为空
int HPSize(HP* php); // 获取有效元素个数
void Swap(HPDataType* x, HPDataType* y);
void AdjustUp(HPDataType* a, int child);
void AdjustDown(HPDataType* a, int n, int parent);
注意区分:HPTop 读取 堆顶,不删除数据;HPPop 删除堆顶,不返回被删除的值。
3. 基础接口实现
有了结构定义和接口声明,接下来实现交换、初始化、销毁、读取堆顶、判空和获取元素个数等基础操作。
本节还会给出利用已有数组初始化堆的接口,其中需要调用向下调整函数 AdjustDown。可以先理解它"复制数据,再调整成堆"的整体过程,向下调整的具体原理和建堆复杂度将在后文展开。由于前面已经声明了该函数,即使它的定义写在后面,也可以正常调用。
3.1 交换两个元素
向上调整和向下调整都会调用 Swap。通过指针交换两个位置的数据,就能修改原数组中的元素。
c
void Swap(HPDataType* x, HPDataType* y)
{
HPDataType tmp = *x;
*x = *y;
*y = tmp;
}
3.2 初始化与销毁
初始化时,将数组指针置为 NULL,元素个数和容量都置为 0。暂时不申请空间,等第一次插入时再扩容。
c
void HPInit(HP* php)
{
assert(php);
php->a = NULL;
php->size = 0;
php->capacity = 0;
}
销毁时释放动态数组,并重置各个成员,避免留下悬空指针和失效的大小信息。
c
void HPDestroy(HP* php)
{
assert(php);
free(php->a); // free(NULL) 也是合法操作
php->a = NULL;
php->size = 0;
php->capacity = 0;
}
HPInit用于初始化尚未持有资源的堆对象。如果堆已经申请了空间,应先调用HPDestroy,再重新初始化,否则原来的空间将无法释放。
3.3 读取堆顶、判空与获取元素个数
堆顶始终存储在数组下标 0 的位置,因此读取堆顶不需要遍历数组。但在读取之前,必须保证堆不为空。
c
HPDataType HPTop(HP* php)
{
assert(php && php->size > 0);
return php->a[0];
}
判断堆是否为空,只需要检查有效元素个数是否为 0:
c
bool HPEmpty(HP* php)
{
assert(php);
return php->size == 0;
}
获取堆中元素个数时,直接返回 size,注意不要返回表示容量的 capacity。
c
int HPSize(HP* php)
{
assert(php);
return php->size;
}
这三个接口的时间复杂度都是 O(1)。
assert用于检查调用前提,不能代替正常的业务判断。使用堆时,应先确认非空,再调用HPTop或HPPop。
3.4 利用已有数组初始化堆
如果已经有一组数据,可以先将数据复制到堆自己的数组中,再从最后一个非叶子结点开始向下调整。
这样既能保留原数组的数据,也能让堆独立管理自己的内存。
c
void HPInitArray(HP* php, HPDataType* a, int n)
{
// 元素个数不能为负;非空数组必须提供有效指针
assert(php && n >= 0 && (n == 0 || a != NULL));
HPInit(php);
// 空数组直接初始化为空堆
if (n == 0)
return;
php->a = malloc(sizeof(HPDataType) * n);
if (php->a == NULL)
{
perror("malloc fail");
exit(EXIT_FAILURE);
}
// 复制数据,避免直接接管外部数组
memcpy(php->a, a, sizeof(HPDataType) * n);
php->size = n;
php->capacity = n;
// 自底向上建堆,保证调整时左右子树已经分别是堆
if (n >= 2)
{
for (int i = (n - 2) / 2; i >= 0; --i)
{
AdjustDown(php->a, php->size, i);
}
}
}
AdjustDown 的参数依次为数组指针、有效元素个数和当前父结点下标:
c
AdjustDown(数组指针, 有效元素个数, 当前父结点下标);
复制数组需要 O(n) 时间,向下调整建堆也需要 O(n) 时间,所以整个初始化过程的时间复杂度为 O(n) 。由于另外申请了一个数组,所需存储空间为 O(n)。
使用示例:
c
int a[] = {20, 70, 50, 90, 60, 80};
int n = (int)(sizeof(a) / sizeof(a[0]));
HP hp;
HPInitArray(&hp, a, n);
if (!HPEmpty(&hp))
{
printf("堆顶:%d\n", HPTop(&hp)); // 90
}
printf("元素个数:%d\n", HPSize(&hp)); // 6
HPDestroy(&hp);
HPInitArray 内部已经完成初始化,调用前不需要再执行 HPInit。同样,不应对尚未销毁、仍持有动态数组的堆重复调用它。
4. 向上调整与插入
4.1 为什么把新元素放在末尾?
插入首先要保持完全二叉树的结构,因此应该把新元素放到数组末尾,即下一个连续的下标位置。
插入之前整个数组已经是大堆,新增结点不会改变原有结点之间的关系,可能被破坏的只有新结点到根的路径。只要沿着这条路径向上检查,就能恢复堆的性质。
向上调整的过程是:
- 找到当前结点的父结点。
- 如果孩子大于父亲,交换两者,然后继续向上。
- 如果孩子不大于父亲,或者已经到达根结点,就结束。
例如,向 [90, 70, 80, 20, 60, 50] 插入 95:
text
末尾插入: [90, 70, 80, 20, 60, 50, 95]
95 > 80: [90, 70, 95, 20, 60, 50, 80]
95 > 90: [95, 70, 90, 20, 60, 50, 80]
到达根结点,调整结束。
4.2 向上调整代码
c
void AdjustUp(HPDataType* a, int child)
{
while (child > 0)
{
int parent = (child - 1) / 2;
if (a[child] <= a[parent])
break; // 当前父子关系已经满足大堆性质
Swap(&a[child], &a[parent]);
child = parent; // 沿着父结点继续向上检查
}
}
每次交换后,当前下标都移动到上一层。完全二叉树高度为 O(log n),因此一次向上调整的最坏时间复杂度为 O(log n) ,额外空间为 O(1)。
4.3 插入接口
插入分为三件事:空间不足时扩容、尾部写入数据、向上调整。
c
void HPPush(HP* php, HPDataType x)
{
assert(php);
if (php->size == php->capacity)
{
int newCapacity = php->capacity == 0 ? 4 : php->capacity * 2;
HPDataType* tmp = realloc(php->a,
sizeof(HPDataType) * newCapacity);
if (tmp == NULL)
{
perror("realloc fail");
exit(EXIT_FAILURE);
}
php->a = tmp;
php->capacity = newCapacity;
}
php->a[php->size] = x;
++php->size;
AdjustUp(php->a, php->size - 1);
}
使用临时指针接收 realloc 的返回值,申请成功后再更新原数组指针;申请失败时,报错并退出程序。
复杂度补充 :不发生扩容时,一次插入最坏为 O(log n);如果本次扩容需要搬移已有数据,则单次插入最坏可达 O(n)。按容量翻倍进行连续插入,扩容的均摊成本为 O(1),加上向上调整后,每次插入的均摊时间上界仍为 O(log n)。
5. 向下调整与删除
5.1 删除的是哪一个元素?
这里的删除操作指的是删除堆顶元素。
如果把堆顶删掉后,让后面的所有数组元素向前移动,原有的父子下标关系就会大范围变化。因此采用下面的步骤:
- 交换堆顶和最后一个元素。
- 将
size减一,原来的堆顶就被排除在有效范围之外。 - 对新的堆顶进行向下调整。
size-- 是逻辑删除,不要求清零数组末尾,也不需要立即缩小容量。
5.2 为什么要选较大的孩子?
向下调整有一个前提:当前结点的左右子树已经分别是堆。删除堆顶时,尾部元素被放到了根上,剩余子树仍满足堆的性质,所以符合这个前提。
对于大堆,每次要选左右孩子中较大的一个,再和父结点比较。如果父结点已经不小于较大的孩子,它自然也不小于另一个孩子;如果需要交换,把较大者放到父结点位置,才能同时满足与两个孩子的关系。
例如,父结点是 40,两个孩子是 70、90,如果只与较小的 70 交换,新的父结点 70 仍然小于 90,这一步就没有修复该位置。
5.3 向下调整代码
c
void AdjustDown(HPDataType* a, int n, int parent)
{
int child = parent * 2 + 1; // 先假设左孩子较大
while (child < n)
{
// 右孩子存在,且比左孩子大时,选择右孩子
if (child + 1 < n && a[child + 1] > a[child])
++child;
if (a[child] <= a[parent])
break;
Swap(&a[child], &a[parent]);
parent = child;
child = parent * 2 + 1;
}
}
先判断 child + 1 < n,再读取右孩子,利用 && 的短路求值避免越界。只有左孩子时,也能够正常比较和调整。
5.4 删除接口与示例
c
void HPPop(HP* php)
{
assert(php && php->size > 0);
Swap(&php->a[0], &php->a[php->size - 1]);
--php->size;
if (php->size > 0)
AdjustDown(php->a, php->size, 0);
}
删除 [95, 70, 90, 20, 60, 50, 80] 的堆顶:
text
首尾交换并缩小有效范围: [80, 70, 90, 20, 60, 50] | 95
选择较大的孩子 90: [90, 70, 80, 20, 60, 50]
80 已经大于它的孩子 50,调整结束。
一次向下调整最多走到叶子,最坏时间复杂度为 O(log n) ;删除接口不进行缩容,因此最坏时间也为 O(log n),额外空间为 O(1)。只有一个元素时,删除后为空堆,直接结束。
6. 两种建堆方式的时间复杂度
单次调整的成本与把 n 个元素整体建成堆的成本不同,分析时需要区分。
6.1 逐个插入,向上调整建堆
先初始化空堆,再把数组中的元素逐个插入。每插入一个元素,就调用一次向上调整。
c
HP hp;
HPInit(&hp);
for (int i = 0; i < n; ++i)
HPPush(&hp, a[i]);
// 使用完毕后调用 HPDestroy(&hp)
以高度为 h 的满二叉树估算最坏移动步数。根结点所在层为第 1 层,结点总数为 n = 2^h - 1。
| 层数 | 结点个数 | 每个结点最多向上移动的层数 |
|---|---|---|
| 1 | 2^0 |
0 |
| 2 | 2^1 |
1 |
| 3 | 2^2 |
2 |
| ... | ... | ... |
| h | 2^(h-1) |
h - 1 |
因此最多移动的总步数为:
Tup(h)=∑k=0h−1k2k=2h(h−2)+2. T_{up}(h)=\sum_{k=0}^{h-1}k2^k =2^h(h-2)+2. Tup(h)=k=0∑h−1k2k=2h(h−2)+2.
将求和式乘以 2 后与原式错位相减,即可得到上面的结果。再代入 2^h = n + 1、h = log₂(n + 1):
Tup(n)=(n+1)(log2(n+1)−2)+2. T_{up}(n)=(n+1)\bigl(\log_2(n+1)-2\bigr)+2. Tup(n)=(n+1)(log2(n+1)−2)+2.
所以,向上调整建堆的最坏时间复杂度为 O(n log n)。例如,大堆按严格递增顺序逐个插入时,新元素会不断向上移动,能达到这一量级。实际输入不一定每次都走到根;这里分析的是最坏情况。
6.2 从最后一个非叶子结点开始,向下调整建堆
叶子结点本身就可以看作一个堆,不需要调整。我们从最后一个非叶子结点开始,逐个向前执行向下调整,直到根结点。
当 n >= 2 时,最后一个结点下标是 n - 1,它的父结点就是最后一个非叶子结点,下标为 (n - 2) / 2:
c
if (n >= 2)
{
for (int i = (n - 2) / 2; i >= 0; --i)
AdjustDown(a, n, i);
}
这里的 i 使用有符号整数,才能在递减到 -1 后正常结束。先判断 n >= 2,也让空数组、单元素数组的情况更清楚。
为什么必须从后往前? 因为向下调整要求左右子树已经是堆。先处理下层结点,再处理它们的父结点,就能逐步保证这个前提;不能只对任意数组的根调用一次向下调整,就认为建堆完成。
同样以满二叉树计算:
| 层数 | 结点个数 | 每个结点最多向下移动的层数 |
|---|---|---|
| 1 | 2^0 |
h - 1 |
| 2 | 2^1 |
h - 2 |
| ... | ... | ... |
| h - 1 | 2^(h-2) |
1 |
| h | 2^(h-1) |
0 |
于是:
Tdown(h)=∑k=0h−22k(h−1−k). T_{down}(h)=\sum_{k=0}^{h-2}2^k(h-1-k). Tdown(h)=k=0∑h−22k(h−1−k).
错位相减可得:
Tdown(h)=2h−1−h. T_{down}(h)=2^h-1-h. Tdown(h)=2h−1−h.
代入 n = 2^h - 1:
Tdown(n)=n−log2(n+1). T_{down}(n)=n-\log_2(n+1). Tdown(n)=n−log2(n+1).
加上遍历非叶子结点、比较等基本操作,向下调整建堆的时间复杂度为 O(n)。
这些等式计算的是满二叉树中按层高累计的最大移动步数,不代表任意输入都会发生这么多次交换。一般完全二叉树也具有相同的复杂度结论。
理解差别的关键在于:向下建堆时,数量最多的叶子不需要移动,靠近叶子的结点也只移动很少几层;需要移动很多层的结点很少。因此不能简单用"结点数 × 树高"给出紧确分析。
| 建堆方式 | 执行顺序 | 时间复杂度(最坏情况) |
|---|---|---|
| 向上调整建堆 | 从前往后逐个插入 | O(n log n) |
| 向下调整建堆 | 从最后一个非叶子结点到根 | O(n) |
7. 学习时容易混淆的地方
- 堆顶最大不等于数组有序:大堆约束的是每一组父子关系。
- 插入前原结构已经是堆:尾插后只修复通往根的一条路径。
- 向下调整有前提:左右子树必须分别已经是堆;建堆顺序正是为保证这个前提。
- 大小比较必须统一:如果改成小堆,向上调整要让较小的孩子上移,向下调整要选较小的孩子,再在父结点更大时交换。
- 删除堆顶不等于释放一个数组槽位:减小的是有效元素个数,容量可以不变。
- 单次调整与整体建堆不同 :单次调整最坏
O(log n),但向下建堆整体为O(n)。