C语言数据结构拉练----堆(优先队列)_if(empty) return 0;-CSDN博客

本文链接：https://blog.csdn.net/Maushawkin/article/details/110479383

数据结构 = 结构定义 + 结构操作

0 关于完全二叉树

完全二叉树仅有一个度为1的结点, 且其叶节点索引连续
完全二叉树可被表示成顺序表
若完全二叉树的根结点索引为1, 则其左子结点索引为偶数, 右子结点索引为奇数
技巧: 将顺序表起始地址减1(一个地址), 则在移位计算时顺序表索引可完美对应完全二叉树的索引

1 堆(优先队列)

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

#define swap(a, b) {\
	__typeof(a) __temp = a;\
	a = b; b = __temp;\
}

1.1 结构定义

顺序表的存储结构

typedef struct Priority_Queue {
	int *data;
	int size;
	int cnt;
} Priority_Queue;

1.2 结构操作

初始化/清除

Priority_Queue *init(int n) {
	Priority_Queue *pq = (Priority_Queue *)malloc(sizeof(Priority_Queue));
	pq->data = (int *)malloc(sizeof(int) * n);
	pq->size = n;
	pq->cnt = 0;
	return pq;
}

void clear(Priority_Queue *pq) {
	free(pq->data);
	free(pq);
	return ;
}

查空/查询堆顶

int empty(Priority_Queue *pq) {
	return pq->cnt == 0;
}

int top(Priority_Queue *pq) {
	return pq->data[1];
}

压入/弹出(最大值)[即大顶堆]

入堆操作(维护大顶关系)

将值放在队尾处
前向(自底而上)与父结点比较(交换)

int push(Priority_Queue *pq, int val) {
	if (!pq) return 0;
	if (pq->size == pq->cnt) return 0;
	// 压入队尾, 更新长度, 保存索引
	pq->data[++(pq->cnt)] = val;
	int ind = pq->cnt;
	// 按索引与完全二叉树性质 迭代地寻找 父结点, 维护大顶堆
	while (ind >> 1 && pq->data[ind] > pq->data[ind >> 1]) {
		swap(pq->data[ind], pq->data[ind >> 1]);
		ind >>= 1;
	}
	return 1;
}

出堆操作

队尾覆盖堆顶(堆顶销毁<弹出>)
维护大顶, 后向(自顶而下)与子结点比较(交换)

int pop(Priority_Queue *pq) {
	if (!pq) return 0;
	if (empty(pq)) return 0;
	// 队尾覆盖堆顶(堆顶弹出<被销毁>), 更新长度, 保存堆顶索引
	pq->data[1] = pq->data[(pq->cnt)--];
	int ind = 1;
	// 按索引与完全二叉树性质 迭代地分别寻找 二个子结点, 维护大顶堆排序
	while ((ind << 1) <= pq->cnt) {
		// 分别与两个子结点进行比较, 记录较大一方的索引
		int max_id = ind, l = ind << 1; r = (ind << 1) | 1;
		if (pq->data[l] > pq->data[max_id]) max_id = l;
		if (r <= pq->cnt && pq->data[r] > pq->data[max_id]) max_id = r;
		// 若最大值为本身, 结束操作, 否则交换后对相应子结点继续迭代
		if (max_id == ind) break;
		swap(pq->data[max_id], pq->data[ind]);
		ind = max_id;
	}
	return 1;
}

1.3 例程

int main() {
	srand(time(0));
	#define max_op 20
	Priority_Queue *pq = init(max_op);
	for (int i = 0; i < max_op; i++) {
		int val = rand() % 100;
		push(pq, val);
		printf("push %d into the Max_Top_Heap\n", val);
	}
	for (int i = 0; i < max_op; i++) {
		i == 0 || printf(" ");
		printf("%d", top(pq));
		pop(pq);
	}
	printf("\n");
	#undef max_op
	clear(pq);
	return 0;
}

1.4 关于维护的时间复杂度:

1.4.1 自底而上:

(第0层) 每个结点0次操作, 共2⁰个结点 (root)----[仅有一个结点, 不需调整]—[该层操作数: 0 * 2⁰]
(第1层) 每个结点1次操作, 共2¹个结点------------[各结点可能向上调整1次]—[该层操作数: 1 * 2¹]
(第2层) 每个结点2次操作, 共2²个结点------------[各结点可能向上调整2次]—[该层操作数: 2 * 2²]
… …
(第n层) 每个结点n次操作, 共2ⁿ个结点------------[各结点可能向上调整n次]—[该层操作数: n * 2ⁿ]
结点数总和:
2n - 1
总操作数:
—~~0 * 2⁰ +~~ 1 * 2¹ + … + n * 2ⁿ
= (2¹ - 2 * 2ⁿ) / (1 - 2) + (2² - 2 * 2ⁿ) / (1 - 2) + … + (2ⁿ - 2 * 2ⁿ) / (1 - 2)
= 2 * 2ⁿ - 2¹ + 2 * 2ⁿ - 2² + … + 2 * 2ⁿ - 2ⁿ
= 2 * 2ⁿ * n - 2 * 2ⁿ - 2
= 2 * 2ⁿ * (n - 1) - 2
2n - 1 ==> 2ⁿ⁺¹ * (n - 1) - 2
结点数目为N = 2n ---- 时间复杂度为: O(N) = NlogN

