当前位置： 首页 > article >正文

二叉树 -- 堆（详解）

article 2024/12/22 16:29:45

目录

1、堆的概念及结构

2、堆的实现(附代码)

2.1、向下调整算法建堆

3、堆的应用(附代码)

3.1、堆排序

3.2、TOP-K问题

1、堆的概念及结构

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

将根节点作为最大值的堆叫做最大堆或大根堆，根节点作为最小值的堆叫做最小堆或小根堆。

通俗一点讲就是：

小堆：任意一个父结点的值都小于或者等于其子结点。

大堆：任意一个父结点的值都大于或者等于其子结点。

至于同一个父结点的两个子结点谁大谁小都无所谓。

堆的性质：

(1)堆中某个节点的值总是不大于或不小于其父节点的值。

(2)堆总是一棵完全二叉树。

补充一个问题：

堆的意义是什么？

答：选数，选最大值或最小值 -- 时间复杂度为O(logN)。

ex：

(1)堆排序，时间复杂度为O(N*logN)。 -- 选出每个节点所需时间为O(logN)，选出N个节点所需的总时间为O(N*logN)。

(2)top k问题 -- ex：从100万个值中找出最大的10个值或者说找出最小的10个值。

2、堆的实现(附代码)

对于堆的创建有两种方法，一种是插入法(使用向上调整，时间复杂度为N*logN)，一种是向下调整法(也叫筛选法)(向下调整建堆，时间复杂度为O(N))。

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

堆的底层看起来像是顺序表，但和顺序表是不一样的，从逻辑结构上，要把堆看作是一颗完全二叉树。

Heap.h：

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

typedef int HPDataType;

typedef struct Heap
{
	HPDataType* array;
	int size;
	int capacity;
} HP;
// 堆的底层看起来像是顺序表，但和顺序表是不一样的，从逻辑结构上，要把堆看作是一颗完全二叉树。

// 堆的初始化
void HeapInit(HP* php);

// 堆的销毁
void HeapDestory(HP* php);

// 判断是否需要扩容
void CheckCapacity(HP* php); 

// 交换
void Swap(HPDataType* p1, HPDataType* p2);

// 获取堆顶的元素
HPDataType HeapTop(HP* php);

// 获取堆的大小
int HeapSize(HP* php);

// 判空
bool HeapEmpty(HP* php);

// 小堆的插入
void SmallHeapPush(HP *php, HPDataType x);

// 小堆的向下调整
void SmallAdjustDown(HPDataType *a, int size, int parent);

// 小堆的删除(规定删除栈顶元素)
void SmallHeapPop(HP *php);

// 大堆的插入
void BigHeapPush(HP* php, HPDataType x);

// 大堆向下调整
void BigAdjustDown(HPDataType* a, int size, int parent);

// 大堆的删除(规定删除栈顶元素)
void BigHeapPop(HP* php);

Heap.c：

#include "Heap.h"

// 堆的初始化
void HeapInit(HP* php)
{
	assert(php);

	php->array = NULL;
	php->capacity = php->size = 0;
}

// 堆的销毁
void HeapDestory(HP* php)
{
	assert(php);
	free(php->array); // 连续的空间，直接free即可，不用像链表那种，还要去一个一个节点的free
	php->array = NULL;
	php->capacity = php->size = 0;
}

void CheckCapacity(HP* php) // 判断是否需要扩容
{
	if (php->size == php->capacity)
	{
		int newcapacity = php->capacity ? 2 * php->capacity : 4;
		HPDataType* tmp = (HPDataType*)realloc(php->array, sizeof(HPDataType) * newcapacity);
		if (tmp == NULL)
		{ 
			perror("realloc fail");
			exit(-1);
		}
		php->array = tmp;
		php->capacity = newcapacity;
	}
}

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

// 获取堆顶的元素
HPDataType HeapTop(HP* php)
{
	assert(php);
	assert(php->size);

	return php->array[0];
}

