二叉树详解（C语言实现，带你彻底弄懂二叉树！）

亲爱的沈同学

已于 2023-05-02 23:11:13 修改

阅读量982

点赞数 9

分类专栏：数据结构文章标签： c语言数据结构链表

于 2023-05-02 19:31:22 首次发布

本文链接：https://blog.csdn.net/m0_68621863/article/details/130417158

版权

数据结构专栏收录该内容

1 篇文章 0 订阅

订阅专栏

1.引言

二叉树作为最经典的数据结构之一，在整个算法板块中起到承上启下的作用，不仅是数组和链表的延伸，还是图的基础。学习本节二叉树知识前，你需要详细的了解什么是递归？递归的终止条件等等相关知识。因为二叉树的实现和各种功能都少不了递归的“身影”，相信大家看完这篇文章后，对递归的理解能够更深刻，并且能掌握二叉树的知识！最后码字不易，点个关注再走呗~

2.树概念及结构

2.1 树的概念

树是一种非线性的数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合。把它叫做树是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。

有一个特殊的结点，称为根结点，根节点没有前驱结点。
除根节点外，其余结点被分成M(M>0)个互不相交的集合T1、T2、……、Tm，其中每一个集合Ti(1<= i <= m)又是一棵结构与树类似的子树。每棵子树的根结点有且只有一个前驱，可以有0个或多个后继。
因此，树是递归定义的。

注意在这里插入图片描述 注意：树形结构中，子树之间不能有交集，否则就不是树形结构。

2.2 树的相关概念

在这里插入图片描述

节点的度：一个节点含有的子树的个数称为该节点的度；如上图：A的为6
叶节点或终端节点：度为0的节点称为叶节点；如上图：B、C、H、I…等节点为叶节点
非终端节点或分支节点：度不为0的节点；如上图：D、E、F、G…等节点为分支节点
双亲节点或父节点：若一个节点含有子节点，则这个节点称为其子节点的父节点；如上图：A是B的父节点
孩子节点或子节点：一个节点含有的子树的根节点称为该节点的子节点；如上图：B是A的孩子节点
兄弟节点：具有相同父节点的节点互称为兄弟节点；如上图：B、C是兄弟节点
树的度：一棵树中，最大的节点的度称为树的度；如上图：树的度为6
节点的层次：从根开始定义起，根为第1层，根的子节点为第2层，以此类推；
树的高度或深度：树中节点的最大层次；如上图：树的高度为4
堂兄弟节点：双亲在同一层的节点互为堂兄弟；如上图：H、I互为兄弟节点
节点的祖先：从根到该节点所经分支上的所有节点；如上图：A是所有节点的祖先
子孙：以某节点为根的子树中任一节点都称为该节点的子孙。如上图：所有节点都是A的子孙
森林：由m（m>0）棵互不相交的树的集合称为森林；

2.3 树的表示

树结构相对线性表就比较复杂了，要存储表示起来就比较麻烦了，既然保存值域，也要保存结点和结点之间的关系，实际中树有很多种表示方式如：双亲表示法，孩子表示法、孩子双亲表示法以及孩子兄弟表示法等。我们这里就简单的了解其中最常用的孩子兄弟表示法。

typedef int DataType;
struct Node
{
 struct Node* _firstChild1; // 第一个孩子结点
 struct Node* _pNextBrother; // 指向其下一个兄弟结点
 DataType _data; // 结点中的数据域
};

在这里插入图片描述

2.4 树在实际中的运用（表示文件系统的目录结构）

在这里插入图片描述

3.二叉树概念及结构

一棵二叉树是结点的一个有限集合，该集合:

或者为空
由一个根节点加上两棵别称为左子树和右子树的二叉树组成

从上图可以看出：

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

注意：对于任意的二叉树都是由以下几种情况复合而成的：
在这里插入

3.2 特殊的二叉树

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

3.3 二叉树的性质

