数据结构--树--线索二叉树（中序，前序，后序）

最新推荐文章于 2022-05-15 10:30:24 发布
最新推荐文章于 2022-05-15 10:30:24 发布
阅读量1.6k 收藏 1
点赞数 3
分类专栏： 算法与数据结构
原文链接：https://blog.csdn.net/DouBoomFly/article/details/71572601
版权

线索二叉树
在遍历二叉树的时候，会有许多空指针域，这些空间不存储任何事物，白白浪费了内存的资源。
那么在做遍历的时候，提前记录下每个结点的前驱和后继，这样就更加节约了时间。
                 [ lchild ] [ LTag ] [ data ] [ RTag ] [ rchild ]
LTag  = { 0 : lchild 域指示结点的左孩子 1 : lchild 域指示结点的前驱 }
RTag = { 0 : rchild 域指示结点的右孩子 1 : rchild 域指示结点的后继 }  
以这种结点结构构成的二叉链表作为二叉树的存储结构，叫做线索链表，其中，指向结点前驱和后继的指针，叫做线索。
加上线索的二叉树叫做线索二叉树（Threaded Binary Tree）
对二叉树以某种次序遍历使其变成线索二叉树的过程叫做线索化


★线索二叉树结构：

    #define TElemType char
    typedef enum{
        Link,Thread
    }PointerTag;//Link == 0 :指针 ,Thread == 1: 线索
    typedef struct BiThrNode{
        TElemType data;
        struct BiThrNode *lchild, *rchild; //左右孩子指针
        PointerTag LTag , RTag;            //左右标志
    }BiThrNode, *BiThrTree;


                 [ lchild ] [ LTag ] [ data ] [ RTag ] [ rchild ]
LTag  = { 0 : lchild 域指示结点的左孩子 1 : lchild 域指示结点的前驱 }
RTag = { 0 : rchild 域指示结点的右孩子 1 : rchild 域指示结点的后继 }  


★线索化二叉树之前，咱们先把树建起来（用前序遍历建树）

    //char Vexch[20]={'H','D','A','$','$','C','$','B','$','$','G','F','$','E','$','$','$'};  
    char Vexch[26]={'A','B','D','H','$','$','I','$','$','E','J','$','$','$','C','F','$','$','G','$','$'};  
    int i=0;  
    //二叉树的创建  
    Status CreatBiThrTree(BiThrTree &T)  
    {  
        if(Vexch[i++]=='$') T=NULL;  
        else  
        {  
            T= (BiThrTree)malloc(sizeof(BiThrNode));
            if(!T)  return 0;  
            T->data=Vexch[i-1];//生成根节点  
            printf("%5c",T->data);
            T->LTag=Link;  
            CreatBiThrTree(T->lchild);//创建左子树
            T->RTag=Link;
            CreatBiThrTree(T->rchild);//创建右子树  
        }  
        return 1;  
    }  


建立树为该树：
 

遍历visit()函数

    Status visit(TElemType e){
        printf("%5c",e);
        return OK;
    }


（1）中序遍历，线索二叉树
【让一棵树 直接变成一个线性表去遍历】
遍历 顺序为：H - >D - > I - > B  - > J - > E - > A - > F - > C - >  G
【建立二叉树头结点】（下面的代码没有循环，只是单纯的建立了一个头结点，连接上主体的树部分，方便遍历。）

    //建立头结点，中序线索二叉树
    Status InOrderThreading(BiThrTree &Thrt,BiThrTree T){
        //中序遍历二叉树T，并将其中序线索化，Thrt指向头结点。
        if(!(Thrt = (BiThrTree)malloc(sizeof(BiThrNode))))
            return ERROR;
        
        Thrt->RTag = Link;  //建头结点
        Thrt->rchild = Thrt ;                    //右指针回指
        if(!T){
            Thrt->lchild = Thrt;
            Thrt->LTag = Link;
        }else{
            pre = Thrt ;
            Thrt->lchild = T;
            Thrt->LTag = Link;
            InThreading(T);
            pre->rchild = Thrt ;
            pre->RTag = Thread;
            Thrt->rchild = pre;
        }
        return OK;
    }

【解释】（pre永远指向上一个节点）
Thrt 就是 下图的空指针， 初始化 pre 为 这个空指针，完成下图的【1】【2】步骤
做完树的线索化后，pre 已经到了最后一个节点，那么就可以完成【3】【4】两个步骤了
如下图所示。
【1】让最左的结点，就是中序遍历时 第一个结点的左指针指向 空的头结点。
【第一个结点的左标记肯定是 Thread而不是 link ，这样就能找到最左的结点】 那么既然是线索Thread，就让他指向空的头结点（反正空着也是空着）
【2】头结点顺下来，从左子树开始找
【3】因为空节点的右标记是 Thread线索，那么让他指向最右的，最终结点。（反正空着也是空着）
【4】最终结点G的右线索指向头结点，标记着终结。
构成循环：
                    ↓   →  →  →  →   【  空的头结点】 ← ←  ←  ← ↑
                   H → D →  I → B  →  J → E →  A → F →  C →  G
 