// 获取堆的大小
int HeapSize(HP* php)
{
	assert(php);
	return php->size;
}

// 判空
bool HeapEmpty(HP* php)
{
	assert(php);
	return php->size == 0;
}

void AdjustUp(HPDataType *a, int child) // child至少是0
{
	int parent = (child - 1) / 2;
	while (a[child] < a[parent]) // 把这里改成 > 就是实现大堆了
	{
		Swap(&a[child], &a[parent]);
		child = parent;
		parent = (parent - 1) / 2; // parent怎么变都不会变成负数
	}
}

// 堆的插入(建堆)--时间复杂度为log(N)--主要的时间消耗在于向上调整的时间消耗--最坏的情况要调整log(N)次
void HeapPush(HP *php, HPDataType x)
{
	assert(php);

	CheckCapacity(php);

	php->array[php->size++] = x;

	AdjustUp(php->array, php->size - 1); // 因为size至少是1
}

// 向下调整--删除栈顶元素之后进行的调整--也可用于堆的创建，时间复杂度为O(N)，比向上调整建堆更优
// 思路：
// 因为交换完根结点和尾结点，并删除栈顶元素之后，根结点的左子树和右子树仍旧符合堆的规定
// 所以如下
void AdjustDown(HPDataType *a, int size, int parent) // 将里面的孩子与父亲的大小比较改成>就变成是大堆的调整了
{
	// 分情况讨论法
	int leftchild = parent * 2 + 1;
	int rightchild = parent * 2 + 2;
	while (leftchild < size)
	{
		// 如果左右孩子一样大，跟谁换都行(前提是左右孩子都存在)
		if (rightchild < size && a[leftchild] <= a[rightchild] && a[parent] > a[leftchild]) // 比左孩子大，就跟左孩子交换
		{
			Swap(&a[parent], &a[leftchild]);
			parent = leftchild;
		}
		else if (rightchild < size && a[leftchild] > a[rightchild] && a[parent] > a[rightchild]) // 比右孩子大，就跟右孩子交换
		{
			Swap(&a[parent], &a[rightchild]);
			parent = rightchild;
		}
		else if (a[leftchild] < a[parent]) // 一定要注意要讨论只有左孩子，没有右孩子的情况，不然就出现越界访问了，Bug
		{
			Swap(&a[parent], &a[leftchild]);
			parent = leftchild;
		}
		else // 如果孩子都比父结点大，那就不用再换了
		{
			break;
		}
		leftchild = parent * 2 + 1;
		rightchild = parent * 2 + 2;
	}

	// 假设法
	// int child = parent * 2 + 1;//就假设是左孩子更小
	// while(child < size)
	//{
	//	if(child+1 < size && a[child+1] < a[child]) //这里可能出现越界，需要加一个判断child+1<size
	//                                               //因为存在那种只有左孩子但没有右孩子的情况，这时child+1的值就已经和size相等了
	//                                               //此时a[child+1]就已经是越界访问了
	//   {
	//		++child;
	//	}
	//   if(a[child] < a[parent])
	//   {
	//		Swap(&a[parent],&a[child]);
	//		parent = child;
	//		child = parent * 2 + 1;
	//   }
	//	else
	//	{
	//		break;
	//   }
	// }
}

// 堆的删除(规定删除栈顶元素)
void HeapPop(HP *php)
{
	assert(php);
	assert(php->size);

	// 第一步，先将根结点和尾结点进行交换,然后删除栈顶元素
	Swap(&php->array[0], &php->array[php->size - 1]);
	php->size--;

	AdjustDown(php->array, php->size, 0);
}

2.1、向下调整算法建堆

因为向下调整需要先保证该节点的左右子树已经是大/小堆了，才能向下调整，所以先从尾开始调整(思路就是从尾开始调整，从最后一个叶结点的父结点开始调整，叶结点无需调整，因为叶结点可以看作是一种特殊的子树，既可以当作大堆，也可以当作小堆)。