1.4.2 自顶而下:(线性建堆法)

(第0层) 各结点n次操作, 共2⁰个结点 (root)----[最多向下调整n层]—[该层操作数: n * 2⁰]
(第1层) 各结点n - 1次操作, 共2¹个结点--------[最多向下调整n - 1层]—[该层操作数: (n - 1) * 2¹]
(第2层) 各结点n - 2次操作, 共2²个结点--------[最多向下调整n - 2层]—[该层操作数: (n - 2) * 2²]
… …
(第n - 1层) 各结点1次操作, 共2ⁿ个结点--------[最多向下调整1层]—[该层操作数: 1 * 2^n-1]
(第n层) 各结点无需操作
结点数总和:
2n - 1
总操作数: (整体乘2, 错位相减)
\\ n * 2⁰ + (n - 1) * 2¹ + (n - 2) * 2² + … + 1 * 2^n-1
= 2¹ + 2² + … + 2ⁿ - n
= 2ⁿ⁺¹ - n - 2
结点数目为N = 2n ---- 时间复杂度为: O(N) = N

2 堆排序(线性建堆法实现)

2.1 必要的库函数与宏

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

#define swap(a, b) {\
	__typeof(a) __temp = a;\
	a = b; b = __temp;\
}

#define TEST(arr, n, func, args...) {\
	int *num = (int *)malloc(sizeof(int) * n);\
	memcpy(num, arr, sizeof(int));\
	output(num, n);\
	printf("%s = \t", #func);\
	func(args);\
	output(num, n);\
	free(num);\
}

2.2 堆排序核心算法

2.2.1 线性时间复杂度的堆维护

(自顶而下的维护)[迭代]

输入: 需要获取堆数组arr, 数组长度n 以及维护起始索引ind
循环: 若结点ind在对应的完全二叉树形式下不存在子结点, 维护结束(自顶而下时, 叶结点不需要维护)

获取当前结点ind的左右子结点l, r, 并备份当前结点为cur
令cur分别与l, r 比较(与r比较前需进行边界判定), 更新cur为较大一方的索引
若cur仍为ind, 则表示cur以为当前位置堆的大顶, 维护结束
否则更新ind为cur, 循环继续

void downUpdate(int *arr, int n, int ind) {
	while ((ind << 1) <= n) {
		int l = ind << 1, r = (ind << 1) | 1, cur = ind;
		if (arr[cur] < arr[l]) cur = l;
		if (r <= n && arr[cur] < arr[r]) cur = r;
		if (cur == ind) break;
		swap(arr[ind], arr[cur])
		ind = cur;
	}
	return ;
}

2.2.2 堆排序

升序排列: 维护一个大顶堆
两步循环:

将大顶堆的堆首与堆尾互换
将除去堆尾的部分进行大顶堆维护

最终顺序表中的排列为升序

降序排列: 维护一个小顶堆
两步循环:

将小顶堆的堆首与堆尾互换
将除去堆尾的部分进行小顶堆维护

最终顺序表中的排列为降序

void heap_sort(int *arr, int n) {
	// 维护一个大顶堆
	arr--; // 此步为了方便索引间父子关系的转换
	for (int i = n >> 1; i > 0; i--) {
		downUpdate(arr, n, i);
	}
	// 堆顶堆尾互换并维护
	for (int i = n; i > 0; i--) {
		swap(arr[1], arr[i]);
		downUpdate(arr, i, 1);
	}
	return ;	
}

关于arr--的解释:
传入数组为arr, 第一个元素为*(arr), 第二个元素为*(arr+1), 第n个元素为*(arr+(n-1))
arr, arr+1, arr+2, …, arr+n-1
当arr -1后

实际存储地址偏移		arr	arr+1	arr+2	arr+3	arr+4	arr+5	arr+6
结点的索引		1	2	3	4	5	6	7
arr-1后的地址偏移	arr	arr+1	arr+2	arr+3	arr+4	arr+5	arr+6	arr+7

2.3 输出/输入与主函数

void output(int *num, int n) {
	printf("[");
	for (int i = 0; i < n; i++) {
		i == 0 || printf(" ");
		printf("%d", num[i]);
	}
	printf("]\n");
	return ;
}

void randint(int *num, int n) {
	while (n--) num[n] = rand() % 100;
	return ;
}

int main() {
	srand(time(0));
	#define max_n 20
	int *arr = (int *)malloc(sizeof(int) * max_n);
	randint(arr, max_n);
	TEST(arr, max_n, heap_sort, nums, max_n);
	free(arr);
	#undef max_n
	return 0;
}