【数据结构】树-堆的详解

已于 2024-05-19 20:21:03 修改
阅读量962 收藏 37
点赞数 24
分类专栏： 数据结构 文章标签： 数据结构 算法 二叉树 堆的理解和实现
于 2024-05-16 20:29:05 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_81577798/article/details/138969958
版权

目录

1.树的概念

树的相关概念：

结点的度：

叶结点或终端结点：

非终端结点或分支结点：

双亲结点或父结点：

孩子结点或子结点：

兄弟结点：

树的度：

结点的层次：

树的高度或深度：

堂兄弟结点：

结点的祖先：

子孙：

森林：

二叉树的概念

堆的概念

大堆，小堆概念 

 堆的实现

堆的底层逻辑：动态数组 

初始化和销毁 

堆的插入 

堆的删除 

堆的判空和取堆的顶数据

整体代码及测试： 

 

1.树的概念

在学习了解堆之前，我们需要来了解树，堆是树中的一种特殊情况。 

可能我们听到树这个名字时，脑海中就会不由自主的浮现一颗树的形状，树作为数据结构的一环，它的，模型就像是一颗倒着的树一样的结构，每个节点存放着我们需要的数据，示例图如下：

树的相关概念：

结点的度：

如图所示，节点的度指的就是该节点所连接的其他节点个数，图中A节点的度为6，B节点的度为3 

叶结点或终端结点：

 叶结点或终端结点又称作叶子，就像一颗树上的叶子一样，后续没有枝干延升了，树中的叶子节点指的就是那些度为0的节点。


非终端结点或分支结点：

指的就是那些度不为0的节点


双亲结点或父结点：

如图，A为父亲的话，那么B,C,D,E,F,G都是它的孩子


孩子结点或子结点：

指的就是B,C,D,E,F,G


兄弟结点：


树的度：

以树中节点度中的最大一个为树的度，如图树中A节点的度最大为6，那么树的度就是为6


结点的层次：

从根开始定义起，根为第1层，根的子结点为第2层，以此类推


树的高度或深度：

 树中结点的最大层次； 如上图：树的高度为4


堂兄弟结点：

双亲在同一层的结点互为堂兄弟；如上图：H、I互为兄弟结点


结点的祖先：

从根到该结点所经分支上的所有结点；如上图：A是所有结点的祖先
 


子孙：

以某结点为根的子树中任一结点都称为该结点的子孙。如上图：所有结点都是A的子孙


森林：

由m（m>0）棵互不相交的树的集合称为森林
 

二叉树的概念

 二叉树是树中特殊的一种，它的每一个父亲节点的孩子都不会超过两个。

  •  二叉树不存在度大于2的结点
  • 二叉树的子树有左右之分，次序不能颠倒，因此二叉树是有序树

以下又是二叉树的各种情况： 

 

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

堆的概念

堆就属于满二叉树或者完全二叉树的一种，堆的底层实现可以通过顺序存储或者链式存储，本次我们实现的是顺序存储。那么一个堆在底层的顺序存储又是什么样子的呢，看下图。

 通过上图我们又可以了解如何使用每一个父亲节点去计算孩子节点：

  • 左child = parent * 2 + 1  
  • 右child = parent * 2 + 2

 通过孩子计算父亲节点：

  • parent = (child - 1) /2

大堆，小堆概念 

  • 大堆：所有的父亲节点的数据都>=孩子节点
  • 小堆：所有的父亲节点的数据都<=孩子节点 

 堆的实现

堆的底层逻辑：动态数组 

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

// 类型定义
typedef int HPDataTpye;

typedef struct Heap
{
	// 动态数组
	HPDataTpye* a;
	// 元素个数
	int size;
	// 空间容量
	int capacity;
}Heap;

其实操作堆的底层就是对动态数组的操作，我们只需按照堆的方式进行设计即可。 

以下是我们会实现的接口功能： 

// 函数声明

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

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

// 堆的插入
void HeapPush(Heap* php, HPDataTpye x);

// 堆的删除
void HeapPop(Heap* php);

