【数据结构】这堆是什么

news2024/11/16 3:26:56

目录

1.二叉树的顺序结构

2.堆的概念及结构

3.堆的实现

3.1 向上调整算法与向下调整算法

3.2 堆的创建

 3.3 建堆的空间复杂度

3.4 堆的插入

 3.5 堆的删除

 3.6 堆的代码的实现

4.堆的应用

4.1 堆排序

4.2 TOP-K问题

首先，堆是一种数据结构，一种特殊的完全二叉树，采用顺序结构存储，在学习堆之前，我们先学习一下二叉树的顺序结构，再开始学习本篇文章的重点 --- 堆。

1.二叉树的顺序结构

普通的二叉树是不适合用数组来存储的，因为可能会存在大量的空间浪费。而完全二叉树更适合使用顺序结构存储。现实中我们通常把堆(一种二叉树)使用顺序结构的数组来存储，需要注意的是这里的堆和操作系统虚拟进程地址空间中的堆是两回事，一个是数据结构，一个是操作系统中管理内存的一块区域分段。

完全二叉树的顺序存储：

非完全二叉树的顺序存储：

 可以发现非完全二叉树可能会存在大量的空间浪费。

2.堆的概念及结构

如果有一个关键码的集合K= { k0，k1， k2，...，k(n-1) }，把它的所有元素按完全二叉树的顺序存储方式存储在一个一维数组中，并满足: Ki <= K(2i+1) 且 Ki <=  K(2i+2) (Ki >= K(2i+1) 且 Ki >= K(2i+2) ) i =0，1，2...，则称为小堆(或大堆)。将根节点最大的堆叫做最大堆或大根堆，根节点最小的堆叫做最小堆或小根堆。

概括来说：

堆有大根堆小根堆之分，简称大堆小堆：

大堆：堆内所有父节点都大于子节点。根节点最大。

小堆：堆内所有父节点都小于子节点。根节点最小。

堆的性质:

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

示例：

例题：

1.下列关键字序列为堆的是:（）
A 100,60,70,50,32,65
B 60,70,65,50,32,100

C 65,100,70,32,50,60

D 70,65,100,32,50,60

E 32,50,100,70,65,60

F 50,100,70,65,60,32

答案A

3.堆的实现

3.1 向上调整算法与向下调整算法

建堆有两种算法，一种是向上调整算法，一种是向下调整算法。现在我们给出一个数组，逻辑上看做一颗完全二叉树。

向上调整算法：

前提：前面元素已经构成堆，才能调整。

比如在下面小堆后面插入5

 会将插入的数据向上调整到合适的位置

代码实现：

//交换
void Swap(HeapDataType* p1, HeapDataType* p2)
{
	HeapDataType tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}
//小堆
void AdjustUp(HeapDataType* arr, int child)
{
	int parent = (child - 1) / 2;
	while (child > 0)
	{
		if (arr[child] < arr[parent])
		{
            //交换
			Swap(&arr[child],&arr[parent]);
			
			child = parent;
			parent = (child - 1) / 2;
		}
		else
		{
			break;
		}
	}
}

 建立大堆和小堆的向上调整算法判断条件不同，略有差异。

向下调整算法：

我们通过从根节点开始的向下调整算法，可以把它调整成一个小堆。

向下调整算法有一个前提:左右子树必须是一个堆，才能调整。

int array[] = {27,15,19,18,28,34,65,49,25,37};

以27为根的左右子树,都满足小堆的性质,只有根节点不满足,因此只需将根节点往下调整到合适的位置即可形成堆

代码实现

