【数据结构】二叉树_堆

已于 2024-08-13 22:03:46 修改
阅读量1.7k 收藏 20
点赞数 28
分类专栏： 二叉树专栏 文章标签： 数据结构 c语言 开发语言
于 2024-05-29 18:33:26 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_80404788/article/details/139159636
版权

目录

1、堆的概念及结构

2、堆的实现

2.1堆向下调整算法

2.2堆的创建

2.3建堆的时间复杂度

2.4堆的插入

2.5堆的删除

2.6堆的具体实现

3、堆的应用

3.1 堆排序

3.2 TOP-K问题

一、堆的概念及结构

1.1 堆的概念

1. 堆在逻辑上是一棵 完全二叉树（如下图，类比满二叉树缺了右下角）
2. 堆的实现利用是通过数组，我们通常会利用 动态数组来存放元素，这样可以快速拓容也不      会很浪费空间，我们是将这颗 完全二叉树用层序遍历的方式储存在数组里的。
3.堆有两种，分为大根堆和小根堆。

 注意：这里的堆指的是数据结构中的堆结构，用来存储和用来查找操作；要与操作系统中的堆区区分开

 

 1.2 堆的分类

1.2.1 小根堆

小根堆：其双亲节点数值的大小永远比左右子树节点的数值要小，以此类推到整个堆，可以得知根节点的数值是堆中最小的。如图所示

1.2.2大根堆

大根堆：其双亲节点数值的大小永远比左右子树节点的数值要大，以此类推到整个堆，可以得知根节点的数值是堆中最小的。如图所示

1.3堆的结构

堆的逻辑结构就是完全二叉树。

其物理结构（如何存储）为数组。

左孩子 leftchild = parent * 2 + 1;

右孩子 rightchild = parent * 2 + 2;

双亲节点 parent = (child - 1) / 2;  (这里child可以是左孩子也可以是右孩子，因为C语言的整除规则，无论哪个节点，整除都会是双亲的下标)    

在数组中的表示如下图：

堆的结构：

  • void HPInit(HP* php);  初始化堆
  • void HPDestroy(HP* php);  销毁堆
  • void HPPush(HP* php, HPDataType x);  插入数据
  • void HPPop(HP* php);   删除数据
  • HPDataType HPTop(HP* php);   获取堆顶元素
  • bool HPEmpty(HP* php);   判空操作
  • void AdjustUp(HP* php);   自上而下调整
  • void AdjustDown(HP* php);   自下而上调整

二、堆的实现 

2.1 交换函数

//在调整过程中实现交换
void Swap(HPDataType* px, HPDataType* py)
{
	HPDataType tmp = *px;
	*px = *py;
	*py = tmp;
}

 注意：交换的目的在于使（小）大堆保持原来的规则形态，为了避免在插入和删除之后，兄弟变成父子，父子变成叔侄这样的事情发生，这样就破坏了原有的（小）大堆规则，因此做出调整

2.2 向上调整算法

//向上调整（此处皆以实现大根堆作为示范）
void AdjustUp(HPDataType* a, int child)
{
	int parent = (child - 1) / 2;
	while (child>0) //确保调整有效
	{
		if (a[child] > a[parent]) // 如果孩子节点大于双亲节点
    //若想实现小根堆，则需要把大于好改为小于号即可
		{
			Swap(&a[child], &a[parent]); //则交换孩子和双亲
			child = parent; //把孩子结点向上调整
			parent = (parent - 1) / 2; //将父亲节点同样向上调整
		}
		else
		{
			break;
		}
	}
}

 时间复杂度：O(logN)

2.3 向下调整算法

//向下调整(此处皆以实现大根堆作为示范)
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]) //若实现小根堆，则a[child + 1] < a[child]
		{
			child++;
		}
		if (a[child] > a[parent]) //如果孩子大于父亲，则交换
    //同理，若实现小根堆，则a[child] < a[parent]
		{
			Swap(&a[child], &a[parent]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}

}

