图解线索二叉树与双向线索二叉树（附源码）

数据结构 前端之家
前端之家收集整理的这篇文章主要介绍了图解线索二叉树与双向线索二叉树（附源码），前端之家小编觉得挺不错的，现在分享给大家，也给大家做个参考。

目录

线索二叉树的概念

  当我们对普通的二叉树进行遍历时需要使用栈结构做重复性的操作。线索二叉树不需要如此，在遍历的同时，使用二叉树中空闲的内存空间记录某些结点的前趋和后继元素的位置（不是全部）。这样在算法后期需要遍历二叉树时，就可以利用保存的结点信息，提高了遍历的效率。使用这种方法构建的二叉树，即为“线索二叉树”。

线索二叉树的结构

  每一棵二叉树上，很多结点都含有未使用的指向NULL 的指针域。除了度为2 的结点，度为1 的结点，有一个空的指针域；叶子结点两个指针域都为NULL。

  线索二叉树实际上就是使用这些空指针域来存储结点之间前趋和后继关系的一种特殊的二叉树。线索二叉树中，如果结点有左子树，则lchild 指针域指向左孩子，否则lchild 指针域指向该结点的直接前趋；同样，如果结点有右子树，则rchild 指针域指向右孩子，否则rchild 指针域指向该结点的直接后继。

在这里插入图片描述


  LTag 和RTag 为标志域。实际上就是两个布尔类型的变量：
   LTag 值为0 时，表示lchild 指针域指向的是该结点的左孩子；为1 时，表示指向的是该结点的直接前趋结点；
   RTag 值为0 时，表示rchild 指针域指向的是该结点的右孩子；为1 时，表示指向的是该结点的直接后继结点。
  结点结构代码实现：

  1. #define TElemType int//宏定义，结点中数据域的类型
  2. //枚举，Link 为0，Thread 为1
  3. typedef enum PointerTag{
  4. Link,Thread
  5. }PointerTag;
  6. //结点结构构造
  7. typedef struct BiThrNode{
  8. TElemType data;//数据域
  9. struct BiThrNode* lchild,*rchild;//左孩子，右孩子指针域
  10. PointerTag Ltag,Rtag;//标志域，枚举类型
  11. }BiThrNode,*BiThrTree;

二叉树的线索化

  将二叉树转化为线索二叉树，实质上是在遍历二叉树的过程中，将二叉链表中的空指针改为指向直接前趋或者直接后继的线索。
  线索化的过程即为在遍历的过程中修改空指针的过程。在遍历过程中，如果当前结点没有左孩子，需要将该结点的lchild 指针指向遍历过程中的前一个结点，所以在遍历过程中，设置一个指针（名为pre ），时刻指向当前访问结点的前一个结点。
  代码实现（拿中序遍历为例）：

  1. /**
  2.  * @Description: 中序对二叉树进行线索化
  3.  * @Param: BiThrTree p 二叉树的结构体指针
  4.  * @Return: 无
  5.  * @Author: Carlos
  6.  */
  7. void InThreading(BiThrTree p)
  8. {
  9.     //如果当前结点存在
  10.     if (p)
  11.     {
  12.         //递归当前结点的左子树，进行线索化
  13.         InThreading(p->lchild); 
  14.         //如果当前结点没有左孩子，左标志位设为1，左指针域指向上一结点pre
  15.         if (!p->lchild)
  16.         {
  17.              //前驱线索
  18.             p->Ltag = Thread;
  19.              //左孩子指针指向前驱
  20.             p->lchild = pre; 
  21.         }
  22.         //如果pre 没有右孩子，右标志位设为1，右指针域指向当前结点。
  23.         if (pre && !pre->rchild)
  24.         {
  25.             //后继线索
  26.             pre->Rtag = Thread;
  27.             //前驱右孩子指针指向后继(当前结点p)
  28.             pre->rchild = p;
  29.         }
  30.         pre = p;                //pre 指向当前结点
  31.         InThreading(p->rchild); //递归右子树进行线索化
  32.     }
  33. }

  注意：中序对二叉树进行线索化的过程中，在两个递归函数中间的运行程序，和之前介绍的中序遍历二叉树的输出函数的作用是相同的。将中间函数移动到两个递归函数之前，就变成了前序对二叉树进行线索化的过程；后序线索化同样如此。

