数据结构---二叉树

心怀花木

已于 2024-09-15 12:45:55 修改

阅读量816

点赞数 18

文章标签：数据结构

于 2024-07-22 18:37:15 首次发布

本文链接：https://blog.youkuaiyun.com/weixin_74012727/article/details/140589305

版权

一、树的概念及结构

1、树的基本概念

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

树的特点:

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

注意：树形结构中，子树之间不能有交集，否则就不是树形结构。

2、树的相关概念

节点的度：一个节点含有的子树的个数称为该节点的度；如上图：A的为6。

叶节点或终端节点：度为0的节点称为叶节点；如上图：B、C、H、I...等节点为叶节点

非终端节点或分支节点：度不为0的节点；如上图：D、E、F、G...等节点为分支节点

双亲节点或父节点：若一个节点含有子节点，则这个节点称为其子节点的父节点；如上图：A是B的父节点

孩子节点或子节点：一个节点含有的子树的根节点称为该节点的子节点；如上图：B是A的孩子节点

兄弟节点：具有相同父节点的节点互称为兄弟节点；如上图：B、C是兄弟节点

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

树的度：一棵树中，最大的节点的度称为树的度；如上图：树的度为6

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

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

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

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

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

3、树的表示

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

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

这种方法非常巧妙地将关系串接在一起。

3、树在实际中的运用

用来表示文件系统的目录树结构。

二、二叉树的概念及结构

1、二叉树的概念

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

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

从上图可以看出：

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

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

现实版二叉树：

2、特殊的二叉树

1. 满二叉树：一个二叉树，如果每一个层的结点数都达到最大值，则这个二叉树就是满二叉树。也就是说，如果一个二叉树的层数为K，且结点总数是 $2^{K}-1$ ，则它就是满二叉树。

2.完全二叉树：完全二叉树是效率很高的数据结构，完全二叉树是由满二叉树而引出来的。对于深度为K的，有n个结点的二叉树，当且仅当其每一个结点都与深度为K的满二叉树中编号从1至n的结点一一对应时称之为完全二叉树。要注意的是满二叉树是一种特殊的完全二叉树。

3、二叉树的性质

若规定根节点的层数为1，则一棵非空二叉树的第i层上最多有 $2^{i-1}$ 个结点。(满二叉树对应最多情况)
若规定根节点的层数为1，则深度为h的二叉树的最大结点数是 $2^{h}-1$ 。（满二叉树对应最大情况）
对任何一棵二叉树, 如果度为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。3.若2i+2<n，则右孩子序号为：2i+2。(因为完全二叉树是以数组形式存储的，所以我们这样计算，当然它也可以用链表存储，不过那样太麻烦不推荐，下面还会讲到)

对于性质1、2、4解释如下：

对性质3的解释：

如果一个节点的度为2，那么它一定是由度为1的节点变化而来的度为1的节点必有度为0的节点，要想生成度为2的节点，度为1的节点必减少1个，生成度为2的节点时，必新生成1个度为0的节点，这时度为0的总数比度为2的多一个，接下来如果再生成一个度为2的节点，如果有度为1的节点，直接将它变为度为2的节点，这时度为2的节点增加一个，同时度为0的也增加一个，抵消，总数还是度为0的比度为2的多一个，否则就需要先生成一个度为1的节点，这需要减少一个度为0的，同时又加上一个度为0的，再执行画横线的。总之，度为0的始终比度为2的多一个。

至于性质3，大家记住结论即可。

对性质5的解释：

4、二叉树的存储结构

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

1、顺序存储

顺序结构存储就是使用数组来存储，一般使用数组只适合表示完全二叉树，因为不是完全二叉树会有空间的浪费。而现实中使用中只有堆才会使用数组来存储，关于堆我们上一篇已专门讲解，具体位置：数据结构---堆。二叉树顺序存储在物理上是一个数组，在逻辑上是一颗二叉树。

2、链式存储

二叉树的链式存储结构是指用链表来表示一棵二叉树，即用链来指示元素的逻辑关系。通常的方法是链表中每个结点由三个域组成，数据域和左右指针域，左右指针分别用来给出该结点左孩子和右孩子所在的链结点的存储地址。链式结构又分为二叉链和三叉链。

typedef int BTDataType;
// 二叉链
struct BinaryTreeNode
{
struct BinTreeNode* _pLeft; // 指向当前节点左孩子
 struct BinTreeNode* _pRight; // 指向当前节点右孩子
 BTDataType _data; // 当前节点值域
}
// 三叉链
struct BinaryTreeNode
{
 struct BinTreeNode* _pParent; // 指向当前节点的双亲
 struct BinTreeNode* _pLeft; // 指向当前节点左孩子
 struct BinTreeNode* _pRight; // 指向当前节点右孩子
 BTDataType _data; // 当前节点值域
}；

三、二叉树链式存储应用

在这里我们主要讲二叉树的前序，中序，后序遍历，以及求二叉树的结点个数，二叉树叶子节点个数，二叉树高度，二叉树第k层结点个数，二叉树查找值为x的结点，二叉树的销毁，二叉树层序遍历，判断二叉树是否是完全二叉树等，在本文中不讲如何生成二叉树，只是暴力地生成一个二叉树(详细请看代码)。