时间复杂度：O(logN)

2.4 堆的创建

//结构体成员初始化可以置空，也可以赋值
void HPInit(HP* php)
{
	assert(php);
	php->a = NULL;
	php->capacity = 0;
	php->size = 0;
}

2.5 建堆的时间复杂度

void HPInitArray(HP* php, HPDataType* a, int n)
{
	assert(php);

	php->a = malloc(sizeof(HPDataType) * n);
	if (php->a == NULL)
	{
		perror("malloc fail");
		return;
	}

	memcpy(php->a, a, sizeof(HPDataType) * n);
	php->capacity = php->size = n;

	//建堆
	//分为向上和向下
	//自顶向下（向上）,时间复杂度为O(n*logN)
	/*for (int i = 1; i > php->size - 1; i++)
	{
		AdjustUp(php->a, i);
	}*/

	//向下调整时间复杂度为O(N)
	for (int i = (php->size-1  -  1)/2; i >= 0; --i)  // 这里size-1  -1 是因为双亲节点等于(孩子节点-1)/ 2 ,
	{
		AdjustDown(php->a, php->size, i);
	}
}

2.6 堆的插入

void HPPush(HP* php, HPDataType x)
{
	assert(php);

	//初始化数组操作，为数组分配空间
	if (php->capacity == php->size)
	{
		int newcapacity = php->capacity == 0 ? 4 : 2 * php->capacity;
		HPDataType* tmp = realloc(php->a, sizeof(HPDataType) * newcapacity);

		if (tmp == NULL)
		{
			perror("realloc fail");
			return;
		}
		php->a = tmp;
		php->capacity = newcapacity;

	}
	php->a[php->size] = x;
	php->size++;

	//向上调整
	AdjustUp(php->a, php->size-1);
}

 这张图帮助大家理解：若新插入元素大于其双亲节点，则向上调整

2.7 堆的删除

//删除堆顶元素
void HPPop(HP* php)
{
	assert(php);
	assert(php->size>0);

	//交换堆顶和最后一个元素
	Swap(&php->a[0], &php->a[php->size - 1]);

	php->size--;

	AdjustDown(php->a, php->size, 0);

}

 注意：此处删除元素不能像顺序表一样所有元素向前挪动一位，原因有二：

1. 挪动覆盖的时间复杂度是O(N)

2. 堆结构被破坏，兄弟变父子，父子变叔侄

 2.8 堆的销毁

void HPDestroy(HP* php)
{
	free(php->a);
	php->a = NULL;

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

 2.9 取堆顶元素

//取出堆顶元素
HPDataType HPTop(HP* php)
{
	assert(php);

	return php->a[0];
}

2.10 堆的具体实现

Heap.h

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

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

void HPInit(HP* php);
void HPDestroy(HP* php);

void HPInitArray(HP* php, HPDataType* a, int n);
void HPPush(HP* php, HPDataType x);
void HPPop(HP* php);
void AdjustDown(HPDataType* a, int n, int parent);

HPDataType HPTop(HP* php);

bool HPEmpty(HP* php);

heap.c

#include"heap.h"

void HPInit(HP* php)
{
	assert(php);
	php->a = NULL;
	php->capacity = 0;
	php->size = 0;
}

void HPInitArray(HP* php, HPDataType* a, int n)
{
	assert(php);

	php->a = malloc(sizeof(HPDataType) * n);
	if (php->a == NULL)
	{
		perror("malloc fail");
		return;
	}

	memcpy(php->a, a, sizeof(HPDataType) * n);
	php->capacity = php->size = n;

	//建堆
	//分为向上和向下
	//自上而下,时间复杂度为O(n*logN)
	/*for (int i = 1; i > php->size - 1; i++)
	{
		AdjustUp(php->a, i);
	}*/

	//向下调整时间复杂度为O(N)
	for (int i = (php->size-1  -  1)/2; i >= 0; --i)
	{
		AdjustDown(php->a, php->size, i);
	}
}

void HPDestroy(HP* php)
{
	free(php->a);
	php->a = NULL;
	php->capacity = 0;
	php->size = 0;
}
void Swap(HPDataType* px, HPDataType* py)
{
	HPDataType tmp = *px;
	*px = *py;
	*py = tmp;
}

//向上调整
void AdjustUp(HPDataType* a, int child)
{
	int parent = (child - 1) / 2;
	while (child>0)
	{
		if (a[child] > a[parent])
		{
			Swap(&a[child], &a[parent]);
			child = parent;
			parent = (parent - 1) / 2;
		}
		else
		{
			break;
		}
	}
}

void HPPush(HP* php, HPDataType x)
{
	assert(php);

	//初始化数组操作，为数组分配空间
	if (php->capacity == php->size)
	{
		int newcapacity = php->capacity == 0 ? 4 : 2 * php->capacity;
		HPDataType* tmp = realloc(php->a, sizeof(HPDataType) * newcapacity);

		if (tmp == NULL)
		{
			perror("realloc fail");
			return;
		}
		php->a = tmp;
		php->capacity = newcapacity;

	}
	php->a[php->size] = x;
	php->size++;

	//向上调整
	AdjustUp(php->a, php->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;
		}
	}

}

