实现中序线索化二叉树

/**
*    线索二叉树概念:
*        对于n个结点的二叉树，在二叉链存储结构中有n+1个空链域，
*    利用这些空链域存放在某种遍历次序下该结点的前驱结点和后继
*    结点的指针，这些指针称为线索，加上线索的二叉树称为线索二
*    叉树。
*    实验题目:
*        实现中序线索化二叉树
*    实验目的:
*        领会线索二叉树的构造过程以及构造线索二叉树的算法设计
*    实验内容:
*        设计程序，实现二叉树的中序线索化，采用递归和非递归两
*    种方法输出中序线索二叉树的中序序列。
*/

#include <stdio.h>
#include <malloc.h>

#define MAX_SIZE 100

typedef char ElemType;
typedef struct node
{
    ElemType data; // 数据域
    int ltag; // 线索标记ltag:ltag=0时lchild指向左孩子,ltag=1时lchild指向前驱
    int rtag; // 线索标记rtag:rtag=0时rchild指向右孩子,rtag=1时rchild指向后继
    struct node *lchild; // 指向左孩子结点
    struct node *rchild; // 指向右孩子结点
}TBTNode; // 声明线索二叉链结点类型

TBTNode *pre; // 全局变量

/*-------------由括号表示串str创建含空线索域的二叉链b-----------------*/
// "A(B(D,E(H(J,K(L,M(,N))))),C(F,G(,I)))"
static void create_tb_tree(TBTNode *&b, char *str) // 创建二叉树(形参b:指针的引用)
{
    TBTNode *p;
    TBTNode *st[MAX_SIZE];
    int top = -1;
    int j = 0;
    int k;
    char ch;

    ch = str[j]; // 取第一个字符
    b = NULL; // 建立的二叉树初始时为空
    while(ch != '\0') // str未扫描完时循环
    {
        switch(ch)
        {
        case '(': // 处理左子树
            top++;
            st[top] = p;
            k = 1;
            break;
        case ')':
            top--;
            break;
        case ',': // 处理右子树
            k = 2;
            break;
        default:
            p = (TBTNode *)malloc(sizeof(TBTNode));
            p->data = ch;
            p->lchild = p->rchild = NULL;
            if(b == NULL) // 若b为空
                b = p; // p为二叉树的根结点
            else // 已建立二叉树根结点
            {
                switch(k)
                {
                case 1:
                    st[top]->lchild = p;
                    break;
                case 2:
                    st[top]->rchild = p;
                    break;
                }
            }
            break;
        }
        j++;
        ch = str[j]; // 取下一个字符
    }
}

/*--------------------------以括号表示法输出含空线索域的二叉树b----------------------*/
// "A(B(D,E(H(J,K(L,M(,N))))),C(F,G(,I)))"
static void disp_tb_tree(TBTNode *b)
{
    if(b != NULL)
    {
        printf("%c", b->data);
        if(b->lchild != NULL || b->rchild != NULL)
        {
            printf("("); // 有孩子结点时才输出(
            disp_tb_tree(b->lchild); // 递归处理左子树
            if(b->rchild != NULL) // 有右孩子结点时才输出,
                printf(",");
            disp_tb_tree(b->rchild); // 递归处理右子树
            printf(")"); // 有孩子结点时才输出)
        }
    }
}

static void destroy_tb_tree1(TBTNode *tb)
{
    if(tb != NULL)
    {
        if(tb->lchild != NULL && tb->ltag == 0) // 有左孩子
        {
            destroy_tb_tree1(tb->lchild);
        }

        if(tb->rchild != NULL && tb->rtag == 0) // 有右孩子
        {
            destroy_tb_tree1(tb->rchild);
        }
        free(tb);
    }
}

/*--------------------------释放中序线索二叉树b的所有结点----------------------*/
static void destroy_tb_tree(TBTNode *tb)
{
    destroy_tb_tree1(tb->lchild);
    free(tb);
}

/*--------------------------中序线索化二叉树----------------------*/
static void thread(TBTNode *&p) // 形参p:指针的引用
{
    if(p != NULL)
    {
        thread(p->lchild); // 左子树线索化
        if(p->lchild == NULL) // 若p结点的左指针为空
        {
            p->lchild = pre; // 建立当前结点的前驱线索
            p->ltag = 1;
        }
        else
            p->ltag = 0;

        if(pre->rchild == NULL) // 若pre结点的右指针为空
        {
            pre->rchild = p; // 建立前驱结点的后继线索
            pre->rtag = 1;
        }
        else
            pre->rtag = 0;

        pre = p;
        thread(p->rchild); // 右子树线索化
    }
}

/*--------------------------创建中序线索化二叉树----------------------*/
static TBTNode *create_thread(TBTNode *b)
{
    TBTNode *root;

    root = (TBTNode *)malloc(sizeof(TBTNode)); // 创建根结点
    root->ltag = 0;
    root->rtag = 1;
    root->rchild = b;

    if(b == NULL) // 空二叉树
        root->lchild = root;
    else
    {
        root->lchild = b;
        pre = root;
        thread(b); // 中序遍历线索二叉树
        pre->rchild = root; // 最后处理,加入指向根结点的线索
        pre->rtag = 1;
        root->rchild = pre; // 根结点右线索化
    }

    return root;
}

static void in_order(TBTNode *tb)
{
    if(tb->lchild != NULL && tb->ltag == 0) // 有左孩子
    {
        in_order(tb->lchild);
    }
    printf("%c ", tb->data);
    if(tb->rchild != NULL && tb->rtag == 0) // 有右孩子
    {
        in_order(tb->rchild);
    }
}

/*--------------------------中序线索化二叉树的中序遍历递归算法----------------------*/
static void th_in_order(TBTNode *tb)
{
    in_order(tb->lchild);
}

/*--------------------------中序线索化二叉树的中序遍历非递归算法----------------------*/
static void th_in_order1(TBTNode *tb)
{
    TBTNode *p = tb->lchild; // 指向根结点

    while(p != tb)
    {
        while(p->ltag == 0) // 查找中序开始结点
            p = p->lchild;
        printf("%c ", p->data);
        while(p->rtag == 1 && p->rchild != tb) // 有右线索的情况
        {
            p = p->rchild;
            printf("%c ", p->data);
        }
        p = p->rchild; // 转向结点p的右子树
    }
}

int main(int argc, char *argv[])
{
    TBTNode *b, *tb;

    create_tb_tree(b, "A(B(D,E(H(J,K(L,M(,N))))),C(F,G(,I)))");
    printf("二叉树:");
    disp_tb_tree(b);
    printf("\n");
    tb = create_thread(b);
    printf("线索中序序列:\n");
    printf("    递归算法:");
    th_in_order(tb);
    printf("\n");
    printf("  非递归算法:");
    th_in_order1(tb);
    printf("\n");

    destroy_tb_tree(tb);

    return 0;
}

测试结果:

二叉树:A(B(D,E(H(J,K(L,M(,N))))),C(F,G(,I)))
线索中序序列:
    递归算法:D B J H L K M N E A F C G I
  非递归算法:D B J H L K M N E A F C G I