🍬个人主页：Yanni.—
🌈数据结构：Data Structure.
🎂C语言笔记：C Language Notes
前言
在之前学习了二叉树的基本概念，但二叉树有着更深入知识理解，这篇文章可以帮助大家在面临考试，刷题的时候大有帮助！！！
目录
前言
二叉树的性质
二叉树的储存结构
顺序储存
链式储存
二叉树链式结构的实现
二叉树链式结构的遍历
前序遍历的实现
中序遍历的实现
后序遍历的实现
二叉树的层序遍历
基础思路
代码实现
Text.c
Queue.h
Queue.c
二叉树结点计算
全局变量法
传指针法
二叉树的性质
1. 若规定根节点的层数为1，则一棵非空二叉树的第i层上最多有2^(i-1) 个结点.
2. 若规定根节点的层数为1，则深度为h的二叉树的最大结点数是2^h- 1.
3. 对任何一棵二叉树, 如果度为0其叶结点个数为 n0, 度为2的分支结点个数为 n2,则有n0＝n2
＋1
4. 若规定根节点的层数为1，具有n个结点的满二叉树的深度，h=LogN
二叉树的储存结构
二叉树的储存结构一般使用两种结构来存储，一种顺序结构，一种链式结构。
顺序储存
顺序结构存储就是使用数组来存储
，一般使用数组
只适合表示完全二叉树，因为不是完全二叉树
会有空间的浪费。而现实中使用中只有堆才会使用数组来存储，二叉树顺序存储在物理上是一个数组，在逻辑上是一颗二叉树。
链式储存
二叉树的链式存储结构是指，用链表来表示一棵二叉树，即用链来指示元素的逻辑关系。
通常的方法是链表中每个结点由三个域组成，数据域和左右指针域，左右指针分别用来给出该结点左孩 子和右孩子所在的链结点的存储地址 。
链式结构又分为二叉链和三叉链，当前我们学习中一般都 是二叉链，当我们学到高阶数据结构如红黑树等会用到三叉链。
// 二叉链
struct BinaryTreeNode
{
struct BinTreeNode* pLeft; // 指向当前节点左孩子
struct BinTreeNode* pRight; // 指向当前节点右孩子
BTDataType _data; // 当前节点值域
}// 三叉链
struct BinaryTreeNode
{
struct BinTreeNode* pParent; // 指向当前节点的双亲
struct BinTreeNode* pLeft; // 指向当前节点左孩子
struct BinTreeNode* pRight; // 指向当前节点右孩子
BTDataType _data; // 当前节点值域
}；二叉树链式结构的实现
二叉树链式结构的遍历
所谓遍历(Traversal)是指沿着某条搜索路线，依次对树中每个结点均做一次且仅做一次访问。访
问结点所做的操作依赖于具体的应用问 题。 遍历是二叉树上最重要的运算之一，是二叉树上进行
其它运算之基础。
前序/
中序
/
后序的递归结构遍历：是根据访问结点操作发生位置命名
1. NLR：前序遍历
(Preorder Traversal
亦称先序遍历
)——访问根结点的操作发生在遍历其左右
子树之前。
2. LNR：中序遍历
(Inorder Traversal)——访问根结点的操作发生在遍历其左右子树之中
（间）。
3. LRN：后序遍历
(Postorder Traversal)——访问根结点的操作发生在遍历其左右子树之后。
由于被访问的结点必是某子树的根，所以
N(Node
）、
L(Left subtree
）和
R(Right subtree）又
可解释为根、根的左子树和根的右子树。
NLR
、
LNR
和
LRN分别又称为先根遍历、中根遍历和后根
遍历。
前序遍历的实现
前序遍历的遍历顺序是，根->左子树->右子树。
从图中可以看出最后遍历出数据的顺序是A B D G H C E I F。
仔细观察可以发现，这种图类似与递归算法。所以在实现二叉树的遍历时可以用递归算法来实现。
void PrevOrder(BTNode* root)
{
if (root == NULL)
{
printf("NULL");
return;
}
printf("%d", root->val);
PrevOrder(root->Left);
PrevOrder(root->Right);
}中序遍历的实现
中序遍历的遍历顺序是，左子树->根->右子树。
从图中可以看出最后遍历出数据的顺序是G D H B A E I C F。
同样我们利用递归算法来实现它。
void InOrder(BTNode* root)
{
if (root == NULL)
{
printf("NULL");
return;
}
InOrder(root->Left);
printf("%d", root->val);
InOrder(root->Right);
}后序遍历的实现
中序遍历的遍历顺序是，左子树->右子树>根。
从图中可以看出最后遍历出数据的顺序是G H D B A I E F C 。
同样我们利用递归算法来实现它。
void PostOrder(BTNode* root)
{
if (root == NULL)
{
printf("NULL");
return;
}
PostOrder(root->Left);
PostOrder(root->Right);
printf("%d", root->val);
}二叉树的层序遍历
除了先序遍历、中序遍历、后序遍历外，还可以对二叉树进行层序遍历。
设二叉树的 根节点所在层数为1，层序遍历就是从所在二叉树的根节点出发，首先访问第一层的树根节点，然后从左到右访问第2层上的节点，接着是第三层的节点，以此类推，自上而下，自左至右逐层访问 。树的结点的过程就是层序遍历。
基础思路
层序遍历的实现需要利用之前学到的队列的知识，通过队列的本质（先进先出）来一层一层的访问二叉树的每个结点。
如图所示
当A拿出来时，A的左子树B和右子树C进去队列
当B拿出来时，B的左子树C和右子树D进去队列
当C拿出来时，C的左子树F和右子树G进入队列
依次类推.....最终一层一层的拿出来。
代码实现
Text.c
#include<stdio.h>
#include<stdlib.h>
#include"Queue.h"
typedef int BTNodeDate;
typedef struct BinatyTreeNode
{
struct BinatyTreeNode* Left;
struct BinatyTreeNode* Right;
BTNodeDate val;
}BTNode;
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->val);
if (front->Left)
{
QueuePush(&q, front->Left);
}
if (front->Right)
{
QueuePush(&q, front->Right);
}
}
printf("\n");
QueueDestroy(&q);
}
int main()
{
BTNode* A = (BTNode*)malloc(sizeof(BTNode));
A->Left = NULL;
A->Right = NULL;
A->val = 1;
BTNode* B = (BTNode*)malloc(sizeof(BTNode));
B->Left = NULL;
B->Right = NULL;
B->val = 2;
BTNode* C = (BTNode*)malloc(sizeof(BTNode));
C->Left = NULL;
C->Right = NULL;
C->val = 3;
BTNode* D = (BTNode*)malloc(sizeof(BTNode));
D->Left = NULL;
D->Right = NULL;
D->val = 4;
BTNode* E = (BTNode*)malloc(sizeof(BTNode));
E->Left = NULL;
E->Right = NULL;
E->val = 5;
A->Left = B;
A->Right = C;
B->Left = D;
B->Right = E;
/*PostOrder(A);
printf("\n");*/
LevelOrder(A);
return 0;
}Queue.h
#include<stdio.h>
#include<stdbool.h>
#include<stdlib.h>
#include<assert.h>
struct BinatyTreeNode;//前置声明
typedef struct BinatyTreeNode* QDataType;
//表示队列节点的定义
typedef struct QListNode
{
struct QListNode* next;
QDataType val;
}QNode;
//队列的结构
typedef struct Queue
{
QNode* head;
QNode* tail;
int size;
}Queue;
//初始化队列
void QueueInit(Queue* q);
//队尾入队列
void QueuePush(Queue* q,QDataType x);
//队头出队列
void QueuePop(Queue* q);
//获取队列头部元素
QDataType QueueFront(Queue* q);
//获取队列尾部元素
QDataType QueueBack(Queue* q);
//获取队列中有效元素个数
int QueueSize(Queue* q);
//检验队列是否为空，如果为空则返回非零结果，如果非空则返回0
int QueueEmpty(Queue* q);
//销毁队列
void QueueDestroy(Queue* q);Queue.c
#include"Queue.h"
//初始化队列
void QueueInit(Queue* q)
{
assert(q);
q->head = q->tail = NULL;
q->size = 0;
}
//队尾入队列
void QueuePush(Queue* q, QDataType x)
{
assert(q);
QNode* newnode = (QNode*)malloc(sizeof(QNode));
if (newnode == NULL)//考虑newnode为空的情况
{
printf("malloc fail!!!");
exit(1);
}
newnode->next = NULL;
newnode->val = x;
if (QueueEmpty(q))//队列为空
{
q->head = q->tail = newnode;
}
else { //队列不为空
q->tail->next = newnode;
q->tail = newnode;
}
q->size++;//插入数据之后不要忘了把size++
}
//队头出队列
void QueuePop(Queue* q)
{
assert(q);
if (q->head->next == NULL)
{
free(q->head);
q->head = q->tail = NULL;
}
else {
QNode* next = q->head->next;
free(q->head);
q->head = next;
}
q->size--;
}
//获取队列头部元素
QDataType QueueFront(Queue* q)
{
assert(q);
assert(q->head);
return q->head->val;
}
//获取队列尾部元素
QDataType QueueBack(Queue* q)
{
assert(q);
assert(q->tail);
return q->tail->val;
}
//获取队列中有效元素个数
int QueueSize(Queue* q)
{
assert(q);
return q->size;
}
//检验队列是否为空，如果为空则返回非零结果，如果非空则返回0
int QueueEmpty(Queue* q)
{
assert(q);
return q->size == 0;
}
//销毁队列
void QueueDestroy(Queue* q)
{
assert(q);
QNode* pcur = q->head;
while (pcur)
{
QNode* next = pcur->next;
free(q->head);
pcur = next;
}
q->head = q->tail = NULL;
q->size = 0;
}二叉树结点计算
全局变量法
int size = 0;
void TreeSize(BTNode* root)//计算结点个数
{
if (root == NULL)
{
return;
}
size++;
TreeSize(root->Left);
TreeSize(root->Right);
}传指针法
在参数传参的时候，我们要记住传值不改变值，传地址才会改变值。
void TreeSize(BTNode* root,int* psize)
{
if (root == NULL)
{
return;
}
(*psize)++;
TreeSize(root->Left,psize);
TreeSize(root->Right,psize);
}好啦，这就是今天学习的分享啦！看到希望大家的三连呀！
如果有不当之处，欢迎大佬指正！