线索二叉树进行遍历

  下图中是一个按照中序遍历建立的线索二叉树。其中，实线表示指针，指向的是左孩子或者右孩子。虚线表示线索，指向的是该结点的直接前趋或者直接后继。

在这里插入图片描述


  使用线索二叉树时，会经常遇到一个问题，如上图中，结点8的直接后继直接通过指针域获得，为结点5；而由于结点5的度为2 ，无法利用指针域指向后继结点，整个链表断掉了。当在遍历过程，遇到这种问题是解决的办法就是：寻找先序、中序、后序遍历的规律，找到下一个结点。
  在先序遍历过程中，如果结点因为有右孩子导致无法找到其后继结点，如果结点有左孩子，则后继结点是其左孩子；否则，就一定是右孩子。拿上图举例，结点2的后继结点是其左孩子结点4 ，如果结点4不存在的话，就是结点5 。
  在中序遍历过程中，结点的后继是遍历其右子树时访问的第一个结点，也就是右子树中位于最左下的结点。例如上图中结点5，后继结点为结点11，是其右子树中位于最左边的结点。反之，结点的前趋是左子树最后访问的那个结点。
  后序遍历中找后继结点需要分为3 种情况：
  1. 如果该结点是二叉树的根，后继结点为空；
  2. 如果该结点是父结点的右孩子（或者是左孩子，但是父结点没有右孩子），后继结点是父结点；
  3. 如果该结点是父结点的左孩子，且父结点有右子树，后继结点为父结点的右子树在后序遍历列出的第一个结点。
  使用后序遍历建立的线索二叉树，在真正使用过程中遇到链表的断点时，需要访问父结点，所以在初步建立二叉树时，宜采用三叉链表做存储结构。
遍历线索二叉树非递归代码实现：

  1. /**
  2.  * @Description: 中序遍历线索二叉树 非递归
  3.  * @Param: BiThrTree p 二叉树的结构体指针
  4.  * @Return: 无
  5.  * @Author: Carlos
  6.  */
  7. void InOrderThraverse_Thr(BiThrTree p)
  8. {
  9.     while (p)
  10.     {
  11.         //一直找左孩子，最后一个为中序序列中排第一的
  12.         while (p->Ltag == Link)
  13.         {
  14.             p = p->lchild;
  15.         }
  16.          //此时p指向中序遍历序列的第一个结点（最左下的结点）  
  17.          
  18.         //打印（访问）其左子树为空的结点  
  19.         printf("%c ",p->data); 
  20.         //当结点右标志位为1 时，直接找到其后继结点
  21.         while (p->Rtag == Thread && p->rchild != NULL)
  22.         {
  23.             p = p->rchild;
  24.             //访问后继结点 
  25.             printf("%c ",p->data);
  26.         }
  27.         
  28.         //当p所指结点的rchild指向的是孩子结点而不是线索时，p的后继应该是其右子树的最左下的结点，即遍历其右子树时访问的第一个节点  
  29.         p = p->rchild;
  30.     }
  31. }