★LTag  = { 0 : lchild 域指示结点的左孩子 1 : lchild 域指示结点的前驱 } RTag = { 0 : rchild 域指示结点的右孩子 1 : rchild 域指示结点的后继 }  
概括为：LTag=0(Link)【左孩子】，LTag=1(Thread)【前驱】；RTag=0(Link)【右孩子】 ，RTag=1(Thread)【后继】
【问】那么怎样的称为Link指针 ，怎样的 称为 Thread 线索

【答】可以这样理解，Link指针是本来建树的时候就有的，而Thread线索是为了线索化，而增添的。


【中序遍历线索化】

    BiThrTree pre;  //全局变量，始终指向刚刚访问过的结点。
    void InThreading(BiThrTree p){
        if(p){
            InThreading(p->lchild);     //左子树线索化
            if(!p->lchild){             //没有左孩子
                p->LTag = Thread;       //前驱线索
                p->lchild = pre;        //左孩子指针指向前驱
            }
            if(!pre->rchild){
                pre->RTag = Thread;       //后继线索
                pre->rchild = p ;         //前驱右孩子指针指向后继
            }
            pre = p;
            InThreading(p->rchild);   //右子树线索化
        }
    }

【解释】
首先，很明显：中序遍历线索化，其实也是基于中序遍历的。（从代码中可以看出）
也是先左，再中，后右（左 > 中 > 右）
只是在中间部分，对结点的处理的时候，有些不一样。1、中序遍历时是输出。2、而现在我们把它替换为 处理标记和指针。
介绍如何处理，很简单：
★没有左孩子，或者没有右孩子那肯定是线索，而不是指针
★因为是中序，遍历肯定是从左到右，那么左边的线索肯定是指向前驱的，右边的线索肯定是指向后继的。


【中序遍历】

    //中序 遍历线索二叉树
    Status InOrderTraverse_Thr(BiThrTree T ,Status(* visit)(TElemType e) ){
        //T指向头结点，头结点的左链lchild指向根节点，可参见线索化算法
        //中序遍历二叉线索树T的非递归算法，对每个数据元素调用函数visit
        BiThrTree p ;
        p = T->lchild;            // p指向根节点
        while(p != T){                      //空树 或者遍历结束时 p == T
            while(p->LTag == Link )         // 走到最左结点
                p = p->lchild;
            visit(p->data);  
            while(p->RTag == Thread && p->rchild !=T){
                p = p->rchild ;             // 若有右线索，
                visit(p->data);
            }
            p = p->rchild;
        }
        return OK;
    }

【解释】
最外面的while 从上面构造的时候就已经说明了，当p回到T的时候，那么就标记结束了。
里面的第一个 while(p->LTag == Link) 循环，走到最左结点
输出该节点
while(p->RTag == Thread && p->rchild !=T)  如果右边有线索，且指向的不是最后的根T， 优先按着线索走。
发现这里没有线索了，那么就继续往右孩子找。


