💓 博客主页：C-SDN花园GGbond
⏩ 文章专栏：探索数据结构与算法
目录
一.堆的基本概念
堆的特性
- 堆是一棵完全二叉树，通常使用数组进行存储。
- 堆中任意节点的值都满足堆的性质，即大顶堆中父节点的值大于或等于其子节点的值，小顶堆中父节点的值小于或等于其子节点的值
数组与堆的关联
为什么选择数组？
- 数组在内存中是连续存储的，可以高效地进行访问和修改。
- 对于完全二叉树，可以使用数组进行简单的索引计算来访问任意节点。
注意：我们只是把数组在逻辑上想象成了抽象的堆，其实它本质上就是数组
数组与堆的映射关系（重要）
- 若某节点在数组中的下标为i（i从0开始），则其左子节点(若存在)的下标为2i+1，右子节点（若存在）的下标为2i+2，其父节点（若存在）的下标为（i-1）/2
- 堆的根节点在数组中的下标通常为0。
二.堆的结构定义
堆的结构定义与顺序表基本是一致的，这也更说明了堆的概念更多的是在逻辑上更加抽象
包括
- 指向某种数据类型的指针（用来实现数组）
- 数组的有效数据个数size
- 数组的空间大小capacity
typedef int HPDataType;//数据类型重定义
typedef struct Heap//堆的结构定义
{
HPDataType* a;
int size;
int capacity;
}Heap;三.堆的接口实现
1.初始化
- 首先对形参接收的地址判空
- 指针初始为NULL
- size和capacity初始为0
void HeapInit(Heap* php)//初始化
{
assert(php);
php->a = NULL;
php->size = php->capacity = 0;
}2.销毁
- 对形参接收的地址判空
- 释放为数组动态开辟的空间，并置为NULL
- size和capacity修改为0
3.向上调整算法（重要）
- 该函数在这里是为入堆准备的）
- 接收两个参数，分别是数组或指针，以及对应需要调整的节点位置
- 思想:从该位置向上调整，直到父子满足大小关系，或调整至根结点
void Adjustup(HPDataType* a, int child)//向上调整算法
{
assert(a);//数组必须存在，否则解引用就会报错
int parent = (child - 1) / 2;
while (child > 0 && a[parent] > a[child])//这里以小堆调整为例
{
Swap(&a[parent], &a[child]);//交换数据必须传地址
child = parent;
parent= (child - 1) / 2;
}
}这里额外封装了一个交换函数，方便后面多次使用，并且想要通过形参改变实参的值，需要传址调用
void Swap(HPDataType* a, HPDataType* b)//交换函数
{
HPDataType tmp = *a;
*a = *b;
*b = tmp;
}4.入堆
- 接收两个参数：数组或指针，以及要插入的数据
- 对形参接收的地址判空
- 判断数组有剩余空间（若不足，扩容）
- 将新数据插入到数组最后一个有效数据的后面
- 之后调用向上调整算法 重新调整为堆
void HeapPush(Heap* hp, HPDataType x)//入堆
{
assert(hp);//接收的堆地址必须是有效的
if (hp->size == hp->capacity)//判断是否需要扩容
{
int newcapacity = hp->capacity == 0 ? 4 : (hp->capacity) * 2;
HPDataType* tmp = (HPDataType*)realloc(hp->a,sizeof(HPDataType) * newcapacity);
if (tmp == NULL)
{
perror("Push perror\n");
exit(1);
}
hp->a = tmp;
hp->capacity = newcapacity;
}
hp->a[hp->size++] = x;//插入到尾部
Adjustup(hp->a, hp->size - 1);//进行向上调整
}5.向下调整算法（重要）
- 接收三个参数，数组或指针，以及parent对应要调整的位置，比向上调整算法额外多一个参数n（数组有效数据个数），用来判断是否调整到叶子结点
- 思想:以小堆为例，child等于parent两个孩子中较小的孩子，从该位置开始比较和调整，直到满足堆的大小关系或者调整到叶子结点
void Adjustdown(HPDataType* a, int parent, int n)//向下调整算法
{
assert(a);
int child = parent * 2 + 1;//先假设左孩子小
while (child < n)
{
if (child + 1 < n && a[child + 1] < a[child])//这里以小堆调整为例
child++;//如果右孩子存在，且右孩子小，父节点与右孩子进行比较
if (a[child] < a[parent])
{
Swap(&a[child], &a[parent]);
parent = child;
child = parent * 2 + 1;
}
else
break;
}
}6.出堆
- 接收一个参数：数组或指针，表示堆
- 首先对形参接收的地址判空
- 然后判断堆是否为空
- 交换堆顶和堆尾数据，size--
- 然后从堆顶开始进行向下调整
void HeapPop(Heap* hp)//出堆
{
assert(hp);
assert(hp->size);//判断堆不为空
Swap(&(hp->a[0]), &(hp->a[hp->size - 1]));
hp->size--;//第一个数据与最后一个数据交换,然后删除最后一个
Adjustdown(hp->a, 0, hp->size);
}7.取堆顶元素
- 对形参判空，并且堆不能为空
- 然后返回数组的第一个数据
HPDataType HeapTop(Heap* hp)// 取堆顶的数据
{
assert(hp);
assert(hp->size);
return hp->a[0];
}8.对堆判空
- 对形参判空
- 然后返回size==0的结果
int HeapEmpty(Heap* hp)//堆的判空
{
assert(hp);
return hp->size == 0;
}9.获取堆的数据个数
- 对形参判空
- 然后返回size
int HeapSize(Heap* hp)//堆的数据个数
{
assert(hp);
return hp->size;
}四.C语言实现堆的完整代码
Heap.h
#include<stdio.h>
#include<assert.h>
#include<stdlib.h>
typedef int HPDataType;//数据类型重定义
typedef struct Heap//堆的结构定义
{
HPDataType* a;
int size;
int capacity;
}Heap;
//堆的初始化
void HeapInit(Heap* php);
// 堆的销毁
void HeapDestory(Heap* hp);
//向上调整算法
void Adjustup(HPDataType* a, int child);
//交换函数
void Swap(HPDataType* a, HPDataType* b);
// 堆的插入
void HeapPush(Heap* hp, HPDataType x);
// 向下调整算法
void Adjustdown(HPDataType* a, int parent, int n);
// 堆的删除
void HeapPop(Heap* hp);
// 取堆顶的数据
HPDataType HeapTop(Heap* hp);
// 堆的数据个数
int HeapSize(Heap* hp);
// 堆的判空
int HeapEmpty(Heap* hp);Heap.c
#include"Heap.h"
void HeapInit(Heap* php)//初始化
{
assert(php);
php->a = NULL;
php->size = php->capacity = 0;
}
// 堆的销毁
void HeapDestory(Heap* hp)//销毁
{
assert(hp);
free(hp->a);
hp->a = NULL;
hp->size = hp->capacity = 0;
}
void Swap(HPDataType* a, HPDataType* b)//交换函数
{
HPDataType tmp = *a;
*a = *b;
*b = tmp;
}
void Adjustup(HPDataType* a, int child)//向上调整算法
{
assert(a);//数组必须存在，否则解引用就会报错
int parent = (child - 1) / 2;
while (child > 0 && a[parent] > a[child])//这里以小堆调整为例
{
Swap(&a[parent], &a[child]);//交换数据必须传地址
child = parent;
parent= (child - 1) / 2;
}
}
// 堆的插入
void HeapPush(Heap* hp, HPDataType x)//入堆
{
assert(hp);//接收的堆地址必须是有效的
if (hp->size == hp->capacity)//判断是否需要扩容
{
int newcapacity = hp->capacity == 0 ? 4 : (hp->capacity) * 2;
HPDataType* tmp = (HPDataType*)realloc(hp->a,sizeof(HPDataType) * newcapacity);
if (tmp == NULL)
{
perror("Push perror\n");
exit(1);
}
hp->a = tmp;
hp->capacity = newcapacity;
}
hp->a[hp->size++] = x;//插入到尾部
Adjustup(hp->a, hp->size - 1);//进行向上调整
}
void Adjustdown(HPDataType* a, int parent, int n)//向下调整算法
{
assert(a);
int child = parent * 2 + 1;//先假设左孩子小
while (child < n)
{
if (child + 1 < n && a[child + 1] < a[child])//这里以小堆调整为例
child++;//如果右孩子存在，且右孩子小，父节点与右孩子进行比较
if (a[child] < a[parent])
{
Swap(&a[child], &a[parent]);
parent = child;
child = parent * 2 + 1;
}
else
break;
}
}
void HeapPop(Heap* hp)//出堆
{
assert(hp);
assert(hp->size);//判断堆不为空
Swap(&(hp->a[0]), &(hp->a[hp->size - 1]));
hp->size--;//第一个数据与最后一个数据交换,然后删除最后一个
Adjustdown(hp->a, 0, hp->size);
}
HPDataType HeapTop(Heap* hp)// 取堆顶的数据
{
assert(hp);
assert(hp->size);
return hp->a[0];
}
int HeapSize(Heap* hp)//堆的数据个数
{
assert(hp);
return hp->size;
}
int HeapEmpty(Heap* hp)//堆的判空
{
assert(hp);
return hp->size == 0;
}test.c
#include"Heap.h"
void test1()
{
Heap hp;
HeapInit(&hp);//初始化
if (HeapEmpty(&hp))
printf("堆空\n");
else
printf("堆非空\n");
int arr[] = { 5,7,8,11,2,9,15,13,21};
for (int i = 0; i < sizeof(arr) / sizeof(arr[0]); i++)//数据入堆
{
HeapPush(&hp, arr[i]);
}
if (HeapEmpty(&hp))
printf("堆空\n");
else
printf("堆非空\n");
printf("堆的数据个数：%d\n", HeapSize(&hp));
while (hp.size)//每次打印堆顶元素，并出堆
{
printf("%d ", HeapTop(&hp));
HeapPop(&hp);
}
printf("堆的数据个数：%d\n", HeapSize(&hp));
HeapDestory(&hp);
}
int main()
{
test1();
return 0;
}性能分析
- 堆的插入和删除操作的时间复杂度均为O(log n)，这使得堆在处理大规模数据时具有较高的效率。
- 与其他数据结构（如链表）相比，数组在实现堆时具有更好的空间利用率和访问速度。
应用场景
堆排序：
堆排序是一种基于堆的排序算法，具有O(nlogn)的时间复杂度。
数据流中的TopK问题：
在处理数据流时，可以使用堆来快速找到前K大或前K小的元素。
4万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