完整代码如下：

  1. /*
  2.  * @Description: 线索二叉树
  3.  * @Version: V1.0
  4.  * @Autor: Carlos
  5.  * @Date: 2020-05-20 16:31:33
  6.  * @LastEditors: Carlos
  7.  * @LastEditTime: 2020-06-01 20:19:22
  8.  */
  9. #include <stdio.h>
  10. #include <stdlib.h>
  11. #define TElemType char //宏定义，结点中数据域的类型
  12. //枚举，Link 为0，Thread 为1
  13. typedef enum
  14. {
  15.     Link,Thread
  16. } PointerTag;
  17. //结点结构构造
  18. typedef struct BiThrNode
  19. {
  20.     //数据域
  21.     TElemType data;                    
  22.     //左孩子，右孩子指针域
  23.     struct BiThrNode *lchild,*rchild; 
  24.     //标志域，枚举类型
  25.     PointerTag Ltag,Rtag;             
  26. } BiThrNode,*BiThrTree;
  27. BiThrTree pre = NULL;
  28. /**
  29.  * @Description: 初始化二叉树
  30.  * @Param: BiTree *T 二叉树的结构体指针
  31.  * @Return: 无
  32.  * @Author: Carlos
  33.  */
  34. void CreateBiTree(BiThrTree *T){
  35.     *T=(BiThrNode*)malloc(sizeof(BiThrNode));
  36.     (*T)->data=1;
  37.     (*T)->lchild=(BiThrNode*)malloc(sizeof(BiThrNode));
  38.     (*T)->rchild=(BiThrNode*)malloc(sizeof(BiThrNode));
  39.    
  40.     (*T)->lchild->data=2;
  41.     (*T)->lchild->lchild=(BiThrNode*)malloc(sizeof(BiThrNode));
  42.     (*T)->lchild->rchild=(BiThrNode*)malloc(sizeof(BiThrNode));
  43.     (*T)->lchild->rchild->data=5;
  44.     (*T)->lchild->rchild->lchild=NULL;
  45.     (*T)->lchild->rchild->rchild=NULL;
  46.    
  47.     (*T)->rchild->data=3;
  48.     (*T)->rchild->lchild=(BiThrNode*)malloc(sizeof(BiThrNode));
  49.     (*T)->rchild->lchild->data=6;
  50.     (*T)->rchild->lchild->lchild=NULL;
  51.     (*T)->rchild->lchild->rchild=NULL;
  52.    
  53.     (*T)->rchild->rchild=(BiThrNode*)malloc(sizeof(BiThrNode));
  54.     (*T)->rchild->rchild->data=7;
  55.     (*T)->rchild->rchild->lchild=NULL;
  56.     (*T)->rchild->rchild->rchild=NULL;
  57.    
  58.     (*T)->lchild->lchild->data=4;
  59.     (*T)->lchild->lchild->lchild=NULL;
  60.     (*T)->lchild->lchild->rchild=NULL;
  61. }
  63. /**
  64.  * @Description: 采用前序初始化二叉树  中序和后序只需改变赋值语句的位置即可
  65.  * @Param: BiThrTree *tree 二叉树的结构体指针数组
  66.  * @Return: 无
  67.  * @Author: Carlos
  68.  */
  69. void CreateTree(BiThrTree *tree)
  70. {
  71.     char data;
  72.     scanf("%c",&data);
  73.     if (data != '#')
  74.     {
  75.         if (!((*tree) = (BiThrNode *)malloc(sizeof(BiThrNode))))
  76.         {
  77.             printf("申请结点空间失败");
  78.             return;
  79.         }
  80.         else
  81.         {
  82.             //采用前序遍历方式初始化二叉树
  83.             (*tree)->data = data;          
  84.             //初始化左子树 
  85.             CreateTree(&((*tree)->lchild));
  86.             //初始化右子树 
  87.             CreateTree(&((*tree)->rchild)); 
  88.         }
  89.     }
  90.     else
  91.     {
  92.         *tree = NULL;
  93.     }
  94. }
  96. /**
  97.  * @Description: 中序对二叉树进行线索化
  98.  * @Param: BiThrTree p 二叉树的结构体指针
  99.  * @Return: 无
  100.  * @Author: Carlos
  101.  */
  102. void InThreading(BiThrTree p)
  103. {
  104.     //如果当前结点存在
  105.     if (p)
  106.     {
  107.         //递归当前结点的左子树，进行线索化
  108.         InThreading(p->lchild); 
  109.         //如果当前结点没有左孩子，左标志位设为1，左指针域指向上一结点pre
  110.         if (!p->lchild)
  111.         {
  112.              //前驱线索
  113.             p->Ltag = Thread;
  114.              //左孩子指针指向前驱
  115.             p->lchild = pre; 
  116.         }
  117.         //如果pre 没有右孩子，右标志位设为1，右指针域指向当前结点。
  118.         if (pre && !pre->rchild)
  119.         {
  120.             //后继线索
  121.             pre->Rtag = Thread;
  122.             //前驱右孩子指针指向后继(当前结点p)
  123.             pre->rchild = p;
  124.         }
  125.         pre = p;                //pre 指向当前结点
  126.         InThreading(p->rchild); //递归右子树进行线索化
  127.     }
  128. }
  130. /**
  131.  * @Description: 中序遍历线索二叉树 非递归
  132.  * @Param: BiThrTree p 二叉树的结构体指针
  133.  * @Return: 无
  134.  * @Author: Carlos
  135.  */
  136. void InOrderThraverse_Thr(BiThrTree p)
  137. {
  138.     while (p)
  139.     {
  140.         //一直找左孩子，最后一个为中序序列中排第一的
  141.         while (p->Ltag == Link)
  142.         {
  143.             p = p->lchild;
  144.         }
  145.          //此时p指向中序遍历序列的第一个结点（最左下的结点）  
  146.          
  147.         //打印（访问）其左子树为空的结点  
  148.         printf("%c ",p->data);
  149.         }
  150.         
  151.         //当p所指结点的rchild指向的是孩子结点而不是线索时，p的后继应该是其右子树的最左下的结点，即遍历其右子树时访问的第一个节点  
  152.         p = p->rchild;
  153.     }
  154. }
  155. int main()
  156. {
  157.     BiThrTree t;
  158.     printf("输入前序二叉树:\n");
  159.     CreateTree(&t);
  160.     // CreateBiTree(&t);
  161.     InThreading(t);
  162.     printf("输出中序序列:\n");
  163.     InOrderThraverse_Thr(t);
  164.     return 0;
  165. }

