【C语言】堆(Heap)的数据结构与实现：从构建到应用

无限进步_2026-01-05 10:40

引言

在计算机科学中，堆是一种特殊的完全二叉树结构，它具有独特的性质：每个节点的值都满足特定的顺序关系。堆结构在算法设计和系统开发中扮演着重要角色，从操作系统的内存管理到各种高效的排序算法，都能看到堆的身影。

堆主要分为两种类型：大根堆和小根堆。大根堆中每个节点的值都大于或等于其子节点的值，堆顶元素是最大值；小根堆则相反，每个节点的值都小于或等于其子节点的值，堆顶元素是最小值。这种简单的结构特性使得堆在优先级队列、堆排序、Top-K问题等场景中表现出色。

本文将深入探讨堆的数据结构实现，从基础的构建过程开始，逐步分析堆的核心操作，并通过实际测试案例展示堆的多种应用场景。

目录

引言

堆的基本概念与存储

堆的定义与特性

堆的数组表示

堆的核心算法

向上调整算法 (AdjustUp)

向下调整算法 (AdjustDown)

堆的基本操作

堆的初始化与销毁

插入操作 (HPPush)

删除堆顶 (HPPop)

其他辅助操作

堆的构建过程

逐步构建堆

建堆的优化方法

堆的应用测试

测试1：堆排序

测试2：Top-K问题

测试3：原地排序

堆的类型选择与转换

