数据结构--二叉树的顺序实现（堆实现）

于 2024-10-04 23:22:41 发布
阅读量527 收藏 18
点赞数 27
分类专栏： 数据结构 文章标签： 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2302_81410974/article/details/142707045
版权

引言

在计算机科学中，二叉树是一种重要的数据结构，广泛应用于各种算法和程序设计中。本文将探讨二叉树的顺序实现，特别是堆的实现方式。

一、树

1.1树的概念与结构

树是⼀种⾮线性的数据结构，它是由 n(n>=0)  个有限结点组成⼀个具有层次关系的集合。把它叫做
树是因为它看起来像⼀棵倒挂的树，也就是说它是根朝上，⽽叶朝下的。
• 有⼀个特殊的结点，称为根结点，根结点没有前驱结点。
• 除根结点外，其余结点被分成 M(M>0) 个互不相交的集合 T1、T2、……、Tm ，其中每⼀个集合 Ti(1 <= i <= m) ⼜是⼀棵结构与树类似的⼦树。每棵⼦树的根结点有且只有⼀个前驱，可以有 0 个或多个后继。因此，树是递归定义的。

树形结构中，⼦树之间不能有交集，否则就不是树形结构
⾮树形结构：

总结：

• ⼦树是不相交的（如果存在相交就是图了，图以后得课程会有讲解）
• 除了根结点外，每个结点有且仅有⼀个⽗结点
• ⼀棵N个结点的树有N-1条边

1.2树的基本术语 

  • ⽗结点/双亲结点：若⼀个结点含有⼦结点，则这个结点称为其⼦结点的⽗结点； 如上图：A是B的⽗结点

  • ⼦结点/孩⼦结点：⼀个结点含有的⼦树的根结点称为该结点的⼦结点； 如上图：B是A的孩⼦结点

  • 结点的度：⼀个结点有⼏个孩⼦，他的度就是多少；⽐如A的度为6，F的度为2，K的度为0

  • 树的度：⼀棵树中，最⼤的结点的度称为树的度； 如上图：树的度为 6

  • 叶⼦结点/终端结点：度为 0 的结点称为叶结点； 如上图： B、C、H、I... 等结点为叶结点

  • 分⽀结点/⾮终端结点：度不为 0 的结点； 如上图： D、E、F、G... 等结点为分⽀结点

  • 兄弟结点：具有相同⽗结点的结点互称为兄弟结点(亲兄弟)； 如上图： B、C 是兄弟结点

  • 结点的层次：从根开始定义起，根为第 1 层，根的⼦结点为第 2 层，以此类推；

  • 树的⾼度或深度：树中结点的最⼤层次； 如上图：树的⾼度为 4

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

  • 路径：⼀条从树中任意节点出发，沿⽗节点-⼦节点连接，达到任意节点的序列；⽐如A到Q的路径为： A-E-J-Q；H到Q的路径H-D-A-E-J-Q

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

  • 森林：由 m(m>0)棵互不相交的树的集合称为森林；

1.3树的表示法

孩⼦兄弟表⽰法：
树结构相对线性表就⽐较复杂了，要存储表⽰起来就⽐较⿇烦了，既然保存值域，也要保存结点和结点之间的关系，实际中树有很多种表⽰⽅式如：双亲表⽰法，孩⼦表⽰法、孩⼦双亲表⽰法以及孩⼦兄弟表⽰法等。我们这⾥就简单的了解其中最常⽤的孩⼦兄弟表⽰法 
struct TreeNode
 {
	 struct Node* child; 	// 最左边的孩子结点
	 struct Node* brother; 	// 指向其右边的下一个兄弟结点
	 int data; 				// 结点中的数据域
};

1.4树形结构实际运⽤场景

⽂件系统是计算机存储和管理⽂件的⼀种⽅式，它利⽤树形结构来组织和管理⽂件和⽂件夹。在⽂件系统中，树结构被⼴泛应⽤，它通过⽗结点和⼦结点之间的关系来表⽰不同层级的⽂件和⽂件夹之间的关联。

二、二叉树 

2.1二叉树的概念与结构

二叉树（binary tree） 是一种非线性数据结构，代表“祖先”与“后代”之间的派生关系，体现了“一分为二” 的分治逻辑。与链表类似，二叉树的基本单元是节点，每个节点包含值、左子节点引用和右子节点引用。