//删除堆顶元素
void HPPop(HP* php)
{
	assert(php);
	assert(php->size>0);

	//交换堆顶和最后一个元素
	Swap(&php->a[0], &php->a[php->size - 1]);

	php->size--;

	AdjustDown(php->a, php->size, 0);

}

HPDataType HPTop(HP* php)
{
	assert(php);

	return php->a[0];
}

bool HPEmpty(HP* php)
{
	assert(php);
	return php->size == 0;
}

test.c

#include"heap.h"

int main()
{
	HP hp;
	int a[] = { 50, 100, 70, 65, 60, 32 };

	HPInit(&hp);
	for (int i = 0; i < sizeof(a) / sizeof(int); i++)
	{
		HPPush(&hp, a[i]);
	}
	//HPInitArray(&hp, a, sizeof(a) / sizeof(int));
	while(!HPEmpty(&hp))
	{
		printf("%d\n", HPTop(&hp));
		HPPop(&hp);
	}
	HPDestroy(&hp);

	return 0;
}

三、堆的应用

3.1 堆排序

学习堆并不只是为了学习知识，更在应用。

堆在排序、查找方面对于其他排序方法效率是很高的， 因为我们知道，堆顶元素一定是整个数组的最大(小)值，向下只要根据堆的性质，就可以做到升序或是降序排序。

以实现升序排序为例：

1.将该数组建成一个大堆

2.第一个数和最后一个数交换，然后把交换的那个较大的数不看做堆里面的节点

3.前n-1和数进行向下调整算法，选出大的数放到根节点，再跟倒数第二个交换......

 代码如下：

void HeapSort(int* a,int n)
{
	int i = 0;
	//这里用向下调整算法来建堆,因为时间复杂度只有O(N)
	for (i = (n - 1 - 1) / 2; i >= 0; i--)
	{
		AdjustDown(a, n, i);
	}
	int end = n - 1;
	while (end > 0)
	{
		Swap(&a[0], &a[end]);
		AdjustDown(a, end, 0);
		--end;
	}
}

 时间复杂度：O(N*logN)

3.2 TOP-K问题

我们在做一些编程题会遇到一类问题，就是top-k问题

top-k问题指的有一组很大的数据，我们需要返回它最大（最小）的前K个元素。

这里我们就可以用堆排序很好的解决此类问题。

这里力扣平台有一个练习题，我们一起来看一看

面试题 17.14. 最小K个数 - 力扣（LeetCode）

 思路：我们先建立一个大堆，先把前K个元素建成一个大堆，然后在将剩下的数和堆顶元素进行比较，如过大于堆顶数据，我们就和堆顶元素进行交换，然后将现在的堆顶元素向下调整，前k个数就是这组数据中最小的前K个数。