【总的中序遍历线索二叉树代码】

    #include <iostream>
    #include <string.h>
    #include <cstdio>
    #include <stdlib.h>
    using namespace std;
    #define Status int
    #define OK 1
    #define ERROR 0
    #define TElemType char
    typedef enum{
        Link,Thread
    }PointerTag;//Link == 0 :指针 ,Thread == 1: 线索
    typedef struct BiThrNode{
        TElemType data;
        struct BiThrNode *lchild, *rchild; //左右孩子指针
        PointerTag LTag , RTag;            //左右标志
    }BiThrNode, *BiThrTree;
     
    //char Vexch[20]={'H','D','A','$','$','C','$','B','$','$','G','F','$','E','$','$','$'};  
    char Vexch[26]={'A','B','D','H','$','$','I','$','$','E','J','$','$','$','C','F','$','$','G','$','$'};  
    int i=0;  
    //二叉树的创建  
    Status CreatBiThrTree(BiThrTree &T)  
    {  
        if(Vexch[i++]=='$') T=NULL;  
        else  
        {  
            T= (BiThrTree)malloc(sizeof(BiThrNode));
            if(!T)  return 0;  
            T->data=Vexch[i-1];//生成根节点  
            printf("%5c",T->data);
            T->LTag=Link;  
            CreatBiThrTree(T->lchild);//创建左子树
            T->RTag=Link;
            CreatBiThrTree(T->rchild);//创建右子树  
        }  
        return 1;  
    }  
    Status visit(TElemType e){
        printf("%5c",e);
        return OK;
    }
     
    BiThrTree pre;  //全局变量，始终指向刚刚访问过的结点。
    void InThreading(BiThrTree p){
        if(p){
            InThreading(p->lchild);     //左子树线索化
            if(!p->lchild){             //没有左孩子
                p->LTag = Thread;       //前驱线索
                p->lchild = pre;        //左孩子指针指向前驱
            }
            if(!pre->rchild){
                pre->RTag = Thread;       //后继线索
                pre->rchild = p ;         //前驱右孩子指针指向后继
            }
            pre = p;
            InThreading(p->rchild);   //右子树线索化
        }
    }
    //建立头结点，中序线索二叉树
    Status InOrderThreading(BiThrTree &Thrt,BiThrTree T){
        //中序遍历二叉树T，并将其中序线索化，Thrt指向头结点。
        if(!(Thrt = (BiThrTree)malloc(sizeof(BiThrNode))))
            return ERROR;
        
        Thrt->RTag = Link;  //建头结点
        Thrt->rchild = Thrt ;                    //右指针回指
        if(!T){
            Thrt->lchild = Thrt;
            Thrt->LTag = Link;
        }else{
            pre = Thrt ;
            Thrt->lchild = T;
            Thrt->LTag = Link;
            InThreading(T);
            pre->rchild = Thrt ;
            pre->RTag = Thread;
            Thrt->rchild = pre;
        }
        return OK;
    }
    //中序 遍历线索二叉树
    Status InOrderTraverse_Thr(BiThrTree T ,Status(* visit)(TElemType e) ){
        //T指向头结点，头结点的左链lchild指向根节点，可参见线索化算法
        //中序遍历二叉线索树T的非递归算法，对每个数据元素调用函数visit
        BiThrTree p ;
        p = T->lchild;            // p指向根节点
        while(p != T){                      //空树 或者遍历结束时 p == T
            while(p->LTag == Link )         // 走到最左结点
                p = p->lchild;
            visit(p->data);  
            while(p->RTag == Thread && p->rchild !=T){
                p = p->rchild ;             // 若有右线索，
                visit(p->data);
            }
            p = p->rchild;
        }
        return OK;
    }
    int main()
    {
        BiThrTree T, inorderT;
        printf("创建树\n");
        CreatBiThrTree(T);
        printf("\n中序遍历线索二叉树\n");
        InOrderThreading(inorderT , T);
        InOrderTraverse_Thr(inorderT , visit);
        printf("\n");
        return 0;
    }

 


（2）前序遍历，线索二叉树


【前序遍历二叉树线索化】

    BiThrTree pre;  //全局变量，始终指向刚刚访问过的结点。
    void PreThreading(BiThrTree p){
        if(p){
            if(!p->lchild){             //没有左孩子
                p->LTag = Thread;       //前驱线索
                p->lchild = pre;        //左孩子指针指向前驱
            }
            if(!pre->rchild && pre){
                pre->RTag = Thread;       //后继线索
                pre->rchild = p ;         //前驱右孩子指针指向后继
            }
            pre = p;
            if(p->LTag == Link)
                PreThreading(p->lchild);     //左子树线索化
            if(p->RTag == Link)
                PreThreading(p->rchild);   //右子树线索化
        }
    }

【建立头结点】（和中序遍历一样）

    //建立头结点，前序线索二叉树
    Status PreOrderThreading(BiThrTree &Thrt,BiThrTree T){
        //前序遍历二叉树T，并将其前序线索化，Thrt指向头结点。
        if(!(Thrt = (BiThrTree)malloc(sizeof(BiThrNode))))
            return ERROR;
        
        Thrt->RTag = Thread;               //建头结点
        Thrt->rchild = Thrt ;              //右指针回指
        Thrt->LTag = Link;
        if(!T){
            Thrt->lchild = Thrt;
        }else{
            Thrt->lchild = T;
            pre = Thrt ;
            PreThreading(T);
            pre->rchild = Thrt ;
            pre->RTag = Thread;
            Thrt->rchild = pre;
        }
        return OK;
    }


                                                                               ↓  ← 【  空的头结点  】 ← ←  ←  ←  ←  ←  ←   ↑
                                                                               A → B →  D → H  →  I →  E →  J → C →  F →  G


   

         1、A的直接前驱

          ㈠若LTag 的值为1，那么LChild 所指结点就是直接前驱

          ㈡若LTag 的值为0，那么

                 ⒈若A为双亲左儿子，那么直接前驱就是A的双亲结点

                 ⒉若A为双亲右儿子，那么直接前驱就是A的双亲左儿子

         2、A的直接后继

          ㈠若RTag 的值为1，那么RChild 所指结点就是直接后继

          ㈡若RTag 的值为0，那么

                  ⒈若LTag 的值为0，那么直接后继就是其左儿子。

                  ⒉若LTag 的值为1，那么直接后继就是其右儿子。

