线索二叉树

线索二叉树

---

线索二叉树是一种特殊的树状数据结构。实际上就是对寻常的二叉树进行了“线索化”。顾名思义，在线索化后，普通的二叉树变成了“线”，实际上，可以理解为变成了双向链表。
线索二叉树的线索化分为中序线索化，前序线索化，后序线索化。
这里只介绍中序线索化。

“A binary tree is threaded by making all right child pointers that would normally be null point to the inorder successor of the node (if it exists), and all left child pointers that would normally be null point to the inorder predecessor of the node.“

这一段的意思可以简单理解为如下内容：
1.普通二叉树中有太多的空指针（NULL），这里将其利用起来，变为”线索“
2.如果一个节点v没有左儿子，那么左儿子指针域指向中序遍历过程中v的前驱。
3.如果一个节点v没有右儿子，那么右儿子指针域指向中序遍历过程中v的后继。
4.为了区别线索与普通的左儿子右儿子指针，结构体中创建两个bool值变量left_thread,right_thread标记是否为线索。

#ifndef _THREADBINTREE_H
#define _THREADBINTREE_H
//线索二叉树,减少空链，线性中序遍历
typedef char DataType;
typedef struct thread_node{
    bool left_thread,right_thread;//标注线索的flag
    struct thread_node  *left_child,*right_child;
    DataType data;
}ThreadNode,*ThreadTree;

void CreatTree(ThreadTree & thrt);//创建线索二叉树
void CreatRoot(ThreadTree & root,ThreadTree & thrt);
void Threading(ThreadTree & thrt);//将一棵二叉树中序遍历线索化
void TraverseThreadTree(ThreadTree thrt);//非递归的遍历线索二叉树
void visit(ThreadTree node);//打印节点信息
#endif // _THREADBINTREE_H

这里我采取的方法是先构造一棵二叉树，之后对其线索化。

void CreatTree(ThreadTree & thrt)//创建线索二叉树
{
    DataType data;

    thrt = (ThreadTree)malloc(sizeof(ThreadNode));
    if(!thrt){
        printf("Don't have enough memory\n");
        exit(0);
    }
    else{
        data = getchar();
        if(data == '\n')//结束符
            return;
        if(data == '#')
            thrt = NULL;
        else{
            thrt = (ThreadTree)malloc(sizeof(ThreadNode));
            if(!thrt){
                printf("Don't have enough memory!\n");
                exit(0);
            }
            thrt->data = data;
            thrt->left_thread = false;
            thrt->right_thread = false;
            CreatTree(thrt->left_child);
            CreatTree(thrt->right_child);
        }
    }
    return;
}

建立如图所示二叉树。
可知，中序遍历结果为：
B E A F C
按照上述线索化构造原则，得到的线索二叉树应该为：

其中箭头代表线索。
注意到这里出现了一个不曾存在的X节点。
实际上，在线索化之前通常给定一个寻址的头节点（类似于链表中的头节点），默认头节点的左儿子是真正的二叉树开始的节点，root.left_thread = true,右儿子设定为NULL,root.right_thread = false。

void CreatRoot(ThreadTree & root,ThreadTree & thrt)
{
    root = (ThreadTree)malloc(sizeof(ThreadNode));
    if(!root){
        printf("Don't have enough memory\n");
        exit(0);
    }
    root->data = ' ';//头节点数据是杂项没有意义,但是这里可以作为一个头节点的标记
    root->left_thread = false;
    root->right_thread = true;
    root->left_child = thrt;//默认头节点的左儿子是“真正"的线索树
    root->right_child = NULL;//头节点的右孩子是空
}

将头节点与二叉树连接好后，就可以进行线索化了。

void Threading(ThreadTree & thrt)//线索化
{
    //printf("in function pre:%p\n",pre);
    if(thrt){//thrt是当前访问的节点，pre是中序遍历过程中thrt之前访问的节点，pre是全局变量
        Threading(thrt->left_child);//线索左子树

        if(!thrt->left_child){//如果没有左孩子
            thrt->left_thread = true;//指向中序遍历过程中的前驱
            thrt->left_child = pre;//第一个pre肯定是根节点
        }
        if(!pre->right_child && pre->data != ' '){//当前节点的前驱没有右孩子并且前驱不是头节点root
            pre->right_thread = true;//指向中序遍历过程中的后继
            pre->right_child = thrt;
        }
        pre = thrt;
        Threading(thrt->right_child);
    }
    return ;
}

这段Treading代码中，有一个地方可能比较不好理解。为什么对right_thread更新时，对pre进行判断呢？

我们知道，right_thread是对当前节点v在中序遍历过程中后继节点的标记，但是在遍历的过程中我们并不能直接知道后继节点是谁，不过可以确定的是，该后继一定是当前节点v的前驱节点pre的右儿子（如果这里不能明白，还是自己画一下图比较容易get）。
因此才有了这种判断方式。

void TraverseThreadTree(ThreadTree thrt)//非递归的遍历线索二叉树
{
    ThreadTree p = thrt->left_child;

    //printf("in function pre:%p\n",pre);
    while(p != thrt){
        while(p->left_thread == false)//迭代寻找第一个有“线索"的节点
            p = p->left_child;
        visit(p);
        while(p->right_thread == true && p->right_child != thrt){//
            p = p->right_child;
            visit(p);
        }
        p = p->right_child;
    }
    return ;
}

这一段代码是非递归的中序遍历线索二叉树。
实际上，这正是线索二叉树一个重要的应用。
通过线索化，使得树形结构变为了一条链，保证了中序遍历时，时间复杂度是O(n).
附上测试主函数：

#include <stdio.h>
#include "ThreadBinTree.h"
#include <time.h>
ThreadTree pre; //全局变量，始终指向在中序遍历过程中刚刚访问过的结点,初始化时根节点
void InOrder(ThreadTree  thrt)
{
    if(thrt){
        InOrder(thrt->left_child);
        visit(thrt);
        InOrder(thrt->right_child);
    }
}
int main()
{
    ThreadTree root,thrt;
    clock_t go,stop;
    //printf("%p\n",&root);
    //printf("%p\n",&thrt);
    CreatTree(thrt);
    //go = clock();
    CreatRoot(root,thrt);
    //printf("after creat :%p\n",&root);
    //printf("after creat :%p\n",&thrt);
    //printf("after creat :%c\n",root->left_child->data);
    pre = root;//文件中共享的全局变量
    //InOrder(root);
    //printf("root: %p\n",&root);
    //printf("pre: %p\n",pre);

    Threading(root);
    TraverseThreadTree(root);
    //stop = clock();
    //printf("time: %g\n",(double)(stop-go) / CLOCKS_PER_SEC);
    return 0;
}
/*
              a

          b       c

        #  e    f  #

          # #  # #
*/

/*ab#e##cf###*/