双向线索二叉树的概念

  在遍历使用中序序列创建的线索二叉树时，对于其中的每个结点，即使没有线索的帮助
下，也可以通过中序遍历的规律找到直接前趋和直接后继结点的位置。也就是说，建立的线索二叉链表可以从两个方向对结点进行中序遍历。线索二叉链表可以从第一个结点往后逐个遍历。但是起初由于没有记录中序序列中最后一个结点的位置，所以不能实现从最后一个结点往前逐个遍历。双向线索链表的作用就是可以让线索二叉树从两个方向实现遍历。

双向线索二叉树的实现过程

  在线索二叉树的基础上，额外添加一个结点。此结点的作用类似于链表中的头指针，数据域不起作用，只利用两个指针域（由于都是指针，标志域都为0 ）。左指针域指向二叉树的树根，确保可以正方向对二叉树进行遍历；同时，右指针指向线索二叉树形成的线性序列中的最后一个结点。
  这样，二叉树中的线索链表就变成了双向线索链表，既可以从第一个结点通过不断地找后继结点进行遍历，也可以从最后一个结点通过不断找前趋结点进行遍历。

在这里插入图片描述


代码实现

  1. /**
  2.  * @Description: 建立双向线索链表
  3.  * @Param: BiThrTree *h 结构体指针数组 BiThrTree t 结构体指针
  4.  * @Return: 无
  5.  * @Author: Carlos
  6.  */
  7. void InOrderThread_Head(BiThrTree *h,BiThrTree t)
  8. {
  9.     //初始化头结点
  10.     (*h) = (BiThrTree)malloc(sizeof(BiThrNode));
  11.     if ((*h) == NULL)
  12.     {
  13.         printf("申请内存失败");
  14.         return;
  15.     }
  16.     (*h)->rchild = *h;
  17.     (*h)->Rtag = Link;
  18.     //如果树本身是空树
  19.     if (!t)
  20.     {
  21.         (*h)->lchild = *h;
  22.         (*h)->Ltag = Link;
  23.     }
  24.     else
  25.     {
  26.         //pre 指向头结点
  27.         pre = *h;        
  28.         //头结点左孩子设为树根结点 
  29.         (*h)->lchild = t; 
  30.         (*h)->Ltag = Link;
  31.         //线索化二叉树，pre 结点作为全局变量，线索化结束后，pre 结点指向中序序列中最后一个结点
  32.         InThreading(t); 
  33.         //链接最后一个节点（最右下角G节点）和头结点
  34.         pre->rchild = *h;
  35.         pre->Rtag = Thread;
  36.         //将头结点的右指针指向中序序列最后一个节点
  37.         (*h)->rchild = pre;
  38.     }
  39. }