总结：
1. ⼆叉树不存在度⼤于 2 的结点
2. ⼆叉树的⼦树有左右之分，次序不能颠倒，因此⼆叉树是有序树
注意：对于任意的⼆叉树都是由以下⼏种情况复合⽽成的

2.2二叉树的基本术语

  • 根节点（root node） ：位于二叉树顶层的节点，没有父节点。
  • 叶节点（leaf node）：没有子节点的节点，其两个指针均指向 None 。
  • 节点所在的 层（level） ：从顶至底递增，根节点所在层为 1 。
  • 节点的度（degree） ：节点的子节点的数量。在二叉树中，度的取值范围是 0、1、2 。
  • 二叉树的高度（height） ：从根节点到最远叶节点所经过的边的数量。
  • 节点的深度（depth） ：从根节点到该节点所经过的边的数量。
  • 节点的高度（height） ：从距离该节点最远的叶节点到该节点所经过的边的数量。

 2.3特殊二叉树

1.完美二叉树(满二叉树)

完美二叉树(perfect binary tree) 所有层的节点都被完全填满。在完美二叉树中，叶节点的度
为 0 ，其余所有节点的度都为 2 ；若树的高度为 ℎ ，则节点总数为 2 ℎ+1 − 1 ，呈现标准的指数级关系，反映了自然界中常见的细胞分裂现象。

2. 完全二叉树
完全二叉树(complete binary tree) 只有最底层的节点未被填满，且最底层节点尽量靠左填充。

2.4二叉树的存储结构

⼆叉树⼀般可以使⽤两种结构存储，⼀种顺序结构，⼀种链式结构。

2.4.1顺序结构

顺序结构存储就是使⽤数组来存储，⼀般使⽤数组只适合表⽰完全⼆叉树 ，因为不是完全⼆叉树会有空间的浪费，完全⼆叉树更适合使⽤顺序结构存储。

2.3.2 链式结构

⼆叉树的链式存储结构是指，⽤链表来表⽰⼀棵⼆叉树，即⽤链来指⽰元素的逻辑关系。 通常的⽅法是链表中每个结点由三个域组成，数据域和左右指针域，左右指针分别⽤来给出该结点左孩⼦和右孩⼦所在的链结点的存储地址 。链式结构⼜分为 ⼆叉链 和 三叉链 。（红⿊树等会⽤到三叉链。）

三、实现顺序结构二叉树 

⼀般堆使⽤顺序结构的数组来存储数据，堆是⼀种特殊的⼆叉树，具有⼆叉树的特性的同时，还具备其他的特性。

3.1堆的概念与结构

堆是一种完全二叉树，具有以下性质：

  • 最大堆：每个节点的值都大于或等于其子节点的值。

  • 最小堆：每个节点的值都小于或等于其子节点的值。

堆常用于实现优先队列，因为它能有效地支持插入和删除操作。

总结
• 堆中某个结点的值总是不⼤于或不⼩于其⽗结点的值；
• 堆总是⼀棵完全⼆叉树。

3.2堆的实现

我们以小堆为例进行实现：

3.2.1存储结构

二叉树的顺序存储通常使用数组来实现。对于一个节点在数组中的索引 i，可以通过以下方式找到其父节点和子节点的索引：

  • 父节点：(i - 1) / 2（取整）
  • 左子节点：2 * i + 1
  • 右子节点：2 * i + 2
typedef struct Heap
{
	DataType *arr;
	int size;
	int capacity;
}HP;

这里可以看到堆的底层结构和动态顺序表一样。

3.2.2相关操作

1.初始化

//初始化
void HPInit(HP* p)
{
	assert(p);
	p->arr = NULL;
	p->size = p->capacity = 0;
}

2.销毁 

//销毁
void HPDestory(HP* p)
{
	assert(p);
	if (p->arr)
	{
		free(p->arr);
	}
	p->arr = NULL;
	p->size = p->capacity = 0;
}
Swap(int* x, int* y)
{
	int tmp = *x;
	*x = *y;
	*y = tmp;
}

3.向上调整

💡 向上调整算法
• 先将元素插⼊到堆的末尾,即最后⼀个孩⼦之后
• 插⼊之后如果堆的性质遭到破坏，将新插⼊结点顺着其双双亲往上调整到合适位置即可 

//堆的向上调整
void AdjustUp(DataType* arr, int child)
{
	int parent = (child - 1) / 2;//父节点
	while(child>0)//注意child可能会被调整到根节点，这时候就不能再调整了
	{
		if (arr[child] < arr[parent])//如果条件语句不成立，就说明堆已经成型
		{
			Swap(&arr[child], &arr[parent]);
			child = parent;
			parent = (child - 1) / 2;//循环以上步骤
		}
		else
		{
			break;
		}
	}
}

