第五章树和二叉树（上）【24王道数据结构笔记】 - 码农知识堂 - 文章详情页

第五章树和二叉树（上）【24王道数据结构笔记】
1.树的概念

1.1 树的基本定义

树:n(n>=0)个节点的有限集合，是一种逻辑结构，当n=0时为空树，且非空树满足:
- 有且仅有一个特定的称为根的节点.
- 当n>1时，其余结点可分为m (m >0) 个互不相交的有限集合，其中每个集合本身又是一棵树，并且称为根结点的子树。
树是一种递归的数据结构

非空树特点：
- 有且仅有一个根节点
- 没有后继的结点称为“叶子结点”（或终端节点）
- 有后继的结点称为“分支结点” (或非终端结点)
- 除了根节点外，任何一个结点都有且仅有一个前驱
- 每个结点可以有0个或多个后继
1.2 基本术语
- 祖先结点：自己的之上都是祖先节点。
- 子孙结点：自己的之下都是子孙节点。
- 双亲结点 (父节点) ：和自己相连的上一个就是父节点。
- 孩子结点：和自己相连的下面一个。
- 兄弟结点：我自己同一个父节点的。
- 堂兄弟结点：同一层的节点。
属性:
- 结点的层次(深度)--从上往下数，默认从 1开始
- 结点的高度-一从下往上数
- 树的高度 (深度)-一总共多少层
- 结点的度--有几个孩子(分支)，叶子结点的度=0
- 树的度一-各结点的度的最大值
- 两个结点之间的路径——从上往下经历的结点
- 路径长度——经过的边的的条数
有序树和无序树
- 有序树--逻辑上看，树中结点的各子树从左至右是有次序的，不能互换
- 无序树--逻辑上看，树中结点的各子树从左至右是无次序的，可以互换
选用有序树还是无序树具体看你用树存什么，是否需要用结点的左右位置反映某些逻辑关系

1.3.森林

森林是m(>=0)棵互不相交的树的集合。

m可为0——空森林

2. 树的常考性质
- 常见考点1：结点数=总度数+1
结点的度——结点有几个孩子（分支），最后再加上根结点
- 常见考点2：度为m的树、m叉树的区别
树的度——各结点的度的最大值，m叉树——每个结点最多只能有m个孩子的树
- 常见考点3：度为m的树第 i 层至多有 mi-1 个结点（i≥1） m叉树第 i 层至多有 mi-1 个结点（i≥1）
- 常见考点4: 高度为h的m叉树至多有 $\frac{m^{h}-1}{m-1}$ 个结点。
等比数列求和公式：
- 常见考点5: 高度为h的m叉树至少有h个结点；高度为h、度为m的树至少有h+m-1个结点。
- 常见考点6: 具有n个结点的m叉树的最小高度为 $\log_{m}[n(m-1)+1]$ (考点4反解)
高度最小的情况——所有结点都有m个孩子

3. 二叉树

3.1 二叉树的定义

二叉树是n (n>=0)个结点的有限集合
1. 或者为空二叉树，即n =0。
2. 或者由一个根结点和两个互不相交的被称为根的左子树和右子树组成。左子树和右子树又分别是一棵二叉树。
特点：
- 每个结点至多只有两棵子树
- 左右子树不能颠倒 (二叉树是有序树)
- 二叉树可以是空集合，根可以有空的左子树和空的右子树
注意区别：度为2的有序树（至少有一个结点度为2）

二叉树的五种状态

3.2 特殊二叉树

3.2.1 满二叉树：

一棵深度为k且有 $2^{k-1}$ 个结点的二叉树称为满二叉树。特点：
- 每一层上的结点数都达到最大，不存在度为 1 的结点
- 叶子全部在最低层。
- 按层序从1开始编号，结点i的左孩子为 2i，右孩子为 2i+1;结点i的父节点为 $\left \lfloor i/2 \right \rfloor$ (向下取整)
- i<= $\left \lfloor i/2 \right \rfloor$ 为分支结点，i> $\left \lfloor i/2 \right \rfloor$ 为叶子结点
3.2.2 完全二叉树：

深度为k的具有n个结点的二叉树，当且仅当其每一个结点都与深度为k的满二叉树中编号为1~n的结点一一对应时，称之为完全二叉树。特点：
- 只有最后两层可能有叶子结点，
- 最多只有一个度为1的结点（0个或1个），如果某结点只有一个孩子，那么一定是左孩子
- 按层序从1开始编号，结点i的左孩子为 2i，右孩子为 2i+1;结点i的父节点为[i/2]
- i<= $\left \lfloor i/2 \right \rfloor$ 为分支结点，i> $\left \lfloor i/2 \right \rfloor$ 为叶子结点
3.2.3 二叉排序树：