我们知道二叉树中度最多为2，在结构体中，我们只需有左右指针以及数据部分。

typedef int BTDataType;
typedef struct BinaryTreeNode
{
	BTDataType data;  //数据部分
	struct BinaryTreeNode* left;  //指向左孩子
	struct BinaryTreeNode* right; //指向右孩子
}BTNode;

在二叉树中，每个结点需要动态开辟出来，所有结点通过左右指针有联系的串联起来，就暴力地生成一个二叉树。

BTNode* BuyNode(BTDataType x)
{
	BTNode* tmp = (BTNode*)malloc(sizeof(BTNode));
	if (tmp == NULL)
	{
		perror("malloc fail");
		return NULL;
	}
	tmp->data = x;
	tmp->left = tmp->right = NULL;
	return tmp;
}

BTNode* CreateBinaryTree()
{
	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;
}

返回node1就是二叉树的根节点。

最后生成的逻辑图是：

接下来，就根据此二叉树求上述相关问题。

1、二叉树的三种遍历

所谓二叉树遍历(Traversal)是按照某种特定的规则，依次对二叉树中的结点进行相应的操作，并且每个结点只操作一次。访问结点所做的操作依赖于具体的应用问题。遍历是二叉树上最重要的运算之一，也是二叉树上进行其它运算的基础。

按照规则，二叉树的遍历有：前序/中序/后序的递归结构遍历：

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

这里，我们着重讲前序遍历，因为中序遍历和后序遍历和前序遍历相差不大，掌握前序遍历，其它两个也就会了。

前序遍历，我们先访问根节点，若根节点为空，则返回，否则就打印，接着访问左子树，将左子树看成一颗新的树，还是先访问根节点，若根节点为空，则返回，否则就打印，接着再访问新的树的左子树，依次进行，知道根结点为空，则返回，开始访问右子树，开始回归。这就实现了，根，左子树，右子树的访问顺序。

这里需要用到递归算法。

//前序遍历
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 LastOrder(BTNode* root)
{
	if (root == NULL)
	{
		printf("NULL ");
		return;
	}
	LastOrder(root->left);
	LastOrder(root->right);
	printf("%d ", root->data);
}

三种遍历生成的结果如下：

2、二叉树的结点个数

到这里，大家就会想，我来一个前序遍历就可以解决问题了，多么简单啊！随后直接给出代码：

int TreeSize(BTNode* root)
{
	int size = 0;
	if (root == NULL)
		return 0;
	else
		++size;

	TreeSize(root->left);
	TreeSize(root->right);

	return size;
}

这里会有一个致命的错误，每次递归调用时，size都会初始化0，显然是错误的。

那么改进方法来了：

int TreeSize(BTNode* root)
{
	static int size = 0;
	if (root == NULL)
		return 0;
	else
		++size;

	TreeSize(root->left);
	TreeSize(root->right);

	return size;
}

当我调用该函数是发现是我想要的结果：

那代码真的正确吗？当我多次调用时：

这不对呀，结点还能自动增加吗？太荒谬！

这是为什么呢？

因为静态的局部变量size，只初始化一次，当第二次调用此函数时，size不是从0开始的，而是从6开始的，多次调用会出现累加效应，导致返回错误。

那么改进方法是什么呢？

我们可以对参数“动手”。

void TreeSize(BTNode* root,int* psize)
{
	if (root == NULL)
		return 0;
	else
		++(*psize);

	TreeSize(root->left,psize);
	TreeSize(root->right,psize);
}

调用时：

	BTNode* root = CreateBinaryTree();
	int size = 0;
	TreeSize(root, &size);
	printf("TreeSize:%d\n", size);
	size = 0;
	TreeSize(root, &size);
	printf("TreeSize:%d\n", size);

这种方法虽然可行，但在调用时会不会有点麻烦？想到这里，那有没有更好的办法？

答案是有的！

我们可以把大问题拆解成小问题，求一个二叉树的结点个数，相当于求1+左子树结点个数+右子树结点个数，利用递归，左子树结点个数又可以分为1+左子树结点个数+右子树结点个数。不断递归，就求得整个二叉树的结点个数了。

//二叉树结点个数
int TreeSize(BTNode* root)
{
	if (root == NULL)
		return 0;
	
	return 1 + TreeSize(root->left) + TreeSize(root->right);
}

在这个调用树中，每个节点代表TreeSize函数的一次调用。从根节点开始，每次调用都会检查当前节点是否为NULL。如果不是，函数会返回1(代表当前结点)加上左右子树的大小。当到达叶子节点时，由于它们没有子节点，对应的TreeSize调用会返回1(因为只有一个节点)加上0(左右子树的大小).最终，整个树的大小由所有这些调用的返回值累加起来得到。在我们的例子中，树的大小将是6。大家如果没有看懂，可以自己在纸上画一下整个过程，就会更好的理解。

这样就解决了上述出现的种种问题。这种方法也是优解。

3、二叉树叶子结点个数

叶子结点的特征就是左右子树为空，我们就可以通过这点入手，利用递归来解决问题。

