堆结构的实现和应用

已于 2024-03-10 10:35:56 修改
阅读量1k 收藏 28
点赞数 17
分类专栏： 数据结构学习 文章标签： 数据结构 算法
于 2024-02-22 16:42:34 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_74319491/article/details/136176442
版权

堆结构的实现和应用

1. 堆结构的代码实现

首先，我们先定义一个堆的结构，这里和顺序表的结构一样

typedef int HPDataType;

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

初始化堆

void HeapInit(HP* hp)
{
	hp->a = NULL;
	hp->capacity = 0;
	hp->size = 0;
}

销毁堆

void HeapDestroy(HP* hp)
{
	free(hp->a);
	hp->a = NULL;
	hp->size = 0;
	hp->capacity = 0;
}

因为堆的空间是动态开辟的，所以在堆使用结束后，需要把动态开辟的空间释放，避免造成内存泄漏。

堆的插入

在堆尾插入数据后并不能保证插入之后的数据是堆，所以，在插入之后，要进行向上调整算法，直到满足堆。

void HeapPush(HP* hp, HPDataType x)
{
	assert(hp);

	HeapCheckCapacity(hp);

	hp->a[hp->size] = x;
	hp->size++;

	HeapUp(hp->a, hp->size - 1);
}

这里也可以不把扩容的代码单独写成一个函数，因为这里只有这一个地方会用到扩容操作，但是还是建议封装成一个函数，一方面可以提高代码的可读性，另一方面平时我们写代码的时候这个操作一般都是封装成一个函数，所以这样写可以在一定程度上避免代码出错。

检查是否需要扩容

void HeapCheckCapacity(HP* hp)
{
	if (hp->size == hp->capacity)
	{
		int newcapacity = hp->capacity == 0 ? 4 : hp->capacity * 2;

		HPDataType* ptr = (HPDataType*)realloc(hp->a, sizeof(HPDataType) * newcapacity);
		if (ptr == NULL)
		{
			perror("realloc fail");
			return NULL;
		}

		hp->a = ptr;
		hp->capacity = newcapacity;
	}
}

向上调整算法

要求插入之前这个数组是大堆或者小堆，如果时小堆，当插入的孩子比父亲小就交换，直到孩子等于0，即没有父亲的时候交换结束。

算法思想（小堆）：

  1. 将目标节点与父节点比较。
  2. 如果目标节点的值比父节点的值小，则交换目标节点与父节点的位置，并把父节点当作新的目标节点继续向上交换，当目标节点的值比父亲节点大，或者目标节点变成根节点，则停止交换，此时，数组就可以看作一个小堆了。

在这里插入图片描述

//假如是小堆
void AdjustUp(HPDataType* a, int child)
{
	
	while (child > 0)//调整到根节点处停止
	{
		int parent = (child - 1) / 2;

		if (a[child] < a[parent])//当孩子比父亲小就交换
		{
			HPDataType tmp = a[child];
			a[child] = a[parent];
			a[parent] = tmp;
		}
		else//如果孩子比父亲大就变成堆了，停止交换。
		{
			break;
		}
	}
}

堆的删除

删除堆是删除堆顶的数据，因为删除堆尾的数据意义不大

  1. 挪动覆盖删除堆顶元素，重新建堆。
    挪动覆盖，不能保证还是堆，父子关系全乱了，只能重新建堆，代价太大。
  2. 将堆顶的数据根最后一个数据一换，然后删除数组最后一个数据，再进行向下调整算法。
    在这里插入图片描述
void HeapPop(HP* hp)
{
	assert(hp);
	assert(!HeapEmpty(hp));

	Swap(&hp->a[0], &hp->a[hp->size - 1]);
	hp->size--;

	AdjustDown(hp->a,hp->size,0);
}

注意：堆为空的时候不能删除

向下调整算法

算法思想（小堆）：

  1. 从根节点开始，选出左右孩子中值较小的孩子
  2. 如果较小的孩子的值比父节点的值小，则交换该孩子节点与父节点的位置，并把该孩子点当作新的父亲节点继续向下交换，当较小孩子节点的值比父亲节点大，或者孩子节点出了数据有效范围，则停止交换，此时，数组就可以看作一个小堆了。

向下调整算法有一个前提：左右子树必须是一个堆，才能调整。
在这里插入图片描述

代码如下：

