第五章 树和二叉树（中）【线索二叉树、树和森林】

info8252023-11-18 14:46

1.线索二叉树

1.1 线索二叉树的概念

n 个结点的二叉树，有 n+1 个空链域，可用来记录前驱、后继的信息。指向前驱、后继的指针被称为"线索"，形成的二叉树被称为线索二叉树。

  • 在二叉树的结点上加上线索的二叉树称为线索二叉树，对二叉树以某种遍历方式（如先序、中序、后序或层次等）进行遍历，使其变为线索二叉树的过程称为对二叉树进行线索化。
  • 线索二叉树的结点在原本二叉树的基础上，新增了左右线索标志 tag。当 tag == 0 时，表示指针指向孩子；当 tag == 1 时，表示指针是"线索"。
cpp 复制代码 
//线索二叉树结点
typedef struct ThreadNode{
   ElemType data;
   struct ThreadNode *lchild, *rchild;
   int ltag, rtag;                // 左、右线索标志
}ThreadNode, *ThreadTree;

1.2 中序线索化的存储

思路： 从根节点出发，重新进行一次中序 遍历，指针q记录当前访问的结点， 指针 pre 记录上一个被访问的结点

①当q==p时，pre为前驱

②当pre==p时，q为后继

**缺点：**找前驱、后 继很不方便；遍历 能否从一个指定结点开始中序遍历？ 操作必须从根开始

1.3 三种线索二叉树的对比

1.4 手算画出线索二叉树

1.确定线索二叉树类型------中、先、后

2.按照对应的遍历规则，确定各个节点的访问顺序，并写上序号

3.将n+1个空域连接上前驱和后继（没有前驱或者后继的对应位置补NULL）

1.5 二叉树的线索化

1.5.1 中序线索化：

cpp 复制代码 
typedef struct ThreadNode{
   int data;
   struct ThreadNode *lchild, *rchild;
   int ltag, rtag;                // 左、右线索标志
}ThreadNode, *ThreadTree;
 
TreadNode *pre=NULL;    //全局变量pre, 指向当前访问的结点的前驱
 
void InThread(ThreadTree T){
    if(T!=NULL){
        InThread(T->lchild);    //中序遍历左子树
        visit(T);               //访问根节点
        InThread(T->rchild);    //中序遍历右子树
    }
}
 
void visit(ThreadNode *q){
   if(q->lchid = NULL){                 // 左子树为空，建立前驱线索   
      q->lchild = pre;                  // 将左指针线索化指向前驱结点
      q->ltag = 1;                      // 标记左指针已经线索化
   }
 
   if(pre!=NULL && pre->rchild = NULL){ // pre只有一开始为空，此时不需要判断后继
      pre->rchild = q;           // 建立前驱结点的后继线索
      pre->rtag = 1;             // 标记右指针已经线索化
   }
   pre = q;
}
 
//中序线索化二叉树T，最后还要检查pre 的rchild 是否为 NULL，如果是，则令 rtag=1
void CreateInThread(ThreadTree T){
   pre = NULL;                //pre初始为NULL
   if(T!=NULL);{              //非空二叉树才能进行线索化
      InThread(T);            //中序线索化二叉树
      if(pre->rchild == NULL)
         pre->rtag=1;         //处理遍历的最后一个结点
   }
}

1.5.2 先序线索化

当通过先序遍历线索化二叉树的时候，我们在递归遍历左子树以及右子树的时候都需要加以判断，否则就会出现死循环------爱滴魔力转圈圈

先序二叉树遍历的时候是根左右，在遍历过程中会先对根结点，以及根结点的左子树进行线索化，但是看下面的一种情况

我们对结点"D"进行访问的时候，即调用visit()函数的时候，此时pre指针指向的是结点"B"，通过判断结点D的左孩子为空，因此建立左索引，将其前驱指向结点B，即D->lchild = B，但接下来执行PreThread(D->lchild) 的时候如果不加判断，此时已经将左指针指向B，那么就会在此处进行不断循环，所以我们在递归遍历左子树的时候需要加以判断其前结点的lchild不是前驱线索，其实当递归遍历右结点的时候同时也需要进行遍历，否则也会出现转圈的问题，例如当访问结点F的时候，visit(F)，其左右孩子结点都为空，因此有：F->lchild = C; F->ltag = 1; 以及C->rchild = F; C->rtag = 1;，遍历完F结点，接着就会运行PreThread(C->rchild);，如果此时不加以判断，就会同上面所说的一样出现"爱滴魔力转圈圈"问题

cpp 复制代码 
typedef struct ThreadNode{
   int data;
   struct ThreadNode *lchild, *rchild;
   int ltag, rtag;                // 左、右线索标志
}ThreadNode, *ThreadTree;
 
//全局变量pre, 指向当前访问的结点的前驱
TreadNode *pre=NULL;
 
