线索二叉树（中序线索所及遍历）

经过对先序、中序、后序等方式遍历后，可以将二叉树的节点按照一定的规则排列成一个线性序列，即对树这样一个非线性结够进行线性化操作，使得每个节点（除了第一个和最个一个）在个序列中只有唯一的前趋和唯一的后继。（第一个有唯一的后继承，最后一个有唯一的前趋）。希望很快得到一个节点的前趋和后继，但是有不希望每次都对二叉树进行遍历，便引入了线索二叉树

为了记录节点的前趋和后继，可以在原来的节点中增加指向前趋和后继的指针域。但是直接这样做会大大浪费存储空间，

考虑到 n 个节点 会有 （ N+1 ）个空指针，因此我们可以直接利用这些空指针区域，存放某种遍历下指向前趋和后继的指针。这种指针称为线索。为了区分线索指针和指向孩子的指针，我们可以为每个指针区域增加一个标记，记录它当前是线索指针还是指向孩子的指针。(标记为0时代表指向孩子的指针，标记为1是代表是线索指针，其中 ltag 和 rtag 为 标记) 

注：线索化后的 lchild 指向该结点的后继；线索化后 rchild 指向该结点的前驱

lchild

ltag

rchild

rtag

下面介绍二叉树的中序线索化：

例如对（ABCDEFG）中序遍历后：（DBEAFCG）

线索化以后我们可以直接找每个节点的前趋和后继（存在的情况下）；例如 A 的前趋是E，后继是F

中序线索化思想：

利用中序遍历左根右的特性。///p 表示当前节点，pre 代表 p 的 前驱动

（1）从根节点开始找到最左下第一个左孩子为空的节点为起点。记为 p///此时 pre 为空

（2）判断 p 的前趋节点 pre的右指针是否是指向右孩子的指针，如果不是 ， 则 pre 的前趋就是 p /// 前提是pre 节点存在

///你想一下简单的情况  根据左根右的特性， 一个节点有左孩子，没有有孩子， 这个节点的前趋不就是他的左孩子哇 。

（3）如果p 的 lchild 被线索化了指向 pre   

其思想按照中序遍历进行即可

BT *pre;///全局变量
void Threa_BT_in(BT *p)
{
    if(p!=NULL)
    {
        Threa_BT_in(p->lchild);///一直向左走找到第一个左空的为起点
        
        ///线索化的对当前节点线所化》》》》》》》》》》》》》》
        if(p->lchild==NULL)///线索化
            p->ltag=1;
        if(p->rchild==NULL)///线索化
            p->rtag=1;
        if(pre!=NULL)///pre 为 p 的直接前驱节点
        {
            if(pre->rtag==1)///前驱没有右孩子，则pre的后继就是 P 节点
                pre->rchild=p;
            if(p->ltag==1)///当前节点没有左孩子，则前驱就是根节点pre
                p->lchild=pre;
        }
    pre=p;
    ///《《《《《《《《《《《《《《《《《《《《《《《《《《《
    
    Threa_BT_in(p->rchild);
    }
}

访问一个节点的后继

核心思想：

（1）如果这个节点有孩子指针被线索化了， 我们可以直接的 线索化指向的右孩子就是 该节点的 后继

（2）如果这个节点右孩子存在，就沿着右孩子向向左找到最左下的节点，这个节点就是后继。

///如果不理解，你就想 左根右的特性， 右孩子的左子树节点一定在左孩子前遍历，然后依次。。。。

BT *InorderNext(BT*p)
{
    BT *q=NULL;
    if(p->rtag==1)///被线索化了，后继直接就是右孩子
        return p->rchild;
    else{
        q=p->rchild;///右孩子
        while(q->ltag==0)///找右子树最左下
            q=q->lchild;
    }
    return q;
}

 

完整代码：

#include<stdio.h>
#include<stdlib.h>
typedef struct node
{
    char ch;
    struct node *lchild,*rchild;
    int ltag,rtag;
} BT;
const int Maxsize = 1000;
BT *pre;
BT *Create_BT()
{
    char ch;
    BT *root,*s;
    root=NULL;
    BT *Q[Maxsize];
    int Front=1, Rear=0;
    while((ch=getchar())!='#')
    {
        s=NULL;
        if(ch!='@')
        {
            s=(BT*)malloc(sizeof(BT));
            s->ch=ch;
            s->lchild=NULL;///初始化很重要
            s->rchild=NULL;///初始化很重要
            s->ltag=0;///初始化很重要
            s->rtag=0;///初始化很重要
        }
        Rear++;
        Q[Rear]=s;
        if(Rear==1)
            root=s;
        else
        {
            if(Q[Front]&&s)
            {
                if(Rear%2==0)
                    Q[Front]->lchild=s;
                else
                    Q[Front]->rchild=s;
            }
            if(Rear%2==1)
                Front++;
        }
    }
    return root;
}
void Threa_BT_in(BT *p)
{
    if(p!=NULL)
    {
        Threa_BT_in(p->lchild);///一直向左走找到第一个左空的为起点
        
        ///线索化的对当前节点线所化》》》》》》》》》》》》》》
        if(p->lchild==NULL)///线索化
            p->ltag=1;
        if(p->rchild==NULL)///线索化
            p->rtag=1;
        if(pre!=NULL)///pre 为 p 的直接前驱节点
        {
            if(pre->rtag==1)///前驱没有右孩子，则pre的后继就是 P 节点
                pre->rchild=p;
            if(p->ltag==1)///当前节点没有左孩子，则前驱就是根节点pre
                p->lchild=pre;
        }
    pre=p;
    ///《《《《《《《《《《《《《《《《《《《《《《《《《《《
    
    Threa_BT_in(p->rchild);
    }
}
BT *InorderNext(BT*p)///找p 节点的后继
{
    BT *q=NULL;
    if(p->rtag==1)///被线索化了，后继直接就是右孩子
        return p->rchild;
    else{
        q=p->rchild;///右孩子
        while(q->ltag==0)///找右子树最左下
            q=q->lchild;
    }
    return q;
}
void TravIn_Thread_BT(BT *p)///遍历 中序线索二叉树 
{
    if(p!=NULL)
    {
        while(p->ltag==0)///找起点
            p=p->lchild;

        do{
            printf("%c ",p->ch);
            p=InorderNext(p);///后继的后继
        }while(p!=NULL);
    }
}
int main()
{
    BT*t=Create_BT();///建树
    Threa_BT_in(t);///线索化
    TravIn_Thread_BT(t);///遍历中序线索化树
    return 0;
}