4.堆的插⼊

将新数据插⼊到数组的尾上，再进⾏向上调整算法，直到满⾜堆。

//插入
void HPPush(HP* p, DataType x)
{
	assert(p);
	if (p->size == p->capacity)//判断空间是否足够
	{
		//扩容
		int NewCap = p->capacity == 0 ? 4 : 2 * p->capacity;
		DataType* tmp = (DataType*)realloc(p->arr, NewCap * sizeof(DataType));
		if (tmp == NULL) 
		{
			perror("realloc fail!");
			exit(1);
		}
		p->arr = tmp;
		p->capacity = NewCap;
	} 
	p->arr[p->size] = x;
	AdjustUp(p->arr, p->size);
	++p->size;
}

5.向下调整法

💡 向下调整算法
• 将堆顶元素与堆中最后⼀个元素进⾏交换
• 删除堆中最后⼀个元素
• 将堆顶元素向下调整到满⾜堆特性为⽌
向下调整算法有⼀个前提：左右⼦树必须是⼀个堆，才能调整。 

//堆的向下调整
void AdjustDwon(DataType* arr, int parent, int n)
{
	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;
		}
	}
}

 6.堆的删除

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

//删除,出堆顶数据
void HPPop(HP* p)
{
	assert(p && p->size);
	Swap(&p->arr[0], &p->arr[p->size - 1]);
	--p->size;
	AdjustDwon(p->arr, 0, p->size);
}

7.判空

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

8.返回堆顶元素

//返回堆顶元素
DataType HPTop(HP* p)
{
	assert(p && p->size);
	return p->arr[0];
}

四、完整代码

Heap.h

#pragma once
#include<stdio.h>
#include<assert.h>
#include<stdlib.h>
#include<stdbool.h>
//定义堆的结构--数组
typedef int DataType;
typedef struct Heap//小堆为例
{
	DataType *arr;
	int size;
	int capacity;
}HP;
//初始化
void HPInit(HP* p);
//销毁
void HPDestory(HP* p);
//插入
void HPPush(HP* p,DataType x);
//删除，出堆顶数据
void HPPop(HP* p);
//判空
bool HPEmpty(HP* p);
//返回堆顶元素
DataType HPTop(HP* p);

Heap.c