//先序遍历二叉树，一边遍历一边线索化
void PreThread(ThreadTree T){
   if(T!=NULL){
      visit(T);
      if(T->ltag == 0)         //lchild不是前驱线索
         PreThread(T->lchild);
      if(T->rtag == 0)         //rchild不是后继线索
      PreThread(T->rchild);
   }
}
 
void visit(ThreadNode *q){
   if(q->lchid = NULL){                 //左子树为空，建立前驱线索   
      q->lchild = pre;
      q->ltag = 1;
   }
 
   if(pre!=NULL && pre->rchild = NULL){ 
      pre->rchild = q;           //建立前驱结点的后继线索
      pre->rtag = 1;
   }
   pre = q;
}
 
//先序线索化二叉树T
void CreateInThread(ThreadTree T){
   pre = NULL;                //pre初始为NULL
   if(T!=NULL);{              //非空二叉树才能进行线索化
      PreThread(T);            //先序线索化二叉树
      if(pre->rchild == NULL)
         pre->rtag=1;         //处理遍历的最后一个结点
   }
}

1.5.3 后序线索化

cpp 复制代码 
typedef struct ThreadNode{
   int data;
   struct ThreadNode *lchild, *rchild;
   int ltag, rtag;                // 左、右线索标志
}ThreadNode, *ThreadTree;
 
//全局变量pre, 指向当前访问的结点的前驱
TreadNode *pre=NULL;
 
//后序遍历二叉树，一边遍历一边线索化
void PostThread(ThreadTree T){
   if(T!=NULL){
      PostThread(T->lchild);
      PostThread(T->rchild);
      visit(T);                  //访问根节点
   }
}
 
void visit(ThreadNode *q){
   if(q->lchid = NULL){                 //左子树为空，建立前驱线索   
      q->lchild = pre;
      q->ltag = 1;
   }
 
   if(pre!=NULL && pre->rchild = NULL){ 
      pre->rchild = q;           //建立前驱结点的后继线索
      pre->rtag = 1;
   }
   pre = q;
}
 
//后序线索化二叉树T
void CreateInThread(ThreadTree T){
   pre = NULL;                //pre初始为NULL
   if(T!=NULL);{              //非空二叉树才能进行线索化
      PostThread(T);            //后序线索化二叉树
      if(pre->rchild == NULL)
         pre->rtag=1;         //处理遍历的最后一个结点
   }
}

1.6 线索二叉树找前驱/后继

1.6.1 中序线索二叉树

在中序线索二叉树中找到指定节点*p的中序后继next：

  1. 若p->rtag==1，则next = p->rchild；
  2. 若p->rtag==0，则 next 为 p 的右子树中最左下结点。
cpp 复制代码 
//找到以p为根的子树中，第一个被中序遍历的节点
ThreadNode *FirstNode(ThreadNode *p)
{
    //循环找到最左下节点（不定为叶节点）
    while(p->ltag == 0)
        p = p->lchild;
    return p;
}
 
//在中序线索二叉树中找到节点p的后继节点
ThreadNode *NextNode(ThreadNode *p)
{
    //右子树的最左下节点
    if(p->rtag == 0)
        return FirstNode(p->rchild);
    else
        return p->rchild;    //rtag == 1直接返回后继线索
}
 
//对中序线索二叉树进行中序遍历（利用线索实现的非递归算法）
void Inorder(ThreadNode *T)
{
    for(ThreadNode *p = FirstNode(T); p!=NULL; p=NextNode(p))
        visit(p);
}

在中序线索二叉树中找到指定节点*p的中序前驱pre：

① p->ltag == 1, pre = p->lchild

② p->ltag == 0，pre = p的左子树中最右下节点，代码：

cpp 复制代码 
//找到以p为根的子树中，最后一个被中序遍历的节点
ThreadNode *LastNode(ThreadNode *p)
{
    //循环找到最右下节点（不定为叶节点）
    while(p->rtag == 0)
        p = p->rchild;
    return p;
}
 
//在中序线索二叉树中找到节点p的前驱节点
ThreadNode *PreNode(ThreadNode *p)
{
    //左子树中最右下节点
    if(p->ltag == 0)
        return Lastnode(p->lchild);
    else
        return p->lchild;
}
 
//对中序线索二叉树进行逆向中序遍历
void RevInorder(ThreadNode *T)
{
    for(ThreadNode *p = LastNode(T); p!=NULL; p=PreNode(p))
        visit(p);
}

1.6.2 先序线索二叉树

在先序线索二叉树中找到指定节点*p的先序后继next：

① p->rtag == 1, next = p->rchild

② p->rtag == 0，next = 左孩子（没有就右孩子）

先序线索二叉树找到指定结点 * p 的先序前驱 pre：

