【数据结构 —— 堆的实现（顺序表）】

一.堆

1.1堆的定义及结构

1.1.1.堆的定义

堆就是以二叉树的顺序存储方式来存储元素，同时又要满足父亲结点存储数据都要大于儿子结点存储数据（也可以是父亲结点数据都要小于儿子结点数据）的一种数据结构。堆只有两种即大堆和小堆，大堆就是父亲结点数据大于儿子结点数据，小堆则反之。

1.1.2.堆的性质

堆中某个节点的值总是不大于或不小于其父节点的值；
堆总是一棵完全二叉树。

1.1.3.堆的结构

用图画展示就如下图所示：
(1).小堆展示

(2).大堆展示

二.堆的实现

2.1.头文件的实现 —— （Heap.h）

Heap.h

#pragma once


#include
#include
#include
#include


//小堆
typedef int HPDataType;
typedef struct Heap
{
	HPDataType* a;
	int size;
	int capacity;
}HP;

//创建/销毁
void HeapInit(HP* php);
void HeapDestroy(HP* php);
//插入/删除
void HeapPush(HP* php, HPDataType x);
void HeapPop(HP* php);
//获取堆顶元素
HPDataType HeapTop(HP* php);
//判空/统计堆内元素个数
bool HeapEmpty(HP* php);
int HeapSize(HP* php);

2.2.源文件的实现 —— （Heap.c）

2.2.1.小堆的源文件

Heap.c

#include"Heap.h"


//小堆
//创建/销毁
void HeapInit(HP* php)
{
	assert(php);
	php->a = NULL;
	php->size = 0;
	php->capacity = 0;
}
void HeapDestroy(HP* php)
{
	assert(php);
	free(php->a);
	php->a = NULL;
	php->size = php->capacity = 0;
}

//交换函数
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[child] < a[parent])
		{
			Swap(&a[child], &a[parent]);
			child = parent;
			parent = (child - 1) / 2;
		}
		else
		{
			break;
		}
	}
}
//插入/删除
void HeapPush(HP* php, HPDataType x)
{
	assert(php);
	if (php->size == php->capacity)//判断数组空间不够就扩容
	{
		int newcapacity = php->capacity == 0 ? 4 : php->capacity * 2;
		HPDataType* tmp = (HPDataType*)realloc(php->a, newcapacity * sizeof(HPDataType));
		if (tmp == NULL)
		{
			perror("realloc fail");
			exit(-1);
		}
		php->a = tmp;
		php->capacity = newcapacity;
	}
	php->a[php->size] = x;
	php->size++;
	AdJustUp(php->a, php->size - 1);

}
//向下调整函数
void AdJustDown(HPDataType* a, int size, int parent)
{
	int child = parent * 2 + 1;
	while (child < size)
	{
		if (child+1 < size && 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(HP* php)
{
	assert(php);
	Swap(&php->a[0], &php->a[php->size - 1]);
	php->size--;
	AdJustDown(php->a, php->size, 0);
}
//获取堆顶元素
HPDataType HeapTop(HP* php)
{
	assert(php);
	assert(php->size > 0);
	return php->a[0];

}
//判空/统计堆内元素个数
bool HeapEmpty(HP* php)
{
	assert(php);
	return php->size == 0;
}
int HeapSize(HP* php)
{
	assert(php);
	assert(php->size > 0);
	return php->size;
}

2.2.2.大堆的源文件

Heap.h

#include"Heap.h"


//大堆
//创建/销毁
void HeapInit(HP* php)
{
	assert(php);
	php->a = NULL;
	php->size = 0;
	php->capacity = 0;
}
void HeapDestroy(HP* php)
{
	assert(php);
	free(php->a);
	php->a = NULL;
	php->size = php->capacity = 0;
}

//交换函数
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[child] > a[parent])
		{
			Swap(&a[child], &a[parent]);
			child = parent;
			parent = (child - 1) / 2;
		}
		else
		{
			break;
		}
	}
}
//插入/删除
void HeapPush(HP* php, HPDataType x)
{
	assert(php);
	if (php->size == php->capacity)//判断数组空间不够就扩容
	{
		int newcapacity = php->capacity == 0 ? 4 : php->capacity * 2;
		HPDataType* tmp = (HPDataType*)realloc(php->a, newcapacity * sizeof(HPDataType));
		if (tmp == NULL)
		{
			perror("realloc fail");
			exit(-1);
		}
		php->a = tmp;
		php->capacity = newcapacity;
	}
	php->a[php->size] = x;
	php->size++;
	AdJustUp(php->a, php->size - 1);

}
//向下调整函数
void AdJustDown(HPDataType* a, int size, int parent)
{
	int child = parent * 2 + 1;
	while (child < size)
	{
		if (child+1 < size && 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(HP* php)
{
	assert(php);
	Swap(&php->a[0], &php->a[php->size - 1]);
	php->size--;
	AdJustDown(php->a, php->size, 0);
}
//获取堆顶元素
HPDataType HeapTop(HP* php)
{
	assert(php);
	assert(php->size > 0);
	return php->a[0];

}
//判空/统计堆内元素个数
bool HeapEmpty(HP* php)
{
	assert(php);
	return php->size == 0;
}
int HeapSize(HP* php)
{
	assert(php);
	assert(php->size > 0);
	return php->size;
}

2.3.源文件的实现 —— （test.c）

test.c

#include"Heap.h"

//小堆
int main()
{
	HP ph;
	HeapInit(&ph);

	int a[] = { 4,6,2,1,5,8,2,9};
	for (int i = 0; i < (sizeof(a) / sizeof(int)); i++)
	{
		HeapPush(&ph, a[i]);//插入
	}

	//获取前k个最小值
	/*int k = 3;
	while (k--)
	{
		printf("%d\n", HeapTop(&ph));
		HeapPop(&ph);
	}*/
	//小堆排序
	while (!HeapEmpty(&ph))
	{
		printf("%d ", HeapTop(&ph));
		HeapPop(&ph);
	}

	return 0;
}

//大堆
//int main()
//{
//	HP ph;
//	HeapInit(&ph);
//	int a[] = { 4,6,2,1,5,8,2,9 };
//	for (int i = 0; i < (sizeof(a) / sizeof(int)); i++)
//	{
//		HeapPush(&ph, a[i]);
//	}
//	//前k个最大值
//	/*int k = 3;
//	while (k--)
//	{
//		printf("%d\n", HeapTop(&ph));
//		HeapPop(&ph);
//	}*/
//	//大堆排序
//	while(!HeapEmpty(&ph))
//	{
//		printf("%d ", HeapTop(&ph));
//		HeapPop(&ph);
//	}
//	return 0;
//}

三.实际数据测试展示

3.1.插入数据

3.1.1.小堆插入 ——（调试窗口展示）

3.1.2.大堆插入 ——（调试窗口展示）

3.2 打印前k个最值 ——（小型top-k问题）

3.2.1.小堆打印前k个最小值 —— （运行展示）

3.2.2.大堆打印前k个最大值 —— （运行展示）

3.3简单类堆排序 ——（非真堆排序）

3.3.1.类小堆排序 ——（运行展示）

3.3.2.类大堆排序 ——（运行展示）