目录
一：堆的概念及结构
1.概念
2.堆的性质
二：堆的实现
逻辑上为二叉树，但其存储模式为数组。
typedef int HPDataType;//类型重定义
typedef struct Heap
{
HPDataType* _a;
int _size;
int _capacity;
}Heap;
//逻辑结构为二叉树
//存储结构为数组
1.堆的构建
void HeapCreate(Heap* hp, HPDataType* a, int n);
将数组内容，容量元素个数置为0 --- 初始化
代码为：
// 堆的构建
void HeapCreate(Heap* hp, HPDataType* a, int n)
{
assert(hp);
hp->_capacity = 0;
hp->_size = 0;
hp->_a = NULL;
}
2.堆的销毁
void HeapDestory(Heap* hp);
堆本质是存储在数组中，销毁数组时（其空间是由malloc realloc 开辟而来的），需要free释放掉，free(hp->_a) 。然后将数组，容量，堆内数据个数置为NULL或者0.
代码为：
// 堆的销毁
void HeapDestory(Heap* hp)
{
assert(hp);
//本质是数组
free(hp->_a);
hp->_a = NULL;
hp->_capacity = 0;
hp->_size = 0;
}
3.数据的交换
void Swap(HPDataType* p1, HPDataType* p2)；
在进行向上调整算法，堆的删除，向下调整算法时等时，会存在数据的交换，此时，为了后续更方便使用，我们可以将其分装为一个函数。
//进行数据的交换
void Swap(HPDataType* p1, HPDataType* p2)
{
//进行数据的交换
HPDataType tmp = *p1;
*p1 = *p2;
*p2 = tmp;
}4.堆的插入
void HeapPush(Heap* hp, HPDataType x);
在插入数据时，需要考虑容量问题 --- 当 hp->_capacity == hp->_size 时，需要开辟空间，或者进行增容，当空间开好后，更新新的数据，数组的空间大小、容量都发生了变化。
进行数据的插入 --- 当数组的数据为 size 个时，其数组对应的下标为 0 - (size-1),所以插入的新的数据的下标为 hp->_size 。然后进行堆内数据 ++ 。
其逻辑结构为二叉树，插入数据后可能需要数据调整，在此处采用向上调整法 --- 需要传入相应的数组，及孩子结点的下标。 --- eg:小根堆
//调整堆 --- 向上调整法
// 数组 孩子的下标 ***
AdjustUp(hp->_a,hp->_size-1);
代码为：
//调整堆 --- 向上调整法
//在此处先设计改为小根堆 --- 每个父亲都 <= 孩子
void AdjustUp(HPDataType* a, int child)
{
int parent = (child - 1) / 2;
//循环结束的条件
while (child > 0)
{
//如果父亲结点大于孩子结点，则把孩子节点向上调 --- 小根堆
if (a[parent] > a[child])
{
Swap(&a[parent], &a[child]);
child = parent;
parent = (child - 1) / 2;
}
else
{
break;
}
}
}
5.堆的判空
int HeapEmpty(Heap* hp);
在堆删除的过程中，可能会存在，堆内已经没有数据，但是仍在删除的情况，此时肯定会出现错误。当堆内无数据时，则无法进行删除
堆判空的条件为，堆内无数据，即 hp->_size == 0。
代码为：0
// 堆的判空
int HeapEmpty(Heap* hp)
{
assert(hp);
return hp->_size == 0;
}6.堆的删除
在进行堆的删除的时候，需要进行判断堆内是否为空，若堆内为空，则无法进行删除。
若堆内有数据，则将首尾元素进行交换，再删除 ，再调堆。 堆删除的前提是左子树和右子树为大堆 / 小堆（此过程在堆的插入时，已经被做好了）
首尾元素进行交换，可以直接使用数据的交换的函数；
在进行数据删除时，可以直接对 hp->_size--
再调堆的时候 --- 向下调整算法 需要传入数组，数组的大小，及起初时的父亲结点 （数组下标）。
画图分析：
代码为：
// 堆的判空
int HeapEmpty(Heap* hp)
{
assert(hp);
return hp->_size == 0;
}
//向下调整算法
//在此处先设计改为小根堆 --- 每个父亲都 <= 孩子
void AdjustDown(int* a, int* n, int parent)
{
//对其逻辑结构进行分析，如果没有左孩子，则一定没有右孩子
int child = parent * 2 + 1;//左孩子
while (child < n)
{
//找到左右孩子中的较小孩子 --- 判断右孩子存在
// 有左孩子不一定有右孩子 --- 右孩子要先存在，才能与左孩子进行比较，注意写代码时的顺序
if ( child + 1 < n && a[child] > a[child + 1])//左孩子大于右孩子，则 child 为右孩子，上述假设时，假设的为左孩子小
{
++child;
}
//找到较小的孩子，与父亲节点进行比较，若比其小，让其与其父亲节点进行交换
if (a[parent] > a[child])
{
Swap(&a[parent], &a[child]);//让小的节点向上走，大节点向下走
parent = child;
child = parent * 2 + 1;//循环更替条件
}
else
{
break;
}
}
}
// 堆的删除
void HeapPop(Heap* hp)
{
assert(hp);
//需要对堆进行判空，若堆为空，则无法进行删除操作
assert(!HeapEmpty(hp));
//首尾元素（数据）进行交换，再删除，再调堆
//前提：左子树和右子树为大堆/小堆
//采用向下调整法
//交换首尾数据
Swap(&hp->_a[0], &hp->_a[hp->_size-1]);
//进行删除
hp->_size--;
//调整堆 -- 向下调整
AdjustDown(hp->_a, hp->_size, 0);
}
7.取堆顶的数据
HPDataType HeapTop(Heap* hp);
需要判断堆是否为空，若堆为空，则无法获取栈顶数据，
又因为在存储结构为数组，所以堆顶数据即为数组下标为0的元素。
代码为：
// 取堆顶的数据
HPDataType HeapTop(Heap* hp)
{
assert(hp);
//判断堆是否为空，若为空则无堆顶数据
assert(!HeapEmpty(hp));
return hp->_a[0];
}
8.堆的数据个数
int HeapSize(Heap* hp);
在插入时，进行了 hp->_size++
在删除时，进行了 hp->_size--
hp->_size 即为堆的数据个数。
代码为：
// 堆的数据个数
int HeapSize(Heap* hp)
{
assert(hp);
return hp->_size;
}9.示例
#include"Heap.h"
//堆使用的示例
int main()
{
Heap hp;
int a[] = { 65,100,70,32,50,60 };
HeapCreate(&hp, &a, 0);
for (int i = 0; i < sizeof(a) / sizeof(a[0]); i++)
{
HeapPush(&hp, a[i]);
}
while (!HeapEmpty(&hp))
{
int top = HeapTop(&hp);
printf("%d\n", top);
HeapPop(&hp);
}
return 0;
}
效果为：
三：完整的代码
Heap.h
#pragma once
#include<stdio.h>
#include<assert.h>
#include<stdlib.h>
typedef int HPDataType;//类型重定义
typedef struct Heap
{
HPDataType* _a;
int _size;
int _capacity;
}Heap;
//逻辑结构为二叉树
//存储结构为数组
// 堆的构建
void HeapCreate(Heap* hp, HPDataType* a, int n);
// 堆的销毁
void HeapDestory(Heap* hp);
// 堆的插入
void HeapPush(Heap* hp, HPDataType x);
// 堆的删除
void HeapPop(Heap* hp);
// 取堆顶的数据
HPDataType HeapTop(Heap* hp);
// 堆的数据个数
int HeapSize(Heap* hp);
// 堆的判空
int HeapEmpty(Heap* hp);
Heap.c
#include"Heap.h"
// 堆的构建
void HeapCreate(Heap* hp, HPDataType* a, int n)
{
assert(hp);
hp->_capacity = 0;
hp->_size = 0;
hp->_a = NULL;
}
//进行数据的交换
void Swap(HPDataType* p1, HPDataType* p2)
{
//进行数据的交换
HPDataType tmp = *p1;
*p1 = *p2;
*p2 = tmp;
}
//调整堆 --- 向上调整法
//在此处先设计改为小根堆 --- 每个父亲都 <= 孩子
void AdjustUp(HPDataType* a, int child)
{
int parent = (child - 1) / 2;
//循环结束的条件
while (child > 0)
{
//如果父亲结点大于孩子结点，则把孩子节点向上调 --- 小根堆
if (a[parent] > a[child])
{
Swap(&a[parent], &a[child]);
child = parent;
parent = (child - 1) / 2;
}
else
{
break;
}
}
}
// 堆的插入
void HeapPush(Heap* hp, HPDataType x)
{
assert(hp);
//需要插入新的数据 --- 数组实现
if (hp->_capacity == hp->_size)
{
int newcapacity = hp->_capacity == 0 ? 4 : hp->_capacity * 2;
//当空间不够时，需要进行扩容
//realloc
//void *realloc( void *memblock, size_t size );
// 要调整的内存地址 调整之后新的大小
HPDataType* tmp = (HPDataType*)realloc(hp->_a, sizeof(HPDataType) * newcapacity);
if (tmp == NULL)
{
perror("realloc fail\n");
return;
}
//空间开好后，更新新的数据
hp->_a = tmp;
hp->_capacity = newcapacity;
}
//数据的插入，size个元素，下标为 0 - size-1
//即新插入的数据的下标为 hp->_size
hp->_a[hp->_size] = x;
hp->_size++;
//调整堆 --- 向上调整法
// 数组 孩子的下标 ***
AdjustUp(hp->_a,hp->_size-1);
}
// 堆的判空
int HeapEmpty(Heap* hp)
{
assert(hp);
return hp->_size == 0;
}
//向下调整算法
//在此处先设计改为小根堆 --- 每个父亲都 <= 孩子
void AdjustDown(int* a, int* n, int parent)
{
//对其逻辑结构进行分析，如果没有左孩子，则一定没有右孩子
int child = parent * 2 + 1;//左孩子
while (child < n)
{
//找到左右孩子中的较小孩子 --- 判断右孩子存在
// 有左孩子不一定有右孩子 --- 右孩子要先存在，才能与左孩子进行比较，注意写代码时的顺序
if ( child + 1 < n && a[child] > a[child + 1])//左孩子大于右孩子，则 child 为右孩子，上述假设时，假设的为左孩子小
{
++child;
}
//找到较小的孩子，与父亲节点进行比较，若比其小，让其与其父亲节点进行交换
if (a[parent] > a[child])
{
Swap(&a[parent], &a[child]);//让小的节点向上走，大节点向下走
parent = child;
child = parent * 2 + 1;//循环更替条件
}
else
{
break;
}
}
}
// 堆的删除
void HeapPop(Heap* hp)
{
assert(hp);
//需要对堆进行判空，若堆为空，则无法进行删除操作
assert(!HeapEmpty(hp));
//首尾元素（数据）进行交换，再删除，再调堆
//前提：左子树和右子树为大堆/小堆
//采用向下调整法
//交换首尾数据
Swap(&hp->_a[0], &hp->_a[hp->_size-1]);
//进行删除
hp->_size--;
//调整堆 -- 向下调整
AdjustDown(hp->_a, hp->_size, 0);
}
// 堆的数据个数
int HeapSize(Heap* hp)
{
assert(hp);
return hp->_size;
}
// 取堆顶的数据
HPDataType HeapTop(Heap* hp)
{
assert(hp);
//判断堆是否为空，若为空则无堆顶数据
assert(!HeapEmpty(hp));
return hp->_a[0];
}
// 堆的销毁
void HeapDestory(Heap* hp)
{
assert(hp);
//本质是数组
free(hp->_a);
hp->_a = NULL;
hp->_capacity = 0;
hp->_size = 0;
}test.c
#include"Heap.h"
//堆使用的示例
int main()
{
Heap hp;
int a[] = { 65,100,70,32,50,60 };
HeapCreate(&hp, &a, 0);
for (int i = 0; i < sizeof(a) / sizeof(a[0]); i++)
{
HeapPush(&hp, a[i]);
}
while (!HeapEmpty(&hp))
{
int top = HeapTop(&hp);
printf("%d\n", top);
HeapPop(&hp);
}
return 0;
}
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