**前提：**改用三叉链表，可以找到结点 * p 的父节点。

  • 如果能找到 p 的父节点，且 p 是左孩子：p 的父节点即为其前驱；
  • 如果能找到 p 的父节点，且 p 是右孩子，其左兄弟为空：p 的父节点即为其前驱；
  • 如果能找到 p 的父节点，且 p 是右孩子，其左兄弟非空：p 的前驱为左兄弟子树中最后一个被先序遍历的结点；
  • 如果 p 是根节点，则 p 没有先序前驱。

1.6.3 后序线索二叉树

在后序线索二叉树中找到指定节点*p的后序前驱pre：

① p->ltag == 1, pre = p->lchild

② p->ltag == 0，pre = 右孩子（没有就左孩子）

后序线索二叉树找到指定结点 * p 的后序后继 next：

**前提：**改用三叉链表，可以找到结点 * p 的父节点。

  • 如果能找到 p 的父节点，且 p 是右孩子：p 的父节点即为其后继；
  • 如果能找到 p 的父节点，且 p 是左孩子，其右兄弟为空：p 的父节点即为其后继；
  • 如果能找到 p 的父节点，且 p 是左孩子，其右兄弟非空：p 的后继为右兄弟子树中第一个被后序遍历的结点；
  • 如果 p 是根节点，则 p 没有后序后继。

2. 树和森林

2.1 树的存储结构

2.1.1 双亲表示法

本质是顺序存储，用数组顺序存储各个结点。每个结点中保存数据元素、指向双亲结点（父节点）的"指针"

cpp 复制代码 
//数据域：存放结点本身信息。
//双亲域：指示本结点的双亲结点在数组中的位置。
#define MAX_TREE_SIZE 100  //树中最多结点数
 
typedef struct{      //树的结点定义
   ElemType data;   // 数据域
   int parent;      //双亲位置域
}PTNode;
 
typedef struct{                   //树的类型定义
   PTNode nodes[MAX_TREE_SIZE];   //双亲表示
   int n;                         //结点总数
}PTree;

**增：**新增数据元素，无需按逻辑上的次序存储；（需要更改结点数n）

删：（叶子结点）：

① 将伪指针域设置为-1；

②用后面的数据填补；（需要更改结点数n）

查询：

①优点-查指定结点的双亲很方便；

②缺点-查指定结点的孩子只能从头遍历，空数据导致遍历更慢；

优点 : 查指定结点的双亲很方便
缺点:查指定结点的孩子只能从头遍历

适用于 "找父亲" 多，"找孩子" 少 的应用场景。如：并查集

拓展：双亲表示法存储"森林"

2.1.2 孩子表示法（顺序+链式存储）

顺序存储+链式存储结合：用数组顺序存储各个结点。每个结点中保存数据元素、孩子链表头指针

cpp 复制代码 
struct CTNode{
   int child;    //孩子结点在数组中的位置
   struct CTNode *next;    // 下一个孩子
};
 
typedef struct{
   ElemType data;
   struct CTNode *firstChild;    // 第一个孩子
}CTBox;
 
typedef struct{
   CTBox nodes[MAX_TREE_SIZE];
   int n, r;   // 结点总数和根的位置
}CTree;

**优点：**找孩子很方便

**缺点：**找双亲（父节点）不方便，只能遍历每个链表

适用于"找孩子" 多，"找父亲" 少 的应用场景。如：服务流程树

拓展：孩子表示法存储"森林"

用孩子表示法存储森林，需要记录多个根的位置

孩子兄弟表示法（链式存储）

树的孩子兄弟表示法，与二叉树类似，采用二叉链表实现。 每个结点内保存数据元素和两个指针，但两个指针的含义 与二叉树结点不同，分别指向第一个孩子和右兄弟结点

cpp 复制代码 
//孩子兄弟表示法结点
typedef struct CSNode{
    ElemType data;
    struct CSNode *firstchild, *nextsibling;	//第一个孩子和右兄弟结点
}CSNode, *CSTree;

拓展：孩子兄弟表示法存储"森林"

森林中每棵树的 根节点视为平级 的兄弟关系，当使用"孩子兄弟表示法"存储树或森林时，从存储视角来看形态上与二叉树类似。

2.2 树、森林与二叉树的转换

2.2.1 树->二叉树

①在二叉树中画出一个根节点

②按"树的层序"依此处理每个节点：如果当前节点有孩子就把所有孩子节点用右指针串起来，并把第一个孩子挂在该节点左指针下方

③进行步骤②，直到各节点左指针指向第一个孩子，右指针连接最近的一个右兄弟为止。

2.2.2 森林->二叉树

将各树的根节点视为同级的兄弟，其他和树到二叉树的转换方式一样。

①先把所有树的根结点画出来，在二叉树中用右指针串成糖葫芦。