双向线索二叉树的遍历

  双向线索二叉树遍历时，如果正向遍历，就从树的根结点开始。整个遍历过程结束的标志是：当从头结点出发，遍历回头结点时，表示遍历结束。

  1. /**
  2.  * @Description: 中序正向遍历双向线索二叉树
  3.  * @Param: BiThrTree h 二叉树的结构体指针
  4.  * @Return: 无
  5.  * @Author: Carlos
  6.  */
  7. void InOrderThraverse_Thr(BiThrTree h)
  8. {
  9.     BiThrTree p;
  10.     //p 指向根结点
  11.     p = h->lchild; 
  12.     while (p != h)
  13.     {
  14.         //当ltag = 0 时循环到中序序列的第一个结点。
  15.         while (p->Ltag == Link) 
  16.         {
  17.             p = p->lchild;
  18.         }
  19.         //显示结点数据，可以更改为其他对结点的操作
  20.         printf("%c ",p->data); 
  21.         
  22.         //如果当前节点经过了线索化，直接利用该节点访问下一节点
  23.         while (p->Rtag == Thread && p->rchild != h)
  24.         {
  25.             p = p->rchild;
  26.             printf("%c ",p->data);
  27.         }
  28.         //如果没有线索化或者跳出循环，说明其含有右子树。p 进入其右子树
  29.         p = p->rchild; 
  30.     }
  31. }

  逆向遍历线索二叉树的过程即从头结点的右指针指向的结点出发，逐个寻找直接前趋结点，结束标志同正向遍历一样：

  1. /**
  2.  * @Description: 中序逆方向遍历线索二叉树 和正向的区别在于 p = p->rchild 。逆向遍历我们要一直访问到右子树的最后一个。
  3.  * @Param: BiThrTree h 二叉树的结构体指针
  4.  * @Return: 无
  5.  * @Author: Carlos
  6.  */
  7. void InOrderThraverse_Thr(BiThrTree h)
  8. {
  9.     BiThrTree p;
  10.     p = h->rchild;
  11.     while (p != h)
  12.     {
  13.         while (p->Rtag == Link)
  14.         {
  15.             p = p->rchild;
  16.         }
  17.         printf("%c",p->data);
  18.         //如果lchild 为线索，直接使用，输出
  19.         while (p->Ltag == Thread && p->lchild != h)
  20.         {
  21.             p = p->lchild;
  22.             printf("%c",p->data);
  23.         }
  24.         p = p->lchild;
  25.     }
  26. }

  完整代码如下

  1. /*
  2.  * @Description: 双向线索二叉树的遍历
  3.  * @Version: V1.0
  4.  * @Autor: Carlos
  5.  * @Date: 2020-06-01 20:46:38
  6.  * @LastEditors: Carlos
  7.  * @LastEditTime: 2020-06-01 21:17:23
  8.  */
  9. #include <stdio.h>
  10. #include <stdlib.h>
  11. //宏定义，结点中数据域的类型
  12. #define TElemType char 
  13. //枚举，Link 为0，Thread 为1
  14. typedef enum
  15. {
  16.     Link,Thread
  17. } PointerTag;
  18. //结点结构构造
  19. typedef struct BiThrNode
  20. {
  21.     //数据域
  22.     TElemType data;    
  23.     //左孩子，右孩子指针域                
  24.     struct BiThrNode *lchild,*BiThrTree;
  25. BiThrTree pre = NULL;
  26. /**
  27.  * @Description: 采用前序初始化二叉树  中序和后序只需改变赋值语句的位置即可
  28.  * @Param: BiThrTree *tree 二叉树的结构体指针数组
  29.  * @Return: 无
  30.  * @Author: Carlos
  31.  */
  32. void CreateTree(BiThrTree *tree)
  33. {
  34.     char data;
  35.     scanf("%c",&data);
  36.     if (data != '#')
  37.     {
  38.         if (!((*tree) = (BiThrNode *)malloc(sizeof(BiThrNode))))
  39.         {
  40.             printf("申请结点空间失败");
  41.             return;
  42.         }
  43.         else
  44.         {
  45.             //采用前序遍历方式初始化二叉树
  46.             (*tree)->data = data;           
  47.             //初始化左子树
  48.             CreateTree(&((*tree)->lchild)); 
  49.             //初始化右子树
  50.             CreateTree(&((*tree)->rchild)); 
  51.         }
  52.     }
  53.     else
  54.     {
  55.         *tree = NULL;
  56.     }
  57. }
  58. /**
  59.  * @Description: 中序对二叉树进行线索化 
  60.  * @Param: BiThrTree p 二叉树的结构体指针
  61.  * @Return: 无
  62.  * @Author: Carlos
  63.  */
  64. void InThreading(BiThrTree p)
  65. {
  66.     //如果当前结点存在
  67.     if (p)
  68.     {
  69.         //递归当前结点的左子树，进行线索化
  70.         InThreading(p->lchild); 
  71.         //如果当前结点没有左孩子，左标志位设为1，左指针域指向上一结点pre
  72.         if (!p->lchild)
  73.         {
  74.             p->Ltag = Thread;
  75.             //pre为头结点，链接中序遍历的第一个节点（最左边的结点）与头结点
  76.             p->lchild = pre;
  77.         }
  78.         //如果pre 没有右孩子，右标志位设为1，右指针域指向当前结点。
  79.         if (pre && !pre->rchild)
  80.         {
  81.             pre->Rtag = Thread;
  82.             pre->rchild = p;
  83.         }
  84.         //pre 指向当前结点
  85.         pre = p;             
  86.         //递归右子树进行线索化   
  87.         InThreading(p->rchild); 
  88.     }
  89. }
  91. /**
  92.  * @Description: 建立双向线索链表
  93.  * @Param: BiThrTree *h 结构体指针数组 BiThrTree t 结构体指针
  94.  * @Return: 无
  95.  * @Author: Carlos
  96.  */
  97. void InOrderThread_Head(BiThrTree *h,BiThrTree t)
  98. {
  99.     //初始化头结点
  100.     (*h) = (BiThrTree)malloc(sizeof(BiThrNode));
  101.     if ((*h) == NULL)
  102.     {
  103.         printf("申请内存失败");
  104.         return;
  105.     }
  106.     (*h)->rchild = *h;
  107.     (*h)->Rtag = Link;
  108.     //如果树本身是空树
  109.     if (!t)
  110.     {
  111.         (*h)->lchild = *h;
  112.         (*h)->Ltag = Link;
  113.     }
  114.     else
  115.     {
  116.         //pre 指向头结点
  117.         pre = *h;        
  118.         //头结点左孩子设为树根结点 
  119.         (*h)->lchild = t; 
  120.         (*h)->Ltag = Link;
  121.         //线索化二叉树，pre 结点作为全局变量，线索化结束后，pre 结点指向中序序列中最后一个结点
  122.         InThreading(t); 
  123.         //链接最后一个节点（最右边下角）和头结点
  124.         pre->rchild = *h;
  125.         pre->Rtag = Thread;
  126.         (*h)->rchild = pre;
  127.     }
  128. }
  130. /**
  131.  * @Description: 中序正向遍历双向线索二叉树
  132.  * @Param: BiThrTree h 二叉树的结构体指针
  133.  * @Return: 无
  134.  * @Author: Carlos
  135.  */
  136. void InOrderThraverse_Thr(BiThrTree h)
  137. {
  138.     BiThrTree p;
  139.     //p 指向根结点
  140.     p = h->lchild; 
  141.     while (p != h)
  142.     {
  143.         //当ltag = 0 时循环到中序序列的第一个结点。
  144.         while (p->Ltag == Link) 
  145.         {
  146.             p = p->lchild;
  147.         }
  148.         //显示结点数据，可以更改为其他对结点的操作
  149.         printf("%c ",p->data);
  150.         }
  151.         //如果没有线索化或者跳出循环，说明其含有右子树。p 进入其右子树
  152.         p = p->rchild; 
  153.     }
  154. }
  155. /**
  156.  * @Description: 中序逆方向遍历线索二叉树 和正向的区别在于 p = p->rchild 。逆向遍历我们要一直访问到右子树的最后一个。
  157.  * @Param: BiThrTree h 二叉树的结构体指针
  158.  * @Return: 无
  159.  * @Author: Carlos
  160.  */
  161. void InOrderThraverse_Thr(BiThrTree h)
  162. {
  163.     BiThrTree p;
  164.     p = h->rchild;
  165.     while (p != h)
  166.     {
  167.         while (p->Rtag == Link)
  168.         {
  169.             p = p->rchild;
  170.         }
  171.         printf("%c",p->data);
  172.         }
  173.         p = p->lchild;
  174.     }
  175. }
  176. int main()
  177. {
  178.     BiThrTree t;
  179.     BiThrTree h;
  180.     printf("输入前序二叉树:\n");
  181.     CreateTree(&t);
  182.     InOrderThread_Head(&h,t);
  183.     printf("输出中序序列:\n");
  184.     InOrderThraverse_Thr(h);
  185.     return 0;
  186. }