【前序遍历二叉树】

    //前序 遍历线索二叉树
    Status PreOrderTraverse_Thr(BiThrTree T ,Status(* visit)(TElemType e) ){
        //T指向头结点，头结点的左链lchild指向根节点，可参见线索化算法
        //前序遍历二叉线索树T的非递归算法，对每个数据元素调用函数visit
        BiThrTree p ;
        p = T->lchild;            // p指向根节点
        while(p != T){            //空树 或者遍历结束时 p == T
            visit(p->data);  
            if(p->LTag == Link)
                p = p->lchild;
            else
                p = p->rchild;
        }
        return OK;
    }


【总的前序遍历线索二叉树代码】

    #include <iostream>
    #include <string.h>
    #include <cstdio>
    #include <stdlib.h>
    using namespace std;
    #define Status int
    #define OK 1
    #define ERROR 0
    #define TElemType char
     
    typedef enum{
        Link,Thread
    }PointerTag;//Link == 0 :指针 ,Thread == 1: 线索
    typedef struct BiThrNode{
        TElemType data;
        struct BiThrNode *lchild, *rchild; //左右孩子指针
        PointerTag LTag , RTag;            //左右标志
    }BiThrNode, *BiThrTree;
     
    //char Vexch[20]={'H','D','A','$','$','C','$','B','$','$','G','F','$','E','$','$','$'};  
    char Vexch[26]={'A','B','D','H','$','$','I','$','$','E','J','$','$','$','C','F','$','$','G','$','$'};  
    int i=0;  
    //二叉树的创建  
    Status CreatBiThrTree(BiThrTree &T)  
    {  
        if(Vexch[i++]=='$') T=NULL;  
        else  
        {  
            T= (BiThrTree)malloc(sizeof(BiThrNode));
            if(!T)  return 0;  
            T->data=Vexch[i-1];//生成根节点  
            printf("%5c",T->data);
            T->LTag=Link;
            CreatBiThrTree(T->lchild);//创建左子树
            T->RTag=Link;
            CreatBiThrTree(T->rchild);//创建右子树  
        }  
        return 1;  
    }  
    Status visit(TElemType e){
        printf("%5c",e);
        return OK;
    }
     
    BiThrTree pre;  //全局变量，始终指向刚刚访问过的结点。
    void PreThreading(BiThrTree p){
        if(p){
            if(!p->lchild){             //没有左孩子
                p->LTag = Thread;       //前驱线索
                p->lchild = pre;        //左孩子指针指向前驱
            }
            if(!pre->rchild){
                pre->RTag = Thread;       //后继线索
                pre->rchild = p ;         //前驱右孩子指针指向后继
            }
            pre = p;
            if(p->LTag == Link)
                PreThreading(p->lchild);     //左子树线索化
            if(p->RTag == Link)
                PreThreading(p->rchild);   //右子树线索化
        }
    }
    //建立头结点，前序线索二叉树
    Status PreOrderThreading(BiThrTree &Thrt,BiThrTree T){
        //前序遍历二叉树T，并将其前序线索化，Thrt指向头结点。
        if(!(Thrt = (BiThrTree)malloc(sizeof(BiThrNode))))
            return ERROR;
        
        Thrt->RTag = Thread;               //建头结点
        Thrt->rchild = Thrt ;              //右指针回指
        Thrt->LTag = Link;
        if(!T){
            Thrt->lchild = Thrt;
        }else{
            Thrt->lchild = T;
            pre = Thrt ;
            PreThreading(T);
            pre->rchild = Thrt ;
            pre->RTag = Thread;
            Thrt->rchild = pre;
        }
        return OK;
    }
    //前序 遍历线索二叉树
    Status PreOrderTraverse_Thr(BiThrTree T ,Status(* visit)(TElemType e) ){
        //T指向头结点，头结点的左链lchild指向根节点，可参见线索化算法
        //前序遍历二叉线索树T的非递归算法，对每个数据元素调用函数visit
        BiThrTree p ;
        p = T->lchild;            // p指向根节点
        while(p != T){            //空树 或者遍历结束时 p == T
            visit(p->data);  
            if(p->LTag == Link)
                p = p->lchild;
            else
                p = p->rchild;
        }
        return OK;
    }
    int main()
    {
        BiThrTree T, PreT;
        printf("创建树\n");
        CreatBiThrTree(T);
        printf("\n前序遍历线索二叉树\n");
        PreOrderThreading(PreT , T);
        PreOrderTraverse_Thr(PreT , visit);
        printf("\n");
        return 0;
    }

 