②按"森林的层序"依次处理每个结点：如果当前处理的结点在树中有孩子，就把所有孩子结点"用右 指针串成糖葫芦"，并在二叉树中把第一个孩子挂在当前结点的左指针下方

2.2.3 二叉树->树

①画出树的根节点

②从根节点开始，按"树的层序"恢复每个节点的孩子：在二叉树中，如果当前处理的结点有左孩子，就把左孩 子和"一整串右指针糖葫芦" 拆下来，按顺序挂在当前结点的下方

2.2.4 二叉树->森林

步骤与二叉树到树的转变相同，只不过第一串右子树要拆成不同的几棵树

①先把二叉树的根节点和"一整串右指针糖葫芦"拆下来，作为多棵树的根节点

②按"森林的层序"恢复每个结点的孩子：：在二叉树中，如果当前处理的结点有左孩子，就把左孩子和"一整串右指针糖葫 芦" 拆下来，按顺序挂在当前结点的下方

3.树和森林的遍历

3.1 树的先根遍历

若树非空，先访问根结点，再依次对每棵子树进行先根遍历；（与对应二叉树的先序遍历序列相同）

树的先根遍历序列与这棵树相应二叉树的先序序列相同。

cpp 复制代码 
void PreOrder(TreeNode *R){
   if(R!=NULL){
      visit(R);    //访问根节点
      while(R还有下一个子树T)
         PreOrder(T);      //先跟遍历下一个子树
   }
}

树的后根遍历

若树非空，先依次对每棵子树进行后根遍历，最后再访问根结点。（深度优先遍历）

树的后根遍历序列与这棵树相应二叉树的中序序列相同。

cpp 复制代码 
void PostOrder(TreeNode *R){
   if(R!=NULL){
      while(R还有下一个子树T)
         PostOrder(T);      //后跟遍历下一个子树
      visit(R);    //访问根节点
   }
}

层序遍历（队列实现）广度优先遍历

  1. 若树非空，则根结点入队；
  2. 若队列非空，队头元素出队并访问，同时将该元素的孩子依次入队；
  3. 重复以上操作直至队尾为空；

森林的遍历

  • 先序遍历：若森林为非空，则按如下规则进行遍历：访问森林中第一棵树的根结点。
    先序遍历第一棵树中根结点的子树森林。先序遍历除去第一棵树之后剩余的树构成的森林。

等同于依次对各个树进行先根遍历；也可以先转换成与之对应的二叉树，对二叉树进行先序遍历；

  • 中序遍历：若森林为非空，则按如下规则进行遍历：访问森林中第一棵树的根结点。
    先序遍历第一棵树中根结点的子树森林。先序遍历除去第一棵树之后剩余的树构成的森林。

等同于依次对各个树进行后根遍历；也可以先转换成与之对应的二叉树，对二叉树进行中序遍历；

相关推荐
liuwill9 分钟前
从技术打磨到产品验证：读《程序员修炼之道》的务实之道
笔记·程序人生
爱数模的小云25 分钟前
【华为杯】2024华为杯数模研赛E题 解题思路
算法·华为
白葵新27 分钟前
PCL addLine可视化K近邻
c++·人工智能·算法·计算机视觉·3d
seanli100833 分钟前
线性dp 总结&详解
算法·动态规划
小丁爱养花35 分钟前
记忆化搜索专题——算法简介&力扣实战应用
java·开发语言·算法·leetcode·深度优先
Faris_yzf42 分钟前
物联网LoRa定位技术详解
科技·算法
Crossoads1 小时前
【数据结构】排序算法---快速排序
c语言·开发语言·数据结构·算法·排序算法
DS数模1 小时前
2024华为杯研赛E题保姆级教程思路分析
算法·数学建模·华为·华为杯数学建模·2024华为杯·2024研赛
6230_1 小时前
git使用“保姆级”教程2——初始化及工作机制解释
开发语言·前端·笔记·git·html·学习方法·改行学it
眰恦3741 小时前
数据结构--第五章树与二叉树
数据结构·算法
热门推荐
01RAG 实践- Ollama+RagFlow 部署本地知识库02组基轨迹建模 GBTM的介绍与实现（Stata 或 R）032024年高教社杯数学建模国赛C题超详细解题思路分析04软件工程从理论到实践客观题汇总(头歌第一章至第八章)05苍穹外卖面试总结06【2024数模国赛赛题思路公开】国赛B题思路丨附可运行代码丨无偿自提07【halcon】halcon字符识别——OCR08yolov8实战第五天——yolov8+ffmpg实时视频流检测并进行实时推流——（推流，保姆教学）09【2024高教社杯全国大学生数学建模竞赛】B题 生产过程中的决策问题——解题思路 代码 论文10比特币钱包库 bitcoinjs-lib 讲解：生成钱包、导入钱包、签名验证、转账交易