线索二叉树

一、相关知识

1. 目的是将二叉链表不用的节点充分利用起来。
   
   
2. 二叉链表的浪费情况推算。      

     

对于一个 n 个节点的二叉链表，共有 2n 个指针域。而 n 个节点的二叉树才有 n-1 条分支线路，故存在 2n - （n-1）= n + 1个空指针域，浪费了系统的资源。

3. 定义：把指向前驱和后继指针称为线索，加上线索的二叉链表称为线索二叉树。
   
   
4. 前驱和后继的解释，对于上图，中序遍历的结果是 HDIBJEAFCG 。对于节点 B 它的前驱为 I ，后继为 E。对于节点 A 它的前驱为 E ，后继为 F，依次类推。

二、线索二叉树的实质表示

1. 前驱的表示，通过一次中序遍历后，将所有的空指针域中的右子树指针改为指向它的后继节点，进而得到下图。
   

2. 将所有空指针域中左子树改为指向它前驱的节点，得到下图。
   

           

3. 将上述两幅图合到一起，可以看出，线索二叉树就是将一棵二叉树转变成了一个双向链表。所以将二叉树以某种次序遍历使其变为线索二叉树的过程叫线索化。
   
   

我们可以看到后继的遍历过程就是从中序遍历的第一个节点开始，当该节点有直接的后继时，则输出该节点，否则的话，就按照以该节点为根进行中序遍历找到的第一个结点，作为后继结点。

也就是说按照中序遍历线索二叉树时，会出现有后序结点，和没有后序结点的两种情况。

二、线索二叉树的构建

注意：这是递归的过程，左右标志位的确定是在构建完子树后进行的。

三、线索二叉树的线索化

1. 如何区别某一结点的左子树指针指向的是左孩子还是前驱节点，右子树指针指向的是右孩子还是后继结点呢？
   
   所以引入了两个标志域 leftTag，rightTag。当 leftTag = 0 时，说明指向的是左孩子， leftTag = 1 时 指向的是前驱结点。
   同样当 rightTag = 0 时，说明指向的是右孩子， rightTag = 1 时 指向的是后继结点。
   
   
2. 中序遍历线索化的过程
   
   实质：将二叉链表中的空指针域改为指向前驱或后继的线索，由于前驱和后继只有在遍历二叉树的时候才能得到，所以线索化的过程就是在遍历的过程中修改指针的过程。
   
   过程：实际上就是两个指针移动的过程
   
   

由于还是有两个是空指针域，即第一个结点的前序结点，和最后一个结点的后继结点。

所以添加了一个头节点，让头节点的左子树域指向第一个结点，头节点的右子树域指向最后一个结点。同样第一个结点的前序结点指向头节点，最后一个结点的后继结点指向头节点，如下图。

这样我们可以从第一个节点按照后继进行遍历，也可以从最后一个节点按照前驱进行遍历。

四、线索二叉树的实现

#include "string.h"
#include "stdio.h"    
#include "stdlib.h"   

#include "math.h"  
#include "time.h"

#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0

#define MAXSIZE 100 /* 存储空间初始分配量 */

typedef int Status; /* Status是函数的类型,其值是函数结果状态代码,如OK等 */
typedef char TElemType;
typedef enum {Link,Thread} PointerTag;  /* Link==0表示指向左右孩子指针, */
                                        /* Thread==1表示指向前驱或后继的线索 */
typedef  struct BiThrNode   /* 二叉线索存储结点结构 */
{
    TElemType data; /* 结点数据 */
    struct BiThrNode *lchild, *rchild;  /* 左右孩子指针 */
    PointerTag LTag;
    PointerTag RTag;        /* 左右标志 */
} BiThrNode, *BiThrTree;

TElemType Nil='#'; /* 字符型以空格符为空 */

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

/* 按前序输入二叉线索树中结点的值,构造二叉线索树T */
/* 0(整型)/空格(字符型)表示空结点 */
Status CreateBiThrTree(BiThrTree *T)
{ 
    TElemType h;
    scanf("%c",&h);

    if(h==Nil)
        *T=NULL;
    else
    {
        *T=(BiThrTree)malloc(sizeof(BiThrNode));
        if(!*T)
            exit(OVERFLOW);
        (*T)->data=h; /* 生成根结点(前序) */
        CreateBiThrTree(&(*T)->lchild); /* 递归构造左子树 */
        if((*T)->lchild) /* 有左孩子 */
            (*T)->LTag=Link;
        CreateBiThrTree(&(*T)->rchild); /* 递归构造右子树 */
        if((*T)->rchild) /* 有右孩子 */
            (*T)->RTag=Link;
    }
    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; /* 前驱右孩子指针指向后继(当前结点p) */
        }
        pre=p; /* 保持pre指向p的前驱 */
        InThreading(p->rchild); /* 递归右子树线索化 */
    }
}

/* 中序遍历二叉树T,并将其中序线索化,Thrt指向头结点 */
Status InOrderThreading(BiThrTree *Thrt,BiThrTree T)
{ 
    *Thrt=(BiThrTree)malloc(sizeof(BiThrNode));
    if(!*Thrt)
        exit(OVERFLOW);
    (*Thrt)->LTag=Link; /* 建头结点 */
    (*Thrt)->RTag=Thread;
    (*Thrt)->rchild=(*Thrt); /* 右指针回指 */
    if(!T) /* 若二叉树空,则左指针回指 */
        (*Thrt)->lchild=*Thrt;
    else
    {
        (*Thrt)->lchild=T;
        pre=(*Thrt);
        InThreading(T); /* 中序遍历进行中序线索化 */
        pre->rchild=*Thrt;
        pre->RTag=Thread; /* 最后一个结点线索化 */
        (*Thrt)->rchild=pre;
    }
    return OK;
}

/* 中序遍历二叉线索树T(头结点)的非递归算法 */
Status InOrderTraverse_Thr(BiThrTree T)
{ 
    BiThrTree p;
    p=T->lchild; /* p指向根结点 */
    while(p!=T)
    { /* 空树或遍历结束时,p==T */
        while(p->LTag==Link)
            p=p->lchild;
        if(!visit(p->data)) /* 访问其左子树为空的结点 */
            return ERROR;
        while(p->RTag==Thread&&p->rchild!=T)
        {
            p=p->rchild;
            visit(p->data); /* 访问后继结点 */
        }
        p=p->rchild;
    }
    return OK;
}

int main()
{
    BiThrTree H,T;
    printf("请按前序输入二叉树(如:'ABDH##I##EJ###CF##G##')\n");
    CreateBiThrTree(&T); /* 按前序产生二叉树 */
    InOrderThreading(&H,T); /* 中序遍历,并中序线索化二叉树 */
    printf("中序遍历(输出)二叉线索树:\n");
    InOrderTraverse_Thr(H); /* 中序遍历(输出)二叉线索树 */
    printf("\n");

    return 0;
}