// 堆的判空
bool HeapEmpty(Heap* php);

// 取堆的顶数据
HPDataTpye HeapTop(Heap* php);

初始化和销毁 

// 堆的初始化
void HeapInit(Heap* php)
{
	// 判空
	assert(php);

	// 初始化
	php->a = NULL;
	php->size = php->capacity = 0;

}

// 堆的销毁
void HeapDestory(Heap* php)
{
	// 判空
	assert(php);

	// 释放空间
	free(php->a);
	php->a = NULL;
	php->size = php->capacity = 0;

}

堆的插入 

 这边我们先实现一个大堆的案例：

首先我们在插入堆的情况可能有以下三种情况： 

 

 

如果插入的数据是图一的情况，我们直接不用管理了，插入之后还是一个大堆，但是如果是图二或者图三的情况，我们就需要对堆进行一个调整，将它调整为大堆的情况。

首先我们需要计算出最后插入数据的父亲节点，让后进行比较，如果刚插入的孩子节点大我们就进行交换，简单点说就是谁大谁当爹，然后通过这样不断的调整，直到插入的孩子到顶，或者中途有父亲节点比它大才结束。

以下是图形过程：

代码实现： 

// 向上调整
void AdjustUp(HPDataTpye* a, int child)
{
	// 算父亲节点
	int parent = (child - 1) / 2;

	// 循环向上排序
	while (child > 0)
	{
		if (a[child] > a[parent])
		{
			// 交换
			Swap(&a[child], &a[parent]);
			// 把父亲赋值给孩子
			child = parent;
			parent = (child - 1) / 2;
		}
		else {
			break;
		}
	}
}

