头文件
#include"stdio.h"
#include"malloc.h"
#include "assert.h"
typedef int DataType;
typedef struct Heap
{
DataType* _hp;
int _capacity; // 空间的大小
int _size; // 堆中有效元素的个数
}Heap;
void CreateHeap(Heap* pHp, DataType array[], int size);//创建堆
void InitHeap(Heap* pHp);//初始化堆
void Insert(Heap* pHp, DataType data);//任意插入数据
void Remove(Heap* pHp);//删除
int EmptyHeap(Heap* pHp);//判空
int SizeHeap(Heap* pHp);//大小
void AdjustDown(Heap* pHp, int Root);//向下调整
void AdjustUp(Heap* pHp, int child);//向上调整
DataType Top(Heap* pHp);//找出堆顶元素
void CheckCapacity(Heap* pHp);//扩容
void HeapSort(Heap* pHp,int size);//堆排序
void Swap(int left, int right);
主函数
#include"Heap.h"
void CreateHeap(Heap* pHp, DataType arr[], int size)//创建堆
{
//开辟空间
pHp->_hp = (DataType*)malloc(sizeof(DataType)*(size + 3));
if (NULL == pHp->_hp)//没有申请成功
{
return;
}
//申请成功，更新空间，并初始化数组
pHp->_capacity = size + 3;
for (int i = 0; i < size; i++)
{
pHp->_hp[i] = arr[i];
}
int root = arr[0];
int last = (size - 2) / 2;//最后一个双亲结点
for (; last >= 0; last--)//只需要双亲结点，就可以进行向下调整
{
AdjustDown(pHp,last);
}
}
void InitHeap(Heap* pHp)//初始化堆
{
assert(pHp);
pHp->_hp = NULL;
pHp->_capacity = 0;
pHp->_size = 0;
}
void Insert(Heap* pHp, DataType data)//任意插入数据
{
assert(pHp);
pHp->_hp[pHp->_size] = data;//在数组的最后一位插入元素
AdjustUp(pHp, pHp->_size - 1);
}
void Remove(Heap* pHp)//删除
{
if (NULL == pHp)
{
return;
}
if (EmptyHeap(pHp))
{
return;
}
Swap(&pHp->_hp[0], pHp->_hp[pHp->_size - 1]);//相当于删除最后一个
pHp->_size--;
AdjustDown(pHp, pHp->_hp[0]);
}
int EmptyHeap(Heap* pHp)//判空
{
assert(pHp);
if (NULL == pHp->_hp)
{
return 1;
}
return 0;
}
int SizeHeap(Heap* pHp)//大小
{
return pHp->_size;
}
void AdjustDown(Heap* pHp, int Root)//向下调整
{
int parent = 0;
int child = 2 * parent + 1;
while (child<pHp->_size)
{
if (pHp->_hp[child] > pHp->_hp[child + 1]&&child<pHp->_size)
{
child = child + 1;
}
if (pHp->_hp[child] < pHp->_hp[parent])
{
Swap(pHp->_hp[parent], pHp->_hp[child]);//交换位置
parent = child;//更新双亲结点和孩子jiedain
child = parent * 2 + 1;
}
}
}
void AdjustUp(Heap* pHp, int child)//向上调整
{
int parent = (child - 1) / 2;//找到双亲结点
while (parent > 0)
{
if (pHp->_hp[parent] < pHp->_hp[child])
{
Swap(pHp->_hp[parent], pHp->_hp[child]);
child = parent;
parent = (child - 1) / 2;
}
}
}
DataType Top(Heap* pHp)//找出堆顶元素
{
return pHp->_hp[0];
}
void CheckCapacity(Heap* pHp)//扩容
{
assert(pHp);
int newcap = pHp->_capacity * 2;
if (pHp->_size > pHp->_capacity)
{
DataType *pnewcap = (DataType*)malloc(sizeof(pHp->_capacity) * 2);
assert(pnewcap);
free(pHp->_hp);//释放掉旧的空间
}
pHp->_capacity = newcap;
}
void Swap(int left, int right)
{
int t = left;
left = right;
right = t;
}
void HeapSort(Heap* pHp, int size)//堆排序
{
int end = size - 1;
int root = (end-1) / 2;
for (; root >= 0; root--)//只需要双亲结点，就可以进行向下调整
{
AdjustDown(pHp, root);
}
while (end > 1)
{
Swap(pHp->_hp[0], pHp->_hp[end]);
AdjustDown(pHp, pHp->_hp[0]);
}
测试函数
#include"Heap.h"
int main()
{
Heap hp;
int arr[] = { 53, 17, 78, 9, 4, 5, 65, 87 };
int size = sizeof(arr) / sizeof(arr[0]);
InitHeap(&hp);
CreateHeap(&hp, arr, size);
Insert(&hp,8);//插入数据
Remove(&hp);//删除
}