[大根堆 vs 小根堆](#大根堆 vs 小根堆)

向上调整算法

向下调整算法

选择策略

性能分析与优化

时间复杂度总结

空间复杂度

实际优化建议

实际应用场景

[1. 优先级队列](#1. 优先级队列)

[2. 堆排序](#2. 堆排序)

[3. Top-K问题](#3. Top-K问题)

[4. 图算法](#4. 图算法)

[5. 事件驱动模拟](#5. 事件驱动模拟)

[6. 中位数查找](#6. 中位数查找)

总结

堆的基本概念与存储

堆的定义与特性

堆是一种完全二叉树，具有以下关键特性：

  1. 结构特性：堆是一棵完全二叉树，意味着除了最后一层，其他层都是满的，且最后一层的节点都靠左排列

  2. 顺序特性：

    • 大根堆：父节点的值 ≥ 子节点的值

    • 小根堆：父节点的值 ≤ 子节点的值

  3. 堆顶特性：堆顶元素（根节点）是整个堆中的极值元素

堆的数组表示

由于堆是完全二叉树，我们可以用数组来高效地表示堆结构：

复制代码 
typedef struct Heap
{
    HPDataType* a;    // 动态数组存储堆元素
    int size;         // 当前堆中元素个数  
    int capacity;     // 堆的容量
}HP;

数组索引关系：

  • 父节点索引：parent = (child - 1) / 2

  • 左孩子索引：left = parent * 2 + 1

  • 右孩子索引：right = parent * 2 + 2

这种数组表示法避免了指针的开销，同时保持了缓存友好性。

堆的核心算法

向上调整算法 (AdjustUp)

向上调整算法用于在插入新元素后维护堆的性质：

复制代码 
void AdjustUp(HPDataType* a, int child)
{
    assert(a);
    int parent = (child - 1) / 2;

    while (child > 0)
    {
        if (a[child] > a[parent])  // 大堆：子节点大于父节点则交换
        {
            Swap(&a[child], &a[parent]);
            child = parent;
            parent = (child - 1) / 2;
        }
        else
        {
            break;
        }
    }
}

算法流程：

  1. 从新插入的子节点开始

  2. 与父节点比较，如果违反堆性质则交换

  3. 继续向上比较，直到满足堆性质或到达根节点

  4. 时间复杂度：O(log n)

向下调整算法 (AdjustDown)

向下调整算法用于在删除堆顶元素后维护堆的性质：

复制代码 
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[parent] < a[child])  // 父节点小于子节点，需要调整
        {
            Swap(&a[parent], &a[child]);
            parent = child;
            child = parent * 2 + 1;
        }
        else
        {
            break;  // 已满足堆性质
        }
    }
}

算法流程：

  1. 从父节点开始，找到较大的子节点

  2. 如果父节点小于子节点，交换它们

  3. 继续向下调整，直到满足堆性质或到达叶子节点

  4. 时间复杂度：O(log n)

堆的基本操作

堆的初始化与销毁

复制代码 
void HPInit(HP* php)
{
    assert(php);
    php->a = NULL;
    php->capacity = php->size = 0;
}

void HPDestroy(HP* php)
{
    assert(php);
    free(php->a);
    php->a = NULL;
    php->capacity = php->size = 0;
}

内存管理：使用动态数组，支持自动扩容，确保资源正确释放。

插入操作 (HPPush)

复制代码 
void HPPush(HP* php, HPDataType x)
{
    assert(php);
    
    // 扩容检查
    if (php->size == php->capacity)
    {
        int newcapacity = php->capacity == 0 ? 4 : 2 * php->capacity;
        HPDataType* temp = (HPDataType*)realloc(php->a, newcapacity * sizeof(HPDataType));
        if (temp == NULL)
        {
            perror("realloc fail!");
            exit(1);
        }
        php->a = temp;
        php->capacity = newcapacity;
    }

    php->a[php->size] = x;  // 插入到末尾
    php->size++;
    AdjustUp(php->a, php->size - 1);  // 向上调整维护堆性质
}

操作步骤：

  1. 检查容量，必要时扩容

  2. 将新元素插入数组末尾

  3. 执行向上调整，恢复堆性质

删除堆顶 (HPPop)

复制代码 
void HPPop(HP* php)
{
    assert(php);
    assert(php->size > 0);

    Swap(&php->a[0], &php->a[php->size - 1]);  // 交换堆顶和最后一个元素
    php->size--;  // 删除最后一个元素（原堆顶）
    AdjustDown(php->a, php->size, 0);  // 对新的堆顶向下调整
}

删除策略：通过交换堆顶和末尾元素，然后向下调整，高效维护堆结构。

其他辅助操作

复制代码 
// 获取堆顶元素
HPDataType HPTop(HP* php)
{
    assert(php);
    assert(php->size > 0);
    return php->a[0];
}

// 判断堆是否为空
bool HPEmpty(HP* php)
{
    assert(php);
    return php->size == 0;
}

// 获取堆中元素个数
int HPSize(HP* php)
{
    assert(php);
    return php->size;
}

堆的构建过程

逐步构建堆

堆的构建可以通过逐个插入元素来实现：

复制代码 
HP hp;
HPInit(&hp);
int a[] = { 4,2,8,1,5,6,9,7,3,2,23,55,232,66,222,33,7,1,66,3333,999 };
for (int i = 0; i < sizeof(a) / sizeof(a[0]); i++)
{
    HPPush(&hp, a[i]);
}

构建过程分析：

  1. 初始为空堆

  2. 依次插入每个元素

  3. 每次插入后通过向上调整维护堆性质

  4. 最终形成完整的大根堆

时间复杂度：O(n log n)，每个插入操作需要O(log n)时间

建堆的优化方法

对于已知所有元素的场景，可以使用更高效的Floyd建堆算法，时间复杂度为O(n)：

复制代码 
// 自底向上的建堆方法
void HeapBuild(HP* php, HPDataType* array, int n)
{
    assert(php);
    php->a = (HPDataType*)malloc(n * sizeof(HPDataType));
    memcpy(php->a, array, n * sizeof(HPDataType));
    php->size = php->capacity = n;
    
    // 从最后一个非叶子节点开始向下调整
    for (int i = (n - 1 - 1) / 2; i >= 0; i--)
    {
        AdjustDown(php->a, n, i);
    }
}

堆的应用测试

测试1：堆排序

复制代码 
// 依次取出顶部的数（大堆会按降序输出）
while (!HPEmpty(&hp))
{
    printf("%d ", HPTop(&hp));
    HPPop(&hp);
}

排序原理：

  • 大根堆：依次取出堆顶（最大值），得到降序序列

  • 小根堆：依次取出堆顶（最小值），得到升序序列

时间复杂度 ：O(n log n)
空间复杂度：O(1)（如果不计堆本身）

测试2：Top-K问题

复制代码 
// 取出前n大的数
int n = 0;
scanf("%d", &n);
while (n--)
{
    printf("%d ", HPTop(&hp));
    HPPop(&hp);
}

应用场景：

  • 找出数据流中最大的K个元素

  • 推荐系统中的热门物品筛选

  • 数据分析中的异常值检测

算法优势：相比全排序，只需要O(k log n)时间

测试3：原地排序

复制代码 
// 排序：将堆元素放回原数组
int i = 0;
while (!HPEmpty(&hp))
{
    a[i++] = HPTop(&hp);
    HPPop(&hp);
}

特点：可以实现原地的堆排序，空间效率高

堆的类型选择与转换

大根堆 vs 小根堆

通过修改比较条件，可以轻松切换堆的类型。以下是完整函数的对比：

向上调整算法

大根堆版本：

复制代码 
void AdjustUp(HPDataType* a, int child)
{
    assert(a);
    int parent = (child - 1) / 2;

    while (child > 0)
    {
        if (a[child] > a[parent])  // 大堆：子节点大于父节点则交换
        {
            Swap(&a[child], &a[parent]);
            child = parent;
            parent = (child - 1) / 2;
        }
        else
        {
            break;
        }
    }
}

小根堆版本：

复制代码 
void AdjustUp(HPDataType* a, int child)
{
    assert(a);
    int parent = (child - 1) / 2;

    while (child > 0)
    {
        if (a[child] < a[parent])  // 小堆：子节点小于父节点则交换
        {
            Swap(&a[child], &a[parent]);
            child = parent;
            parent = (child - 1) / 2;
        }
        else
        {
            break;
        }
    }
}
向下调整算法

大根堆版本：

复制代码 
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[parent] < a[child])  // 父节点小于子节点，需要调整
        {
            Swap(&a[parent], &a[child]);
            parent = child;
            child = parent * 2 + 1;
        }
        else
        {
            break;
        }
    }
}

小根堆版本：

复制代码 
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[parent] > a[child])  // 父节点大于子节点，需要调整
        {
            Swap(&a[parent], &a[child]);
            parent = child;
            child = parent * 2 + 1;
        }
        else
        {
            break;
        }
    }
}

