C语言详解如何实现堆及堆的结构与接口

int array[] = { 27,15,19,18,28,34,65,49,25,37 }; // 根节点的左右子树都是小堆

// 向下调整算法，建小堆，把大的节点往下调整
// 前提是：左右子树都是小堆
void AdjustDown(int* a, int size, int parent)
{
	// 指向左孩子，默认左孩子最小
	int child = parent * 2 + 1;
	while (child < size)
	{
		// 1. 选出左右孩子最小的那个，先判断右孩子是否存在
		if (child + 1 < size && a[child] > a[child + 1])
		{
			child++; // 指向右孩子
		}
		// 2. 最小的孩子与父亲比较
		if (a[parent] > a[child]) // 如果父亲大于孩子
		{
			// 父亲与孩子交换位置
			Swap(&a[parent], &a[child]);
			// 更新父子下标，原先最小的孩子作为父亲，继续往下调
			parent = child;
			child = parent * 2 + 1;
		}
		else // 如果父亲小于孩子，说明已经为小堆了，停止调整
		{
			break;
		}
	}
}

int a[] = { 1,5,3,8,7,6 };

// 交换函数
void Swap(int* a, int* b)
{
	int tmp = *a;
	*a = *b;
	*b = tmp;
}
// 向下调整算法，建大堆，把小的节点往下调
// 前提是：左右子树都是大堆
void AdjustDown(int* a, int size, int parent)
{
	// 指向左孩子，默认左孩子最大
	int child = parent * 2 + 1;
	while (child < size)
	{
		// 1. 选出左右孩子最大的那个，先判断右孩子是否存在
		if (child + 1 < size && a[child] < a[child + 1])
		{
			child++; // 指向右孩子
		}
		// 2. 最大的孩子与父亲比较
		if (a[parent] < a[child]) // 如果父亲小于孩子
		{
			// 父亲与孩子交换位置
			Swap(&a[parent], &a[child]);
			// 更新父子下标，原先最大的孩子作为父亲，继续往下调
			parent = child;
			child = parent * 2 + 1;
		}
		else // 如果父亲大于孩子，说明已经为大堆了，停止调整
		{
			break;
		}
	}
}
void HeapSort(int* a, int size)
{
    /* 建堆（大堆）
    * 倒着调整，从倒数第一个非叶子节点的子树进行向下调整，直到调整到根节点的树
    */
	int parent = ((size - 1) - 1) / 2; // 最后一个叶子节点的父亲的下标
	for (int i = parent; i >= 0; i--)  // 从下到上，依次遍历完所有子树，分别对其进行调整
	{
		AdjustDown(a, size, i);
	}
    /* 堆排序
    * 排升序 --> 建大堆，每次选出一个最大的数放到最后
    * 排降序 --> 建小堆，每次选出一个最小的数放到最后
    */
    // 下面是排升序：
	int end = size - 1; // 记录堆中最后一个元素的下标
	while (end > 0)
	{
		Swap(&a[0], &a[end]);  // 将堆顶元素和堆中最后一个元素交换，把最大的数(堆顶)放到最后
		AdjustDown(a, end, 0); // 不看最后一个数，从根节点开始，对前面的数进行向下调整成大堆
		end--;
	}
}

#pragma once
#include<stdio.h>   // printf, perror
#include<stdbool.h> // bool
#include<assert.h>  // assert
#include<stdlib.h>  // malloc, free
#include<string.h>  // memcpy
typedef int HPDataType;
typedef struct Heap
{
	HPDataType* a; // 指向动态开辟的数组
	int size;      // 数组中有效元素个数
	int capacity;  // d容量
}Heap;
// 交换函数
void Swap(HPDataType* a, HPDataType* b);
// 向下调整函数（调成大堆，把小的往下调）
void AdjustDown(HPDataType* a, int size, int parent);
// 向上调整函数（调成大堆，把大的往上调）
void AdjustUp(HPDataType* a, int child);
// 初始化堆
void HeapInit(Heap* php, HPDataType* arr, int n);
// 销毁堆
void HeapDestroy(Heap* php);
// 插入元素（插入到堆的末尾），插入后并保持它依然是堆
void HeapPush(Heap* php, int x);
// 删除堆顶元素，删除后保持它依然是堆
void HeapPop(Heap* php);
// 获取堆顶元素，也即是最值
HPDataType HeapTop(Heap* php);
// 判断堆是否为空，为空返回true，不为空返回false
bool HeapEmpty(Heap* php);
// 获取堆中有效元素个数
int HeapSize(Heap* php);
// 打印堆
void HeapPrint(Heap* php);