// 堆的插入
void HeapPush(Heap* php, HPDataTpye x)
{
	// 判空
	assert(php);

	// 判断空间是否满
	if (php->size == php->capacity)
	{
		// 看原来的空间容量是否为0，为0分配4个空间，不为0空间*2
		int newcapacity = php->capacity == 0 ? 4 : php->capacity * 2;
		// 分配动态空间
		HPDataTpye* tmp = (HPDataTpye*)realloc(php->a, newcapacity * sizeof(HPDataTpye));
		if (NULL == tmp)
		{
			perror("malloc fail");
			return;
		}

		php->a = tmp;
		php->capacity = newcapacity;
	}

	// 插入
	php->a[php->size - 1] = x;
	php->size++;

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

 测试一下：

void HeapText01()
{
	Heap h;
	// 初始化
	HeapInit(&h);

	int arr[] = { 4,2,8,1,5,6,9,7};
	for (int i = 0; i < sizeof(arr) / sizeof(int); i++)
	{
		HeapPush(&h, arr[i]);
	}

	// 销毁
	HeapDestory(&h);
}


int main()
{
	HeapText01();
	return 0;
}

 

那么实现小堆模型呢，其实很简单，我们只需要将判定大小的条件改一下即可 

// 向上调整
void AdjustUp(HPDataTpye* a, int child)
{
	// 算父亲节点
	int parent = (child - 1) / 2;

	// 循环向上排序
	while (child > 0)
	{
		if (a[child] < a[parent])
		{
			// 交换
			Swap(&a[child], &a[parent]);
			// 把父亲赋值给孩子
			child = parent;
			parent = (child - 1) / 2;
		}
		else {
			break;
		}
	}
}

堆的删除 

 

// 向下调整
void AdjustDown(HPDataTpye* 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 HeapPop(Heap* php)
{
	// 判空
	assert(php);
	assert(php->size > 0);

	// 交换
	Swap(&php->a[0], &php->a[php->size - 1]);
	php->size--;

	// 向下调整
	AdjustDown(php->a, php->size, 0);
}

堆的判空和取堆的顶数据

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

// 取堆的顶数据
HPDataTpye HeapTop(Heap* php)
{
	// 判空
	assert(php);

	return php->a[0];
}

时间复杂度计算 

以下图片是向上调整和向下调整的时间复杂度计算：

 

整体代码及测试： 

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

// 类型定义
typedef int HPDataTpye;

typedef struct Heap
{
	// 动态数组
	HPDataTpye* a;
	// 元素个数
	int size;
	// 空间容量
	int capacity;
}Heap;


// 函数声明

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

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

// 堆的插入
void HeapPush(Heap* php, HPDataTpye x);

// 堆的删除
void HeapPop(Heap* php);

// 堆的判空
bool HeapEmpty(Heap* php);

// 取堆的顶数据
HPDataTpye HeapTop(Heap* php);
#include "Heap.h"


// 堆的初始化
void HeapInit(Heap* php)
{
	// 判空
	assert(php);

	// 初始化
	php->a = NULL;
	php->size = php->capacity = 0;

}

// 堆的销毁
void HeapDestory(Heap* php)
{
	// 判空
	assert(php);

	// 释放空间
	free(php->a);
	php->a = NULL;
	php->size = php->capacity = 0;

}

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

// 向上调整
void AdjustUp(HPDataTpye* a, int child)
{
	// 算父亲节点
	int parent = (child - 1) / 2;

	// 循环向上排序
	while (child > 0)
	{
		if (a[child] > a[parent])
		{
			// 交换
			Swap(&a[child], &a[parent]);
			// 把父亲赋值给孩子
			child = parent;
			parent = (child - 1) / 2;
		}
		else {
			break;
		}
	}
}

// 堆的插入
void HeapPush(Heap* php, HPDataTpye x)
{
	// 判空
	assert(php);

	// 判断空间是否满
	if (php->size == php->capacity)
	{
		// 看原来的空间容量是否为0，为0分配4个空间，不为0空间*2
		int newcapacity = php->capacity == 0 ? 4 : php->capacity * 2;
		// 分配动态空间
		HPDataTpye* tmp = (HPDataTpye*)realloc(php->a, newcapacity * sizeof(HPDataTpye));
		if (NULL == tmp)
		{
			perror("malloc fail");
			return;
		}

		php->a = tmp;
		php->capacity = newcapacity;
	}

	// 插入
	php->a[php->size] = x;
	php->size++;

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

// 向下调整
void AdjustDown(HPDataTpye* 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 HeapPop(Heap* php)
{
	// 判空
	assert(php);
	assert(php->size > 0);

	// 交换
	Swap(&php->a[0], &php->a[php->size - 1]);
	php->size--;

	// 向下调整
	AdjustDown(php->a, php->size, 0);
}


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

// 取堆的顶数据
HPDataTpye HeapTop(Heap* php)
{
	// 判空
	assert(php);
	assert(php->size > 0);

	return php->a[0];
}
#include "Heap.h"

void HeapText()
{
	Heap h1;
	// 初始化
	HeapInit(&h1);

	int arr[] = { 4,2,8,1,5,6,9,7};
	for (int i = 0; i < sizeof(arr) / sizeof(int); i++)
	{
		HeapPush(&h1, arr[i]);
	}

	int i = 0;
	while (!HeapEmpty(&h1))
	{
		printf("%d ", HeapTop(&h1));
		//arr[i++] = HeapTop(&h1);
		HeapPop(&h1);
	}
	printf("\n");

	 //计算前十最富有的人
	/*int k = 0;
	scanf_s("%d", &k);
	while (k--)
	{
		printf("%d ", HeapTop(&h1));
		HeapPop(&h1);
	}*/


	// 销毁
	HeapDestory(&h1);
}




int main()
{
	HeapText();
	return 0;
}

 

阳区欠
关注
专栏目录
深入理解堆 —— 堆的底层实现，堆排序，TopK问题
ifwecande的博客
09-10 978
概念 结构特点 堆（数据结构） 逻辑上：完全二叉树 物理上：数组 堆是一种顺序存储结构（采用数组方式存储），仅仅是利用完全二叉树的顺序结构的特点进行分析。 结点下标计算公式（根节点从0开始） 已知二叉树根结点的下标是root,那么它左孩子的下标left=2root+1，右孩子的下标right=2root+2。 已知孩子结点的下标（不区分左右）为child，那么双亲的下标为（child-1)/2。 如果从1开始，则已知root，则左孩子节点left=2root+1,right=2root+2。已知chil
基于"堆"的底层实现和应用
weixin_34218579的博客
03-09 808
Precious time, which cannot be recovered once lost. 宝贵的时间，一旦失去就无法挽回。重复造"轮子"是大忌，但是不造"轮子"，最起码得了解"轮子"的内部结构。堆是一种特殊的树（完全二叉树）。本地主要分享了堆的实现原理，基于堆的排序以及堆的几个应用。所有源码均已上传至github：链接准备堆的定义：必须是一个完全二叉树堆中每一个节点的值都必须大于等于...
数据结构与算法——堆的原理和实现
m0_62179366的博客
05-20 2149
目录 一、堆的原理 二、堆的实现 1.堆的定义 2.堆的初始化 3.向上调整算法 4.向上调整算法代码实现 5.堆的插入 6.向下调整算法 6.堆的删除 7.堆的大小 8.判断堆是否为空 总结 一、堆的原理 堆（英语：Heap）是计算机科学中的一种特别的完全二叉树。若是满足以下特性，即可称为堆：“给定堆中任意节点P和C，若P是C的母节点，那么P的值会小于等于（或大于等于）C的值”。若母节点的值恒小于等于子节点的值，此堆称为最小堆（min heap）；反之，若母节点的..
栈和堆的底层区别
weixin_46433786的博客
04-11 605
栈和堆栈和堆栈堆 栈和堆 程序运行时，它的数据必须存储在内存中。一个数据项需要多大的内存、存储在什么地方、以及如何存储都因爱与该数据项的类型。 运行中的程序使用两个内存区域来进行存储数据：栈和堆。 栈 栈是一个内存数组，是一个LIFO（Last-In Fist-Out，后进先出）的数据结构。栈存储几种类型的数据： 某些类型变量的值； 程序当前的执行环境； 传递给方法的参数； 系统管理所有的栈操...
Java栈与堆 ————底层原理
Deep Learning and NLP Farm
11-19 2002
Java栈与堆 ----对这两个概念的不明好久，终于找到一篇好文，拿来共享 1. 栈(stack)与堆(heap)都是Java用来在Ram中存放数据的地方。与C++不同，Java自动管理栈和堆，程序员不能直接地设置栈或堆。 2. 栈的优势是，存取速度比堆要快，仅次于直接位于CPU中的寄存器。但缺点是，存在栈中的数据大小与生存期必须是确定的，缺乏灵活性。另外，栈数据可以共享，
数据结构算法--树详解
jy18817386398的博客
03-22 581
二叉树：有序树；每个节点最多有2个子节点，子节点有左右之分。二叉树第i层有2^(i - 1)个节点。假如二叉树深度为K，则二叉树最多有2^(K - 1)个节点。
数据结构-堆-详解
2401_86587256的博客
09-09 1515
数据结构初阶部分，堆的详解
数据结构--二叉树--详解
热门推荐
weixin_45796387的博客
03-20 12万+
本章目录1. 树概念及结构1.1树概念1.2树的表示2. 二叉树概念及结构3. 二叉树顺序结构及概念4. 二叉树链式结构及实现 1. 树概念及结构 1.1树概念 树是一种非线性的数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合。把它叫做树是因 为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。 有一个特殊的结点，称为根结点，根节点没有前驱结点。 除根节点外，其余结点被分成是一棵结构与树类似的子树。每棵子树的根结点有且只有一个前驱，可以有0个或多个后继。 因此，树是递归定义的
数据结构C语言排序方法-堆排序详解！.pdf
01-15
【数据结构】C语言排序方法——堆排序详解 堆排序是一种基于比较的排序算法，它利用了二叉堆这一数据结构的特点。堆是一种特殊的树形数据结构，形状近似完全二叉树，同时满足堆积性质：在最大堆中，每个父节点的值...
数据结构之堆详解
09-04
掌握堆的概念和操作对于理解和实现高级算法至关重要，比如在图的最小生成树算法Prim和Dijkstra中，以及在解决实时系统中的调度问题时，堆都是关键的数据结构。 总结来说，堆是数据结构中的重要组成部分，其灵活的...
SCAU数据结构-STL详解-20210609.pptx
06-25
《SCAU数据结构——STL详解》 STL（Standard Template Library，标准模板库）是C++编程语言中不可或缺的一部分，它提供了丰富的数据结构和算法，极大地提升了开发效率。SCAU（华南农业大学）在此主题中深入讲解了...
数据结构-严蔚敏-堆排序算法详解
"这篇资源主要讨论的是数据结构中的堆排序算法，引用了严蔚敏、吴伟民编著的《数据结构(C语言版)》教材，并提到了其他相关参考文献，包括数据结构与算法的学习资料。堆排序是一种基于比较的排序算法，通过构建和调整...
数据结构-堆排序算法详解
在河南大学的计算机与信息工程学院，数据结构课程可能包括线性表、栈、队列、串、数组、广义表、树和二叉树、图、动态存储管理、查找、内部排序、外部排序和文件等内容。通过学习这些内容，学生可以提升解决问题的...
数据结构------堆(二、堆的实现)
tonyzxy的博客
07-12 1万+
一、堆的定义   我们知道堆是一个树形结构，其实堆的底层是一棵完全二叉树。而完全二叉树是一层一层按照进入的顺序排成的。按照这个特性，我们可以用数组来按照完全二叉树实现堆。    上面的图片就是一个完全二叉树，也是一个最大堆。而最大堆有一个性质：每一个节点的值都小于它父节点的值。我们也可以从上面的图片中看出来。但是需要注意的是，每一个节点的值的大小与它所处的深度没有必然的联系。因为我们可以看到第三层...
通用型函数——冒泡排序
2401_84654619的博客
10-29 389
计算机中，任何数据最终都是二进制数，故只需有足够的空间，就可以将任何数据存储起来，相应的，读取时使用数据类型容器识别就可还原原本的意思。memcpy函数用于将指定数量的字节从源内存地址（src）复制到目标内存地址（dest）。n : 要复制的字节数，类型为size_t表示要复制的字节的数量。代码：（char型）
栈和队列（数据结构）
etamaos的博客
10-28 324
1.创建新队列（结点；
数据结构和算法-动态规划(3)-经典问题
qq_36115196的博客
10-30 818
动态规划(Dynamic Programming): 计算并存储小问题的解， 并将这些解组合成大问题的解。
java-数据结构
2301_80708315的博客
10-30 979
如果使用 left < right 作为条件，那么在最后一次迭代中，当 left 和 right 相邻时（即 left = right - 1），循环就会提前终止，从而可能错过目标元素（如果它正好位于 left 或 right 指向的位置）。left ==right 意味着它们指向的元素也会参与比较，left < right 只意味着middle指向的元素参与比较。l为总循环次数，当元素在最右边与最左边时的循环次数不一致。eg 当我的数组为{1，23，45，77，123}时我查找12时就会返回。
【数据结构篇】探索堆的算法的巧妙
最新发布
braveact的博客
11-02 538
⽤剩余的N-K个元素依次与堆顶元素来⽐较，不满⾜则替换堆顶元素 ，然后再将交换进去后的元素向下调整（保证这k个元素始终是堆），最后将剩余N-k个元素依次与堆顶元素⽐完之后，堆中剩余的K个元素就是所求的前k个最⼩或者最⼤的元素。对于Top-K问题，能想到的最简单直接的⽅式就是排序，但是：如果数据量⾮常⼤，排序就不太可取了 (可能数据都不能⼀下⼦全部加载到内存中)。依次将堆顶最大的数据与最后一个（不断发生变化）元素交换，每次都是将最大的数据放最后，可以想象一下，就是升序了。前k个最⼩的元素，则建⼤堆。
评论 8
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值