一棵二叉树或者是空二叉树，或者是具有如下性质的二叉树:
- 左子树上所有结点的关键字均小于根结点的关键字;
- 右子树上所有结点的关键字均大于根结点的关键字;
- 左子树和右子树又各是一棵二叉排序树。
二叉排序树可用于元素的排序、搜索

3.2.4 平衡二叉树：

树上任一结点的左子树和右子树的深度之差不超过1。

平衡二叉树能有更高的搜索效率

3.3 二叉树的性质

3.3.1 二叉树的常考性质

常见考点1：设非空二叉树中度为0、1和2的结点个数分别为 $n_{0}$ 、 $n_{1}$ ,和 $n_{2}$ ，则 $n_{0}=n_{2}+1$ (叶子结点比二分支结点多一个)

常见考点2：二叉树第层至多有 $2^{i-1}$ 个结点 (>=1)；m叉树第层至多有 $m^{i-1}$ 个结点 (>=1)

常见考点3：高度为h的二叉树至多有 $2^{h}-1$ 个结点(满二叉树)；高度为h的m叉树至多 $\frac{m^{h}-1}{m-1}$ 结点

3.3.2 完全二叉树的常考性质

常见考点1：（注意此处是完全二叉树才具备的）

常见考点2：对于完全二叉树，可以由总结点数 n 推出度为 0、1 和 2 的结点个数 $n_{0}$ 、 $n_{1}$ 、 $n_{2}$

推导过程：
        因为： $n_{0} = n_{2}+1$ :所以 $n_{0} + n_{2}$ 为奇数
        又因为： $n=n_{0} +n_{1}+n_{2}$
        所以：若完全二叉树有偶数n个节点，则 $n_{1}$ 为1； $n_{0}$ 为 $\frac{n}{2}$ ； $n_{2}$ 为 $\frac{n}{2}-1$
        若完全二叉树有奇数n个节点，则 $n_{1}$ 为0； $n_{0}$ 为 $\frac{n+1}{2}$ ； $n_{2}$ 为 $\frac{n+1}{2}-1$

3.4二叉树存储实现

3.4.1 二叉树的顺序存储：

二叉树的顺序存储中，一定要把二叉树的结点编号与完全二叉树对应起来；

可以让第一个位置空缺，保证数组下标和结点编号一致

定义一个长度为 MaxSize 的数组 t ，按照从上至下、从左至右的顺序依次存储完全二叉树中的各个结点,代码实现如下
```
#define MaxSize 100
 
struct TreeNode{
   ElemType value; //结点中的数据元素
   bool isEmpty;   //结点是否为空
}
 
// 初始化时所有结点标记为空 
void InItTree(TreeNode t[])
{
    for (int i=0; i
      t[i].isEmpty = true;
   }
}
main(){
   TreeNode t[MaxSize];
   InItTree(t);
}
```
几个重要常考的基本操作：
- i 的左孩子：2i
- i 的右孩子：2i+1
- i 的父节点：i/2
- i 所在的层次： $\log_{2}(n+1)$ 或者 $\log_{2}n+1$
若完全二叉树中共有n个结点，则
- 判断i是否有左孩子? $2i\leqslant n$ ？
- 判断i是否有右孩子? $2i+1\leqslant n$ ？
- 判断i是否是叶子/分支结点? ?
注：如果不是完全二叉树，依然按层序将各节点顺序存储，那么无法从结点编号反映出结点间的逻辑关系

二叉树的顺序存储中，一定要把二叉树的结点编号与完全二叉树对应起来

最坏情况：高度为 h 且只有 h 个结点的单支树（所有结点只有右孩子），也至少需要 2h-1 个存储单元

结论：二叉树的顺序存储结构，只适合存储完全二叉树

3.4.2 二叉树的链式存储

包含数据域和左右孩子指针，n个结点的二叉链表共有 n+1 个空链域，可以用于构造线索二叉树
```
//二叉树的结点
 
struct ElemType{
   int value;
};
 
typedef struct BiTnode{
   ElemType data;          //数据域
   struct BiTNode *lchild, *rchild; //左、右孩子指针
}BiTNode, *BiTree;
 
//定义一棵空树
BiTree root = NULL;
 
//插入根节点
root = (BiTree) malloc (sizeof(BiTNode));
root->data = {1};
root->lchild = NULL;
root->rchild = NULL;
 
//插入新结点
BiTNode *p = (BiTree) malloc (sizeof(BiTNode));
p->data = {2};
p->lchild = NULL;
p->rchild = NULL;
root->lchild = p; //作为根节点的左孩子
```
优点：找到指定结点 p 的左/右孩子——超简单

