目录
前言
在学习二叉树的基本操作前，需先要创建一棵二叉树，然后才能学习其相关的基本操作。由于现在大家对二叉树结构掌握可能还不够深入，为了降低大家学习成本，此处手动快速创建一棵简单的二叉树，快速进入二叉树操作学习，等二叉树结构了解的差不多时，我们反过头再来研究二叉树真正的创建方式。
1、前置准备
先手动创建一个链式二叉树：
注意：以下代码并不是创建二叉树的方式，真正创建二叉树方式后序详解重点讲解。
typedef int BTDataType;
typedef struct BinaryTreeNode
{
BTDataType data; //存放数据
struct BinaryTreeNode* left; //左子树
struct BinaryTreeNode* right; //右子树
}BTNode;
BTNode* BuyNode(BTDataType x)
{
BTNode* newnode = (BTNode*)malloc(sizeof(BTNode)); //开辟空间
if(newnode == NULL) //开辟失败直接结束程序
{
perror("malloc fail");
exit(-1);
}
newnode->data = x;
newnode->left = newnode->right = NULL; //初始化为空
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;
}在学习链式二叉树的基本操作之前，我们先来回顾一下二叉树的基本概念：
二叉树是：
1、空树
2、非空树：是由 根节点，根节点的左子树、根节点的右子树 组成的
从概念中可以看出，二叉树定义是 递归式 的，因此后序基本操作中基本都是按照该概念实现的。
2、二叉树的遍历
二叉树的遍历采用的是 分治思想 ，即将一个难以直接解决的大问题，分割成一些规模较小的相同问题，以便各个击破，分而治之。
所以我们可以把整个二叉树的大问题，通过递归分成一个个节点的小问题逐个处理。
2.1、前序遍历/先根遍历
先处理 根节点 ，再处理 左子树 ，最后处理 右子树 的顺序。
使用递归方法实现：
void PreOrder(BTNode* root)
{
if(root == NULL) //如果是空节点，就打印后直接返回
{
printf("NULL ");
return;
}
printf("%d ", root->data); //先打印该根节点，再遍历左子树，最后遍历右子树
PreOrder(root->left);
PreOrder(root->right);
}因为是首次讲解递归方法，所以为了方便大家理解，我画了一张递归展开图，以后的递归代码就不再重复画了：
2.2、中序遍历/中根遍历
先处理 左子树 ，再处理 根节点 ，最后处理 右子树 的顺序。
递归方法实现：
void InOrder(BTNode* root)
{
if(root == NULL) //如果是空节点，就打印后直接返回
{
printf("NULL ");
return;
}
InOrder(root->left); //先遍历左子树，再打印该根节点，最后遍历右子树
printf("%d ", root->data);
InOrder(root->right);
}2.3、后序遍历/后根遍历
先处理 左子树 ，再处理 右子树 ，最后处理 根节点 的顺序。
递归方法实现：
void PostOrder(BTNode* root)
{
if(root == NULL) //如果是空节点，就打印后直接返回
{
printf("NULL ");
return;
}
PostOrder(root->left); //先遍历左子树，再遍历右子树，最后打印该根节点
PostOrder(root->right);
printf("%d ", root->data);
}2.4、层序遍历
从第一行开始，从左向右依次遍历。
层序遍历是借助队列来实现的，逻辑如下：
队列里面存放数据的 数据类型 为二叉树节点的 结构体 ，但是由于结构体拷贝起来比较大，所以我们存放 结构体的指针 。
先判断根节点是否为空，如果根节点不为空，就把根节点放入队列，如果根节点为空，就不把根节点放入队列。
再判断队列是否为空，如果队列不为空，就while循环以下操作：把队头数据取出，并把对头数据的 左孩子 与 右孩子 当作根节点重复上面根节点的判断，队列为空的时候停止循环，层序遍历结束。
层序遍历的规律总结一句话就是：出上一层，带下一层
void LevelOrder(BTNode* root)
{
Queue q;
QueueInit(&q);
if(root)
QueuePush(&q, root);
while(!QueueEmpty(&q))
{
BTNode* front = QueueFront(&q);
printf("%d ", front->data);
QueuePop(&q);
if(front->left)
{
QueuePush(&q, front->left);
}
if(front->right)
{
QueuePush(&q, front->right);
}
}
printf("\n");
QueueDestroy(&q);
}3、二叉树相关问题
3.1、计算二叉树节点的个数
解决这个问题有以下几种思路：
- 先创建一个计算节点数量的变量 size ，然后直接遍历二叉树，如果二叉树节点不是空，就让 size++ ，二叉树结点是空，就直接返回。
- 使用分治思想，把大问题分解成小问题，逐层统计。
思路一：
先创建一个计算节点数量的变量 size ，然后直接遍历二叉树，如果二叉树节点不是空，就让 size++ ，二叉树结点是空，就直接返回。
实现代码如下：
int TreeSize(BTNode* root)
{
if(root == NULL)
return;
int size == 0;
size++;
TreeSize(root->left);
TreeSize(root->right);
return size;
}先说结论，这种方法是 不可以 的。
如果是在普通循环程序外定义一个变量 size ，在循环内使用 size++ 是可以的，因为每次 size++ 都是对同一个 size 进行的。但是如果是在 递归程序 中定义了一个变量 size ，那么在递归调用的过程会建立很多 函数栈帧 （这方面内容我在之前的一篇文章《函数栈帧的创建与销毁中有过详细的讲解》），每一个函数栈帧里都会定义一个变量 size ，这样就会导致每一次的 size++ 都是对不同的 size 进行的。
那么可能还会有同学会想到把 size 定义成 静态变量，使变量 size 创建在 静态区 而不在 栈区，这样问题不久解决了吗？
int TreeSize(BTNode* root)
{
if(root == NULL)
return;
static int size == 0;
size++;
TreeSize(root->left);
TreeSize(root->right);
return size;
}这样使用 static 来定义静态变量之后，如果同学们去尝试一下，会发现在第一次计算二叉树的节点数量时，结果是正确的，但是在第二次及之后再去计算节点数量的话，会发现结果越来越大，每一次计算都比上一次多。有的同学会有疑问，上面所写的程序不是在每次递归调用的时候都把 size 初始化为零了吗？为什么还是会越加越大呢？
这是因为 静态变量 与 全局变量 的作用域都是整个程序，所以只有在第一次进入函数时才会在定义的同时进行初始化，而如果使用 size = 0；来直接把 size 赋值为 0 的话，又没有办法控制什么时候把 size 赋值为 0 。
所以如果非要使用这种思想来计算二叉树节点数量的话，就只有一种方法，就是直接定义一个 全局变量 size ，并且 TreeSize 函数不使用返回值：
int size = 0;
void TreeSize(BTNode* root)
{
if(root == NULL)
return;
size++;
TreeSize(root->left);
TreeSize(root->right);
}需要注意的是，每次调用 TreeSize 函数时，都要手动让 size = 0。
思路二：
使用分治思想，把大问题分解成小问题，逐层统计。
统计该节点子树的所有节点数量，并把统计到的节点数量加一，返回给该节点的父节点。
实现代码：
int TreeSize2(BTNode* root)
{
if(root == NULL)
return 0;
return TreeSize2(root->left) + TreeSize2(root->right) + 1;
}使用很少量的代码就可以实现预期的功能，方便又快捷。
所以 思路二 是计算二叉树节点数量的最优解。
3.2、计算二叉树叶子节点的个数
与计算二叉树节点个数相似，只不过不需要加上节点本身（即不需要每次都加 1 ）。
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); //把叶子节点都加起来
}3.3、计算二叉树的高度/深度
因为二叉树的高度是由高度最高的子树所决定的，所以需要返回最高子树的高度。
所以我们依然使用分治思想，计算该节点的 左子树 与 右子树 的高度，再相互比较，最后返回最高子树的高度 + 1。
需要注意的是，在求 左子树 与 右子树 的高度时，必须采用 后序遍历 的方法，因为在求高度时，必须先递归到最末端的叶子节点，再从 0 开始层层往回依次加 1 ，然后再选取最大的那个子树的高度。
通过以上思想，可以写出以下代码：
int TreeHight(BTNode* root)
{
if(root == NULL)
return 0;
return TreeHight(root->left) > TreeHight(root->right)
? TreeHight(root->left) + 1 : TreeHight(root->right) + 1;
}这段代码在逻辑上是正确的，但是依然存在很大的问题，因为每次比较完左子树与右子树的高度之后，直接就把已经得到的结果扔掉了，在返回结果时还要重新再计算一次高度，造成了非常大的性能浪费，所以需要再定义两个变量来保存已经得到的结果。
最终实现代码如下：
int TreeHight(BTNode* root)
{
if(root == NULL)
return 0;
int leftHight = TreeHight(root->left);
int rightHight = TreeHight(root->right);
return leftHight > rightHight ? leftHight + 1 : rightHight + 1;
}3.4、计算二叉树第K层的节点个数（K >= 1）
主要思路：
对于第 一 层，需要计算的是 左子树第 K 层的节点个数 + 右子树第 K 层的节点个数
对于第 二 层，需要计算的是 左子树第 K - 1 层的节点个数 + 右子树第 K - 1 层的节点个数
对于第 三 层，需要计算的是 左子树第 K - 2 层的节点个数 + 右子树第 K - 2 层的节点个数
............
对于第 K 层，需要计算的是 左子树第 一 层的节点个数 + 右子树第 一 层的节点个数
根据以上思路，我们需要根据 K 的数值分为两种情况分析：
1、当 K == 1 时，直接返回第一层的节点个数：1
2、当 K > 1 时，第 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);
}3.5、查找某个值所在的节点
思路：如果当前节点就是指定数值所在的节点，那么直接返回该节点，如果当前节点不是指定节点，那么就先找左子树，再找右子树，如果最终还是没有找到指定节点，返回空。
BTNode* TreeFind(BTNode* root, BTDataType x)
{
if(root == NULL) //如果根节点是空，直接返回空
return NULL;
if(root->data == x) //找到指定节点直接返回
return root;
BTNode* ret1 = TreeFind(root->left, x); //创建变量接收返回值
if(ret1) //如果接收到的返回值不是空，就说明找到指定节点了，返回指定节点
return ret1;
BTNode* ret2 = TreeFind(root->right, x);
if(ret2)
return ret2;
return NULL; //什么都没找到，返回空
}3.6、判断是否是完全二叉树
判断一个二叉树是否是完全二叉树，是否可以通过计算二叉树节点的数量来判断呢？答案是 不可以 的，因为完全二叉树节点的数量是一个范围，如果二叉树的高度为 h ，那么二叉树节点数量就在 2^(h - 1) ~ 2^h - 1 之间。
所以我们通过层序遍历来判断，只不过这里所用的层序遍历与上面所讲过的层序遍历有所不同，在这里 二叉树的空节点也要被排进队列当中 ，逻辑如下：
因为层序遍历的逻辑是出上一层，带下一层，所以再根据完全二叉树的性质：最后一层可以不满，但是所有节点必须从左到右连续排列。所以当队头数据为空时，只需要判断队列内还有没有非空节点就可以了，如果队列内还存在非空节点，就是非完全二叉树，如果队列内全是空节点，就是完全二叉树。
实现代码：
int 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;
}
else
{
QueuePush(front->left);
QueuePush(front->right);
}
}
while(!QueueEmpty(&q))
{
BTNode* front = QueueFront(&q);
if(front)
{
QueueDestroy(&q);
return false;
}
else
{
QueuePop(&q);
}
}
QueueDestroy(&q);
return true;
}3.7、二叉树的销毁
我们使用 后序遍历 来销毁二叉树：从最后一层开始，先销毁左子树，再销毁右子树，最后释放根节点，如果遇到空节点直接返回。
实现代码：
void TreeDestroy(BTNode* root)
{
if(root == NULL)
{
return;
}
TreeDestroy(root->left);
TreeDestroy(root->right);
free(root);
}需要注意的是：因为我们传递的是一级指针，而形参的改变不会影响实参，所以整个二叉树的根节点不会被销毁，需要用户自己在外面手动把根节点置空。
4、完整代码
因为之前已经对队列有过较为详细的讲解，所以这里就不再把队列的代码放出来了
#include <stdio.h>
#include "Queue.h"
BTNode* BuyBTNode(BTDataType x)
{
BTNode* newnode = (BTNode*)malloc(sizeof(BTNode));
if (newnode == NULL)
{
perror("malloc fail");
exit(-1);
}
newnode->data = x;
newnode->left = NULL;
newnode->right = NULL;
return newnode;
}
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);
}
//求二叉树节点个数
int size = 0;
void TreeSize(BTNode* root)
{
if (root == NULL)
{
return;
}
size++;
TreeSize(root->left);
TreeSize(root->right);
}
//求叶子节点的个数
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);
}
//求二叉树的高度
int TreeHeight(BTNode* root)
{
if (root == NULL)
{
return 0;
}
int LeftHeight = TreeHeight(root->left);
int RightHeight = TreeHeight(root->right);
return LeftHeight > RightHeight ? LeftHeight + 1 : RightHeight + 1;
}
//求第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);
}
//查找指定数字所在的节点
BTNode* TreeFind(BTNode* root, int k)
{
if (root == NULL)
{
return NULL;
}
if (root->data == k)
{
return root;
}
BTNode* left = TreeFind(root->left, k);
if (left)
{
return left;
}
BTNode* right = TreeFind(root->right, k);
if (right)
{
return right;
}
return NULL;
}
void LevelOrder(BTNode* root)
{
Queue q;
QueueInit(&q);
if (root)
QueuePush(&q, root);
while (!QueueEmpty(&q))
{
BTNode* front = QueueFront(&q);
printf("%d ", front->data);
QueuePop(&q);
if (front->left)
{
QueuePush(&q, front->left);
}
if (front->right)
{
QueuePush(&q, front->right);
}
}
printf("\n");
QueueDestroy(&q);
}
//检查是否是完全二叉树
bool TreeComplete(BTNode* root)
{
Queue q;
QueueInit(&q);
if (root)
{
QueuePush(&q, root);
}
while (!QueueEmpty(&q))
{
BTNode* front = QueueFront(&q);
QueuePop(&q);
if (!front)
{
break;
}
QueuePush(&q, front->left);
QueuePush(&q, front->right);
}
//检查出到NULL以后后面是不是全为NULL
while (!QueueEmpty(&q))
{
if (QueueFront(&q))
{
QueueDestroy(&q);
return false;
}
QueuePop(&q);
}
QueueDestroy(&q);
return true;
}
//使用后续遍历
void BinaryTreeDestory(BTNode* root)
{
if (!root)
{
return;
}
BinaryTreeDestory(root->left);
BinaryTreeDestory(root->right);
free(root);
//root = NULL;
}
int main()
{
BTNode* n1 = BuyBTNode(1);
BTNode* n2 = BuyBTNode(2);
BTNode* n3 = BuyBTNode(3);
BTNode* n4 = BuyBTNode(4);
BTNode* n5 = BuyBTNode(5);
BTNode* n6 = BuyBTNode(6);
BTNode* n7 = BuyBTNode(7);
n1->left = n2;
n1->right = n4;
n2->left = n3;
n2->right = n7;
n4->left = n5;
n4->right = n6;
PrevOrder(n1);
printf("\n");
InOrder(n1);
printf("\n");
PostOrder(n1);
printf("\n");
size = 0;
TreeSize(n1);
printf("TreeSize: %d\n", size);
size = 0;
TreeSize(n1);
printf("TreeSize: %d\n", size);
size = 0;
TreeSize(n1);
printf("TreeSize: %d\n", size);
printf("%d\n", TreeLeafSize(n1));
printf("%d\n",TreeHeight(n1));
printf("%d\n", TreeKLevelSize(n1, 2));
printf("%d\n", TreeFind(n1, 4)->data);
LevelOrder(n1);
printf("%d ", TreeComplete(n1));
BinaryTreeDestory(n1);
n1 = NULL;
return 0;
}对于链式二叉树的基本操作就讲解到这里，希望同学们多多支持，如果有不妥的地方欢迎大佬指正，谢谢！
1739
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
