0. 前言
在前面的博客，我们初步学习了二叉树的概念和实现二叉树的顺序结构，最主要的是使用二叉树的顺序结构建堆，从而实现堆排序，这期博客中我们要学习的是二叉树的另一个结构——二叉树的链式结构，与顺序结构不同的是，顺序结构的底层是一个数组，链式结构是使用递归将多个结点链接起来组成的二叉树，讲到这里，递归还不是很熟悉的小伙伴需要回去复习C语言递归的知识才能更好的理解链式二叉树的实现，话不多说，我们进入正题！
1. 前置说明-创建一棵二叉树
在学习二叉树的基本操作前，需先要创建一棵二叉树，然后才能学习其相关的基本操作。由于现在大家对二叉树结构掌握还不够深入，我们可以手动创建一棵简单的二叉树，快速进入二叉树操作学习，等二叉树结构了解的差不多时，我们会过头再来研究二叉树真正的创建方式。
1.1 节点的定义
以链式结构实现二叉树，即使用类似链表的方式，将数据存放于一个节点中，该节点的指针域存放指向左孩子和右孩子节点的指针。节点的定义如下：
typedef int BTDataType;//定义二叉树节点
typedef struct BinaryTreeNode
{BTDataType data;//存放的数据struct BinaryTreeNode* leftchild;//指向左孩子的指针struct BinaryTreeNode* rightchild;//指向右孩子的指针
}BTNode;1.2 创建新节点
创建新节点的方式与链表相同。注意新节点的左孩子 右孩子指针都置为空指针：
//创建新节点
BTNode* BTBuyNode(BTDataType x)
{BTNode* newnode = (BTNode*)malloc(sizeof(BTNode));//申请一个节点的空间if (newnode == NULL)//内存申请失败，则直接退出程序{perror("malloc");exit(-1);}newnode->data = n;newnode->leftchild = newnode->rightchild = NULL;return newnode;
}1.3 手动创建二叉树
接下来，我们创建一些节点，然后将这些节点连接起来，形成一颗二叉树。
//手动创建二叉树
BTNode* CreateTree()
{//创建6个节点BTNode* n1 = BTBuyNode(1);BTNode* n2 = BTBuyNode(2);BTNode* n3 = BTBuyNode(3);BTNode* n4 = BTBuyNode(4);BTNode* n5 = BTBuyNode(5);BTNode* n6 = BTBuyNode(6);//连接节点n1->leftchild = n2;n1->rightchild = n3;n2->leftchild = n4;n2->rightchild = n5;n3->rightchild = n6;//返回根节点return n1;
}这样我们就手动构建了一个二叉树，它的逻辑结构如图所示：
注意：上述代码并不是创建二叉树的方式，真正创建二叉树方式后序会给大家详细讲解。
2. 链式二叉树的基本操作
在讲解二叉树基本操作前，再回顾下二叉树的概念，
二叉树有以下两种：
1. 空树
2. 非空：根结点，根结点的左子树、根结点的右子树组成的。
从概念中可以看出，二叉树定义是递归式的，因此后序基本操作中基本都是按照该概念实现的。
2. 二叉树相关操作函数功能的声明
关于二叉树我们要实现的函数声明如下：
//前序遍历
void PreOrder(BTNode* root);//中序遍历
void InOrder(BTNode* root);//后序遍历
void PostOrder(BTNode* root);//二叉树节点个数
int BTSize(BTNode* root);//叶子节点个数
int BTLeafSize(BTNode* root);//第K层节点个数
int BTLevelKSize(BTNode* root, int k);//二叉树高度
int BTDepth(BTNode* root);//查找
BTNode* BTFind(BTNode* root, BTDataType n);//判断是否为完全二叉树
bool BTComplete(BTNode* root);//销毁二叉树
void BTDestroy(BTNode** proot);3. 方法的实现
接下来，我们一一介绍并尝试实现这些函数功能。
3.1 前序遍历、中序遍历、后序遍历
前、中、后序遍历是二叉树最常见、最重要的遍历方式。这三种遍历方式都将二叉树分为三个部分：根节点、左子树、右子树。理解这三种遍历方式，会加深我们对函数递归的理解。接下来我们一一讲解。
3.1.1 遍历规则
1）前序遍历(Preorder Traversal 亦称先序遍历)：访问根结点的操作发⽣在遍历其左右⼦树之前
访问顺序为：根结点、左⼦树、右⼦树
2）中序遍历(Inorder Traversal)：访问根结点的操作发⽣在遍历其左右⼦树之中（间）
访问顺序为：左⼦树、根结点、右⼦树
3）后序遍历(Postorder Traversal)： 访问根结点的操作发⽣在遍历其左右⼦树之后
访问顺序为：左⼦树、右⼦树、根结点
当访问到每一棵子树时，这棵子树也可以再分为根节点、左子树、右子树，然后继续遵循这一套访问方式。不难发现，这是一个递归的过程。递归结束的条件是访问到空指针，意味着该节点的左子树或右子树不存在。
我们就拿刚才创建好的那个二叉树为例，分析一下对其前序遍历、中序遍历、后序遍历的结果：
前序遍历：
中序遍历：
后序遍历：
3.1.2 代码实现
//前序遍历
void PreOrder(BTNode* root)
{if (root == NULL)//访问到空指针就停止遍历{return;}printf("%d ", root->data);//打印根节点数据PreOrder(root->leftchild);//遍历左子树PreOrder(root->rightchild);//遍历右子树
}//中序遍历
void InOrder(BTNode* root)
{if (root == NULL)//访问到空指针就停止遍历{return;}InOrder(root->leftchild);//遍历左子树printf("%d ", root->data);//打印根节点数据InOrder(root->rightchild);//遍历右子树
}//后序遍历
void PostOrder(BTNode* root)
{if (root == NULL){return;}PostOrder(root->leftchild);//遍历左子树PostOrder(root->rightchild);//遍历右子树printf("%d ", root->data);//打印根节点数据
}我们来测试一下：
#include <stdio.h>
#include <stdlib.h>typedef int BTDataType;//定义二叉树节点
typedef struct BinaryTreeNode
{BTDataType data;//存放的数据struct BinaryTreeNode* leftchild;//指向左孩子的指针struct BinaryTreeNode* rightchild;//指向右孩子的指针
}BTNode;//创建新节点
BTNode* BTBuyNode(BTDataType x)
{BTNode* newnode = (BTNode*)malloc(sizeof(BTNode));//申请一个节点的空间if (newnode == NULL)//内存申请失败，则直接退出程序{perror("malloc");exit(-1);}newnode->data = x;newnode->leftchild = newnode->rightchild = NULL;return newnode;
}//手动创建二叉树
BTNode* CreateTree()
{//创建6个节点BTNode* n1 = BTBuyNode(1);BTNode* n2 = BTBuyNode(2);BTNode* n3 = BTBuyNode(3);BTNode* n4 = BTBuyNode(4);BTNode* n5 = BTBuyNode(5);BTNode* n6 = BTBuyNode(6);//连接节点n1->leftchild = n2;n1->rightchild = n3;n2->leftchild = n4;n2->rightchild = n5;n3->rightchild = n6;//返回根节点return n1;
}//前序遍历
void PreOrder(BTNode* root)
{if (root == NULL)//访问到空指针就停止遍历{printf("N ");return;}printf("%d ", root->data);//打印根节点数据PreOrder(root->leftchild);//遍历左子树PreOrder(root->rightchild);//遍历右子树}//中序遍历
void InOrder(BTNode* root)
{if (root == NULL)//访问到空指针就停止遍历{printf("N ");return;}InOrder(root->leftchild);//遍历左子树printf("%d ", root->data);//打印根节点数据InOrder(root->rightchild);//遍历右子树
}//后序遍历
void PostOrder(BTNode* root)
{if (root == NULL){printf("N ");return;}PostOrder(root->leftchild);//遍历左子树PostOrder(root->rightchild);//遍历右子树printf("%d ", root->data);//打印根节点数据}int main()
{BTNode* root = CreateTree();PreOrder(root);printf("\n");InOrder(root);printf("\n");PostOrder(root);printf("\n");return 0;
}
3.2 结点个数以及高度等
// ⼆叉树结点个数
int BinaryTreeSize(BTNode* root);
// ⼆叉树叶⼦结点个数
int BinaryTreeLeafSize(BTNode* root);
// ⼆叉树第k层结点个数
int BinaryTreeLevelKSize(BTNode* root, int k);
//⼆叉树的深度/⾼度
int BinaryTreeDepth(BTNode* root);
// ⼆叉树查找值为x的结点
BTNode* BinaryTreeFind(BTNode* root, BTDataType x);
// ⼆叉树销毁
void BinaryTreeDestory(BTNode** root);
3.2.1 二叉树节点个数
接下来，我们写一个函数统计二叉树节点个数。它的实现方法十分简单，当一个节点有效时，返回1，之后递归判断该节点的左右孩子是否有效......最后将这些“1”相加即可。
代码如下：
//二叉树节点个数
int BinaryTreeSize(BTNode* root)
{if (root == NULL)//访问到空指针，则结束{return 0;}return 1 + BinaryTreeSize(root->leftchild) + BinaryTreeSize(root->rightchild);
//节点有效，返回1，再与左右孩子的判断结果相加
}递归展开图：
测试：
//二叉树节点个数
int BinaryTreeSize(BTNode* root)
{if (root == NULL)//访问到空指针，则结束{return 0;}return 1 + BTSize(root->leftchild) + BTSize(root->rightchild);//节点有效，返回1，再与左右孩子的判断结果相加
}int main()
{//BTNode* root = CreateTree();//PreOrder(root);//printf("\n");//InOrder(root);//printf("\n");//PostOrder(root);//printf("\n");printf("BinaryTreeSize:%d\n", BinaryTreeSize(root));return 0;
}
3.2.2 叶子节点个数
在统计叶子节点时，需要注意：叶子节点是度为0的节点。所以我们在做节点判断时，要判断该节点的左右孩子是否为空。如果都为空，则它是一个叶子节点。实现代码如下：
//叶子节点个数
int BinaryTreeLeafSize(BTNode* root)
{if (root == NULL){return 0;}if (root->leftchild == NULL && root->rightchild == NULL)//满足叶子节点的条件，返回1{return 1;}return BinaryTreeLeafSize(root->leftchild) + BinaryTreeLeafSize(root->rightchild);
//将左子树和右子树统计结果相加
}递归示意图：
测试结果：
//叶子节点个数
int BinaryTreeLeafSize(BTNode* root)
{if (root == NULL){return 0;}if (root->leftchild == NULL && root->rightchild == NULL)//满足叶子节点的条件，返回1{return 1;}return BinaryTreeLeafSize(root->leftchild) + BinaryTreeLeafSize(root->rightchild);//将左子树和右子树统计结果相加
}int main()
{BTNode* root = CreateTree();//PreOrder(root);//printf("\n");//InOrder(root);//printf("\n");//PostOrder(root);//printf("\n");//printf("BinaryTreeSize:%d\n", BinaryTreeSize(root));printf("BinaryTreeLeafSize:%d\n", BinaryTreeLeafSize(root));return 0;
}
3.2.3 第K层节点个数
对于二叉树第k层节点的统计，在使用递归时，每次遍历下一层（左右孩子）并传入k-1这个值，当k值为1时，再做统计，就实现了统计第k层节点的功能。代码实现：
//第K层节点个数
int BinaryTreeLevelKSize(BTNode* root, int k)
{if (root == NULL)//访问到空，返回0{return 0;}if (k == 1)//k值为1，做统计{return 1;}return BinaryTreeLevelKSize(root->leftchild, k - 1) + BinaryTreeLevelKSize(root->rightchild, k - 1);//递归访问左右孩子（下一层）
}递归示意图：
测试代码与结果：
int main()
{BTNode* root = CreateTree();int k = 0;scanf("%d", &k);printf("第%d层节点个数为：%d\n", k, BinaryTreeLevelKSize(root, k));}
3.2.4 二叉树高度
二叉树的高度计算原理十分简单，和之前节点个数的统计相似，当访问了一个有效节点之后，说明层数至少为1。之后再去访问它的左子树和右子树是否有效...这里需要注意：有时候二叉树的左子树和右子树高度不相同，需要将最高的那棵子树计入到高度当中。
代码实现：
//二叉树高度
int BinaryTreeDepth(BTNode* root)
{if (root == NULL)//根节点为空则为0层{return 0;}int leftDepth = BinaryTreeDepth(root->leftchild);//统计左子树高度int rightDepth = BinaryTreeDepth(root->rightchild);//统计右子树高度return leftDepth > rightDepth ? leftDepth + 1 : rightDepth + 1;//统计左右子树最大高度，再与根节点层数相加
}递归示意图：
测试结果：
//二叉树高度
int BinaryTreeDepth(BTNode* root)
{if (root == NULL)//根节点为空则为0层{return 0;}int leftDepth = BinaryTreeDepth(root->leftchild);//统计左子树高度int rightDepth = BinaryTreeDepth(root->rightchild);//统计右子树高度return leftDepth > rightDepth ? leftDepth + 1 : rightDepth + 1;//统计左右子树最大高度，再与根节点层数相加
}int main()
{BTNode* root = CreateTree();printf("TreeHeight:%d\n", BinaryTreeDepth(root));return 0;
}
3.2.4 查找
查找的思路也比较简单，只需要遍历根节点、左子树、右子树，若找到相应的值，则将该节点返回即可。代码如下：
// ⼆叉树查找值为x的结点
BTNode* BinaryTreeFind(BTNode* root, BTDataType x);
{if (root == NULL)//访问到空则停止{return NULL;}if (root->data == x)//找到了，返回该节点{return root;}BTNode* leftFind = BinaryTreeFind(root->leftchild, x);//遍历左子树if (leftFind != NULL)//若查找结果不是空，则说明找到了，将该节点带回{return leftFind;}BTNode* rightFind = BinaryTreeFind(root->rightchild, x);//遍历右子树if (rightFind != NULL)//若查找结果不是空，则说明找到了，将该节点带回{return rightFind;}
}测试代码及结果：
// ⼆叉树查找值为x的结点
BTNode* BinaryTreeFind(BTNode* root, BTDataType x)
{if (root == NULL)//访问到空则停止{return NULL;}if (root->data == x)//找到了，返回该节点{return root;}BTNode* leftFind = BinaryTreeFind(root->leftchild, x);//遍历左子树if (leftFind != NULL)//若查找结果不是空，则说明找到了，将该节点带回{return leftFind;}BTNode* rightFind = BinaryTreeFind(root->rightchild, x);//遍历右子树if (rightFind != NULL)//若查找结果不是空，则说明找到了，将该节点带回{return rightFind;}
}
int main()
{BTNode* root = CreateTree();int x = 0;while (scanf("%d", &x) != EOF){if (BinaryTreeFind(root, x) != NULL){printf("找到了\n");}else{printf("找不到\n");}printf("\n");}
}
3.3 判断是否为完全二叉树
我们在进行层序遍历二叉树时，是按照从上到下，从左到右的顺序进行的。由于完全二叉树最后一层的节点需要从左到右依次排列，我们就可以对这棵二叉树进行层序遍历。
如果遍历结果当中有两个节点之间有空指针，就说明这两个节点不是从左到右依次排列的，这棵二叉树也就不是完全二叉树了；反之，如果节点之间没有空指针，则说明它就是一棵完全二叉树。这里需要注意：由于要判断空指针的存在，遍历时就需要将空指针也存入队列。
我们针对创建好的二叉树，画个图演示一下执行流程：
代码实现：
// 判断二叉树是否是完全二叉树
bool BinaryTreeComplete(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->leftchild);QueuePush(&q, front->rightchild);}while (!QueueEmpty(&q)){BTNode* front = QueueFront(&q);QueuePop(&q);// 如果有非空，就不是完全二叉树if (front){QueueDestroy(&q);return false;}}QueueDestroy(&q);return true;
}
测试代码与结果：
int main()
{BTNode* root = CreateTree();if (BinaryTreeComplete(root)){printf("是完全二叉树\n");}else{printf("不是完全二叉树\n");}
}
3.4 销毁二叉树
完成了这么多的工作之后，我们就要销毁这棵二叉树了。销毁二叉树的过程与后序遍历相似，先将左右子树销毁，然后销毁根节点。由于这里会改变根节点的值，所以需要传入二级指针。
代码如下：
//销毁二叉树
void BinaryTreeDestroy(BTNode** proot)
{if (*proot == NULL)//访问到空指针则回退{return;}BTDestroy(&((*proot)->leftchild));//销毁左子树（leftchild是一级指针，函数接收二级指针所以要取地址）BTDestroy(&((*proot)->rightchild));//销毁右子树（rightchild是一级指针，函数接收二级指针所以要取地址）free(*(proot));//销毁根节点*proot = NULL;
}4. 程序完整代码
之前写过的队列实现代码：
Queue.h
#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>
#include<assert.h>
#include<stdbool.h>typedef struct BinaryTreeNode* QDataType;typedef struct QueueNode
{struct QueueNode* next;QDataType val;
}QNode;typedef struct Queue
{QNode* phead;QNode* ptail;int size;
}Queue;void QueueInit(Queue* pq);
void QueueDestroy(Queue* pq);// 队尾插入
void QueuePush(Queue* pq, QDataType x);
// 队头删除
void QueuePop(Queue* pq);// 取队头和队尾的数据
QDataType QueueFront(Queue* pq);
QDataType QueueBack(Queue* pq);int QueueSize(Queue* pq);
bool QueueEmpty(Queue* pq);
Queue.c
void QueueInit(Queue* pq)
{assert(pq);pq->phead = NULL;pq->ptail = NULL;pq->size = 0;
}void QueueDestroy(Queue* pq)
{assert(pq);QNode* cur = pq->phead;while (cur){QNode* next = cur->next;free(cur);cur = next;}pq->phead = pq->ptail = NULL;pq->size = 0;
}// 队尾插入
void QueuePush(Queue* pq, QDataType x)
{assert(pq);QNode* newnode = (QNode*)malloc(sizeof(QNode));if (newnode == NULL){perror("malloc fail");return;}newnode->next = NULL;newnode->val = x;if (pq->ptail == NULL){pq->phead = pq->ptail = newnode;}else{pq->ptail->next = newnode;pq->ptail = newnode;}pq->size++;
}// 队头删除
void QueuePop(Queue* pq)
{assert(pq);assert(pq->size != 0);/*QNode* next = pq->phead->next;free(pq->phead);pq->phead = next;if (pq->phead == NULL)pq->ptail = NULL;*/// 一个节点if (pq->phead->next == NULL){free(pq->phead);pq->phead = pq->ptail = NULL;}else // 多个节点{QNode* next = pq->phead->next;free(pq->phead);pq->phead = next;}pq->size--;
}QDataType QueueFront(Queue* pq)
{assert(pq);assert(pq->phead);return pq->phead->val;
}QDataType QueueBack(Queue* pq)
{assert(pq);assert(pq->ptail);return pq->ptail->val;
}int QueueSize(Queue* pq)
{assert(pq);return pq->size;
}bool QueueEmpty(Queue* pq)
{assert(pq);return pq->size == 0;
}// 判断二叉树是否是完全二叉树
bool BinaryTreeComplete(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->leftchild);QueuePush(&q, front->rightchild);}while (!QueueEmpty(&q)){BTNode* front = QueueFront(&q);QueuePop(&q);// 如果有非空，就不是完全二叉树if (front){QueueDestroy(&q);return false;}}QueueDestroy(&q);return true;
}二叉树完整实现代码：
#define _CRT_SECURE_NO_WARNINGS 1#include <stdio.h>
#include <stdlib.h>typedef int BTDataType;//定义二叉树节点
typedef struct BinaryTreeNode
{BTDataType data;//存放的数据struct BinaryTreeNode* leftchild;//指向左孩子的指针struct BinaryTreeNode* rightchild;//指向右孩子的指针
}BTNode;//创建新节点
BTNode* BTBuyNode(BTDataType x)
{BTNode* newnode = (BTNode*)malloc(sizeof(BTNode));//申请一个节点的空间if (newnode == NULL)//内存申请失败，则直接退出程序{perror("malloc");exit(-1);}newnode->data = x;newnode->leftchild = newnode->rightchild = NULL;return newnode;
}//手动创建二叉树
BTNode* CreateTree()
{//创建6个节点BTNode* n1 = BTBuyNode(1);BTNode* n2 = BTBuyNode(2);BTNode* n3 = BTBuyNode(3);BTNode* n4 = BTBuyNode(4);BTNode* n5 = BTBuyNode(5);BTNode* n6 = BTBuyNode(6);//连接节点n1->leftchild = n2;n1->rightchild = n3;n2->leftchild = n4;n2->rightchild = n5;n3->rightchild = n6;//返回根节点return n1;
}//前序遍历
void PreOrder(BTNode* root)
{if (root == NULL)//访问到空指针就停止遍历{printf("N ");return;}printf("%d ", root->data);//打印根节点数据PreOrder(root->leftchild);//遍历左子树PreOrder(root->rightchild);//遍历右子树}//中序遍历
void InOrder(BTNode* root)
{if (root == NULL)//访问到空指针就停止遍历{printf("N ");return;}InOrder(root->leftchild);//遍历左子树printf("%d ", root->data);//打印根节点数据InOrder(root->rightchild);//遍历右子树
}//后序遍历
void PostOrder(BTNode* root)
{if (root == NULL){printf("N ");return;}PostOrder(root->leftchild);//遍历左子树PostOrder(root->rightchild);//遍历右子树printf("%d ", root->data);//打印根节点数据}//二叉树节点个数
int BTSize(BTNode* root)
{if (root == NULL)//访问到空指针，则结束{return 0;}return 1 + BTSize(root->leftchild) + BTSize(root->rightchild);//节点有效，返回1，再与左右孩子的判断结果相加
}//叶子节点个数
int BTLeafSize(BTNode* root)
{if (root == NULL){return 0;}if (root->leftchild == NULL && root->rightchild == NULL)//满足叶子节点的条件，返回1{return 1;}return BTLeafSize(root->leftchild) + BTLeafSize(root->rightchild);//将左子树和右子树统计结果相加
}//第K层节点个数
int BinaryTreeLevelKSize(BTNode* root, int k)
{if (root == NULL)//访问到空，返回0{return 0;}if (k == 1)//k值为1，做统计{return 1;}return BinaryTreeLevelKSize(root->leftchild, k - 1) + BinaryTreeLevelKSize(root->rightchild, k - 1);//递归访问左右孩子（下一层）
}//二叉树高度
int BinaryTreeDepth(BTNode* root)
{if (root == NULL)//根节点为空则为0层{return 0;}int leftDepth = BinaryTreeDepth(root->leftchild);//统计左子树高度int rightDepth = BinaryTreeDepth(root->rightchild);//统计右子树高度return leftDepth > rightDepth ? leftDepth + 1 : rightDepth + 1;//统计左右子树最大高度，再与根节点层数相加
}// ⼆叉树查找值为x的结点
BTNode* BinaryTreeFind(BTNode* root, BTDataType x)
{if (root == NULL)//访问到空则停止{return NULL;}if (root->data == x)//找到了，返回该节点{return root;}BTNode* leftFind = BinaryTreeFind(root->leftchild, x);//遍历左子树if (leftFind != NULL)//若查找结果不是空，则说明找到了，将该节点带回{return leftFind;}BTNode* rightFind = BinaryTreeFind(root->rightchild, x);//遍历右子树if (rightFind != NULL)//若查找结果不是空，则说明找到了，将该节点带回{return rightFind;}
}// 判断二叉树是否是完全二叉树
bool BinaryTreeComplete(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->leftchild);QueuePush(&q, front->rightchild);}while (!QueueEmpty(&q)){BTNode* front = QueueFront(&q);QueuePop(&q);// 如果有非空，就不是完全二叉树if (front){QueueDestroy(&q);return false;}}QueueDestroy(&q);return true;
}
5. 总结
本期博客，我们学习了二叉树链式结构相关功能的实现，如遍历、统计节点个数、查找、销毁等。这些功能的实现加深了我们对递归的理解，并且让我们学会了使用数据结构作为辅助来解决问题。
如果你觉得博主讲的还不错对你有帮助的话，给我的博客留个赞和关注，后期不断给大家讲解新的知识。本期博客分享就到这里，我们下期再见~👋👋