//二叉树叶子结点个数
int TreeLeafSize(BTNode* root)
{
	if (root == NULL)
		return 0;
	if (root->left == NULL && root->right == NULL)
		return 1;
	return TreeLeafSize(root->left) + TreeLeafSize(root->right);
}

4、二叉树的高度

根据分治思想，求二叉树高度可以转换为1+MAX(左子树高度，右子树高度)。

然后不断递归求解。

//二叉树的高度
int TreeHeight(BTNode* root)
{
	if (root == NULL)
		return 0;

	int LH = TreeHeight(root->left);
	int RH = TreeHeight(root->right);

	return LH > RH ? LH + 1 : RH + 1;
}

5、二叉树第k层结点个数

二叉树如果为空，结点数就为0，不为空时，k==1时结点数为1，我们求第k层结点个数，可以转换为第2层的k-1层，第三层的k-2层，以此类推，直到k==1(相对于第k层时)。

//二叉树第k层结点个数
int TreeLevelKSize(BTNode* root, int k)
{
	if (root == NULL)
		return 0;
	if (k == 1)
		return 1;
	return TreeLevelKSize(root->left, k - 1) + TreeLevelKSize(root->right, k - 1);
}

6、二叉树中值为x的结点

这也是利用递归，先从左数开始找，如果找到就返回，左数如果没找到，就到右树找，找到返回，如果左右树都没有找到，就返回NULL。

//二叉树查找值为x的结点
BTNode* TreeFind(BTNode* root, BTDataType x)
{
	if (root == NULL)
		return NULL;
	if (root->data == x)
	{
		return root;
	}

	BTNode* s1 = TreeFind(root->left, x);
	if (s1)
		return s1;
	BTNode* s2 = TreeFind(root->right, x);
	if (s2)
		return s2;

	return NULL;
}

7、二叉树层序遍历

二叉树层序遍历，就是一层一层按顺序将整棵树遍历完成。

这里我们借助队列实现，我们先将根结点入队列，出根结点时，将根节点的所有孩子入队列，接着再出，每出一个结点就将它的所有孩子入队列，直到队列中的元素全部出完为止。

由于我们这里用的C语言实现的，C语言中没有STL库，所以我们需要先写一个队列才行。

具体的操作这里不展示了(我们的重点不是如何生成队列)。大家主要掌握层序遍历的思想！

//二叉树层序遍历
void TreeLevelOrder(BTNode* root)
{
	Queue q; //定义队列q
	QueueInit(&q); //初始化队列q
	if (root)
		QueuePush(&q, root); //向队列中插入元素(队尾)
	while (!QueueEmpty(&q))  //判断队列是否为空，为空返回true，不为空返回false
	{
		BTNode* front = QueueFront(&q); //队列首元素
		QueuePop(&q);  //队列中移除元素(队头)

		printf("%d ", front->data);
		if (front->left)
			QueuePush(&q,front->left);
		if (front->right)
			QueuePush(&q,front->right);
	}

	QueueDestroy(&q); //摧毁队列
}

8、判断二叉树是否为完全二叉树

完全二叉树的特点：一棵深度为k的有n个结点的二叉树，对树中的结点按从上至下、从左到右的顺序进行编号，如果编号为i（1≤i≤n）的结点与满二叉树中编号为i的结点在二叉树中的位置相同，则这棵二叉树称为完全二叉树。

了解至此，我们同时可以借助队列来进行判断，进行层序遍历时，出队列时，如果为空，立即停止，看队列中是否有非空元素，若有，则一定不是完全二叉树，若没有，则是完全二叉树。

为什么这样判断呢？

我们先假设是完全二叉树，出到空时，队列中一定没有其他非空元素，这点时毋庸置疑的。

那有没有一种可能，非完全二叉树出到空时，队列中没有其他非空元素，这是不可能的！

所以我们在层序遍历的基础上作修改即可。

//判断二叉树是否是完全二叉树
bool TreeComplete(BTNode* root)
{
	Queue q;
	QueueInit(&q);
	if (root)
		QueuePush(&q, root);
	while (!QueueEmpty(&q))
	{
		BTNode* front = QueueFront(&q);
		QueuePop(&q);
		//遇到第一个空，就可以进行判断，如果队列中还有非空，就不是完全二叉树
		if (front == NULL)
		{
			break;
		}
		QueuePush(&q, front->left);
		QueuePush(&q, front->right);
	}
	while (!QueueEmpty(&q))
	{
		BTNode* front = QueueFront(&q);
		QueuePop(&q);

		//如果有非空，就不是完全二叉树
		if (front)
		{
			QueueDestroy(&q);
			return false;
		}
	}
	QueueDestroy(&q);
	return true;
}

9、二叉树的销毁

二叉树的销毁非常简单，我们在前序遍历的基础上作出修改即可实现。

//二叉树的销毁
void TreeDestroy(BTNode* root)
{
	if (root == NULL)
		return;
	TreeDestroy(root->left);
	TreeDestroy(root->right);
	free(root);
}

四、结语

以上就是本篇的全部内容啦！有不足的地方，大家多多提出批评！希望大家有所收获！