若规定根节点的层数为1，则一棵非空二叉树的第i层上最多有 $2^{i-1}$ 个结点。
若规定根节点的层数为1，则深度为h的二叉树的最大结点数是。
对任何一棵二叉树, 如果度为0其叶结点个数为n0，度为2的分支结点个数为n2，则有n0 ＝ n2＋1
若规定根节点的层数为1，具有n个结点的满二叉树的深度，h= $log_{2}(n+1)$
对于具有n个结点的完全二叉树，如果按照从上至下从左至右的数组顺序对所有节点从0开始编号，则对于序号为i的结点有：
1. 若i>0，i位置节点的双亲序号：(i-1)/2；i=0，i为根节点编号，无双亲节点
2. 若2i+1<n，左孩子序号：2i+1，2i+1>=n否则无左孩子
3. 若2i+2<n，右孩子序号：2i+2，2i+2>=n否则无右孩子

3.4 二叉树的链式存储结构

二叉树的链式存储结构是指，用链表来表示一棵二叉树，即用链来指示元素的逻辑关系 .。通常的方法是链表中每个结点由三个域组成，数据域和左右指针域，左右指针分别用来给出该结点左孩子和右孩子所在的链结点的存储地址。链式结构又分为二叉链和三叉链，当前我们学习中一般都是二叉链，后面学到高阶数据结构如红黑树等会用到三叉链。
在这里插入图片描述

用C语言代码表示：

在这里插入图片描述

4. 二叉树链式结构的实现

4.1 前置说明

在学习二叉树的基本操作前，需先要创建一棵二叉树，然后才能学习其相关的基本操作。由于现在大家对二叉树结构掌握还不够深入，为了降低大家学习成本，此处手动快速创建一棵简单的二叉树，快速进入二叉树操作学习，等二叉树结构了解的差不多时，我们反过头再来研究二叉树真正的创建方式。
说明：后面的代码BTDataType都是int型数据类型。

typedef int BTDataType;//typedef用来重命名，将int型数据类型重命名为BTDataType
typedef struct BinaryTreeNode
{
 BTDataType _data;
 struct BinaryTreeNode* left;
 struct BinaryTreeNode* right;
}BTNode;//这里重命名是为了接下来写代码方便

//创建节点的函数
BTNode* BuyBTNode(BTDataType x)
{
	BTNode* newnode = (BTNode*)malloc(sizeof(BTNode));
	if (newnode == NULL)//这里是为了判空，若malloc失败，则直接退出
	{
		perror("malloc failed");//perror输出错误信息
		exit(-1);
	}
	newnode->left = newnode->right = NULL;
	newnode->data = x;
	return newnode;
}

BTNode* CreatBinaryTree()
{
 BTNode* node1 = BuyNode(1);
 BTNode* node2 = BuyNode(2);
 BTNode* node3 = BuyNode(3);
 BTNode* node4 = BuyNode(4);
 BTNode* node5 = BuyNode(5);
 BTNode* node6 = BuyNode(6);
 
 node1->_left = node2;
 node1->_right = node4;
 node2->_left = node3;
 node4->_left = node5;
 node4->_right = node6;
 return node1;
}

注意：上述代码并不是创建二叉树的方式，真正创建二叉树方式后序详解重点讲解。

再看二叉树基本操作前，再回顾下二叉树的概念，二叉树是：

空树
非空：根节点，根节点的左子树、根节点的右子树组成的。

下面是根据代码创建的二叉树：
在这里插入图片描述
从概念中可以看出，二叉树定义是递归式的，因此后序基本操作中基本都是按照该概念实现的。

4.2 二叉树的遍历

4.2.1 前序、中序以及后序遍历

学习二叉树结构，最简单的方式就是遍历。所谓二叉树遍历(Traversal)是按照某种特定的规则，依次对二叉树中的节点进行相应的操作，并且每个节点只操作一次。访问结点所做的操作依赖于具体的应用问题。遍历是二叉树上最重要的运算之一，也是二叉树上进行其它运算的基础。
在这里插入图片描述
按照规则，二叉树的遍历有：前序/中序/后序的递归结构遍历：

