目录
一、前言
📽：前几篇博文中我们重点讲了堆和二叉树的一些基础知识，我们知道对于堆来说其物理结构是数组，而其逻辑结构二叉树。这也就意味着对于二叉树来说我们可以用数组进行实现，那既然可以用数组实现，为何又要引出链式二叉树这一概念呢？
🎬：下面我们来看一幅图：
🙋🏻♂️我们可以看到：对于储存相同的数据，如果使用数组结构创建二叉树，对于非完全二叉树来说，存在大量的空间浪费。而对于完全二叉树来说空间利用率为100%，所以对于普通的二叉树我们采用链式结构存储。
📽：以前我们学习顺序表、链表、堆、栈时我们学的都是它们的增删查改操作，而对于链式二叉树来说增删查改意义不大，如果仅仅只是为了存储数据，我们完全可以使用线性表。我们学习链式二叉树主要是为了更好的控制它的结构，为后续学习更复杂的搜索二叉树打基础，同时也有很多的二叉树OJ题出在普通二叉树上面。
在学习二叉树的基本操作前，需先要创建一棵二叉树，然后才能学习其相关的基本操作。由于现在我们对二叉树结构掌握还不够深入，为了降低大家学习成本，此处手动快速创建一棵简单的二叉树，快速进入二叉树操作学习，等二叉树结构了解的差不多时，我们反过头再来研究二叉树真正的创建方式。✈接下来我们将手动创建下图二叉树✈
✍🏻代码如下：
//创建链式二叉树结构 typedef int BTDataType; typedef struct BinaryTreeNode { struct BinaryTreeNode* left; //存储左孩子结点 struct BinaryTreeNode* right; //存储右孩子结点 int data; //存储结点数据 }BTNode; //创建结点 BTNode* BuyBTNode(BTDataType x) { BTNode* node = (BTNode*)malloc(sizeof(BTNode)); if (node == NULL) { printf("malloc fail\n"); exit(-1); } node->data = x; node->left = node->right = NULL; return node; } //构建树 BTNode* CreatBinaryTree() { //创建6个结点 BTNode* node1 = BuyBTNode(1); BTNode* node2 = BuyBTNode(2); BTNode* node3 = BuyBTNode(3); BTNode* node4 = BuyBTNode(4); BTNode* node5 = BuyBTNode(5); BTNode* node6 = BuyBTNode(6); //链接起来构建树 node1->left = node2; node1->right = node4; node2->left = node3; node4->left = node5; node4->right = node6; //返回根结点 return node1; } int main() { BTNode* tree = CreatBinaryTree(); return 0; }
二、二叉树的遍历
中序遍历
📝遍历顺序：左子树->根结点->右子树
🤔思路：
因为中序遍历的顺序是：左子树->根结点->右子树。所以当我们要访问数据为1的结点时我们要先访问其左子树的根也就是数据为2的结点，而当我们要访问数据为2的结点时我们首先要访问其左子树的根也就是数据为3的结点，当我们要访问数据为3的结点我们首先要访问的是3的左子树也就是空，此时递归回溯，就可以访问到3，然后再访问3的右子树NULL，继续回溯以此类推.........
🎨画图演示：
✍🏻代码演示：
//中序遍历 void InOrder(BTNode* root) { if (root == NULL) { printf("NULL "); //这里打印空指针纯粹是为了更好理解，可加可不加 return; } InOrder(root->left); printf("%d ", root->data); InOrder(root->right); }🎨递归演示：
🖱效果如下：
前序遍历
📝遍历顺序：根结点->左子树->右子树
🤔思路：
和中序遍历思路一样，只不过遍历顺序发生改变，这里不再过多赘述。
🎨画图演示：
✍🏻代码演示：
//前序遍历 void PrevOrder(BTNode* root) { if (root == NULL) { printf("NULL "); return; } printf("%d ", root->data); PrevOrder(root->left); PrevOrder(root->right); }🎨递归演示：
🖱效果如下：
后续遍历
📝遍历顺序：左子树->右子树->根结点
🤔思路：
参考中序遍历思路，这里不再多赘述。
🎨画图演示：
✍🏻代码演示：
//后序遍历 void PosOrder(BTNode* root) { if (root == NULL) { printf("NULL "); return; } PosOrder(root->left); PosOrder(root->right); printf("%d ", root->data); }🎨递归演示：
🖱效果如下：
层序遍历
📝遍历顺序：一层一层按照顺序遍历
🤔思路：层序遍历和前面的几种遍历方式有所不同，前面几种遍历方式基本都是通过递归来完成，而层序遍历是通过队列来实现。
首先我们将结点1的地址存入队列，队列此时不为空。出队头数据，然后将出的队头结点的左右孩子2和4结点地址存入队列。队列此时不为空，出2，入孩子3，队列仍不为空，再出4，入孩子5和6，然后继续出继续入，直到出到队列为空。总结如下：
1.先把根入队列，借助队列性质：先进先出
2.上一层的结点出队列的时候带下一层结点入队列
🎨画图演示：
✍🏻代码演示：
//层序遍历 void LevelOrder(BTNode* root) { Queue q; QueueInit(&q); if (root) { QueuePush(&q, root); //入根结点 } while (!QueueEmpty(&q)) { BTNode* front = QueueFront(&q); //取队头 QueuePop(&q); //出队头 printf("%d ", front->data); //打印队头数据 if (front->left) { QueuePush(&q, front->left); //front左孩子不为空就入队列 } if (front->right) { QueuePush(&q, front->right); //front右孩子不为空就入队列 } } printf("\n"); QueueDestory(&q); }🖱效果如下：
三、二叉树的重要接口
📄：关于二叉树的大部分问题我们基本上都需要用到分治的思想，也就是把一个大的问题分成若干个规模小的子问题，再将子问题分成规模更小的子问题，一直将子问题分割，直到子问题不能再进行分割，最后得到结果。
结点个数
🤔思路：
我们有多种方法可以求树的结点的个数，各种方法的本质也离不开分治与递归，接下来我们将由劣到优循序渐进进行讲解。
。法一：直接遍历
在前面我们已经学过了二叉树的前中后遍历，现在我们要求树的结点的个数，那我们直接定义一个变量count来替换打印，然后随便采用一种遍历方式，最后变量得到的就是结点的个数。但这样真的行得通吗？？我们来看看如下代码：
//结点个数 void BTreeSize(BTNode* root) { int count = 0; if (root == NULL) return; count++; BTreeSize(root->left); BTreeSize(root->right); }对于上述代码根本求不出结点的个数。
我们遍历树用的是递归，每调用一次函数就会在栈帧里面开辟一块空间，而每个栈帧里面都有一个局部变量count，我们希望的是把所有的count加在一起，但递归回溯时因为count为局部变量，所以递归完count就会销毁，无法保留数值，同形参的改变不影响实参一样。
法二：定义局部静态变量
在法一中我们定义的是局部变量count，因为每递归一次就要开辟栈帧，栈帧里面创建局部变量count，递归结束栈帧空间被回收，count销毁。那我们把count放入静态区不就解决问题了吗？？这样真的可行吗？我们看如下代码、
//结点个数 int BTreeSize(BTNode* root) { static int count = 0; if (root == NULL) return count; count++; BTreeSize(root->left); BTreeSize(root->right); } int main() { BTNode* tree = CreatBinaryTree(); printf("%d\n", BTreeSize(tree)); return 0; }
打印出6了，符合预期数值，但这样真的算成功了吗？下面我们来多次调用一下：
//结点个数 int BTreeSize(BTNode* root) { static int count = 0; if (root == NULL) return count; count++; BTreeSize(root->left); BTreeSize(root->right); } int main() { BTNode* tree = CreatBinaryTree(); printf("%d\n", BTreeSize(tree)); printf("%d\n", BTreeSize(tree)); printf("%d\n", BTreeSize(tree)); return 0; }
我们可以看到多次调用以后size的数据并不准确。这是因为我们将count定义在静态区，当我们第二次调用函数的时候count不会初始化为0，而是会保留上次调用的最终结果。静态变量的特点就是生命周期在全局，但只能初始化一次，所以此种方法不可行。
法三：定义全局变量
既然法二的静态局部变量不行，那就直接定义一个全局变量，全局变量也存放在静态区，所不同的是全局变量可以重复初始化为0。
//结点个数 int count = 0; void BTreeSize(BTNode* root) { if (root == NULL) return; count++; BTreeSize(root->left); BTreeSize(root->right); } int main() { BTNode* tree = CreatBinaryTree(); BTreeSize(tree); printf("size:%d\n",count); count = 0; BTreeSize(tree); printf("size:%d\n",count); count = 0; BTreeSize(tree); printf("size:%d\n", count); return 0; }
我们可以看到用全局变量可以解决问题，只要我们在调用前将count初始化为0。但其实用全局变量也会存在一些线程安全的问题，这个等到我们学到linux再来讨论，接下来我们用一种更优的方法。
法四：存储计数变量地址
我们可以将计数变量的地址传到函数里面，通过计数变量地址从而改变计数数据。
//结点个数 void BTreeSize(BTNode* root,int*pCount) { if (root == NULL) return; (*pCount)++; BTreeSize(root->left,pCount); BTreeSize(root->right,pCount); } int main() { BTNode* tree = CreatBinaryTree(); int count = 0; BTreeSize(tree,&count); printf("size:%d\n",count); return 0; }
法五：新思路
按照分治思想，如果root为空返回0，不为空就递归左子树＋右子树+1。
//结点个数 int BTreeSize(BTNode* root) { return root == NULL ? 0 : BTreeSize(root->left) + BTreeSize(root->right) + 1; } int main() { BTNode* tree = CreatBinaryTree(); printf("%d\n", BTreeSize(tree)); return 0; }
叶结点个数
🤔思路：
所谓叶结点也就是左子树和右子树都为空的结点。如果结点为空结点直接返回0，如果结点的左子树和右子树均为空则为叶结点，此时返回1，其他情况则分治递归。
✍🏻代码演示
//叶结点个数 int BTreeLeafSize(BTNode* root) { if (root == NULL) return 0; //空结点返回0 if (root->left == NULL && root->right == NULL) return 1; //左子树和右子树都为空的结点为叶结点，返回1 return BTreeLeafSize(root->left) + BTreeLeafSize(root->right); //继续分治递归 }🎨递归演示：
🖱效果如下：
符合预期。
第K层结点个数
🤔思路：
空树返回0。非空且k==1，返回1。非空且k>1,则转换为左子树k-1层结点个数+右子树k-1层结点个数。假设k=3
✍🏻代码演示
//第k层结点个数 int BTreeKLevelSize(BTNode* root, int k) { assert(k >= 1); if (root == NULL) return 0; if (k == 1) return 1; return BTreeKLevelSize(root->left, k - 1) + BTreeKLevelSize(root->right, k - 1); }🎨递归演示：
🖱效果如下：
符合预期。
二叉树的深度
🤔思路：
依旧采用分治的思想，同时要比较左子树和右子树的高度，因为要考虑自身也算一层，所以返回左子树和右子树较高的高度＋1
✍🏻代码演示
//求树的高度 int BTreeDepth(BTNode* root) { if (root == NULL) return 0; int leftDepth = BTreeDepth(root->left); //左子树高度 int rightDepth = BTreeDepth(root->right); //右子树高度 return leftDepth > rightDepth ? leftDepth + 1 : rightDepth + 1; }🎨递归演示：
🖱效果如下：
和预期相同。
二叉树查找值为X的结点
🤔思路：
1.先判断根结点，是就返回此结点
2.去左子树查找有无此结点，如果有，返回此结点位置
3.去右子树查找有无此结点，如果有，返回此结点位置
4.若左右子树都找不到此节点，直接返回空
✍🏻代码演示
//二叉树查找值为x的结点 BTNode* BTreeFind(BTNode* root, BTDataType x) { //如果根结点为空，直接返回空 if (root == NULL) return NULL; //如果找到结点，直接返回结点地址 if (root->data == x) return root; //若没找到，去左子树找 BTNode* ret1 = BTreeFind(root->left, x); if (ret1) return ret1; //此时左子树没找到，去右子树找 BTNode* ret2 = BTreeFind(root->right, x); if (ret2) return ret2; //若左子树和右子树都没找到，直接返回空 return NULL; }🖱效果如下：
判断二叉树是否是完全二叉树
对于完全二叉树我想大家都不陌生。完全二叉树的前K-1层是满的，最后一层是连续的。
上图中我们知道图二和图三是完全二叉树，图一不是，那么它们之间的差距是什么呢？我们又如何能够根据它们之间的差距判断其是否为完全二叉树？
🤔思路：
判断其是否为完全二叉树我们肯定需要遍历二叉树，这里我们采用层序遍历的方法，因为对于完全二叉树来说，在其层序遍历的时候是不会出现间隔的NULL。例如图一当我们层序遍历到第三层的时候结果为3->NULL->5->NULL->6,而对于图二和图三来说就不会出现此类问题。利用这一区别我们可以在层序遍历的基础上稍加做出改变：当队列中pop头结点后，无论头结点的左右孩子是否为空我们都将其push进队列，而其停止的条件就是当我们pop出来的头结点为NULL时，停止push，然后开始pop队列直至队列为空，如果我们pop出来的结点都为空则为完全二叉树，反之则不是。
🎨画图演示：
✍🏻代码演示：
//判断一颗二叉树是否为完全二叉树 bool BTreeComplete(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) { QueueDestory(&q); return false; } } QueueDestory(&q); return true; }
二叉树的销毁
🤔思路：
二叉树的销毁和链表的销毁思路一样，都是需要遍历其本身。但二叉树有四种遍历方式，哪一种才是最优解呢？倘若我们用前序遍历，那我们刚开始就把二叉树的根销毁了，这样就入法找到其左右孩子结点，所以我们采用后续遍历思想。
✍🏻代码演示：
//二叉树的销毁 void BTreeDestory(BTNode* root) { if (root) return; BTreeDestory(root->left); BTreeDestory(root->right); free(root); root = NULL; }
四、总代码
#include "Queue.h"
//创建链式二叉树结构
typedef int BTDataType;
typedef struct BinaryTreeNode
{
struct BinaryTreeNode* left; //存储左孩子结点
struct BinaryTreeNode* right; //存储右孩子结点
int data; //存储结点数据
}BTNode;
//创建结点
BTNode* BuyBTNode(BTDataType x)
{
BTNode* node = (BTNode*)malloc(sizeof(BTNode));
if (node == NULL)
{
printf("malloc fail\n");
exit(-1);
}
node->data = x;
node->left = node->right = NULL;
return node;
}
//构建树
BTNode* CreatBinaryTree()
{
//创建6个结点
BTNode* node1 = BuyBTNode(1);
BTNode* node2 = BuyBTNode(2);
BTNode* node3 = BuyBTNode(3);
BTNode* node4 = BuyBTNode(4);
BTNode* node5 = BuyBTNode(5);
BTNode* node6 = BuyBTNode(6);
BTNode* node7 = BuyBTNode(7);
//链接起来构建树
node1->left = node2;
node1->right = node4;
node2->left = node3;
node2->right = node7;
node4->left = node5;
node4->right = node6;
//返回根结点
return node1;
}
//中序遍历
void InOrder(BTNode* root)
{
if (root == NULL)
{
printf("NULL "); //这里打印空指针纯粹是为了更好理解，可加可不加
return;
}
InOrder(root->left);
printf("%d ", root->data);
InOrder(root->right);
}
//前序遍历
void PrevOrder(BTNode* root)
{
if (root == NULL)
{
printf("NULL ");
return;
}
printf("%d ", root->data);
PrevOrder(root->left);
PrevOrder(root->right);
}
//后序遍历
void PosOrder(BTNode* root)
{
if (root == NULL)
{
printf("NULL ");
return;
}
PosOrder(root->left);
PosOrder(root->right);
printf("%d ", root->data);
}
//层序遍历
void LevelOrder(BTNode* root)
{
Queue q;
QueueInit(&q);
if (root)
{
QueuePush(&q, root); //入根结点
}
while (!QueueEmpty(&q))
{
BTNode* front = QueueFront(&q); //取队头
QueuePop(&q); //出队头
printf("%d ", front->data); //打印队头数据
if (front->left)
{
QueuePush(&q, front->left); //front左孩子不为空就入队列
}
if (front->right)
{
QueuePush(&q, front->right); //front右孩子不为空就入队列
}
}
printf("\n");
QueueDestory(&q);
}
//结点个数
int BTreeSize(BTNode* root)
{
return root == NULL ? 0 : BTreeSize(root->left) + BTreeSize(root->right) + 1;
}
//叶结点个数
int BTreeLeafSize(BTNode* root)
{
if (root == NULL)
return 0; //空结点返回0
if (root->left == NULL && root->right == NULL)
return 1; //左子树和右子树都为空的结点为叶结点，返回1
return BTreeLeafSize(root->left) + BTreeLeafSize(root->right); //继续分治递归
}
//第k层结点个数
int BTreeKLevelSize(BTNode* root, int k)
{
assert(k >= 1);
if (root == NULL)
return 0;
if (k == 1)
return 1;
return BTreeKLevelSize(root->left, k - 1) + BTreeKLevelSize(root->right, k - 1);
}
//求树的高度
int BTreeDepth(BTNode* root)
{
if (root == NULL)
return 0;
int leftDepth = BTreeDepth(root->left); //左子树高度
int rightDepth = BTreeDepth(root->right); //右子树高度
return leftDepth > rightDepth ? leftDepth + 1 : rightDepth + 1;
}
//二叉树查找值为x的结点
BTNode* BTreeFind(BTNode* root, BTDataType x)
{
//如果根结点为空，直接返回空
if (root == NULL)
return NULL;
//如果找到结点，直接返回结点地址
if (root->data == x)
return root;
//若没找到，去左子树找
BTNode* ret1 = BTreeFind(root->left, x);
if (ret1)
return ret1;
//此时左子树没找到，去右子树找
BTNode* ret2 = BTreeFind(root->right, x);
if (ret2)
return ret2;
//若左子树和右子树都没找到，直接返回空
return NULL;
}
//判断一颗二叉树是否为完全二叉树
bool BTreeComplete(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)
{
QueueDestory(&q);
return false;
}
}
QueueDestory(&q);
return true;
}
//二叉树的销毁
void BTreeDestory(BTNode* root)
{
if (root)
return;
BTreeDestory(root->left);
BTreeDestory(root->right);
free(root);
root = NULL;
}
500
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
