数据结构之堆

最新推荐文章于 2022-11-14 00:26:32 发布
最新推荐文章于 2022-11-14 00:26:32 发布
阅读量211 收藏
点赞数
分类专栏： 数据结构 文章标签： 大堆 小堆
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42307601/article/details/102467622
版权
本文详细介绍了完全二叉树的概念及其与满二叉树的区别，阐述了完全二叉树适合使用数组存储的原因。并通过实例演示了如何利用数组存储完全二叉树，并在此基础上构建小堆和大堆，包括初始化堆、调整堆以及插入和删除操作的具体实现。
摘要由CSDN通过智能技术生成

写在前面：

普通的二叉树是不适合用数组来存储的，因为可能会存在大量的空间浪费。而完全二叉树更适合使用顺序结构存储。现实中我们通常把 堆 (一种二叉树) 使用顺序结构的数组来存储。

二叉树一般可以使用两种结构存储，一种顺序结构，一种链式结构，今天总结一下顺序结构。

首先来了解一下完全二叉树

在这里插入图片描述

  1. 满二叉树：一个二叉树，如果每一个层的结点数都达到最大值，则这个二叉树就是满二叉树。也就是 说，如果一个二叉树的层数为K，且结点总数是(2^k) -1 ，则它就是满二叉树。
  2. 完全二叉树：完全二叉树是效率很高的数据结构，完全二叉树是由满二叉树而引出来的。对于深度为K 的，有n个结点的二叉树，当且仅当其每一个结点都与深度为K的满二叉树中编号从1至n的结点一一对 应时称之为完全二叉树。 要注意的是满二叉树是一种特殊的完全二叉树

这里主要涉及到堆排序的问题，通过将一维数组构建成一个堆，然后进行排序插入，查找，删除等操作。

初始化堆与调整成为大堆或小堆

开始初始化为：下图（一个无序的堆），是没有太大的意义的，因此我们需要通过算法的调整来构建成一个小堆或大堆，以方便以后的查找和删除等操作。
在这里插入图片描述

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

简单来说：
1.大堆：根节点是最大的，且除根节点外所有的父亲结点都大于它的孩子结点
2.小堆：根节点是最小的，且除根节点外所有的父亲结点都小于它的孩子结点
比如：
在这里插入图片描述

如何初始化堆并调整成为一个小堆或大堆

我们给出一个数组，这个数组逻辑上可以看做一颗完全二叉树，但是还不是一个堆，现在我们通过算法，把它构建成一个堆。如何调整为大堆或小堆呢？这里我们从根节点开始调整，一直调整到非叶子节点，就可以调整成堆。
所以首先我们需要初始化一个堆，但在这之前需要定义堆类型的结构体。

具体实现

因为我们知道堆在实际上是用数组来存储的
1.定义结构体：

typedef int HPDataType;
typedef struct  Heap//定义结构体
{
	HPDataType* _a;//堆在实际上是一个数组，完全二叉树是逻辑上的存储，但物理上还是存在数组里的
	int _size;//大小
	int _capacity;//容量
}Heap;

2.定义一个结构体变量和一个数组：

	int a[]={2,13,23,6,35,16,56,36};
	Heap hp;

3.初始化一个堆并构建成小堆或者大堆：
这里就以初始化小堆为例
（1）先申请内存，初始化为一个堆：

void HeapInit1(Heap*hp,HPDataType* a,int n)//初始化为小堆
{   //这里的 n 是接受数组元素个数的形参
	int i;
	hp->_a=(HPDataType*)malloc(sizeof(HPDataType)*n);//申请内存
	memcpy(hp->_a,a,sizeof(HPDataType)*n);//将数据复制到申请的内存中
	hp->_size=n;//大小和容量
	hp->_capacity=n;
	//构建成堆
	for(i=(n-1-1)/2;i>=0;--i)//循环调整堆
	{
     AdjustDown1(hp->_a,hp->_size,i);//构建成小堆
	 }

}