void Swap(int* p1, int* p2)
{
	int temp = *p1;
	*p1 = *p2;
	*p2 = temp;
}
//向下调整
void AdjustDown(int* 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;
		}
	}
}
 
int* smallestK(int* arr, int arrSize, int k, int* returnSize)
{
    if(k==0)
    {
        *returnSize=0;
        return NULL;
    }
    int *ret=(int*)malloc(sizeof(int)*k);
    for(int i=0;i<k;i++)
    {
        ret[i]=arr[i];
    }
 
 
    //给前k个元素建大堆
    for(int i=(k-1-1)/2;i>=0;i--)
    {
        AdjustDown(ret, k, i);
    }
 
    for(int i=k;i<arrSize;i++)
    {
        if(ret[0]>arr[i])
        {
            ret[0]=arr[i];
            AdjustDown(ret,k,0);
        }
    }
    *returnSize=k;
    return ret;
}

每文一言：

当你觉得这个事情无法实现的时候，或者你觉得烦闷的时候，每天消灭一点点，可能你就爱上它了

异或没有以后
关注
专栏目录
算法_（基础排序算法）_以及_数据结构（二叉树__堆_栈_队列等）_algorithm.zip
09-26
算法_（基础排序算法）_以及_数据结构（二叉树__堆_栈_队列等）_algorithm
数据结构_交并集_中缀转后缀_模拟叫号_二叉树_huffman树_图_
04-03
在数据结构中，可以用堆（heap）来实现优先队列，根据优先级（如号码的大小）决定下一个处理的对象。 4. **二叉树**：二叉树是一种每个节点最多有两个子节点的数据结构。二叉树的操作包括遍历（前序、中序、后序）...
数据结构第八讲：二叉树_堆
2301_79761834的博客
08-01 823
数据结构第八讲：二叉树_堆
数据结构二叉树、堆的理解
bw2810592402的博客
08-29 970
对于深度为K的，有n个结点的二叉树，当且仅当其每一个结点都与深度为K的满二叉树中编号从1至n的结点一一对应时称之为完全二叉树。要注意的是满二叉树是一种特殊的完全二叉树。如上图：B、C是兄弟结点，D、E是兄弟结点等等（即连接在同一个根结点上的两个子结点叫做兄弟结点）；：一个二叉树的每一层结点数都达到最大值，则为满二叉树，也就是说当一个二叉树的结点为K层的时候，此时二叉树的结点个数是2^k-1个。2、堆属性：如上所述，堆中的每个节点都满足堆属性，即父节点的值与子节点的值之间的关系（取决于是最大堆还是最小堆）。
二叉树_堆（上卷）
Octopus2077的博客
07-24 823
本篇文章跳过二叉树的基础概念，直接从二叉树内容的正题开始，即二叉树的顺序存储结构，或者说堆。
目前初阶数据结构最难的一集-树+二叉树_堆
liu3290607528的博客
06-09 937
本文主要讲述了树的概念以及二叉树的基本概念，二叉树的前置体系-堆，以及堆的相关体系 下期预告二叉树的真正实现
【数据结构】二叉树和堆
super_coders的博客
05-26 960
二叉树，作为一种重要的数据结构，由节点组成，每个节点可以有两个子节点，通常称为左子节点和右子节点。二叉树是有序的，树中包含的各个节点的度不能超过2，即只能是0、1或者2。特殊二叉树满二叉树一个二叉树，如果每一个层的结点数都达到最大值，则这个二叉树就是满二叉树。也就是说，如果一个二叉树的层数为K，且结点总数是 2的k次方-1，则它就是满二叉树。完全二叉树完全二叉树，作为一种效率很高的数据结构，是由满二叉树衍生出来的。
【数据结构课程学习】二叉树_堆：Lesson2
幻想有一天能进大厂
05-18 1105
数据结构第二课：二叉树_堆的学习
数据结构——二叉树
2301_80373479的博客
08-16 1849
轻松学会二叉树
数据结构_二叉树(Binary tree)与堆排序(Heap sorting)
QinMou
05-20 1023
本文的重点是二叉树实现堆、堆排序和topK问题
数据结构——二叉树(堆)
weixin_74795859的博客
05-01 1250
普通的二叉树是不适合用数组来存储的，因为可能会存在大量的空间浪费，因此完全二叉树更适合使用顺序结构来存储。二叉树一般有两种结构存储: 顺序结构和链式结构。顺序结构也就是顺序表(数组)来存储，一般只有完全二叉树和满二叉树适合数组来存储。其他二叉树会有空值——会造成空间浪费。而我们通常把堆(一种二叉树)使用顺序结构的数组来存储。二叉树顺序存储在物理上是一个数组，在逻辑上(想象中的)是一颗二叉树。小堆：每个父亲都小于等于孩子 parent=childl
【数据结构】二叉树&堆
qq_40376612的博客
02-23 646
二叉树和堆
tree_二叉树_数据结构_
10-03
在计算机科学中，二叉树是一种非常基础且重要的数据结构，它由节点（或称为顶点）和连接这些节点的边组成。每个节点通常包含两个子节点，分别被称为左子节点和右子节点，这也是“二叉”这个名称的来源。二叉树广泛...
matlab.rar_matlab 二叉树_matlab二叉树_二叉树_二叉树 matlab_二叉树MATLAB
09-20
在MATLAB中实现二叉树是一种常见的数据结构操作，它在算法分析、计算机科学和许多其他领域都有广泛应用。本文将深入探讨如何在MATLAB中创建、操作和可视化二叉树，以及提供的特色方法。 首先，二叉树是每个节点最多...
二叉树_二叉树遍历_二叉树_
10-04
二叉树是计算机科学中数据结构的一个重要概念，它是一种特殊的树形结构，每个节点最多有两个子节点，分别称为左子节点和右子节点。在实际应用中，二叉树常用于实现查找、排序和表达式求解等多种算法。本节我们将深入...
考研数据结构——C语言实现插入排序
最新发布
weixin_58879477的博客
09-24 403
C语言实现插入排序
数据结构：树、森林
pranaa的博客
09-24 840
此外，访问子节点和父节点的索引计算也会变得复杂，因为需要额外的数据结构（如指针或索引数组）来跟踪每个节点的子节点位置。在转换为二叉树时，我们可以将节点的第一个孩子视为二叉树的左孩子，将节点的下一个兄弟视为二叉树的右孩子。这种转换在处理树形结构的问题时非常有用，因为二叉树具有一些特殊的性质（如左子树和右子树的明确区分）和高效的算法（如二叉搜索树、堆等）。二叉树和树的顺序存储结构在本质上是相似的，但由于二叉树结构的特殊性，它在顺序存储中更加高效和直接。二叉树转换为树的过程是上述转换的逆过程。
优先级队列(堆)
wuweixiaoyue的博客
09-24 336
什么是优先级队列：队列是一种先进先出(FIFO)的数据结构，但如果操作的数据带有优先级并且我们需要处理优先级更高的队列，此时光用【队列】不太合适，故而我们引入了【优先级队列(PriorityQueue)】如何实现优先级队列：JDK1.8中的PriorityQueue底层使用了堆这种数据结构来模拟优先级队列概念：堆实际就是在完全二叉树的基础上进行了一些调整 + 以顺序存储(数组)的方式存储二叉树。
javaScript 数据结构可变性和不可变性
everyStudy的博客
09-24 400
【代码】javaScript 数据结构可变性和不可变性。
数据结构：二叉树与堆的概念解析
"堆的定义-树与二叉树" 在数据结构中，树是一种非常...总结来说，堆和树的概念是数据结构中的基础，它们在算法设计、数据存储和优化问题中发挥着关键作用。理解并掌握这些概念及其相关操作对于解决实际问题至关重要。
评论 9
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值