选择策略

  • 大根堆：适用于需要频繁获取最大值的场景

  • 小根堆：适用于需要频繁获取最小值的场景

  • 双堆结构：同时维护大根堆和小根堆，用于中位数查找等问题

通过修改这两个函数中的比较符号，就可以实现堆类型的切换。在实际项目中，可以通过宏定义或函数指针来动态选择堆类型，增加代码的灵活性。

性能分析与优化

时间复杂度总结

操作 时间复杂度 说明
插入 O(log n) 向上调整
删除堆顶 O(log n) 向下调整
获取堆顶 O(1) 直接访问
建堆 O(n log n) 逐个插入
优化建堆 O(n) Floyd算法
堆排序 O(n log n) 所有元素出堆

空间复杂度

  • 基础存储：O(n)

  • 操作额外空间：O(1)（递归实现除外）

实际优化建议

  1. 批量建堆：使用Floyd算法优化初始化

  2. 内存预分配：根据业务需求预估容量，减少扩容次数

  3. 缓存优化：数组存储具有良好的缓存局部性

  4. 避免频繁调整：批量操作后统一调整

实际应用场景

1. 优先级队列

堆是优先级队列的自然实现，操作系统进程调度、网络数据包处理等都依赖于此。

2. 堆排序

高效的原地排序算法，在最坏情况下仍保持O(n log n)性能。

3. Top-K问题

快速找出前K个最大或最小元素，广泛应用于数据分析。

4. 图算法

Dijkstra最短路径算法、Prim最小生成树算法使用堆优化性能。

5. 事件驱动模拟

离散事件仿真中按时间顺序处理事件。

6. 中位数查找

使用双堆技巧在数据流中实时维护中位数。

总结

堆作为一种高效的数据结构，通过简单的数组实现和精巧的调整算法，提供了极值访问的O(1)时间复杂度和元素更新的O(log n)时间复杂度。从基础的堆构建到复杂的应用场景，堆都展现出了其独特的价值。

通过本文的分析，我们可以看到：

  1. 设计简洁而强大：数组表示和完全二叉树性质使得堆既高效又易于实现

  2. 算法精巧而实用：向上调整和向下调整算法优雅地维护了堆性质

  3. 应用广泛而深入：从排序算法到系统调度，堆在计算机科学的各个领域都有重要应用

  4. 性能优异而稳定：在各种操作下都能保持良好的时间复杂度

理解堆的原理和实现，不仅有助于我们解决具体的算法问题，更重要的是培养了分析问题、设计数据结构的能力。堆所体现的"用简单构建复杂"的思想，在软件工程和算法设计中具有普遍的指导意义。

无论是初学者学习数据结构，还是有经验的开发者优化系统性能，堆都是一个值得深入理解和掌握的重要工具。通过不断实践和应用，我们可以更好地发挥堆在各种场景中的潜力，构建出更高效、更可靠的软件系统。

相关推荐
2401_8384725112 小时前
C++模拟器开发实践
开发语言·c++·算法
31087487612 小时前
0005.C/C++学习笔记5
c语言·c++·学习
s1hiyu13 小时前
实时控制系统验证
开发语言·c++·算法
daad77713 小时前
V4L2_mipi-csi
算法
楼田莉子13 小时前
C++现代特性学习：C++14
开发语言·c++·学习·visual studio
2301_7657031413 小时前
C++代码复杂度控制
开发语言·c++·算法
m0_7088309613 小时前
C++中的享元模式实战
开发语言·c++·算法
naruto_lnq13 小时前
分布式计算C++库
开发语言·c++·算法
好好研究13 小时前
总结SSM设置欢迎页的方式
xml·java·后端·mvc
m0_7066532313 小时前
模板编译期排序算法
开发语言·c++·算法
热门推荐
01GitHub 镜像站点02Clawdbot 中文汉化版 接入微信、飞书03OpenCode 入门教程：介绍 · 安装 · 配置第三方 API (如 Claude)042026数学建模美赛题目特点与选题建议，常用四大模型汇总052026美赛A题智能手机电池续航时间预测的连续时间数学模型06Claude Code Skills 实用使用手册07UV安装并设置国内源08在Trae中使用Pencil MCP09Linux下V2Ray安装配置指南10一种新的LCA算法