缺点：找指定结点 p 的父结点只能从根开始遍历寻找

解决：三叉链表——方便找父结点（根据实际需求决定要不要加父结点指针）
```
struct ElemType{
   int value;
};
 
typedef struct BiTnode{
   ElemType data;          //数据域
   struct BiTNode *lchild, *rchild; //左、右孩子指针
    struct BiTNode *parent;         // 父结点指针
}BiTNode, *BiTree;
```
4.二叉树的先中后序遍历
- 遍历：按照某种次序把所有结点都访问一遍。
- 层次遍历:基于树的层次特性确定的次序规则
二又树的递归特性:
- 要么是个空二叉树
- 要么就是由“根节点+左子树+右子树”组成的二叉树
4.1二叉树的先中后遍历

4.1.1 二叉树先中后序遍历的递归实现
- 先序遍历:根左右(NLR)
```
typedef struct BiTnode{
   ElemType data;          
   struct BiTNode *lchild, *rchild; 
}BiTNode, *BiTree;
 
void PreOrder(BiTree T){
   if(T!=NULL){
      visit(T);                 //访问根结点
      PreOrder(T->lchild);      //递归遍历左子树
      PreOrder(T->rchild);      //递归遍历右子树
   }
}
```
C++实现
```
    void traversal(TreeNode* cur, vector<int>& vec) {
        if (cur == NULL) return;
        vec.push_back(cur->val);    // 中
        traversal(cur->left, vec);  // 左
        traversal(cur->right, vec); // 右
    }
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> result;
        traversal(root, result);
        return result;
    }
};
```
- 中序遍历:左根右 (LNR)
```
typedef struct BiTnode{
   ElemType data;          
   struct BiTNode *lchild, *rchild; 
}BiTNode, *BiTree;
 
void InOrder(BiTree T){
   if(T!=NULL){
      InOrder(T->lchild);       //递归遍历左子树
      visit(T);                 //访问根结点
      InOrder(T->rchild);       //递归遍历右子树
   }
}
```
- 后序遍历:左右根(LRN)
```
typedef struct BiTnode{
   ElemType data;          
   struct BiTNode *lchild, *rchild; 
}BiTNode, *BiTree;
 
void PostOrder(BiTree T){
   if(T!=NULL){
      PostOrder(T->lchild);       //递归遍历左子树    
      PostOrder(T->rchild);       //递归遍历右子树
      visit(T);                 //访问根结点
   }
}
```
4.1.2 用栈实现了二叉树先中后序的迭代遍历（非递归）。

基本思路：将访问的节点放入栈中，把要处理的节点也放入栈中但是要做标记，只有空节点弹出的时候，才将下一个节点放进结果集。如何标记呢，就是要处理的节点放入栈之后，紧接着放入一个空指针作为标记。

迭代法中序遍历
```
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> result;
        stack st;
        if (root != NULL) st.push(root);
        while (!st.empty()) {
            TreeNode* node = st.top();
            if (node != NULL) {
                st.pop(); // 将该节点弹出，避免重复操作，下面再将右中左节点添加到栈中
                if (node->right) st.push(node->right);  // 添加右节点（空节点不入栈）
 
                st.push(node);                          // 添加中节点
                st.push(NULL); // 中节点访问过，但是还没有处理，加入空节点做为标记。
 
                if (node->left) st.push(node->left);    // 添加左节点（空节点不入栈）
            } else { // 只有遇到空节点的时候，才将下一个节点放进结果集
                st.pop();           // 将空节点弹出
                node = st.top();    // 重新取出栈中元素
                st.pop();
                result.push_back(node->val); // 加入到结果集
            }
        }
        return result;
    }
```
迭代法前序遍历 (注意此时我们和中序遍历相比仅仅改变了两行代码的顺序)
```
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> result;
        stack st;
        if (root != NULL) st.push(root);
        while (!st.empty()) {
            TreeNode* node = st.top();
            if (node != NULL) {
                st.pop();
                if (node->right) st.push(node->right);  // 右
                if (node->left) st.push(node->left);    // 左
                st.push(node);                          // 中
                st.push(NULL);
            } else {
                st.pop();
                node = st.top();
                st.pop();
                result.push_back(node->val);
            }
        }
        return result;
    }
```
迭代法后序遍历
```
class Solution {
public:
    vector<int> postorderTraversal(TreeNode* root) {
        vector<int> result;
        stack st;
        if (root != NULL) st.push(root);
        while (!st.empty()) {
            TreeNode* node = st.top();
            if (node != NULL) {
                st.pop();
                st.push(node);                          // 中
                st.push(NULL);
 
                if (node->right) st.push(node->right);  // 右
                if (node->left) st.push(node->left);    // 左
 
            } else {
                st.pop();
                node = st.top();
                st.pop();
                result.push_back(node->val);
            }
        }
        return result;
    }
};
```
4.2 二叉树的层序遍历