//向下调整
//完全二叉树没有左孩子，肯定没有右孩子   n是数组元素个数
void AdjustDown(HeapDataType* arr, int n, int parent)
{
	int child = parent * 2 + 1;
	while (child < n)
	{
        //找出左右孩子中最小的
		if (child + 1 < n && arr[child] > arr[child + 1])
		{
			child++;
		}
		if (arr[child] < arr[parent])
		{
            //交换
			Swap(&arr[child], &arr[parent]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}

3.2 堆的创建

这里用向下调整算法创建，因为向上调整法时间复杂度较大，后面会讲

下面我们给出一个数组，这个数组逻辑上可以看做一颗完全二叉树，但是还不是一个堆，现在我们通过算法，把它构建成一个堆。根节点左右子树不是堆，我们怎么调整呢？这里我们从倒数的第一个非叶子节点的子树开始调整，一直调整到根节点的树，就可以调整成堆。

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

步骤如下： 

 3.3 建堆的空间复杂度

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

向下调整算法建堆：

 所以向下调整算法建堆的时间复杂度为O(N)。

向上调整算法建堆：

向上调整算法需要从第2个节点开始向上调整，调整好之后，第3个节点向上调整，依次向后，直到调完。

 所以向上调整算法建堆的时间复杂度为O(N*(logN))。

所以这里推荐使用向下调整算法。

3.4 堆的插入

先插入一个10到数组的尾上，再进行向上调整算法，直到满足堆。

 3.5 堆的删除

删除堆是删除堆顶的数据，将堆顶的数据根最后一个数据一换，然后删除数组最后一个数据，再进行向下调整算法。

 3.6 堆的代码的实现

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

// 堆的构建
void HeapCreate(Heap* hp, HPDataType* a, int n);
// 堆的销毁
void HeapDestory(Heap* hp);
// 堆的插入
void HeapPush(Heap* hp, HPDataType x);
// 堆的删除
void HeapPop(Heap* hp);
// 取堆顶的数据
HPDataType HeapTop(Heap* hp);
// 堆的数据个数
int HeapSize(Heap* hp);
// 堆的判空
int HeapEmpty(Heap* hp);

具体实现：

//交换元素
void Swap(HPDataType* p1, HPDataType* p2)
{
	HPDataType t = *p1;
	*p1 = *p2;
	*p2 = t;
}
//向下调整 小堆
void AdjustDown(HPDataType* arr, int n, int parent)
{
	int child = parent * 2 + 1;
	while (child < n)
	{
		//找最小子树
		if (child + 1 < n && arr[child] > arr[child + 1])
		{
			child++;
		}

		if (arr[child] < arr[parent])
		{
			Swap(&arr[child], &arr[parent]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			return;
		}
	}
}
// 堆的构建
void HeapCreate(Heap* hp, HPDataType* a, int n)
{
	assert(hp);
	hp->a = (HPDataType*)malloc(sizeof(HPDataType) * n);
	if (hp->a == NULL)
	{
		return;
	}
	hp->capacity = n;
	hp->size = n;
	for (int i = 0; i < n; i++)
	{
		hp->a[i] = a[i];
	}
	
	for (int i = (n-1-1)/2; i >= 0; i--)
	{
		AdjustDown(hp->a, n, i);
	}
 }
// 堆的销毁
void HeapDestory(Heap* hp)
{
	assert(hp);
	free(hp->a);
	hp->a = NULL;
	hp->size = hp->capacity = 0;
}

//向上调整  小堆
void AdjustUp(HPDataType* arr, int child)
{
	int parent = (child - 1) / 2;
	while (child > 0)
	{
		if (arr[child] < arr[parent])
		{
			Swap(&arr[child], &arr[parent]);

			child = parent;
			parent = (child - 1) / 2;
		}
		else
		{
			return;
		}
	}
}
// 堆的插入
void HeapPush(Heap* hp, HPDataType x)
{
	assert(hp);
	if (hp->size == hp->capacity)
	{
		int newcapacity = hp->a == NULL ? 4 : hp->capacity * 2;
		HPDataType* ptr = (HPDataType*)realloc(hp->a, sizeof(HPDataType) * newcapacity);
		if (ptr == NULL)
		{
			perror("realloc fail");
			return;
		}
		hp->a = ptr;
		hp->capacity = newcapacity;
	}
	hp->a[hp->size] = x;
	hp->size++;
	//向上调整
	AdjustUp(hp->a, hp->size - 1);
}

// 堆的删除
void HeapPop(Heap* 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(Heap* hp)
{
	assert(hp);
	assert(!HeapEmpty(hp));
	return hp->a[0];
}
// 堆的数据个数
int HeapSize(Heap* hp)
{
	assert(hp);
	return hp->size;
}
// 堆的判空
int HeapEmpty(Heap* hp)
{
	assert(hp);
	return hp->size == 0;
}

4.堆的应用

4.1 堆排序

堆排序即利用堆的思想来进行排序，总共分为两个步骤:
1.建堆

  • 升序:建大堆
  • 降序:建小堆

2.利用堆删除思想来进行排序。

建堆和堆删除中都用到了向下调整，因此掌握了向下调整，就可以完成堆排序。

示例：升序：

#include<stdio.h>
//交换
void swap(int* p1, int* p2)
{
	int t = *p1;
	*p1 = *p2;
	*p2 = t;
}

//向下调整 大堆
void Adjustdown(int* arr, int n, int parent)
{
	int child = parent * 2 + 1;
	while (child < n)
	{
		if (child + 1 < n && arr[child] < arr[child + 1])
		{
			child++;
		}
		if (arr[child] > arr[parent])
		{
			swap(&arr[child], &arr[parent]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}

void HeapSort(int* a, int n)
{
	//建堆  升序建大堆
	//向下调整
	for (int i = (n - 1 - 1) / 2; i >= 0; i--)
	{
		Adjustdown(a, n, i);
	}
	
	//排序 
	int end = n - 1;
	while (end)
	{
		swap(&a[end], &a[0]);
		Adjustdown(a, end, 0);
		end--;
	}
}

int main()
{
	
	int arr[] = { 10,50,40,20,30,60,70 };
	int sz = sizeof(arr) / sizeof(int);
	HeapSort(arr, sz);
	for (int i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
	
	return 0;
}

4.2 TOP-K问题

TOP-K问题：即求数据结合中前K个最大的元素或者最小的元素，一般情况下数据量都比较大。比如:专业前10名、世界500强、富豪榜、游戏中前100的活跃玩家等。

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

1.用数据集合中前K个元素来建堆

  • 前k个最大的元素，则建小堆
  • 前k个最小的元素，则建大堆

2.用剩余的N-K个元素依次与堆顶元素来比较，不满足则替换堆顶元素，再向下调整。

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

示例代码：这里需要生成文件后打开文件把几个数改成较大的值，模拟数据中的最大值，再注释掉CreateNDate()函数，模拟TOP-K问题，因为再写文件会把原来的数据覆盖掉。

#include<stdio.h>
#include<time.h>
void swap(int* p1, int* p2)
{
	int t = *p1;
	*p1 = *p2;
	*p2 = t;
}

//小堆
void Adjustdown(int* arr, int n, int parent)
{
	int child = parent * 2 + 1;
	while (child < n)
	{
		if (child + 1 < n && arr[child] > arr[child + 1])
		{
			child++;
		}
		if (arr[child] < arr[parent])
		{
			swap(&arr[child], &arr[parent]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}

void CreateNDate()
{
	// 造数据
	int n = 10000;
	srand((unsigned int)time(NULL));
	FILE* file = fopen("data.txt", "w");
	for (int i = 0; i < n; i++)
	{
		fprintf(file,"%d\n", rand() % 10000);//生成10000以内的随机数
	}

	fclose(file);
}

void PrintTopK(int k)//最大的k个数
{
	CreateNDate();//造数据，选这些数据中的最大值
	FILE* file = fopen("data.txt", "r");

	//建立小堆
	int* arr = (int*)malloc(sizeof(int) * k);
	for (int i = 0; i < k; i++)
	{
		fscanf(file, "%d", &arr[i]);
	}
	for (int i = (k-1-1)/2; i >=0 ; i--)
	{
		Adjustdown(arr, k, i);
	}

	int a = 0;
	while (fscanf(file, "%d", &a)!=EOF)
	{
		if (arr[0] < a)
		{
			swap(&arr[0], &a);
		}
		Adjustdown(arr, k, 0);
	}
	for (int i = 0; i < k; i++)
	{
		printf("%d ", arr[i]);
	}
	fclose(file);
	free(arr);
}


int main()
{
	PrintTopK(5);
	return 0;
}

本篇结束
 

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/811403.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

Selenium开发环境搭建

Selenium开发环境搭建

1.下载Python https://www.python.org/downloads/ 下载下来选择自己创建的路径进行安装&#xff0c;然后配置环境变量 cmd命令框查看 2.安装selenium cmd命令框输入&#xff1a; pip install selenium3.下载pycharm https://www.jetbrains.com/pycharm/download/#sec…
阅读更多...
VLOOKUP多条件查询

VLOOKUP多条件查询

LOOKUP(1,0/((A3:A15A18)*(C3:C15C18)),F3:F15)
阅读更多...
打印Winfrom控件实现简陋版的打印(C#)

打印Winfrom控件实现简陋版的打印(C#)

本文在前面写的博文基础上进行修改&#xff1a;利用Graphics的CopyFromScreen实现简陋版的打印(C#)_zxy2847225301的博客-CSDN博客 通过截图的方式进行打印在前面的文章后面已经介绍过&#xff0c;有问题。 UI布局如下&#xff1a; 代码如下&#xff1a; using System; using…
阅读更多...
无涯教程-jQuery - Dialog组件函数

无涯教程-jQuery - Dialog组件函数

小部件对话框函数可与JqueryUI中的小部件一起使用。对话框是在HTML页面上显示信息的一种不错的方法。对话框是一个带有标题和内容区域的浮动窗口。此窗口可以移动&#xff0c;调整大小&#xff0c;并且默认情况下可以使用" X"图标关闭。 Dialog - 语法 $( "#d…
阅读更多...
CAN转ETHERCAT网关can协议和485协议区别

CAN转ETHERCAT网关can协议和485协议区别

大家好&#xff0c;今天要跟大家分享一款自主研发的通讯网关&#xff0c;JM-ECT-CAN。这款产品能够将各种CAN总线和ETHERCAT网络连接起来&#xff0c;实现高效的数据传输和通信。那么&#xff0c;这款通讯网关具体有哪些功能和特点呢&#xff1f;接下来&#xff0c;我们就一起来…
阅读更多...
苍穹外卖心得与总结【对比瑞吉】【如何获得铁粉】

苍穹外卖心得与总结【对比瑞吉】【如何获得铁粉】

对于苍穹外卖项目&#xff0c;从学习课程加复习已经13天了。 对于一名已经学习过SSMLinuxRedis数据库的Java练习生来说&#xff0c;这个项目相对于之前学习的《瑞吉外卖》新增了很多功能和技术&#xff0c;是很值得练手和提升的课程&#xff0c;下面给出自己的一些见解。&#…
阅读更多...
大厂程序员的水平比非大厂高很多嘛？

大厂程序员的水平比非大厂高很多嘛？

最近一个月&#xff0c;筛选了一百多份简历&#xff0c;前前后后面试了二三十人&#xff0c;基本上都是有大厂经历的人。同时&#xff0c;也录用了几个有大厂经历的。但整体而言&#xff0c;打破了对大厂出来的都是优质人才的幻觉。看到的实际情况与想象中的落差还是比较大的。…
阅读更多...
从零开始学python（十二）如何成为一名优秀的爬虫工程师

从零开始学python（十二）如何成为一名优秀的爬虫工程师

前言 回顾之前讲述了python语法编程 必修入门基础和网络编程&#xff0c;多线程/多进程/协程等方面的内容&#xff0c;后续讲到了数据库编程篇MySQL&#xff0c;Redis&#xff0c;MongoDB篇&#xff0c;和机器学习&#xff0c;全栈开发&#xff0c;数据分析前面没看的也不用往…
阅读更多...
ChatIE：通过多轮问答问题实现实命名实体识别和关系事件的零样本信息抽取，并在NYT11-HRL等数据集上超过了全监督模型

ChatIE：通过多轮问答问题实现实命名实体识别和关系事件的零样本信息抽取，并在NYT11-HRL等数据集上超过了全监督模型

项目设计集合&#xff08;人工智能方向&#xff09;&#xff1a;助力新人快速实战掌握技能、自主完成项目设计升级&#xff0c;提升自身的硬实力&#xff08;不仅限NLP、知识图谱、计算机视觉等领域&#xff09;&#xff1a;汇总有意义的项目设计集合&#xff0c;助力新人快速实…
阅读更多...
【机器学习】Cost Function

【机器学习】Cost Function

Cost Function 1、计算 cost2、cost 函数的直观理解3、cost 可视化总结附录 首先&#xff0c;导入所需的库&#xff1a; import numpy as np %matplotlib widget import matplotlib.pyplot as plt from lab_utils_uni import plt_intuition, plt_stationary, plt_update_onclic…
阅读更多...
【数字IC设计】VCS仿真DesignWare IP

【数字IC设计】VCS仿真DesignWare IP

DesignWare介绍 DesignWare是SoC/ASIC设计者最钟爱的设计IP库和验证IP库。它包括一个独立于工艺的、经验证的、可综合的虚拟微架构的元件集合&#xff0c;包括逻辑、算术、存储和专用元件系列&#xff0c;超过140个模块。DesignWare和 Design Compiler的结合可以极大地改进综合…
阅读更多...
c++ 给无名形参提供默认值

c++ 给无名形参提供默认值

如上图&#xff0c;若函数的形参不在函数体里使用&#xff0c;可以不提供形参名&#xff0c;而且可以给此形参提供默认值。也能编译通过。 在看vs2019上的源码时&#xff0c;也出现了这种写法。应用SFINAE&#xff08;substitute false is not an error&#xff09;原则&#x…
阅读更多...
Go Ethereum源码学习笔记 001 Geth Start

Go Ethereum源码学习笔记 001 Geth Start

Go Ethereum源码学习笔记 前言[Chapter_001] 万物的起点: Geth Start什么是 geth&#xff1f;go-ethereum Codebase 结构 Geth Start前奏: Geth Consolegeth 节点是如何启动的NodeNode的关闭 Ethereum Backend附录 前言 首先读者需要具备Go语言基础&#xff0c;至少要通关菜鸟…
阅读更多...
周末放松大作战：优化生活质量的秘密武器

周末放松大作战：优化生活质量的秘密武器

博主 默语带您 Go to New World. ✍ 个人主页—— 默语 的博客&#x1f466;&#x1f3fb; 《java 面试题大全》 &#x1f369;惟余辈才疏学浅&#xff0c;临摹之作或有不妥之处&#xff0c;还请读者海涵指正。☕&#x1f36d; 《MYSQL从入门到精通》数据库是开发者必会基础之…
阅读更多...
C++代码质量提升指南-工具篇

C++代码质量提升指南-工具篇

提高代码质量的方法&#xff1a; 使用代码规范&#xff1a;代码规范是指对代码的编写风格和格式进行规范的规则。使用代码规范可以提高代码的可读性、可维护性和可扩展性。进行单元测试&#xff1a;单元测试是一种用于验证代码单元是否正确运行的测试方法。进行单元测试可以帮…
阅读更多...
C++ ——STL容器【list】模拟实现

C++ ——STL容器【list】模拟实现

代码仓库&#xff1a; list模拟实现 list源码 数据结构——双向链表 文章目录 &#x1f347;1. 节点结构体&#x1f348;2. list成员&#x1f349;3. 迭代器模板&#x1f34a;4. 迭代器&#x1f34b;5. 插入删除操作&#x1f34c;5.1 insert & erase&#x1f34c;5.2 push_…
阅读更多...
Python实现GA遗传算法优化循环神经网络回归模型(LSTM回归算法)项目实战

Python实现GA遗传算法优化循环神经网络回归模型(LSTM回归算法)项目实战

说明&#xff1a;这是一个机器学习实战项目&#xff08;附带数据代码文档视频讲解&#xff09;&#xff0c;如需数据代码文档视频讲解可以直接到文章最后获取。 1.项目背景 遗传算法&#xff08;Genetic Algorithm&#xff0c;GA&#xff09;最早是由美国的 John holland于20世…
阅读更多...
Zabbix分布式监控Web监控

Zabbix分布式监控Web监控

目录 1 概述2 配置 Web 场景2.1 配置步骤2.2 显示 3 Web 场景步骤3.1 创建新的 Web 场景。3.2 定义场景的步骤3.3 保存配置完成的Web 监控场景。 4 Zabbix-Get的使用 1 概述 您可以使用 Zabbix 对多个网站进行可用性方面监控&#xff1a; 要使用 Web 监控&#xff0c;您需要定…
阅读更多...
【GitOps系列】监听镜像版本变化触发 GitOps工作流

【GitOps系列】监听镜像版本变化触发 GitOps工作流

文章目录 前言工作流总览安装和配置 ArgoCD Image Updater创建 Image Pull Secret&#xff08;可选&#xff09;创建 Helm Chart 仓库创建 ArgoCD Application删除旧应用&#xff08;可选&#xff09;配置仓库访问权限创建 ArgoCD 应用 体验 GitOps 工作流总结 前言 在【GitOps…
阅读更多...
AQS之ReentrantLock源码详解

AQS之ReentrantLock源码详解

一、管程 管程&#xff1a;指的是管理共享变量以及对共享变量的操作过程&#xff0c;让它们支持并发 互斥&#xff1a;同一时刻只允许一个线程访问共享资源 同步&#xff1a;线程之间如何通信、协作 MESA模型 在管程的发展史上&#xff0c;先后出现过三种不同的管程模型&a…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023