// 交换函数
void Swap(HPDataType* a, HPDataType* b)
{
	HPDataType tmp;
	tmp = *a;
	*a = *b;
	*b = tmp;
}
// 向下调整算法（调成大堆，把小的往下调）
void AdjustDown(HPDataType* a, int size, int parent)
{
	// 左孩子下标，初始默认左孩子最大
	int child = parent * 2 + 1;
	while (child < size)
	{
		// 选出左右孩子最大的那个，先判断右孩子是否存在
		if (child + 1 < size && a[child] < a[child + 1])
		{
			child++; // 右孩子最大
		}
		// 最大的孩子与父亲比较
		if (a[parent] < a[child]) // 如果父亲小于孩子
		{
			// 父亲与孩子交换位置
			Swap(&a[parent], &a[child]);
			// 更新父子下标，原先最大的孩子作为父亲，继续往下调
			parent = child;
			child = parent * 2 + 1;
		}
		else // 如果父亲大于孩子，说明已经为大堆了，停止调整
		{
			break;
		}
	}
}

// 初始化堆，用一个给定的数组来初始化
void HeapInit(Heap* php, HPDataType* arr, int n)
{
	assert(php); // 断言
	// 动态开辟n个空间
	php->a = (HPDataType*)malloc(sizeof(HPDataType) * n);
	if (php->a == NULL)
	{
		perror("malloc");
		exit(-1);
	}
	// 把给定数组的各元素值拷贝过去
	memcpy(php->a, arr, sizeof(HPDataType) * n);
	php->size = php->capacity = n;
	// 建堆(建大堆）
	int parent = ((php->size - 1) - 1) / 2; // 倒数第一个非叶子节点下标
	for (int i = parent; i >= 0; i--) // 从下到上，依次遍历完所有子树，分别对其进行调整
	{
		AdjustDown(php->a, php->size, i);
	}
}

// 销毁堆
void HeapDestroy(Heap* php)
{
	assert(php);
	free(php->a); // 释放动态开辟的空间
	php->a = NULL;
	php->size = php->capacity = 0;
}

// 向上调整算法（调成大堆，把大的往上调）
void AdjustUp(HPDataType* a, int child)
{
	// 父节点的下标
	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, int x)
{
	assert(php);
	// 先检查空间是否已满
	if (php->capacity == php->size)
	{
		// 增容两倍
		php->capacity *= 2;
		HPDataType* tmp = (HPDataType*)realloc(php->a, sizeof(HPDataType) * php->capacity);
		if (tmp != NULL)
		{
			php->a = tmp;
			tmp = NULL;
		}
	}
	// 插入元素
	php->a[php->size] = x;
	php->size++;
	// 从插入的元素开始，进行向上调整，保持它依然是堆
	AdjustUp(php->a, php->size - 1);
}

// 删除堆顶元素，删除后保持它依然是堆
void HeapPop(Heap* php)
{
	assert(php);
	assert(!HeapEmpty(php)); // 堆不能为空
	// 将堆顶元素和最后一个元素交换
	Swap(&php->a[0], &php->a[php->size - 1]);
	// 删除堆中最后一个元素
	php->size--;
	// 从根节点开始，对剩下元素进行向下调整成大堆，保持它依然是堆
	AdjustDown(php->a, php->size, 0);
}

// 获取堆顶元素，也即是最值
HPDataType HeapTop(Heap* php)
{
	assert(php);
	assert(!HeapEmpty(php)); // 堆不能为空
	return php->a[0];
}

// 判断堆是否为空，为空返回true，不为空返回false
bool HeapEmpty(Heap* php)
{
	assert(php);
	return php->size == 0;
}

void TestHeap()
{
	int a[] = { 1,5,3,8,7,6 };
	Heap hp;
	HeapInit(&hp, a, sizeof(a) / sizeof(a[0])); // 初始化堆
	int k = 0;
	scanf("%d", &k);
	printf("找出堆中前%d个最大元素：\n", k);
	while (!HeapEmpty(&hp) && k--)
	{
		printf("%d ", HeapTop(&hp)); // 获取堆顶元素
		HeapPop(&hp); // 删除堆顶元素
	}
	printf("\n");
}

// 向上调整算法建堆
void CreateHeap(int* a, int size)
{
	// 把第一个元素看作是堆，剩余的元素依次插入堆中
	for (int i = 1; i < size; i++)
	{
		AdjustUp(a, i);
	}
}