算法思想:
- 1.初始化一个辅助队列
- 2.根结点入队
- 3.若队列非空，则队头结点出队，访问该结点，并将其左、右孩子插入队尾(如果有的话)
- 4.重复3直至队列为空
```
//二叉树的结点(链式存储)
typedef struct BiTnode{
   ElemType data;          
   struct BiTNode *lchild, *rchild; 
}BiTNode, *BiTree;
 
//链式队列结点
typedef struct LinkNode{
   BiTNode *data;    // 存结点指针而不是结点
   typedef LinkNode *next;
}LinkNode;
 
typedef struct{
   LinkNode *front, *rear;  
}LinkQueue;
 
//层序遍历
void LevelOrder(BiTree T){
   LinkQueue Q;
   InitQueue (Q);          //初始化辅助队列
   BiTree p;
   EnQueue(Q,T);           //将根节点入队
   while(!isEmpty(Q)){     //队列不空则循环
      DeQueue(Q,p);        //队头结点出队
      visit(p);            //访问出队结点
      if(p->lchild != NULL)
         EnQueue(Q,p->lchild);   //左孩子入队
      if(p->rchild != NULL)
         EnQueue(Q,p->rchild);   //右孩子入队
   }
}
```
C++实现

队列法
```
    vectorint>> levelOrder(TreeNode* root) {
        queue que;
        if (root != NULL) que.push(root);
        vectorint>> result;
        while (!que.empty()) {
            int size = que.size();
            vector<int> vec;
            // 这里一定要使用固定大小size，不要使用que.size()，因为que.size是不断变化的
            for (int i = 0; i < size; i++) {
                TreeNode* node = que.front();
                que.pop();
                vec.push_back(node->val);
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
            }
            result.push_back(vec);
        }
        return result;
    }
```
递归法
```
void order(TreeNode* cur, vectorint>>& result, int depth)
    {
        if (cur == nullptr) return;
        if (result.size() == depth) result.push_back(vector<int>());
        result[depth].push_back(cur->val);
        order(cur->left, result, depth + 1);
        order(cur->right, result, depth + 1);
    }
    vectorint>> levelOrder(TreeNode* root) {
        vectorint>> result;
        int depth = 0;
        order(root, result, depth);
        return result;
    }
```
4.3 由遍历序列构造二叉树
- 一个前序遍历序列可能对应多种二叉树形态。
- 同理，一个后序遍历序列、一个中序遍历序列、一个层序遍历序列也可能对应多种二叉树形态。
结论：若只给出一棵二叉树的前/中/后/层序遍历序列中的一种，不能唯一确定一棵二叉树。

由二叉树的遍历序列构造二叉树：

4.3.1 前序+中序遍历序列

由前序+中序遍历序列构造二叉树：由前序遍历的遍历顺序（根节点、左子树、右子树）可推出根节点，由根节点在中序遍历序列中的位置即可推出左子树与右子树分别有哪些结点。

4.3.2 后序+中序遍历序列

由后序+中序遍历序列构造二叉树：由后序遍历的遍历顺序（左子树、右子树、根节点）可推出根节点，由根节点在中序遍历序列中的位置即可推出左子树与右子树分别有哪些结点。

4.3.3 层序+中序遍历序列

由层序+中序遍历序列构造二叉树：由层序遍历的遍历顺序（层级遍历）可推出根节点，由根节点在中序遍历序列中的位置即可推出左子树与右子树分别有哪些结点。

前序、后序、层序序列的两两组合无法唯一确定一科二叉树
相关阅读:
【Mysql】Mysql基本概念和操作
 c++ vector用法入门必看超详细
 git 学习笔记
 小程序wx:if 和hidden的区别？
typora操作手册
 关于视频封装格式和视频编码格式的简介
 【C++提高编程】第一章模板：函数模板|类模板|
继认证后弄清Spring Security实现授权
 【Linux成长史】Linux编辑器-gcc/g++使用
 学习linux从0到工程师（命令）-4
原文地址：https://blog.csdn.net/zhendong825/article/details/134466119