for (int i = (size - 1 - 1) / 2; i >= 0; i--) // (size-1-1)/2是最后一个叶结点的父结点的下标
{
    AdjustDown(a, size, i); // a是一个完全二叉树
}

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

注：向下调整算法的两大优势：

  1. 在进行堆排序或者解决TOP-K问题时，写一个向下调整就能解决。
  2. 时间复杂度为O(N)，效率更高。

补充：为什么用向下调整算法建堆的时间复杂度是O(N)？

答：经过计算时间复杂度的值是一个等比数列乘于等差数列的求和，结果为2^h-1-h(h为树的高度)，因为2^h-1==N，所以时间复杂度为O(N)。

3、堆的应用(附代码)

3.1、堆排序

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

1.建堆

升序：建大堆--注：建大堆，父节点是跟更大的孩子交换

降序：建小堆--注：建小堆，父节点是跟更小的孩子交换

2.利用堆删除思想来进行排序 -- 交换头尾，然后并不是真的删除掉尾，只是把除了尾之外的其他数看成新的堆，再对新的堆进行调整

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

3.2、TOP-K问题

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

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

对于Top-K问题，能想到的最简单直接的方式就是排序。--空间复杂度大(可能导致内存不够用)，时间复杂度还不好说

但是：如果数据量非常大，排序就不太可取了(可能数据都不能一下子全部加载到内存中)。

所以：最佳的方式就是用堆来解决。--空间复杂度很小，时间复杂度仅为O(N(logK))--比较次数为N-K(K可以忽略不计)，调整次数最多为logK次

基本思路如下：

第一步：用数据集合中前K个元素来建堆

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

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

第二步：用剩余的N-K个元素依次与堆顶元素来比较

如果是找前K个最大的元素，将剩余N-K个元素依次与堆顶元素比较，若比堆顶元素大，则替换堆顶元素(替换完后要进行一下向下调整)。

如果是找前K个最小的元素，将剩余N-K个元素依次与堆顶元素比较，若比堆顶元素小，则替换堆顶元素(替换完后要进行一下向下调整)。

最后堆中剩余的K个元素就是所求的前K个最大或者最小的元素。

代码示例：

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

void Print(int* a, int n)
{
	for (int i = 0; i < n; i++)
	{
		printf("%d ", a[i]);
	}
	printf("\n");
}

// 堆排序即利用堆的思想来进行排序，总共分为两个步骤：
// 1. 建堆
// 升序：建大堆
// 降序：建小堆
// 2. 利用堆删除思想来进行排序 --交换头尾，然后并不是真的删除掉尾，只是把除了尾之外的其他数看成新的堆，再对新的堆进行调整
// 总结：建堆和堆删除中都可以用向下调整，因此掌握了向下调整，就可以完成堆排序。

void HeapSort_ascending(int* a, int size) // 这里排升序
{
	assert(a);
	// 第一步把数组建成堆 --时间复杂度为N*log(N)
	// 思路：直接把数组的第一个元素看作是一个堆，从第二个元素开始看作是要插入(Push)的数据
	// 这里演示大堆的建成 
	for (int i = 1; i < size; ++i)
	{
		int child = i;
		int parent = (child - 1) / 2;
		while (a[child] > a[parent])
		{
			// 交换
			int tmp = a[child];
			a[child] = a[parent];
			a[parent] = tmp;

			child = parent;
			parent = (child - 1) / 2;
		}
	}

	// 第二步,交换并进行向下调整--时间复杂度为N*logN
	for (int end = size - 1; end > 0; --end)
	{
		// 先交换头尾
		int tmp = a[0];
		a[0] = a[end];
		a[end] = tmp;

		// 再进行向下调整。这里用的是假设法，就假设左孩子更大，建大堆就是跟更大的孩子换，建小堆则是跟更小的孩子换
		int j = 0;
		int k = j * 2 + 1;
		while (k < end)
		{
			if (k + 1 < end && a[k] < a[k + 1])
			{
				k++;
			}
			if (a[j] < a[k])
			{
				int tmp = a[j];
				a[j] = a[k];
				a[k] = tmp;
			}
			else
			{
				break;
			}
			j = k;
			k = j * 2 + 1;
		}
	}
}