前序遍历(Preorder Traversal 亦称先序遍历)——访问根结点的操作发生在遍历其左右子树之前。
中序遍历(Inorder Traversal)——访问根结点的操作发生在遍历其左右子树之中（间）。
后序遍历(Postorder Traversal)——访问根结点的操作发生在遍历其左右子树之后。

由于被访问的结点必是某子树的根，所以N(Node）、L(Left subtree）和R(Rightsubtree）又可解释为根、根的左子树和根的右子树。NLR、LNR和LRN分别又称为先根遍历、中根遍历和后根遍历。

//先序遍历
void PrevOrder(BTNode* root)
{
	if (root == NULL)//递归终止条件，若遍历到空，则返回
	{
		printf("NULL");
		return;
	}
	printf("%d", root->data);//先序遍历，先输出根节点的值
	PrevOrder(root->left);//递归进入左子树
	PrevOrder(root->right);//递归进入右子树
}
//中序遍历
void InOrder(BTNode* root)
{
	if (root == NULL)
	{
		printf("NULL");
		return;
	}
	InOrder(root->left);
	printf("%d", root->data);
	InOrder(root->right);
}
//后序遍历
void PostOrder(BTNode* root)
{
	if (root == NULL)
	{
		printf("NULL");
		return;
	}
	PostOrder(root->left);
	PostOrder(root->right);
	printf("%d", root->data);
}

从代码分析不难看出，先序遍历、中序遍历和后序遍历，只是输出当前节点值的顺序不同。递归未达到终止条件就会一直递归进入左子树和右子树，直至遍历完所有节点。
下面主要分析前序递归遍历，中序与后序图解类似。
前序遍历递归图解：
在这里插入图片描述

前序遍历结果：1 2 3 4 5 6
中序遍历结果：3 2 1 5 4 6
后序遍历结果：3 2 5 6 4 1

4.2.2 层序遍历

层序遍历：除了先序遍历、中序遍历、后序遍历外，还可以对二叉树进行层序遍历。设二叉树的根节点所在层数为1，层序遍历就是从所在二叉树的根节点出发，首先访问第一层的树根节点，然后从左到右访问第2层上的节点，接着是第三层的节点，以此类推，自上而下，自左至右逐层访问树的结点的过程就是层序遍历。
在这里插入图片描述
注意：了解层序遍历前需要知道队列的知识
思路：首先建立一个空的队列（队列是链式结构实现)，将这每层的节点插入队列，接着再从队列中取出队头数据，再删除队头数据（保证下次取出的节点是其兄弟节点），再将队头节点的左、右孩子节点（如果不为空）插入队列。以此往复直至最后队列为空时，输出结束。
按照上述图解可知进入队列的顺序应当是（如下图）
在这里插入图片描述
注意：队列时刻在更新，当取出队头节点后就会将该节点从队列删去，更新队头节点，并且将该节点的左、右孩子节点（如果左、右孩子不为NULl）加入队尾。

void LevelOrder(BTNode* root)//层序遍历按行输出
{
	Queen q;//创建队列
	QueenInit(&q);//队列初始化
	int levelsize = 0;//用来统计每层的节点个数
	if (root)//根节点不为空
	{
		QueenPush(&q, root);//进入队列
		levelsize = 1;//第一层的节点个数为1
	}
	while (!QueenEmpty(&q))//循环条件：队列是否为空
	{
		while (levelsize--)//层节点
		{
			BTNode* front = QueenFront(&q);//取出队头数据
			printf("%d ", front->data);//输出队头数据
			QueenPop(&q);//因为已经取出数据，删除队头数据，队头数据更新
			if (front->left)//左孩子不为空，进入队列
			{
				QueenPush(&q, front->left);
			}
			if (front->right)//右孩子不为空，进入队列
			{
				QueenPush(&q, front->right);
			}
		}
		printf("\n");//换行输出
		levelsize = QueenSize(&q);//计算队列中的节点数量
	}
	QueenDestroy(&q);//销毁队列
}

4.3 节点个数以及高度等

前言：在解决二叉树的相关问题时，大家要学会借用递归的思想去思考问题，即将一个大的事件分解为一个个小的事件去解决，在小的事情里分解为更小的事情去解决，以此类推最终就可以解决大的问题。

4.3.1 计算树节点个数

思路：计算树节点个数，就是计算节点+节点的左子树节点个数+节点的右子树节点个数，然后进入子树后，加上当前节点，再进入它的子树去计算节点个数，以此类推就可以计算出树的所有节点个数。

//计算树节点个数
int TreeSize(BTNode* root)
{
	if (root == NULL)//如果遇到NULL，则直接返回0
		return 0;
	return 1 + TreeSize(root->left) + TreeSize(root->right);
};

4.3.2 计算叶子节点个数

思路：先判断当前节点的左、右孩子节点是否为空，若为空，则是叶子节点，叶子节点个数加一，若不是，则进入其左、右子树接着寻找叶子节点，最后将左、右子树的所有叶子节点加起来就可得到该树的叶子节点个数。

//计算叶子节点个数

int TreeLeafSize(BTNode* root)
{
	if(root == NULL)
		return 0;
	//若左子树为空，右子树也为空，则为叶子节点，返回1
	//若不是，则进入它的左、右孩子节点寻找叶子节点
	return (root->left == NULL && root->right == NULL) ? 1 :
		TreeLeafSize(root->left) + TreeLeafSize(root->right);//三目运算符
}

4.3.3 计算树的高度

思路：计算树的高度就是计算当前节点的左、右子树最高的那颗树的高度再加一（因为加上当前节点，高度要加一），以此从根节点往下递归，返回树的高度。

//计算树的高度
int TreeHeight(BTNode* root)
{
	if (root == NULL)//到NULL节点，此时的高度就是0，返回0
		return 0;
	int leftHeight = TreeHeight(root->left);//计算左子树的高度
	int rightHeight = TreeHeight(root->right);//计算右子树的高度
	return leftHeight > rightHeight ? leftHeight + 1 : rightHeight + 1;//判断左右子树哪个高，左子树高则左子树的高度+1，相反则右子树的高度+1
}

4.3.4 计算第k层的节点个数（k>=1)

思路：在二叉树中，我们只知道根节点的个数是1，所以我们每次递归进入树的下一层时，就将k-1，直至最后k == 1，我们就知道到达了第k层（此时可以将第k层的节点看成根节点），然后将第k层的所有节点加起来，就可以得到第k层的节点个数。
在这里插入图片描述

//求第k层的节点个数 k >= 1
int TreeKLevelSize(BTNode* root, int k)
{
	if (root == NULL)
		return 0;
	if (k == 1)
		return 1;
	return TreeKLevelSize(root->left, k - 1) + TreeKLevelSize(root->right, k - 1);
}

4.3.5 寻找树中值为x的节点

思路：在树中寻找值为x的节点，就是先从根节点开始寻找，然后再去从它的左子树、右子树中寻找。若寻找到则返回节点，若从该节点和其左、右子树都未找到，返回NULL。

BTNode* TreeFind(BTNode* root, BTDataType x)
{
	if (root == NULL)
		return NULL;

	if (root->data == x)
		return root;
	//代码运行到这里说明root不是空，且root的值不为x
	BTNode* leftroot = TreeFind(root->left, x);//去root的左子树找
	if (leftroot)//leftRet不是空说明找到了
		return leftroot;
		
	//代码运行到这里说明root不是空，且root的值不为x，且root的左子树中没有值为x的结点
	BTNode* rightroot = TreeFind(root->right, x);
	if (rightroot)
		return rightroot;
		
	//代码运行到这里说明root不是空，且root的值不为x，且root的左右子树中均没有值为x的结点
	//说明树中没有值为x的结点，返回空
	return NULL;
}

4.4 二叉树的创建和销毁

4.4.1 通过前序遍历的数组构建二叉树

这里我将介绍真正创建二叉树的方式，指定遍历顺序并给定数组，要求创建二叉树
函数参数说明：

char* a 指向字符数组的指针
int n 数组长度
int* pi 创建的索引指针（因为需要一个索引来遍历数组，但是每递归进入新函数，函数参数都会重新创建，所以创建索引指针保证索引可以一直往后迭代）

//通过前序遍历的数组"ABD##E#H##CF##G##"构建二叉树
BTNode* BinaryTreeCreate(char* a, int n, int* pi)
{
	if (*pi >= n)//如果索引>=数组的长度，直接返回
		return;
	if (a[*pi] == '#')//如果当前数组的数据是‘#’，则说明此时的节点是NULL，直接返回
	{
		(*pi)++;//索引往后迭代
		return NULL;
	}
	//因为通过前序遍历数组创建二叉树，所以先创建父节点，再创建它的左、右孩子节点
	BTNode* root = BuyBTNode(a[(*pi)++]);//根据当前索引的字符创建父节点，索引迭代
	root->left = BinaryTreeCreate(a, n, pi);//递归创建左孩子节点
	root->right = BinaryTreeCreate(a, n, pi);//递归创建右孩子节点
	return root;//返回创建的父节点
}

补充：这里是通过前序遍历创建的二叉树，大家也可以通过中序遍历、后序遍历的数组创建二叉树。下面是创建二叉树的OJ，有思路的朋友们可以练练手。
二叉树的构建及遍历：OJ链接

4.4.2 二叉树销毁

如同二叉树的遍历一样，二叉树的销毁同样使用递归进入子树销毁节点，不过二叉树的销毁使用的是后序遍历，要最后释放根节点，因为若先孩子节点释放父节点，则无法通过父节点找到其孩子节点，销毁也就无法进行。

void BinaryTreeDestory(BTNode* root)
{
	if (root == NULL)
		return;
	//后序遍历删除节点
	BinaryTreeDestory(root->left);
	BinaryTreeDestory(root->right);
	free(root);
}

4.4.3 判断完全二叉树

前面我们对完全二叉树做出了定义，对于深度为K的，有n个结点的二叉树，当且仅当其每一个结点都与深度为K的满二叉树中编号从1至n的结点一一对应时称之为完全二叉树。这里我们就可以结合之前讲解的层序遍历，我们用层序遍历二叉树，当遇到NULL节点时，后面这一层的所有节点都应该为NULL，若是，则为完全二叉树，若后面这一层有不是NULL的节点，则不是完全二叉树。
在这里插入图片描述

bool BinaryTreeComplete(BTNode* root)
{
	Queen q;//创建队列，为层序遍历做准备
	QueenInit(&q);//队列初始化
	if (root)//根节点不为空，插入队列
		QueenPush(&q, root);
	while (!QueenEmpty(&q))//队列不为空，则继续遍历
	{
		BTNode* front = QueenFront(&q);//取出队头节点
		QueenPop(&q);//释放队头节点
		if (front == NULL)//如果遇到NULL节点则退出循环，开始遍历后面这一层的节点，判断是否为完全二叉树
		{
			break;
		}
		else
		{
			//这里不需要判断左、右孩子节点是否为NULL，直接将左、右子节点插入队列
			QueenPush(&q,front->left);
			QueenPush(&q,front->right);
		}
	}
	while (!QueenEmpty(&q))//对列不为空，则继续遍历
	{
		//如果从NULL节点后遍历该层的节点有不是NULL的节点，则不是完全二叉树，返回false
		BTNode* front = QueenFront(&q);
		QueenPop(&q);
		if (front != NULL)
		{
			QueenDestroy(&q);//销毁队列
			return false;
		}
	}
	QueenDestroy(&q);
	return true;//后面该层都是NULL，返回true
}