（3）后序遍历，线索二叉树

【后序遍历线索二叉树时，需要一个parent 指针，所以建树的时候与上面两个有所不同】

    #define TElemType char
    typedef enum{
        Link,Thread
    }PointerTag;//Link == 0 :指针 ,Thread == 1: 线索
    typedef struct BiThrNode{
        TElemType data;
        struct BiThrNode *lchild, *rchild; //左右孩子指针
        struct BiThrNode *parent;
        PointerTag LTag , RTag;            //左右标志
    }BiThrNode, *BiThrTree;
    BiThrTree pre;  //全局变量，始终指向刚刚访问过的结点。
     
    Status visit(TElemType e){
        printf("%5c",e);
        return OK;
    }
    //char Vexch[20]={'H','D','A','$','$','C','$','B','$','$','G','F','$','E','$','$','$'};  
    char Vexch[26]={'A','B','D','H','$','$','I','$','$','E','J','$','$','$','C','F','$','$','G','$','$'};  
    int i=0;  
    //二叉树的创建  
    Status CreatBiThrTree(BiThrTree &T,BiThrTree &p)  
    {  
        if(Vexch[i++]=='$') T=NULL;  
        else  
        {  
            T= (BiThrTree)malloc(sizeof(BiThrNode));
            if(!T)  return 0;  
            T->data=Vexch[i-1];//生成根节点  
        T->parent = p;//指回原来的结点
            visit(T->data);
            T->LTag=Link;
            CreatBiThrTree(T->lchild,T);//创建左子树
            T->RTag=Link;
            CreatBiThrTree(T->rchild,T);//创建右子树  
        }  
        return 1;  
    }  

 

【后序遍历二叉树线索化】

    void PostThreading(BiThrTree p){
        if(p){
            PostThreading(p->lchild);     //左子树线索化
            PostThreading(p->rchild);     //右子树线索化
            if(!p->lchild){               //没有左孩子
                p->LTag = Thread;         //前驱线索
                p->lchild = pre;          //左孩子指针指向前驱
            }
            if(pre && !pre->rchild){
                pre->RTag = Thread;       //后继线索
                pre->rchild = p ;         //前驱右孩子指针指向后继
            }
            pre = p;
        }
    }

【建立头结点】（这里就不建头结点了，因为入口是总根节点，出口也是总根节点）


   

         1、A的直接前驱

          ㈠若LTag 的值为1，那么A的直接前驱为LChild所指结点

          ㈡若LTag 的值为0，那么

                  ⒈若有左儿子，那么直接前驱就是A的左儿子。

                  ⒉若有右儿子，那么直接前驱就是A的右儿子。

         2、A的直接后继

          ㈠若结点A是二叉树的根，则其后继为空

          ㈡若结点A是其双亲的右儿子，或是双亲的左孩子且其双亲没有左子树没有右子树，则其后继即为双亲结点

          ㈢若结点A是其双亲的左儿子，且双亲有右子树，则其后继为双亲的右子树上按后序遍历列出来的第一个结点。


【后序遍历二叉树】

    //后序 遍历线索二叉树
    Status PostOrderTraverse_Thr(BiThrTree T ,Status(* visit)(TElemType e) ){
        BiThrTree p ;
        p = T;            // p指向根节点
        pre=NULL;
        while(p != NULL){            //空树 或者遍历结束时 p == T
            while(p->LTag == Link )         // 走到最左结点  ||左结点
                p = p->lchild;
            
            while(p->RTag == Thread ){      //访问后继       ||右结点
                visit(p->data);
                pre = p;
                p = p->rchild ;            
            }
            if(p == T){                     //是否是最后根节点
                visit(p->data);
                break;
            }
            while(p && p->rchild == pre  ){ //访问根         ||根节点
                visit(p->data);
                pre = p;
                p = p->parent;
            }
            if(p && p->RTag == Link)
                p = p->rchild;
        }
        return OK;
    }

 

