数据结构:堆的概念与实现

前言

堆是数据结构里一个很典型的例子:逻辑上它是一棵完全二叉树,物理上却只用一个数组就能存下。也正因为如此,它的插入、删除都只需要沿着一条路径调整,代码量不大,但每一步的下标关系都值得想清楚。

本文将按照"先看懂结构,再动手实现"的顺序展开:先说明堆的定义和数组存储方式,再给出结构定义与接口,然后逐个实现初始化、插入、删除等操作,最后分析两种建堆方式的时间复杂度,并整理几处初学者容易混淆的地方。

本文代码统一实现大堆,使用 C 语言,从基本原理逐步讲解到完整可运行的实现。

1. 堆的概念与结构

1.1 什么是堆?

把一组数据按照完全二叉树的顺序存入一维数组,如果每个父结点与其孩子都满足同一种大小关系,就可以构成堆。

类型 父子结点的关系 堆顶特点
大堆,也叫大根堆、最大堆 父结点的值不小于孩子结点 根结点是整个堆的最大值
小堆,也叫小根堆、最小堆 父结点的值不大于孩子结点 根结点是整个堆的最小值

设数组为 a,元素个数为 n。对于每个合法下标 i,只要相应孩子存在,大堆就要求:

text 复制代码
a[i] >= a[2*i + 1]    // 有左孩子时
a[i] >= a[2*i + 2]    // 有右孩子时

小堆把上面的两个 >= 都改为 <=。相等的元素也符合堆的性质。

堆有两个需要同时满足的条件:

  1. 结构上是完全二叉树:最后一层可以不满,但结点必须从左到右连续排列;上面的各层都是满的。
  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 为什么把新元素放在末尾?

插入首先要保持完全二叉树的结构,因此应该把新元素放到数组末尾,即下一个连续的下标位置。

插入之前整个数组已经是大堆,新增结点不会改变原有结点之间的关系,可能被破坏的只有新结点到根的路径。只要沿着这条路径向上检查,就能恢复堆的性质。

向上调整的过程是:

  1. 找到当前结点的父结点。
  2. 如果孩子大于父亲,交换两者,然后继续向上。
  3. 如果孩子不大于父亲,或者已经到达根结点,就结束。

例如,向 [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 删除的是哪一个元素?

这里的删除操作指的是删除堆顶元素。

如果把堆顶删掉后,让后面的所有数组元素向前移动,原有的父子下标关系就会大范围变化。因此采用下面的步骤:

  1. 交换堆顶和最后一个元素。
  2. 将 size 减一,原来的堆顶就被排除在有效范围之外。
  3. 对新的堆顶进行向下调整。

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)(log⁡2(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−log⁡2(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)。
相关推荐
H H.3 小时前
Java企业级开发:从框架到工程化实战
java·开发语言·经验分享·其他·课程设计
Pniubi4 小时前
01背包类问题-力扣416.分割等和子集
算法·leetcode·职场和发展
吃我一窝jio14 小时前
Python与Go线程模型深度对比
java·开发语言·python
eggwyw15 小时前
C++ union 的一种妙用法
开发语言·c++
罗西的思考15 小时前
【轻量化复现大模型 / KIMI K3】MTP / EAGLE‑3 模块交互式演示
人工智能·深度学习·算法
starzy199017 小时前
深入理解Scala隐式函数:自动类型转换
开发语言·后端·scala
布莱克60519 小时前
Swift 循环与控制转移详解:从 for-in 到标签跳转
开发语言·ssh·swift·循环
kyle~20 小时前
模型预测控制(MPC)
算法·机器人·控制·传感器
敲上瘾20 小时前
Qt核心机制:信号与槽详解
开发语言·c++·qt·ui·qt6.3