void AdjustDown(HPDataType* a, int n, int parent)
{
	int child = parent * 2 + 1;//假设左孩子小

	while (child < n)
	{
		//如果有右孩子并且右孩子比左孩子小,假设不成立
		if (child + 1 < n && 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 Swap(HPDataType* p1, HPDataType* p2)
{
	HPDataType tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}

取出堆顶元素

HPDataType HeapTop(HP* hp)
{
	assert(hp);
	assert(!HeapEmpty(hp));

	return hp->a[0];
}

检测堆是否为空，如果为空返回非零结果，如果不为空返回0

bool HeapEmpty(HP* hp)
{
	return hp->size == 0;
}

获取堆中有效元素个数

int HeapSize(HP* hp)
{
	assert(hp);

	return hp->size;
}

全部代码实现
Heap.h

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

typedef int HPDataType;

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

void HeapInit(HP* hp);

void HeapDestroy(HP* hp);

void HeapPush(HP* hp,HPDataType x);

void HeapPop(HP* hp);

HPDataType HeapTop(HP * hp);

bool HeapEmpty(HP* hp);

int HeapSize(HP* hp);

Heap.c

#include "Heap.h"

void HeapInit(HP* hp)
{
	assert(hp);

	hp->a = NULL;
	hp->capacity = 0;
	hp->size = 0;
}

void HeapDestroy(HP* hp)
{
	assert(hp);

	free(hp->a);
	hp->a = NULL;
	hp->capacity = 0;
	hp->size = 0;
}

void HeapCheckCapacity(HP* hp)
{
	assert(hp);

	if (hp->size == hp->capacity)
	{
		int newcapacity = hp->capacity == 0 ? 4 : hp->capacity * 2;
		HPDataType* ptr = (HPDataType*)realloc(hp->a, sizeof(HPDataType) * newcapacity);
		if (ptr == NULL)
		{
			perror("realloc fail");
			exit(-1);
		}

		hp->a = ptr;
		hp->capacity = newcapacity;
	}
}


void Swap(HPDataType* p1, HPDataType* p2)
{
	HPDataType tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}

void AdjustUp(HPDataType* a, int child)
{
	
	while (child > 0)
	{
		int parent = (child - 1) / 2;

		if (a[child] < a[parent])
		{
			Swap(&a[child], &a[parent]);
		}
		else
		{
			break;
		}

		child = parent;
	}
}

void HeapPush(HP* hp, HPDataType x)
{
	assert(hp);

	HeapCheckCapacity(hp);

	hp->a[hp->size] = x;
	hp->size++;

	AdjustUp(hp->a, hp->size - 1);
}

void AdjustDown(HPDataType* a, int n, int parent)
{
	int child = parent * 2 + 1;

	while (child < n)
	{
		if (child + 1 < n && a[child + 1] < a[child])
		{
			child++;
		}

		if (a[child] < a[parent])
		{
			Swap(&a[child], &a[parent]);

			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}

bool HeapEmpty(HP* hp)
{
	return hp->size == 0;
}

void HeapPop(HP* hp)
{
	assert(hp);
	assert(!HeapEmpty(hp));

	Swap(&hp->a[0], &hp->a[hp->size - 1]);
	hp->size--;

	AdjustDown(hp->a,hp->size,0);
}

HPDataType HeapTop(HP* hp)
{
	assert(hp);
	assert(!HeapEmpty(hp));

	return hp->a[0];
}

int HeapSize(HP* hp)
{
	assert(hp);

	return hp->size;
}

Test.c

#include "Heap.h"

int main()
{
	HP hp;
	HeapInit(&hp);

	int a[] = { 65,100,70,32,50,60 };
	int sz = sizeof(a) / sizeof(a[0]);


	int i = 0;
	for (i = 0; i < sz; i++)
	{
		HeapPush(&hp, a[i]);
	}
	
	for (i = 0; i < sz; i++)
	{
		printf("%d\n", HeapTop(&hp));
		HeapPop(&hp);
	}

	HeapDestroy(&hp);

	return 0;
}

运行结果如图：
在这里插入图片描述
这里只是把数据从小到大打印出来，并没有改变数组的内容，所以不是堆排序。

2. 向上调整算法和向下调整算法时间复杂度

假如树的高度为h，那么向上调整算法和向下调整算法，调整的次数最多为h-1次，也可以认为h次，因为，我们之前已经推出高度h和节点个数N的关系，那么我们很容易推导处下图的公式。

在这里插入图片描述

所以，向上调整算法和向下调整算法时间复杂度用大O的渐进法表示就是O(logN)。

3. 堆排序

3.1 方法一

#include "Heap.h"

void HeapSort(int* a, int n)
{
	HP hp;
	HeapInit(&hp);

	int i = 0;
	for (i = 0; i < n; i++)
	{
		HeapPush(&hp, a[i]);
	}

	i = 0;
	while (!HeapEmpty(&hp))
	{
		int top = HeapTop(&hp);
		a[i++] = top;
		HeapPop(&hp);
	}

	HeapDestroy(&hp);
}

int main()
{
	int a[] = { 3,5,1,4 };
	int sz = sizeof(a) / sizeof(a[0]);
	HeapSort(a, sz);
	
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", a[i]);
	}
	
	return 0;
}

运行结果如图：
在这里插入图片描述
这样虽然也可以实现堆排序，但是有弊端：必须先有一个堆，太麻烦，需要拷贝数据空间复制度比较高。

3.2 方法二

  1. 利用数组进行向上调整建堆或向上调整建堆的方法进行建堆。
  2. 小堆，选出最小的，首尾交换，最小的放到最后的位置，把最后一个数据，不看作堆里面的，向下调整后就可以选出次小的，最终，排出来的数据就是降序。

向上调整建堆：

void HeapSort(int* a, int n)
{
	//O(N * log(N))
	//建堆 -- 向上调整建堆
	int i = 0;
	for (i = 1; i < n; i++)
	{
		// 升序 -- 建大堆
		// 降序 -- 建小堆
		AdjustUp(a, i);
	}
	
	//O(N * logN)
	int end = n - 1;
	while (end > 0)
	{
		Swap(&a[0], &a[end]);
		//在调整，选出次小的数
		AdjustDown(a, end, 0);
		
		end--;
	}
}

int main()
{
	int a[] = { 3,5,1,4 };
	int sz = sizeof(a) / sizeof(a[0]);
	HeapSort(a, sz);

	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", a[i]);
	}

	return 0;
}

运行结果如图：
在这里插入图片描述

向下调整建堆
在这里插入图片描述

void HeapSort(int* a, int n)
{
	//O(N)
	int i = 0;
	for (i = (n - 1 - 1) / 2; i >= 0; i--)
	{
		AdjustDown(a, n, i);
	}
	
	//O(N * logN)
	int end = n - 1;
	while (end > 0)
	{
		Swap(&a[0], &a[end]);
		AdjustDown(a, end, 0);

		end--;
	}
}

int main()
{
	int a[] = { 3,5,1,4 };
	int sz = sizeof(a) / sizeof(a[0]);
	HeapSort(a, sz);

	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", a[i]);
	}

	return 0;
}

运行结果如图：
在这里插入图片描述

3.3 建堆时间复杂度

因为堆是完全二叉树，而满二叉树也是完全二叉树，此处为了简化使用满二叉树来证明(时间复杂度本来看的就是近似值，多几个节点不影响最终结果)：

在这里插入图片描述

4. TOP-K问题

TOP-K问题：即求数据结合中前K个最大的元素或者最小的元素，一般情况下数据量都比较大。

比如：专业前10名、世界500强、富豪榜、游戏中前100的活跃玩家等。

对于Top-K问题，能想到的最简单直接的方式就是排序，但是：如果数据量非常大，排序就不太可取了(可能数据都不能一下子全部加载到内存中)。最佳的方式就是用堆来解决，基本思路如下：

  1. 用数据集合中前K个元素来建堆
    • 前k个最大的元素，则建小堆
    • 前k个最小的元素，则建大堆
  2. 用剩余的N-K个元素依次与堆顶元素来比较，不满足则替换堆顶元素

将剩余N-K个元素依次与堆顶元素比完之后，堆中剩余的K个元素就是所求的前K个最小或者最大的元素。

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

void Swap(int* p1, int* p2)
{

	int tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}

void AdjustDown(int* a, int n, int parent)
{
	int child = parent * 2 + 1;

	while (child < n)
	{
		if (child + 1 < n && a[child] > a[child + 1])
		{
			child++;
		}

		if (a[child] < a[parent])
		{
			Swap(&a[child], &a[parent]);

			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}

void CreateNDate()
{
	// 造数据
	int n = 100;
	srand(time(NULL));
	const char* file = "data.txt";
	FILE* fin = fopen(file, "w");
	if (fin == NULL)
	{
		perror("fopen error");
		return;
	}

	for (size_t i = 0; i < n; ++i)
	{
		int x = rand() % 100;
		fprintf(fin, "%d\n", x);
	}

	fclose(fin);
}

void PrintTopK(int k)
{
	const char* file = "data.txt";
	FILE* fout = fopen(file, "r");
	if (fout == NULL)
	{
		perror("fopen error");
		return;
	}

	int* kminheap = (int*)malloc(sizeof(int) * k);
	if (kminheap == NULL)
	{
		perror("malloc error");
		return;
	}

	for (int i = 0; i < k; i++)
	{
		fscanf(fout, "%d", &kminheap[i]);
	}

	// 建小堆
	for (int i = (k - 1 - 1) / 2; i >= 0; i--)
	{
		AdjustDown(kminheap, k, i);
	}

	int val = 0;
	while (!feof(fout))
	{
		fscanf(fout, "%d", &val);
		if (val > kminheap[0])
		{
			kminheap[0] = val;
			AdjustDown(kminheap, k, 0);
		}
	}

	for (int i = 0; i < k; i++)
	{
		printf("%d ", kminheap[i]);
	}
	printf("\n");
}

int main()
{
	//CreateNDate();
	PrintTopK(5);

	return 0;
}

我们创造好文件之后可以，可以手动修改文件内容。

在这里插入图片描述

运行结果如图：
在这里插入图片描述

星光终将不负赶路人
关注
  • 17
    点赞
  • 踩
  • 28
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
Java基于堆结构实现优先队列功能示例
08-28
Java基于堆结构实现优先队列功能示例 Java基于堆结构实现优先队列功能示例是介绍Java语言中基于堆结构实现优先队列功能的示例程序。该示例程序主要介绍了Java基于堆结构实现优先队列功能的简单定义与使用方法，并...
数据结构 堆的实现
08-13
- 比较不同数据结构，如数组和链表在实现堆时的优缺点。 堆的实现对于理解高级算法至关重要，因为它在许多实际问题中都有应用，如操作系统中的调度、网络流问题的求解以及动态规划的优化等。熟练掌握堆的实现和操作...
【数据结构与算法】堆的实现
Extreme_wei的博客
03-27 662
本文详细的介绍堆是什么，堆的结构以及堆是如何实现的，本篇重点在于堆的两个调整算法，掌握它们，你就基本可以理解堆是如何实现的，以及堆的应用：堆排序。本篇带有图文解析及代码以供参考。
数据结构---堆的实现
weixin_71594206的博客
05-01 646
堆(Heap)是计算机科学中一类特殊的数据结构，是最高效的优先级队列。堆通常是一个可以被看做一棵完全二叉树的数组对象。现实中我们通常把堆(一种二叉树)使用顺序结构的数组来存储，大根堆：根节点的数值总是大于等于（不小于）其左右节点的数值的二叉树小根堆：根节点的数值总是小于等于（不大于）其左右节点的数值的二叉树
数据结构-堆的实现(详细图解+解说)
Eliauk_U的博客
04-16 2520
本文详细介绍了数据结构-堆的实现
【数据结构】堆的实现（简单易懂，超级详细！！！）
m0_65679465的博客
11-25 2375
堆（heap）是计算机科学中一类特殊的数据结构的统称。堆通常是一个可以被看做一棵树的数组对象。本文从堆的概念和规律，到堆的实现，向下调整算法，建堆，向上调整算法等等，详细讲解，图文并茂！
数据结构之堆（Heap）的实现
weixin_34111819的博客
04-28 725
堆数据结构是一种数组对象，它可以被视为一棵完全二叉树结构，所以堆也叫做二叉堆。二叉堆满足二个特性： 1．父结点的键值总是大于或等于（小于或等于）任何一个子节点的键值。 2．每个结点的左子树和右子树都是一个二叉堆（都是最大堆或最小堆）。 当父结点的键值总是大于或等于任何一个子节点的键值时为最大堆。当父结点的键值总是小于或等于 任何一个子节点的键值时为最小堆。 最...
数据结构-堆及其应用PPT
07-16
例如，上文中的堆结构展示了一种常见的数组表示法，其中元素的位置与其在树中的位置相对应。 堆的插入操作涉及到将新元素添加到堆中并维护堆的性质。插入时，新元素通常被放在数组的末尾，然后通过一系列的上调整...
数据结构课设——小大根交替堆实现的双端优先级队列及应用
11-26
小大根交替堆是一种特殊的堆结构，它可以同时满足大根堆和小根堆的性质。在本文中，我们将对小大根交替堆实现的双端优先级队列进行详细的分析和设计。 双端优先级队列是一种特殊的队列结构，它可以同时满足队列的 ...
数据结构之堆详解
09-04
掌握堆的概念和操作对于理解和实现高级算法至关重要，比如在图的最小生成树算法Prim和Dijkstra中，以及在解决实时系统中的调度问题时，堆都是关键的数据结构。 总结来说，堆是数据结构中的重要组成部分，其灵活的...
堆的实现（数据结构）
Alexwym的博客
06-12 1965
一、问题描述 堆是什么？堆也叫做优先队列，一些按照重要性或优先级来组织的对象称为优先队列。 为什么需要堆？在现实生活中，存在许多需要从一群人、一些任务或一些对象中找出“下一位最重要”目标的情况。例如：在平时处理事情的时候我们总会先把“下一个最重要的”的事情取出来先处理。在处理的过程中，可能还会有其他的事情加进来。因此在事情处理完的事情，我们又要重新找出“下一个最重要”的事情进行处理。 如何......
数据结构------堆(二、堆的实现)
tonyzxy的博客
07-12 1万+
一、堆的定义   我们知道堆是一个树形结构，其实堆的底层是一棵完全二叉树。而完全二叉树是一层一层按照进入的顺序排成的。按照这个特性，我们可以用数组来按照完全二叉树实现堆。    上面的图片就是一个完全二叉树，也是一个最大堆。而最大堆有一个性质：每一个节点的值都小于它父节点的值。我们也可以从上面的图片中看出来。但是需要注意的是，每一个节点的值的大小与它所处的深度没有必然的联系。因为我们可以看到第三层...
堆这种数据结构 Java实现
云聪的技术错题集
03-18 1万+
关于我所遇见的各种堆的含义，可以在下面这两篇博文中看到： Java虚拟机 堆和栈 深入理解计算机系统 1.7 操作系统管理硬件 本文讲的是堆数据结构的实现，并给出Java代码。 堆是一颗完全二叉树，在这棵树中，所有父节点都满足大于等于其子节点的堆叫大根堆，所有父节点都满足小于等于其子节点的堆叫小根堆。堆虽然是一颗树，但是通常存放在一个数组中，父节点和孩子节点的父子关系通过数组下标来确定。
堆结构的实现
明朗晨光的专栏
05-11 547
大根堆的手动实现
堆结构的优秀实现类----PriorityQueue优先队列
热门推荐
Walker_YAM
06-05 1万+
之前的文章中，我们有介绍过动态数组ArrayList，双向队列LinkedList，键值对集合HashMap，树集TreeMap。他们都各自有各自的优点，ArrayList动态扩容，数组实现查询非常快但要求连续内存空间，双向队列LinkedList不需要像ArrayList一样创建连续的内存空间，它以链表的形式连接各个节点，但是查询搜索效率极低。HashMap存放键值对，内部使用数组加链表实现，检索
堆结构实现
子居的博客
03-24 217
堆结构介绍 堆是一种数据结构，在逻辑上是一颗完全二叉树，在存储上是一个数组。堆有大顶堆、和小顶堆之分，大顶堆：对于每个父节点而言，其左右子节点都是小于父节点的，所以根节点也就是堆顶保存的是堆内最大的元素；小顶堆：每个父节点的值都是小于子节点的，堆顶保存堆内最小的元素。 堆的存储 上面已经介绍了堆是用数组来存储的，但是怎么来存呢？其实就是把一棵完全二叉树按层遍历后的顺序依次放入一个数组里面是一样的，...
经典数据结构——堆的实现
Morty的技术乐园
05-15 906
一、完全二叉树 堆是一种完全二叉树，什么是完全二叉树？ 简单的说，一棵满二叉树表示的是所有节点全部饱和，最后一层全部占满： 而完全二叉树指的是满二叉树的最后一层，所有叶子节点都从左往顺序排满： 完全二叉树的特点非常简单，除了最后一层，其他各层节点都是满的，而最后一层，所有要求所有节点从左往右依次排满。它并不关心节点元素的大小，只与这一特定结构有关。 二、堆结构 前面说到，堆是一种特殊的完全二叉树，除了符合完全二叉树的结构特点，它还有另一个特性，由这个特性，我们又可以将堆分为——大根堆、小
数据结构之——堆结构的实现
ThereIsNoCode
03-20 2438
堆 堆是一个数组，可以被看成一个近似的完全二叉树，树上的每一个节点对应数组的每个元素。除了最底层外，该树是完全充满的，而且是从左向右填充。 堆又分为大根堆和小根堆 大根堆：父节点总是大于其子节点， 小根堆：父节点总是小于其子节点。 本文基于Java语言，使用数组实现一个堆结构及其操作。 堆结构实现 public class Heap { final int MAX = 999;// 定义最大容...
数据结构(3.3)——栈的链式存储结构
最新发布
m0_65240792的博客
06-30 267
采用链式存储的栈成为链栈的优点是便于多个栈共享存储空间和提高其效率，且。通常采用单链表实现。
01-绪论和线性表1
08-04
内容涵盖了数据结构的重要性，线性表的物理实现，递归和分治思想的应用，以及线性表在Bitmap中的应用。此外，还探讨了不同数据结构和算法在面对不同问题规模时的适用性，以及现代编程语言和并行计算的相关概念。" ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值