void HeapSort_descending(int* a, int size) // 这里排降序
{
	assert(a);

	// 假设第一个元素自身是一个小堆，将从第二个元素开始之后的元素都视为新插入的元素
	for (int i = 1; i < size; ++i)
	{
		int child = i;
		int parent = (child - 1) / 2;
		while (a[child] < a[parent])
		{
			// 交换
			int tmp = a[child];
			a[child] = a[parent];
			a[parent] = tmp;

			child = parent;
			parent = (child - 1) / 2;
		}
	}

	// 开始排序，就是先交换头尾，再进行向下调整
	for (int i = size - 1; i > 0; --i)
	{
		int tmp = a[i];
		a[i] = a[0];
		a[0] = tmp;
		
		int parent = 0;
		int leftchild = parent * 2 + 1;
		int rightchild = parent * 2 + 2;

		while (rightchild < i || leftchild < i)
		{
			if (rightchild < i && a[rightchild] < a[leftchild] && a[rightchild] < a[parent])
			{
				int tmp = a[rightchild];
				a[rightchild] = a[parent];
				a[parent] = tmp;

				parent = rightchild;
			}
			else if (a[leftchild] < a[parent])
			{
				int tmp = a[leftchild];
				a[leftchild] = a[parent];
				a[parent] = tmp;

				parent = leftchild;
			}
			else
				break;
			leftchild = parent * 2 + 1;
			rightchild = parent * 2 + 2;
		}
	}
}





// TOP-K问题
// 基本思路如下：
// 第一步：用数据集合中前K个元素来建堆
// 要找前k个最大的元素，则建小堆
// 要找前k个最小的元素，则建大堆
// 第二步：用剩余的N-K个元素依次与堆顶元素来比较
// 如果是找前K个最大的元素，将剩余N-K个元素依次与堆顶元素比较，若比堆顶元素大，则替换堆顶元素(替换完后要进行一下向下调整)。
// 如果是找前K个最小的元素，将剩余N-K个元素依次与堆顶元素比较，若比堆顶元素小，则替换堆顶元素(替换完后要进行一下向下调整)。
// 最后堆中剩余的K个元素就是所求的前K个最大或者最小的元素。
// 补充：
// 当N不大时(N太大，会有内存不够的问题)，可以选择建个大小为N的堆，然后 pop K次即可。 // 但不管怎样，这个思路都不如上面的好。

// 造数据
void CreateData()
{
	int n = 1000000;
    FILE* pf = fopen("data.txt", "w");
	if (!pf)
	{
		perror("fopen fail");
		exit(-1);
	}
	for (int i = 0; i < n; i++)
	{
		int x = (rand() + i) % 100000; // 注意rand()产生的随机数是有范围的，范围为0到RAND MAX(32767)之间
		fprintf(pf, "%d ", x);
	}
	fclose(pf);
	pf = NULL; // 好习惯，置不置空都行，因为出了函数就自动销毁了
}