（2）向下调整为小堆：

void AdjustDown1(HPDataType* a,size_t n,size_t parent)//向下调整构建小堆
{//通过父亲节点和孩子节点进行比较
	size_t 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 HeapInit1(Heap*hp,HPDataType* a,int n);//初始化为小堆
void HeapInit2(Heap*hp,HPDataType* a,int n);//初始化为大堆
void AdjustDown1(HPDataType* a,size_t parent,size_t n);//向下调整为小堆
void AdjustDown2(HPDataType* a,size_t n,size_t parent);//向下调整为大堆
void AdjustUp(HPDataType* a,size_t child);//向上调整
void HeapPrint(Heap*hp);//打印数据
void HeapDestory(Heap*hp);//删除堆
void HeapPush(Heap*hp,HPDataType x);//插入数据
void HeapPop(Heap*hp);//删除堆顶
HPDataType HeapTop(Heap*hp);//取堆顶元素
size_t HeapSize(Heap*hp);//堆的大小

这里我们讲一个向上调整，因为在做数据的插入时如果从堆顶插入的话，实现起来不太现实，而且有可能会导致堆顺序的混乱，因此我们采用向上调整法，从数组的最后一个元素后插入，再向上调整构建成大堆或小堆。

同样以小堆为例：

void HeapPush(Heap*hp,HPDataType x)//插入一个数，使用向上调整法
{
	if(hp->_size==hp->_capacity)//如果满了之后
	{
		size_t newcapacity=hp->_capacity== 0 ? 2 : hp->_capacity*2;//成2倍的增
		hp->_a=(HPDataType*)realloc(hp->_a,sizeof(HPDataType)*newcapacity);
		hp->_capacity=newcapacity;//将新的容量给到原来的容量
	}

	hp->_a[hp->_size]=x;
	hp->_size++;

	AdjustUp(hp->_a,hp->_size-1);//向上调，从最后一个下标开始调

}
void	AdjustUp(HPDataType* a,size_t child)//向上调整
{
	int parent = (child -1)/2;//首先计算插入进来的数据的parent,
	//while(parent>=0)//这个有问题
	while(child>0)//走到根
	{
		if(a[child]<a[parent])//如果插入进来的小于parent就交换
		//if(a[child]>a[parent])//如果插入进来的大于parent就交换

		{
			Swap(&a[child],&a[parent]);//只是交换了值，位置并没有交换
			child=parent;//child继续往上走，把parent变成下一个child
			parent=(child-1)/2;//重新计算parent
		}
		else
		{
			break;//没有返回值的情况尽量使用break;表示跳出向上调整的循环
		}
	}
}

测试一下：
在这里插入图片描述
直观验证一下：
在这里插入图片描述

由此可见，通过“尾插”的方式，插入一个数据，然后先找到他的父亲节点，然后与他的父亲节点进行比较，如果它之前是一个小堆的话，如果新插入的数据比父亲节点大则交换，依次循环，而如果是大堆的话则判断它是否大于父亲节点，如果比父亲节点小的话则交换，并继续循环，最终调整成为小堆或大堆。

代码汇总：
头文件：
#include<stdlib.h>
#include<string.h>
#include<stdio.h>
#include<stdlib.h>
typedef int HPDataType;
typedef struct  Heap//定义结构体
{
	HPDataType* _a;//堆在实际上是一个数组，完全二叉树是逻辑上的存储，但物理上还是存在数组里的
	int _size;
	int _capacity;
}Heap;
void HeapInit1(Heap*hp,HPDataType* a,int n);//初始化为小堆
void HeapInit2(Heap*hp,HPDataType* a,int n);//初始化为大堆
void AdjustDown1(HPDataType* a,size_t parent,size_t n);//向下调整
void AdjustDown2(HPDataType* a,size_t n,size_t parent);//向下调整
void AdjustUp(HPDataType* a,size_t child);//向上调整
void HeapPrint(Heap*hp);//打印数据
void HeapDestory(Heap*hp);//删除堆
void HeapPush(Heap*hp,HPDataType x);//插入数据
void HeapPop(Heap*hp);//删除堆顶
HPDataType HeapTop(Heap*hp);//取堆顶元素
size_t HeapSize(Heap*hp);//堆的大小
测试代码：
#include<stdio.h>
#include"Heap.h"
void TestHeap()
{
	int a[]={2,13,23,6,35,16,56,36};
	Heap hp;
	printf("构建的小堆为：\n");
	HeapInit1(&hp,a,sizeof(a)/sizeof(int ));//初始化
	HeapPrint(&hp);
	printf("插入一个数据调整为小堆则为：\n");
    HeapPush(&hp,4);//插入一个数，使用向上调整法
	HeapPrint(&hp);
	//printf("构建的大堆为：\n");
	//HeapInit2(&hp,a,sizeof(a)/sizeof(int ));//初始化
    //HeapPush(&hp,-1);//插入一个数，使用向上调整法
	//HeapPrint(&hp);
    //HeapPop(&hp);//删除，不能动相对位置，只能动头和尾
	//HeapPrint(&hp);
    //HeapPop(&hp);//删除，不能动相对位置，只能动头和尾
    //printf("%d\n",HeapTop(&hp));
	//HeapPrint(&hp);
}

int main()
{

 TestHeap();
 system("pause");
 return 0;
}
子函数：
#include"Heap.h"

void HeapInit1(Heap*hp,HPDataType* a,int n)//初始化为小堆
{
	int i;
	hp->_a=(HPDataType*)malloc(sizeof(HPDataType)*n);//申请内存
	memcpy(hp->_a,a,sizeof(HPDataType)*n);//将数据复制到申请的内存中
	hp->_size=n;//大小和容量
	hp->_capacity=n;
	//构建成堆
	for(i=(n-1-1)/2;i>=0;--i)//循环调整堆
	{
     AdjustDown1(hp->_a,hp->_size,i);//构建成小堆
	 }

}
void HeapInit2(Heap*hp,HPDataType* a,int n)
{
	int i;
	hp->_a=(HPDataType*)malloc(sizeof(HPDataType)*n);
	memcpy(hp->_a,a,sizeof(HPDataType)*n);
	hp->_size=n;
	hp->_capacity=n;
	//构建成堆
	for(i=(n-1-1)/2;i>=0;--i)//循环调整数据
	{
     AdjustDown2(hp->_a,hp->_size,i);//构建成大堆
	 }

}
void Swap(HPDataType*p1,HPDataType* p2)//交换函数
{
	HPDataType x=*p1;//注意解引用
	*p1=*p2;
	*p2=x;

}
void AdjustDown1(HPDataType* a,size_t n,size_t parent)//向下调整构建小堆
{
	size_t 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 AdjustDown2(HPDataType* a,size_t n,size_t parent)//向下调整构建为大堆
{
	size_t 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	HeapPrint(Heap*hp)//打印数据
{
	int i=0;
	for(i=0; i<hp->_size; ++i)
	{
		printf("%d ",hp->_a[i]);
	}
	printf("\n");

}
void HeapDestory(Heap*hp)//删除堆
{
	if(hp->_a)
	{
		free(hp->_a);
	}
	hp->_size=hp->_capacity=0;
}
void HeapPush(Heap*hp,HPDataType x)//插入一个数，使用向上调整法
{
	if(hp->_size==hp->_capacity)//如果满了之后
	{
		size_t newcapacity=hp->_capacity== 0 ? 2 : hp->_capacity*2;//成2倍的增
		hp->_a=(HPDataType*)realloc(hp->_a,sizeof(HPDataType)*newcapacity);
		hp->_capacity=newcapacity;//将新的容量给到原来的容量
	}

	hp->_a[hp->_size]=x;
	hp->_size++;

	AdjustUp(hp->_a,hp->_size-1);//向上调，从最后一个下标开始调

}
void	AdjustUp(HPDataType* a,size_t child)//向上调整
{
	int parent = (child -1)/2;//首先计算插入进来的数据的parent,
	//while(parent>=0)//这个有问题
	while(child>0)//走到根
	{
		if(a[child]<a[parent])//如果插入进来的小于parent就交换
		//if(a[child]>a[parent])//如果插入进来的大于parent就交换

		{
			Swap(&a[child],&a[parent]);//只是交换了值，位置并没有交换
			child=parent;//child继续往上走，把parent变成下一个child
			parent=(child-1)/2;//重新计算parent
		}
		else
		{
			break;//没有返回值的情况尽量使用break;表示跳出向上调整的循环
		}
	}
}
void HeapPop(Heap*hp)//删除，不能动相对位置，只能动头和尾
{
	Swap(&hp->_a[0],&hp->_a[hp->_size-1]);
	hp->_size--;//删掉最后一个数即删掉头
    AdjustDown1(hp->_a,hp->_size,0);//再次向下调整成小堆
}
HPDataType HeapTop(Heap*hp)
{
	return hp->_a[0];

}
size_t HeapSize(Heap*hp)
{

	return hp->_size;
}

另外还有堆排序，会在后面的排序一起总结。

起个名字好难丫
关注
专栏目录
数据结构之堆排序
码莎拉蒂
11-03 2583
1 堆排序 堆排序（英语：Heapsort）是指利用堆这种数据结构所设计的一种排序算法。堆是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点，我们可以理解构建的堆是 完全二叉树 ，它们的下标有如下性质 完全二叉树还有这个性质，比如这个树有n个节点，那么这个树的有左右孩子节点的父节点有n / 2个，如果我们堆顶是从下标0开始的，那么n / 2个数...
C++数据结构：二叉树之一（数组存储）
攻城狮的博客
05-30 3357
树是一种非线性数据结构，它由若干个节点和边组成。每个节点都有一个值，而边则表示节点之间的关系。树具有层次结构，其中一个节点被称为根节点，它没有父节点。除根节点外，每个节点都有且仅有一个父节点。树的基本性质包括树的深度、高度、度数等。森林是由若干棵互不相交的树组成的集合。一棵树可以看作是一个仅包含一棵树的森林。二叉树是一种特殊的树，它的每个节点最多只有两个子节点，分别称为左子节点和右子节点。二叉树是树的一种特殊形式，它具有树的所有基本性质，同时还有一些独特的性质。
c语言 用一维数组存储二叉树,使用一维数组存储二叉树
weixin_32593721的博客
05-21 2213
/**** 需求：使用一维数组存储二叉树* 步骤：* 1、查看原始数据的个数(8个)，从而制定二叉树层级(4层)，得到满二叉树节点个数(15个)* 2、二叉树节点(15个)为一维数组，全设置为0* 3、循环遍历原始数据，第一个值为树根* 4、第二个值与父节点比较，如果大于树根，则往右子树比较，如果数组内的值小于或等于树根，则往左子树比较* 5、【循环】步骤4，直到形成二叉树** 备注：左节点的坐标...
07_15(三 二叉树及其基本性质)
走胡子旭道路
07-15 1296
1.二叉树的定义 二叉树是一个有限的结点集合，该集合或者为空，或者是由一个根结点及其两棵互不相交的左、右二叉树组成。 与一般的树结构比较，二叉树在结构上具有规范性和确定性的特点 特点 a,空的二叉树没有结点，非空二叉树有且只有一个根结点 b,每个结点最多有两棵子树，即二叉树中不存在度大于2的结点 c,二叉树有左右之分，其次序不能任意颠倒 二叉树的每个结点可以有两棵子二叉树，分别称为左...
数据结构与算法-二叉树的名词概念与相关数据的计算
pyhui的技术博客
09-20 338
示例图 名词解释 父节点 一个结点的前面的节点，前面的节点是父节点 子节点 一个节点的后面的节点，是子节点 叶子节点 如果一个节点，没有子节点，它就是叶子节点 根节点 没有父节点的节点，是根节点，也就是最顶端的那个节点 度 一个节点所具备的后件个数，称为度 叶子节点的度为0 深度 树的最大层次，叫做深度 图示的深度为5 子树 以某一个节点的子结点为根所形成的树，称为一个子树 二叉树的相关计算 ...
二叉树操作篇 -- 二叉树的深度
qq_37703292的博客
08-10 877
二叉树的深度 二叉树的根节点为第一层，根节点的子节点为第二层，以此类推，最大层数即为二叉树的深度 如下图所示二叉树深度为3 求二叉树深度 求二叉树的深度可用两种方法：深度优先遍历和广度优先遍历 1. 广度优先遍历（BFS） 使用BFS对二叉树进行层次遍历，每遍历一层树的深度加1，遍历完整个二叉树时即可得到二叉树的深度。 public int TreeDepth(TreeNode root) { if(root == null){ return 0; } in
数据结构 堆
08-17
堆的实现，能够进行插入建堆，插入，删除，判空等操作
数据结构堆
11-08
堆结构是数据结构的重要组成部分，它是一种特殊的完全二叉树，具有结构性和有序性两个主要特性。结构性是指用数组表示的完全二叉树，即对于数组中的任意位置i（从1开始计数），其左子节点的位置是2i，右子节点的位置...
数据结构-堆及其应用PPT
最新发布
07-16
数据结构中的堆是一种特殊的树形数据结构，通常用于实现优先队列。堆有两种主要类型：大根堆和小根堆。在大根堆中，每个父节点的值都大于或等于其子节点的值，而在小根堆中，每个父节点的值都小于或等于其子节点的值...
高级数据结构——堆在解题中的应用.pdf
08-07
高级数据结构——堆在解题中的应用这篇文档，主要围绕堆这种数据结构的定义、性质、操作以及应用场景进行了详细的讨论。文章首先定义了堆的概念，指出堆是一棵完全二叉树，它满足特定的父子节点值的关系：在最大堆中...
数组存放二叉树
12-02
用数组存放二叉树。方法比较简单，比较容易实现。
数据结构_树1
weixin_56219612的博客
11-14 266
又称为是二叉排序树（Binary Sort Tree）或二叉搜索树。二叉排序树或者是一棵空树，或者是具有下列性质的二叉树：1) 若左子树不空，则左子树上所有结点的值均小于它的根结点的值；2) 若右子树不空，则右子树上所有结点的值均大于或等于它的根结点的值；3) 左、右子树也分别为二叉排序树；4) 没有键值相等的节点。二叉查找树的性质：对二叉查找树进行中序遍历，即可得到有序的数列。
数据结构之——二叉树（1）
WenJieya的博客
04-17 1661
一：二叉树的定义 二叉树是 n(n >= 0) 个结点的有限集合，该集合或者为空集（称为空二叉树）, 或者由一根节点和两颗互不相交的、分别称为根节点的左子树和右子树的二叉树构成。 1：二叉树的特点 1：每个结点的子树个数小于等于 2 ，所以二叉树中不存在度大于 2 的结点。 2：左子树和右子树是有顺序的，次序不能任意颠倒。 3：即使树中的某结点只有一棵子树，也要区分它是左子树还是右子树。 二叉树的五种基本形态： 1：空二叉树。 2：只有一个根节点。 3：根节点只有左子树。 4：根节点既有左子树又
二叉树的存储结构
痞子龙3D编程
03-30 2529
<br />   二叉树是非线性结构，即每个数据结点至多只有一个前驱，但可以有多个后继。它可采用顺序存储结构和链式存储结构。 <br />1．顺序存储结构 <br />    二叉树的顺序存储，就是用一组连续的存储单元存放二叉树中的结点。因此，必须把二叉树的所有结点安排成为一个恰当的序列，结点在这个序列中的相互位置能反映出结点之间的逻辑关系，用编号的方法从树根起，自上层至下层，每层自左至右地给所有结点编号,缺点是有可能对存储空间造成极大的浪费，在最坏的情况下，一个深度为k且只有k个结点的右单支树需要2k-1
用数组存放树
u011624157的专栏
03-29 2746
用数组存放树概念介绍满二叉树和完全二叉树存储树的两种方式链式存储法基于数组的循序存储法二叉树层次遍历 概念介绍 满二叉树和完全二叉树 上图中，编号 2 和编号 3 这两个二叉树是比较特殊的。 编号 2 的二叉树，叶子节点全在最底层，除了叶子节点之外，每个节点都有左右两个子节点，这种二叉树就叫作满二叉树。 编号 3 的二叉树中，叶子节点都在最底下两层，最后一层的叶子节点都靠左排列（最后一层的节点之间不能有空隙，从左到右不能有空隙），并且除了最后一层，其他层的节点个数都要达到最大，这种二叉树叫作完全二叉树。
关于二叉树的性质以及存储方式（学习笔记）
Nanrdml的博客
03-31 765
二叉树的性质 关于二叉树，种类自然多种多样，不过不同种的二叉树会有不同的性质。 性质一：在二叉树第i层上至多有2的（i-1）次方个节点 性质二：深度为k的二叉树至多有2的k次方-1个结点（k>=1） 性质三：具有n个结点的完全二叉树的深度为【log2 n】+1 性质四：对于具有n个节点的完全二叉树，如果按照对满二叉树节点连续编号的方法，对所有节点从1开始顺序编号，则对于任意序号为i的结点有以...
使用一维数组存储二叉树--Java版
热门推荐
北京小辉
08-09 1万+
package com.datastructure;/*** * 需求：使用一维数组存储二叉树 * 步骤： * 1、查看原始数据的个数（8个），从而制定二叉树层级（4层），得到满二叉树节点个数（15个） * 2、二叉树节点（15个）为一维数组，全设置为0 * 3、循环遍历原始数据，第一个值为树根 * 4、第二个值与父节点比较，如果大于树根，则往右子树比较，如果数组内的值小于或等于树根，则
二叉树详解（图文）
0729Liang
05-05 1214
二叉树 1. 树 a) 二叉树定义 每个节点至多两个子结点。 b) 满二叉树，完全二叉树定义 深度为k且有2k-1个结点的二叉树叫满二叉树。 完全二叉树：所有结点与对应的满二叉树对应。 二叉堆：是完全二叉树。 一棵完全二叉树除了最后一层外，其余层的节点数都是满的，最后一层的节点也必须自左至右排列， 例如图(a)是高度为3的满二叉树，图(b)是完全二叉树，图(c)不是完全二...
二叉树的一维数组存储
L-75的专栏
04-10 7272
思路很简单，根放在0位置，以后假定当前位置是i，那么左子结点在2i+1，右子结点在2i+2。 比如根的左子结点在1，右子结点在2。结点1的左子结点在3，右子结点在4。 定义一种空值表示没有子结点，比如empty。  假定一个结点由3个成员组成：value, left, right 数组假定是全局的，如果不是可以作为参数传送。 递归实现比较简单： void btree2array(node,
数据结构与堆排序详解
"堆排序的关键-数据结构 严蔚敏" 在计算机科学中，堆排序是一种基于比较的排序算法，它的核心在于数据结构“堆”的构建和调整。堆是一种特殊的树形数据结构，每个节点都有一个值，且满足父节点的值大于或等于（大...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值