【总的后序遍历线索二叉树代码】

    #include <iostream>
    #include <string.h>
    #include <cstdio>
    #include <stdlib.h>
    using namespace std;
    #define Status int
    #define OK 1
    #define ERROR 0
    #define TElemType char
    typedef enum{
        Link,Thread
    }PointerTag;//Link == 0 :指针 ,Thread == 1: 线索
    typedef struct BiThrNode{
        TElemType data;
        struct BiThrNode *lchild, *rchild; //左右孩子指针
        struct BiThrNode *parent;
        PointerTag LTag , RTag;            //左右标志
    }BiThrNode, *BiThrTree;
    BiThrTree pre;  //全局变量，始终指向刚刚访问过的结点。
     
    Status visit(TElemType e){
        printf("%5c",e);
        return OK;
    }
    //char Vexch[20]={'H','D','A','$','$','C','$','B','$','$','G','F','$','E','$','$','$'};  
    char Vexch[26]={'A','B','D','H','$','$','I','$','$','E','J','$','$','$','C','F','$','$','G','$','$'};  
    int i=0;  
    //二叉树的创建  
    Status CreatBiThrTree(BiThrTree &T,BiThrTree &p)  
    {  
        if(Vexch[i++]=='$') T=NULL;  
        else  
        {  
            T= (BiThrTree)malloc(sizeof(BiThrNode));
            if(!T)  return 0;  
            T->data=Vexch[i-1];//生成根节点  
            T->parent = p;
            visit(T->data);
            T->LTag=Link;
            CreatBiThrTree(T->lchild,T);//创建左子树
            T->RTag=Link;
            CreatBiThrTree(T->rchild,T);//创建右子树  
        }  
        return 1;  
    }  
     
    void PostThreading(BiThrTree p){
        if(p){
            PostThreading(p->lchild);     //左子树线索化
            PostThreading(p->rchild);     //右子树线索化
            if(!p->lchild){               //没有左孩子
                p->LTag = Thread;         //前驱线索
                p->lchild = pre;          //左孩子指针指向前驱
            }
            if(pre && !pre->rchild){
                pre->RTag = Thread;       //后继线索
                pre->rchild = p ;         //前驱右孩子指针指向后继
            }
            pre = p;
        }
    }
    //后序 遍历线索二叉树
    Status PostOrderTraverse_Thr(BiThrTree T ,Status(* visit)(TElemType e) ){
        BiThrTree p ;
        p = T;            // p指向根节点
        pre=NULL;
        while(p != NULL){            //空树 或者遍历结束时 p == T
            while(p->LTag == Link )         // 走到最左结点  ||左结点
                p = p->lchild;
            
            while(p->RTag == Thread ){      //访问后继       ||右结点
                visit(p->data);
                pre = p;
                p = p->rchild ;            
            }
            if(p == T){                     //是否是最后根节点
                visit(p->data);
                break;
            }
            while(p && p->rchild == pre  ){ //访问根         ||根节点
                visit(p->data);
                pre = p;
                p = p->parent;
            }
            if(p && p->RTag == Link)
                p = p->rchild;
        }
        return OK;
    }
    int main()
    {
        BiThrTree PostT;
        printf("创建树\n");
        pre = NULL;
        CreatBiThrTree(PostT,pre);
        printf("\n后序遍历线索二叉树\n");
        PostThreading(PostT);
        PostOrderTraverse_Thr(PostT , visit);
        printf("\n");
        return 0;
    }

 

 

总结：
【问】为什么用先序遍历建树后，可以用来中序遍历线索化？
【答】先序遍历建树，只是一种建树方式（当然可以用别的方法来建树，但是数组里的顺序可能就要变化了），建完树后，跟后面线索化无关。


【问】为什么中序遍历，先序遍历，后序遍历在线索化的时候，要用不同的线索化？
【答】因为中序，先序，后序，他们的前驱和后继是不一样的，根据代码也知道是不一样。


【问】对于做题，画已知二叉树的前序、中序、后序线索二叉树有什么技巧吗？

【答】可以先将 二叉树前序、中序、后序遍历 顺序写出来。再根据写出来的顺序对二叉树进行线索化。

【问】接上，线索化的时候这么乱，不知道线索改连到哪里？

【答】每个结点左右各有一个指针，除了用于建树的“蓝色”线之外，我们只看红色的线索这条线。每个结点只要是线索的部分，左边就是指向排在该结点之前的那个结点，右边就是指排在该节点之后的那个结点，这也就是为什么要先把遍历的顺序提前写好的原因。

