47-线索二叉树测试代码

线索二叉树测试代码：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <string.h>


typedef char ElemType;

//二叉树结点
typedef struct BINARYNODE{

    ElemType data;          //数据域
    int ltag  ,  rtag;      //增加的线索标志
    struct BINARYNODE *lchild;  //左孩子或线索指针
    struct BINARYNODE *rchild;  //右孩子或线索指针

}BinaryNode;

//表示p的前驱节点
BinaryNode *pre;

void Thread(BinaryNode *&p)
{
    if(p != NULL)
    {
        //递归调用左子树线索化
        Thread(p->lchild);

        //如果lchild指针为空，则线索化（指向前驱节点）
        if(p->lchild == NULL)
        {
            p->lchild = pre;
            p->ltag = 1;
        }
        else
        {
            p->ltag = 0;
        }

        //当rchild指针为空，则线索化（指向后继节点）
        if(pre->rchild == NULL)
        {
            pre->rchild = p;
            pre->rtag = 1;
        }
        else
        {
            pre->rtag = 0;
        }
        //把pre移动到p的位置
        pre = p;

        //递归调用将右子树线索化
        Thread(p->rchild);
    }
}

BinaryNode *CreaThread(BinaryNode *b)
{
    BinaryNode *root;
    //创建头结点
    root = (BinaryNode *)malloc(sizeof(BinaryNode));
    root->ltag = 0;
    root->rtag = 1;
    root->rchild = b;

    //判断是否为空树
    if(b == NULL)
    {
        //头结点的lchild指针指向自己
        root->lchild = root;
    }
    else
    {
        root->lchild = b;
        //pre是*p的前驱节点，供加线索用，一开始指向头结点
        pre = root;
        //中序遍历线索化二叉树,找下一个节点
        Thread(b);
        //最后处理，改变为指向头节点的线索
        pre->rchild = root;
        //同时改变标志
        pre->rtag = 1;
        // 将头节点的rchild改变为线索
        root->rchild = pre;
    }
    return root;
}


void ThInOrder(BinaryNode *tb)
{
    if(tb == NULL)
    {
        return;
    }
    //指向根节点 
    BinaryNode  *p = tb->lchild;

    //p不等于头结点
    while(p != tb)
    {
        //访问开始节点（最左下的节点）
        while(p->ltag == 0)
        {
            p = p->lchild;
        }
        printf("%c" , p->data);
        //判断p的rchild指针是否有线索,且该线索不是头结点
        while(p->rtag == 1 && p->rchild != tb)
        {
            //有就访问线索
            p = p->rchild;
            printf("%c" , p->data);
        }
        //p指向右孩子节点
        p = p->rchild;
    }
}

int main(void)
{
    BinaryNode *node = NULL;

    //创建节点
    BinaryNode node1 = { 'A', 0 , 0 , NULL, NULL };
    BinaryNode node2 = { 'B', 0 , 0 , NULL, NULL };
    BinaryNode node3 = { 'C', 0 , 0 ,  NULL, NULL };
    BinaryNode node4 = { 'D', 0 , 0 ,  NULL, NULL };
    BinaryNode node5 = { 'E', 0 , 0 ,  NULL, NULL };
    BinaryNode node6 = { 'F', 0 , 0 ,  NULL, NULL };
    BinaryNode node7 = { 'G', 0 , 0 ,  NULL, NULL };

    //建立二叉树
    node1.lchild = &node2;
    node1.rchild = &node3;
    node2.lchild = &node4;
    node3.lchild = &node5;
    node3.rchild = &node6;
    node4.rchild = &node7;


    printf("中序遍历线索化二叉树：");
    //建立线索二叉树
    node = CreaThread(&node1);
    //以中序遍历线索二叉树
    ThInOrder(node);
    printf("\n\n");
    return 0;
}

测试结果：