数据结构——堆（C语言实现）

定义及头文件

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>

typedef int HPDataType;

typedef struct Heap
{
	HPDataType* _a;//堆存放的数据
	int _size;//数组有多少个数据
	int _capacity;//堆的容量
}Heap;

void AdjustUp(HPDataType* a, int n, int child);//堆的向上调整算法

void AdjustDown(HPDataType* a, int n, int root);//堆的向下调整算法

void HeapInit(Heap* php, HPDataType* a, int n);//初始化，把一堆数组调整成堆

void HeapDestroy(Heap* php);//销毁

void HeapPush(Heap* php, HPDataType* x);// 插入数据

void HeapPop(Heap* php);//删掉堆顶的数据

HPDataType HeapTop(Heap* php); //取堆顶的数据

堆的初始化

void HeapInit(Heap* php, HPDataType* a, int n)
{
	php->_a = (HPDataType*)malloc(sizeof(HPDataType)*n);
	//assert(php->_a);//最好检查空间开辟是否成功
	memcpy(php->_a, a, sizeof(HPDataType)* n);//把a数组的内容开辟一样字节的空间拷贝php->_a数组
	php->_size = n;
	php->_capacity = n;

	//为什么不能直接用向下调整算法构建堆？因为给你的数组不能保证左右子树一定是小（大）堆
	
	for(int i=(n-1-1)/2;i>=0;--i)//n-1是最后一个节点，再-1是倒数第二个节点，除2找到它的父亲i
	{
		AdjustDown(php->_a, php->_size, i);//从倒数第一个非叶节点开始调整，叶节点不用调整
	}
}

堆的向下调整算法

void AdjustDown(HPDataType* a, int n, int root)
//堆的向下调整算法，n表示数组元素数量，root是堆的根的位置
{
	int parent = root;
	int child = parent * 2 + 1;//默认最小的是左孩子
	while (child < n)
	{
		//若child 是最后一个元素，child + 1会越界，所以child + 1 < n
		if (child + 1 < n && a[child + 1] < a[child])
		{
			//如果右孩子比左孩子小，则左孩子加1变成右孩子,改成大堆(排升序)把第二个 < 变成 > 
            ++child;
		}

		if (a[child] < a[parent])//若孩子小于父亲就交换，改成大堆(排升序)把 < 变成 > 
		{
			Swap(&a[child], &a[parent]);
			parent = child;
			child = parent * 2 + 1;
		}

		else
		{
			break;
		}
	}
}

堆的向上调整算法

//插入数据时保证左右子树都是大（小）堆
void AdjustUp(HPDataType* a, int n, int child)//让最后一个元素（child）往上调，n是堆元素数量
{
	int parent = (child - 1) / 2;
	//while(parent>=0)是错的，parent不会小于0
	while (child > 0)
	{
		if (a[child] < a[parent])
		{
			Swap(&a[child], &a[parent]);
			child = parent;
			parent = (child - 1) / 2;
		}
		else
		{
			break;
		}
	}
}

插入数据

void HeapPush(Heap* php, HPDataType x)//堆底插入数据，不能头插（会破坏原有结构，效率低）
{
	assert(php);//检查是否为空
	if (php->_size == php->_capacity)//扩容
	{
		php->_capacity *= 2;
		HPDataType* tmp = (HPDataType*)realloc(php->_a, sizeof(HPDataType)* php->_capacity);
		php->_a = tmp;
	}

	php->_a[php->_size++] = x;
	AdjustUp(php->_a, php->_size, php->_size - 1);//把数组最后一个元素位置传过去
}

删掉堆顶的数据

void HeapPop(Heap* 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 HeapTop(Heap* php)
{
	assert(php);
	assert(php->_size > 0);
	return php->_a[0];//返回数组第一个值
}

堆的销毁

void HeapDestroy(Heap* php)//php不需要free，因为不是malloc创建的
{
	assert(php);
	free(php->_a);
	php->_a = NULL;
	php->_capacity = php->_size = 0;
}

调试代码

void HeapSort(int* a, int n)
{
	for(int i = (n - 1 - 1) / 2; i >= 0; --i)//数组建堆,让左右子树变成大（小）堆
	{
		AdjustDown(a, n, i);
	}

	//以下是堆排序算法：让整个数组变有序
	//选了一个数进行AdjustDown，如何再继续选次小的，直到整个数组有序？
	//不能再用堆选，时间复杂度O（N^2）
	int end = n - 1;//这里排降序，end是最小的数，若排升序，end是最大的数，
	while (end > 0)
	{
		Swap(&a[0], &a[end]); 
		AdjustDown(a,end,0);//继续选次小的，从下标为0（根）开始调，调end次
		--end;
	}
}

int main()
{
	int a[] = { 27,15,19,18,28,34,65,49,25,37 };
	HeapSort(a, sizeof(a) / sizeof(HPDataType));//用堆排序把数组排成有序

	//堆的增删查改
	Heap hp;
    HeapInit(&hp, a, sizeof(a) / sizeof(HPDataType));

	HeapPush(&hp, 12);

	int z=HeapTop(&hp);
	printf("%d\n", z);

	HeapPop(&hp);
	HeapDestroy(&hp);
	return 0;
}