总结

  二叉树的线索化就是充分利用了节点的空指针域。所有节点线索化的过程也就是当前节点指针和上一结点指针进行链接的过程，不断递归所有节点。线索化二叉树的访问，以中序遍历为例，首先需要访问到中序遍历的第一个节点，若当前节点进行了线索化，可以直接利用该节点进行下一节点的访问。否则，说明当前节点含有右子树，则进入右子树进行访问。双向线索二叉树的建立，其实就将头结点的左指针和树的根节点链接，头结点的右指针和中序遍历的最后一个节点的链接。这样我们就可以进行双向访问了。当从头结点出发，遍历回头结点时，表示遍历结束。

有任何问题，均可通过公告中的二维码联系我

猜你在找的数据结构相关文章

【数据结构】键树
键树的基本概念 键树又称数字查找树（Digital Search Tree）。 它是一棵度大于等于2的树，...
【数据结构】绪论
[TOC] 基本概念 数据： 数据 是对客观事物的符号表示，在计算机科学中指所有能输入到计算机...
【数据结构】证明法
[TOC] 反证法 基本概念： 一般地，假设原命题不成立（即 在原命题的条件下，结论不成立），...
数据结构与算法系列之目录
最近抽空整理了&quot;数据结构和算法&quot;的相关文章。在整理过程中，对于每种数...
【数据结构】数组
[TOC] 矩阵在计算机图形学、工程计算中占有举足轻重的地位。在数据结构中考虑的是如何用最...
[操作系统]操作系统中断机制
1.当中断发生时，cpu立即进入核心态 2.当中断发生后，当前进程进入暂停状态，操作系统内核...
[日常] 浏览器前进后退与数据结构的思想
一张图保存一下 红点是当前地址 白色箭头是新打开页面 黑色箭头是后退页面 栈的思想 , 后退...
[算法] 开放寻址法解决哈希冲突方式
开放寻址法：又称开放定址法，当哈希冲突发生时，从发生冲突的那个单元起，按照一定的次序...
二叉树的基本概念介绍与代码实现（多图+代码）
@ 树的基本概念 图1 树的结点 结点：使用树结构存储的每一个数据元素都被称为“结点”。例...
史上最全单链表的增删改查反转等操作汇总以及5种排序算法(C语言)
1.准备工作 首先包含头文件，定义链表结构体，产生随即链表的范围，定义全局头尾节点。 #i...
LinuxWindowsCentOSUbuntuNginxWebServiceScalaMemcacheApacheRedisDockerBashAzureTomcatLNMPShell数据结构服务器运维网络安全
xebugnodemondocker-copydcoselasticsearcwindows-contdocker-windodocker-awsamazon-cloudenvoyproxyhashicorp-vaswisscomdevkafka-pythonzscalerphoton-osdocker-swarmkamongoogle-cloudconcoursewso2-ampersistent-vapi-managerprocess-manamanjarojenkins-workhypriotremoteapikeystonejsbitcoindbitcoin-test