#define _CRT_SECURE_NO_WARNINGS
#include"Heap.h"
//初始化
void HPInit(HP* p)
{
	assert(p);
	p->arr = NULL;
	p->size = p->capacity = 0;
}
//销毁
void HPDestory(HP* p)
{
	assert(p);
	if (p->arr)
	{
		free(p->arr);
	}
	p->arr = NULL;
	p->size = p->capacity = 0;
}
Swap(int* x, int* y)
{
	int tmp = *x;
	*x = *y;
	*y = tmp;
}
//堆的向上调整
void AdjustUp(DataType* arr, int child)
{
	int parent = (child - 1) / 2;//父节点
	while(child>0)//注意child可能会被调整到根节点，这时候就不能再调整了
	{
		if (arr[child] < arr[parent])//如果条件语句不成立，就说明堆已经成型
		{
			Swap(&arr[child], &arr[parent]);
			child = parent;
			parent = (child - 1) / 2;//循环以上步骤
		}
		else
		{
			break;
		}
	}
}
//插入
void HPPush(HP* p, DataType x)
{
	assert(p);
	if (p->size == p->capacity)//判断空间是否足够
	{
		//扩容
		int NewCap = p->capacity == 0 ? 4 : 2 * p->capacity;
		DataType* tmp = (DataType*)realloc(p->arr, NewCap * sizeof(DataType));
		if (tmp == NULL) 
		{
			perror("realloc fail!");
			exit(1);
		}
		p->arr = tmp;
		p->capacity = NewCap;
	} 
	p->arr[p->size] = x;
	AdjustUp(p->arr, p->size);
	++p->size;
}
//堆的向下调整
void AdjustDwon(DataType* arr, int parent, int n)
{
	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 HPPop(HP* p)
{
	assert(p && p->size);
	Swap(&p->arr[0], &p->arr[p->size - 1]);
	--p->size;
	AdjustDwon(p->arr, 0, p->size);
}
//判空
bool HPEmpty(HP* p)
{
	assert(p);
	return p->size == 0;
}
//返回堆顶元素
DataType HPTop(HP* p)
{
	assert(p && p->size);
	return p->arr[0];
}

main.c

#define _CRT_SECURE_NO_WARNINGS
#include"Heap.h"
void test01()
{
	HP hp;
	HPInit(&hp);
	int arr[] = { 17,20,10,13,19,15 };
	for (int i = 0; i < 6; i++)
	{
		HPPush(&hp, arr[i]);
  	}
	//HPPop(&hp);
	while (!HPEmpty(&hp))
	{
		printf("%d-", HPTop(&hp));
		HPPop(&hp);
	}
	HPDestory(&hp);
}
int main()
{
	test01();
	return 0;
}

五、总结

通过顺序实现的方式，我们可以高效地存储和操作二叉树。堆作为一种特殊的二叉树，提供了快速的插入和删除操作，非常适合优先队列的实现。在许多应用场景中，如任务调度、图算法等，堆结构都发挥着重要作用。

希望本文能够帮助你理解二叉树的顺序实现及堆的基本操作。继续探索数据结构的世界，会发现更多有趣的应用和挑战！

平凡程序猿~
关注
专栏目录
C++数据结构---二叉树
Rookie_Ws的博客
04-22 3393
树 树的概念 树是一种能分层存储数据的数据结构，树中的每个元素被称为树的节点，每个节点有若干个指针指向子节点 从节点的角度来看，树是由唯一的起始结点引出的节点集合，这个起始结点被称为根(root)， 树中节点的子树数目称为节点的度 树的度指其中节点的度最大值。比如1号节点的孩子是2、3、4，则1号节点的度数是3，且1号节点的度是最大的，故该树的度为3。 二叉树 二叉树是指对于树中的每个节点而言，最多由两个子节点，即任意节点的度小于等于2 层数：从根节点到某个节点的路径长度，根节点为0层 高度：最大层数+
数据结构--清华严蔚敏版 --二叉树的遍历--案例实现
05-22
二叉树是计算机科学中一种重要的数据结构，它在很多算法和问题解决中都有广泛应用，尤其是在数据存储和检索领域。二叉树的概念源自于它的基本结构：每个节点最多有两个子节点，通常分为左子节点和右子节点。这种特殊...
数据结构-顺序存储二叉树
weixin_73869209的博客
10-06 2505
大家好,今天给大家讲一下顺序存储二叉树顺序存储二叉树是一种将二叉树的节点按照从上到下、从左到右的顺序存储在数组中的方法。具体来说，顺序存储二叉树将二叉树的根节点存储在数组的第一个位置，然后按照从上到下、从左到右的顺序将二叉树的其他节点依次存储在数组中。对于任意一个节点的索引为i（i从1开始),其左子节点的索引为2i右子节点的索引为2i+1。这样，通过数组的索引关系，可以方便地找到节点的父节点、左子节点和右子节点。顺序存储二叉树的优点是可以使用数组的随机访问特性快速找到节点，不需要通过指针进行遍历。
数据结构 - JS实现二叉树
ngd-b的博客
05-30 3284
二叉树的定义、特定； 二叉树的前序遍历、中序遍历、后序遍历、层序遍历； 二叉树的设计与实现；
数据结构 Java数据结构 --- 二叉树
wwzzzzzzzzzzzzz的博客
12-11 5164
二叉树 1. 树形结构 1.1 概念 树是一种非线性的数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合。把它叫做树是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。它具有以下的特点： 有一个特殊的节点，称为根节点，根节点没有前驱节点 除根节点外，其余节点被分成M(M > 0)个互不相交的集合T1、T2、…Tm，其中每一个集合 Ti (1 <= i<= m) 又是一棵与树类似的子树。每棵子树的根节点有且只有一个前驱，可以有0个或多个后继 树是递归定义的。
数据结构---二叉树的顺序结构及实现
MEANSWER的博客
01-13 2207
反反复复
数据结构--二叉树--详解
热门推荐
weixin_45796387的博客
03-20 12万+
本章目录1. 树概念及结构1.1树概念1.2树的表示2. 二叉树概念及结构3. 二叉树顺序结构及概念4. 二叉树链式结构及实现 1. 树概念及结构 1.1树概念 树是一种非线性的数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合。把它叫做树是因 为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。 有一个特殊的结点，称为根结点，根节点没有前驱结点。 除根节点外，其余结点被分成是一棵结构与树类似的子树。每棵子树的根结点有且只有一个前驱，可以有0个或多个后继。 因此，树是递归定义的
数据结构 - 二叉树的遍历
了解➔熟悉➔掌握➔精通
02-18 6万+
分享一个大牛的人工智能教程。零基础！通俗易懂！风趣幽默！希望你也加入到人工智能的队伍中来！请点击http://www.captainbed.net 二叉树的遍历 N：访问根结点，L：遍历根结点的左子树，R：遍历根结点的右子树。 给定一棵二叉树的前序遍历序列和中序遍历序列可以惟一确定一棵二叉树。 二叉树的深度优先遍历的非递归的通用做法是采用栈，广度优先遍历的非递归的通用做法是采用队列。 ...
＜数据结构----二叉树的顺序结构(C语言版)＞
一些普普通通的学习笔记
05-07 1266
数据结构----二叉树的顺序结构（堆）
《数据结构修炼手册》----二叉树的顺序结构及实现
m0_57304511的博客
04-18 1463
《数据结构修炼手册》----二叉树的顺序结构及实现
【数据结构初阶】二叉树--堆(顺序结构实现)
稻草人
09-01 1882
新插入的数据作为子结点（child），找到新插入数据的父结点（parent=（child-1）/ 2）（上面二叉树的性质），父结点和子结点进行比较，若父结点大于子结点，数据交换，不大于则不交换。如果有一个关键码的集合K={k1，k2,，k3，...，k（n-1）}，把它的所有元素按完全二叉树的顺序存储方式存储，在一个一维数组中，并满足：Ki = K(2*i+1) 且 Ki >= K(2*i+2)），i = 0，1，2...，则称为小堆（或大堆）。大堆：父结点不小于孩子结点。
数据结构-二叉树基础.pdf
04-15
- 完全二叉树可以高效地用数组表示，方便实现堆等数据结构。 #### 六、应用场景与面试重点 - **应用领域**：二叉树在计算机科学中有广泛的应用，如文件系统、编译器、数据库索引等。 - **面试重点**：由于二叉树...
数据结构实验报告-二叉树的实现与遍历.pdf
08-15
"数据结构实验报告-二叉树的实现与遍历" 一、实验内容 在本实验中，我们将使用二叉树链表作为存储结构，实现二叉树的建立、遍历和各种操作。二叉树是一种常用的数据结构，它可以用来存储和查询大量数据。我们的...
数据结构实验报告6-树-二叉树的遍历算法-实验内容及要求.docx
07-06
为了实现上述目标，需要设计一种适合存储二叉树的数据结构。通常情况下，二叉树可以通过链式存储结构来表示，即每个节点包含两个指针域（左子树和右子树）和一个数据域。本实验中，节点的数据域选择字符类型，这意味...
数据结构_2.2、顺序表插入删除查找
cfy2401926342的博客
09-29 376
线性表：是具有相同数据类型的n （n≥0）个数据元素的有限序列顺序表：用顺序存储的方式实现线性表顺序存储：把逻辑上相邻的元素存储在物理 位置上也相邻的存储单元中，元素之间的关 系由存储单元的邻接关系来体现。ElemType ：就是你的顺序表中存放的数据元素类型。
数据结构（栈和队列的实现）
2301_80475151的博客
09-30 1088
这里介绍了栈的实现和队列的实现，还有栈和队列的OJ题例如用栈实现队列和用队列实现栈等‘；
【笔记】选择题笔记+数据结构笔记
最新发布
m0_52024881的博客
09-30 587
连通分量是极大连通子图一个连通图的生成树是一个极小连通子图。
数据结构（链表的操作算法）
m0_61903191的博客
09-30 445
编写一个程序exp2_2.cpp,采用单链表表示集合(假设同一个集合中不存在重复素)，将其按递增方式排序，构成有序单链表，并求这样的两个集合的并、交和差。(2)依次采用尾插法插入a、b、c、d、e元素。(8)在第4个元素位置上插人1元素。(10)删除单链表h的第3个元素。(6)输出单链表h的第3个元素。(5)判断单链表h是否为空。(4)输出单链表h长度。(7)输出元素a的位置。(1)初始化单链表h。(11)输出单链表h。(12)释放单链表h。(3)输出单链表h。(9)输出单链表h。
【数据结构】栈和队列
2401_84538476的博客
09-28 408
栈和队列是两种重要的线性结构。本章讨论栈和队列的定义、表示方法。这里栈和队列分别用数组实现和链表实现（这里所说是实现的底层逻辑分别是数组结构和链表结构）
评论 9
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值