void PrintfTopK(int k)
{
	FILE* pf = fopen("data.txt", "r");
	if (!pf)
	{
		perror("fopen fail");
		return;
	}

	// 第一步，建堆(这里建小堆，找大数)
    int* minheap = (int*)malloc(sizeof(int) * k);
	if (!minheap)
	{
		perror("malloc fail");
		return;
	}
	for (int i = 0; i < k; i++)
	{
		// 边读边建堆
		int x = 0;
		if (fscanf(pf, "%d", &x) != EOF) // fscanf的用法，笔记那里没写例子！！
		{
			minheap[i] = x; 
			int j = i;
			while (minheap[j] < minheap[(j - 1) / 2]) // 向上调整
			{
				int tmp = minheap[j];
				minheap[j] = minheap[(j - 1) / 2];
				minheap[(j - 1) / 2] = tmp;
				j = (j - 1) / 2;
			}
		}
	}

	int x = 0;
	while (fscanf(pf, "%d", &x) != EOF)
	{
		if (x > minheap[0])
		{
			// 手动打个条件断点 --因为该例子中，数据太多了，一个一个调试，那得调试一辈子
			// if (x > 100000)
			// {
			//	 int condition = 0; // 因为断点不能打在空语句上，这里只是随便写一句代码，让断点打一下
			// }

			minheap[0] = x;
			// 开始向下调整
			int L = 0;
			int y = L * 2 + 1;
			while (L * 2 + 1 < k)
			{
				if (y + 1 < k && minheap[y + 1] < minheap[y])
				{
					y++;
				}
				if (minheap[L] > minheap[y])
				{
					int tmp = minheap[L];
					minheap[L] = minheap[y];
					minheap[y] = tmp;
				}
				else
				{
					break;
				}
				L = y;
				y = L * 2 + 1;
			}
		}
	}

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

	free(minheap);
	fclose(pf);
}

int main()
{
	srand((unsigned int)time(NULL));

	// CreateData();
	int k = 0;
	printf("请输入你想获取的最大数的个数：\n");
	scanf("%d", &k);
	PrintfTopK(k);

	//int n = 10;
	//int a[10] = { 0 };
	//for (int i = 0; i < n; i++)
	//{
	//	a[i] = rand() % 100 + 1;
	//}

	//HeapSort_ascending(a, sizeof(a) / sizeof(int)); // 堆排序
	//Print(a, sizeof(a) / sizeof(int));
	//HeapSort_descending(a, sizeof(a) / sizeof(int));
	//Print(a, sizeof(a) / sizeof(int));
	
	return 0;
}

http://www.kler.cn/a/446720.html

相关文章：

  • React图标库: 使用React Icons实现定制化图标效果
  • EasyExcel 导出文件
  • C# winform 字符串通过枚举类型转成int类型的数据
  • Linux文件：动静态库制作 动态库链接原理解析
  • Hexo Next主题集成百度统计
  • 机器学习中做时间序列模型考虑把时间作为特征分析
  • 网安信息收集（web层面）
  • springboot——登录认证（包括jwt技术、拦截器过滤器）
  • redis 在 win10中的使用
  • Linux Swap: 深入解析 mkswap, mkfs.swap, 和 swapon
  • Kubernetes(k8s)安装详细过程
  • 服务器数据恢复—RAIDZ离线硬盘数超过热备盘数导致阵列崩溃的数据恢复案例
  • Docker 部署 新版 Nacos、Seata
  • Spring Cloud Gateway 源码
  • DB-GPT V0.6.3 版本更新：支持 SiliconCloud 模型、新增知识处理工作流等
  • Redis篇--常见问题篇3--缓存击穿（数据查询上锁，异步操作，熔断降级，三种缓存问题综合优化策略）
  • RabbitMQ消息可靠性保证机制7--可靠性分析-rabbitmq_tracing插件
  • sqlite3 支持位运算 和view和 triger
  • 使用JUnit进行集成测试
  • QT网络（一）：主机信息查询
  • 【Super Tilemap Editor使用详解】（七）：图块集纹理编辑器(Tileset Atlas Editor)
  • 矩形嵌套 之一题多解dp篇
  • 安全工具 搭建带有 Web 仪表板的Interact.sh
  • 自毁程序密码—阿里聚安全（IDA动态调试）
  • 宠物管理系统（1）：Bean设计
  • EMMC ， UFS, SSD介绍