罗蜜斯丹
关注
  • 3
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
线索二叉树(前中后序线索化/遍历/画线索)
Curz酥的博客
05-01 1万+
考研数据结构笔记。线索二叉树(前中后序线索化/遍历/画线索)
数据结构复习备忘录（2）：线索二叉树的画法
自由
10-31 1万+
所有空指针域均被利用 先写出相应前/中/后序遍历序列 空左孩子指向前驱，空右孩子指向后继；无前驱/后继为NIL
LeetCode 102. 二叉树的层序遍历（广度优先遍历BFS）
your_棒棒糖的博客
11-02 264
二叉树的层序遍历 给你一个二叉树，请你返回其按 层序遍历 得到的节点值。 （即逐层地，从左到右访问所有节点）。 示例： 二叉树：[3,9,20,null,null,15,7], 3 / \ 9 20 / \ 15 7 返回其层次遍历结果： [ [3], [9,20], [15,7] ] 方法一：广度优先遍历 class Solution { public List<List<Integer>> levelOrder(Tree.
图解中序遍历的线索二叉树
热门推荐
KevinsCSDN的博客
06-14 3万+
参考链接： 线索二叉树原理及前序、中序线索化（Java版） 原理不细讲了，参考链接里有。 以下图所示的二叉树为例： 中序遍历的结果： 中序遍历的线索二叉树： 虚线箭头为线索指针，对于所有左指针指向空的节点：将该节点的左指针指向该节点在中序遍历中的上一节点；对于所有右指针指向空的节点，将该节点的右指针指向该节点在中序遍历中的下一结点。 线索二叉树的中序遍历结果： 即形成了...
前序线索二叉树画法
计算机毕业论文源码，学生个人网页制作html源码。贴近用户做网络推广和互联网优化。
11-13 1448
先序线索二叉树和中序线索二叉树有什么区别 最好图解 先序是先根节点在左结点再右结点,中序是先左,再根节点,再右结点 先序线索二叉树和中序线索二叉树有什么区别 先序是先根节点在左结点再右结点，中序是先左，再根节点，再右结点 线索二叉树 //二叉树的二叉线索存储表示 #include #include ty...
二叉树的非递归建立，前序、中序、后序遍历
07-17
关于数据结构实验的二叉树问题
二叉树(线索二叉树、链式二叉树、有序二叉树) 常见操作代码实现
04-08
其中包括构建、销毁、前序/后序/中序遍历、高度、密度、添加、删除、查询等操作 适合人群：具备一定编程基础，尤其是c语言基础，并很好地掌握了指针知识点，同时对数据结构有一定的理解 能学到什么：掌握二叉树的...
Java线索化二叉树数据结构.docx
07-03
说明 n个结点的二叉链表中含有n+1 【公式...根据线索性质的不同，线索二叉树可分为前序线索二叉树、中序线索二叉树和后序线索二叉树三种 一个结点的前一个结点，称为前驱结点 一个结点的后一个结点，称为后继结点
第六章 树和二叉树作业及答案（100分）.docx
09-21
5．线索二叉树中的线索指的是（ ）。 A．左孩子 B.遍历 C.指针 D.标志 6. 建立线索二叉树的目的是（ ）。 A. 方便查找某结点的前驱或后继 B. 方便二叉树的插入与删除 C. 方便查找某结点的双亲 D. 使二叉树的遍历...
非线性表——线索二叉树
ssxx2030的博客
05-13 342
8.5线索二叉树 8.5.1基本概念 每个结点增加两个指针域，指示遍历时得到的前驱和后继。 但是，存储密度大大降低。 在n个结点的二叉链表中必定存在有n+1个空链域， 利用空链域来存放结点的前驱、后继信息。 同时结点增加两个标志域LTag，RTag： 若LTag=0，LChild域指向左孩子； 若LTag=1，LChild域指向其前驱。 若RTag=0，RChild域指向右孩子； 若RTag=1，RChild域指向其后继。 当二叉树以某种次序遍历 使其变为线索二叉...
简记B+树和B-树的区别
baidu_31788709的博客
12-11 648
对于B+树和B-树的区别，网上讲解的都很笼统，大部分都是把概念照抄了一遍，忍不住吐槽，我要是过来看概念，我翻书不就行了，还用得着你来赚流量？ B+和B-树的概念，对于我这样的新人来说，非常的晦涩难懂，但还是得理清楚。言归正传。 我简单梳理了三个区别。 B-树的结点，是从双亲节点中的某关键字的左侧或者右侧，或者两个关键字中间引出的，代表引出的节点中的所有关键字，都大于（小于）双亲节点中前一个（后1个）关键字。而B+树的节点，是从双亲节点的某个关键字引出的，双亲节点有几个关键字，就能引出多少个孩子节点。双亲节
《数据结构》—— 线索二叉树的基础认识、存储结构、图，线索化代码实现。
博樽
10-02 2312
线索二叉树的基本概念线索、构造、存储结构； 中、先、后序遍历结构图；画出线索二叉树，以及二叉树线索化的代码实现。
数据结构-遍历二叉树、线索二叉树（类C语言版）
秃了也弱了
05-15 1739
二叉树遍历的三种方法 由二叉树的递归定义可知，遍历左子树和遍历右子树可如同遍历二叉树一样“递归”进行。 例题1 写出下图二叉树的各种遍历顺序 答： 先序：A B D G C E H F 中序：D G B A E H C F 后序：G D B H E F C A 性质 若二叉树中各节点的值均不相同，则二叉树结点的先序序列、中序序列和后序列都是唯一的。 由二叉树的先序序列和中序序列，或由二叉树的后序序列和中序序列可以确定唯一一棵二叉树。 ...
数据结构—二叉树线索化(线索化的先序、中序、后序遍历)
小虾米编程
07-14 1万+
1.线索二叉树基本概念 二叉树是一种非线性结构，遍历二叉树几乎都是通过递归或者用栈辅助实现非递归的遍历。用二叉树作为存储结构时，取到一个节点，只能获取节点的左孩子和右孩子，不能直接得到节点的任一遍历序列的前驱或者后继。 为了保存这种在遍历中需要的信息，我们利用二叉树中指向左右子树的空指针来存放节点的前驱和后继信息，n个节点的二叉树中含有n+1个空指针域。 试做如下规定： 若结点有左子树，...
建立中序线索链表算法_图解线索二叉树与双向线索二叉树（附源码）
weixin_34079177的博客
01-27 1326
@[TOC] 线索二叉树的概念 当我们对普通的二叉树进行遍历时需要使用栈结构做重复性的操作。线索二叉树不需要如此，在遍历的同时，使用二叉树中空闲的内存空间记录某些结点的前趋和后继元素的位置（不是全部）。这样在算法后期需要遍历二叉树时，就可以利用保存的结点信息，提高了遍历的效率。使用这种方法构建的二叉树，即为“线索二叉树”。 线索二叉树的结构 每一棵二叉树上，很多结点都含有未使用的指向NUL...
中序线索化链表
kiwi55的专栏
12-29 1052
#include using namespace std; //enum falg{child,thread}; struct biNode { char data; biNode* lchild, *rchild; int ltag, rtag; }; class tree { public: tree(); biNode *next(biNode* p); void
线索二叉树，画图教你秒懂线索二叉树（线索二叉树的建立和简单操作）逻辑代码分析
qq_46104786的博客
11-16 1万+
数据结构专升本学习,线索二叉树 前言 前面我们学习树和二叉树的一些基本操作，今天我们学习一个新的知识，学习一下线索二叉树，线索二叉树是由二叉链存储结构变化而来的（我们先得有个二叉链树，再做处理），就是将原来的空域链改为莫种遍历次序下该结点的前驱结点和后继结点的指针，就相当于把我们的空域也利用起来指向下一个要输出的结点，对于下一个结点提高了访问速度，emmm，有点难，博主也有点云里雾里，看博主的解释能不能让你理解。嘿嘿 每日一遍，快乐学习 你们第一次炒菜是不是也是这个样纸！！！！哈哈哈哈 1.什么是线索二叉
建立中序线索链表算法_【数据结构——遍历二叉树和线索二叉树】
weixin_29959615的博客
01-27 2049
【数据结构——遍历二叉树和线索二叉树】目录【数据结构——遍历二叉树和线索二叉树】一、遍历二叉树(一)遍历的三种规则1、先序遍历2、中序遍历3、后序遍历(二)遍历的相关算法1、先序遍历建立二叉链表2、统计二叉树中叶子结点的个数3、求二叉树的深度4、复制二叉树5、统计二叉树中结点的个数二、线索二叉树1、相关概念2、中序线索化算法3、遍历中序线索二叉树一、遍历二叉树遍历的定义——指按某条搜索路...
数据结构中的线索化二叉树
最新发布
05-26
线索化二叉树是一种二叉树的存储结构，它的目的是为了方便对二叉树的遍历操作。在普通的二叉树中，如果要遍历整个二叉树，需要使用递归或者栈等数据结构来实现，而线索化二叉树可以直接通过线索来遍历整个二叉树，从而避免了使用递归或者栈的开销。 线索化二叉树分为前序线索化二叉树、中序线索化二叉树和后序线索化二叉树。其中，中序线索化二叉树是最常用的一种，它的思想是在中序遍历的过程中，将每个节点的左右子树指针修改为指向其前驱和后继节点的线索。具体来说，对于每个节点，如果它的左子树为空，则将其左子树指针指向它的前驱节点；如果它的右子树为空，则将其右子树指针指向它的后继节点。这样，在遍历中序线索化二叉树时，可以直接通过前驱和后继线索来遍历整个二叉树，而不需要使用递归或者栈等数据结构。 线索化二叉树的优点是可以节省遍历二叉树所需要的空间和时间开销，同时也可以避免递归或者栈等数据结构带来的问题。但是，线索化二叉树的缺点是需要额外的空间来存储线索指针，而且线索化二叉树只适用于静态二叉树，即不允许在遍历过程中修改二叉树的结构。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值