第十一周项目3线索化二叉树

最新推荐文章于 2022-05-07 18:56:20 发布
安夏啊
最新推荐文章于 2022-05-07 18:56:20 发布
阅读量355
点赞数
分类专栏：数据结构
本文链接：https://blog.csdn.net/JYHliling/article/details/53113489
版权
数据结构专栏收录该内容
72 篇文章 0 订阅
订阅专栏
问题代码：
/*Copyright(c)2016,烟台大学计算机学院 
 *All right reserved. 
 *文件名称：线索化二叉树.cpp 
 *作者：李玲 
 *完成日期；2016年11月10日 
 *版本号；v1.0 
 *问题描述：将二叉树 
            线索化表示出来 
 *输入描述：输入二叉树各个元素 
 *程序输出：中序线索二叉树 
*/  



#include <stdio.h>  
#include "btree.h"  
int main()  
{  
    BTNode *b,*tb;  
    CreateTBTNode(b,"A(B(D(,G)),C(E,F))");  
    printf(" 二叉树:");  
    DispTBTNode(b);  
    printf("\n");  
    tb=CreaThread(b);  
    printf(" 线索中序序列:");  
    ThInOrder(tb);  
    printf("\n");  
    return 0;  
}  
#include <stdio.h>  
#include <malloc.h>  
#include "btree.h"  
void CreateTBTNode(BTNode * &b,char *str)  
{  
    BTNode *St[MaxSize],*p=NULL;  
    int top=-1,k,j=0;  
    char ch;  
    b=NULL;             //建立的二叉树初始时为空  
    ch=str[j];  
    while (ch!='\0')    //str未扫描完时循环  
    {  
        switch(ch)  
        {  
        case '(':  
            top++;  
            St[top]=p;  
            k=1;  
            break;      //为左结点  
        case ')':  
            top--;  
            break;  
        case ',':  
            k=2;  
            break;                          //为右结点  
        default:  
            p=(BTNode *)malloc(sizeof(BTNode));  
            p->data=ch;  
            p->lchild=p->rchild=NULL;  
            if (b==NULL)                    //*p为二叉树的根结点  
                b=p;  
            else                            //已建立二叉树根结点  
            {  
                switch(k)  
                {  
                case 1:  
                    St[top]->lchild=p;  
                    break;  
                case 2:  
                    St[top]->rchild=p;  
                    break;  
                }  
            }  
        }  
        j++;  
        ch=str[j];  
    }  
}  
  
void DispTBTNode(BTNode *b)  
{  
    if (b!=NULL)  
    {  
        printf("%c",b->data);  
        if (b->lchild!=NULL || b->rchild!=NULL)  
        {  
            printf("(");  
            DispTBTNode(b->lchild);  
            if (b->rchild!=NULL) printf(",");  
            DispTBTNode(b->rchild);  
            printf(")");  
        }  
    }  
}  
  
BTNode *pre;                       //全局变量  
  
void Thread(BTNode *&p)  
{  
    if (p!=NULL)  
    {  
        Thread(p->lchild);          //左子树线索化  
        if (p->lchild==NULL)        //前驱线索  
        {  
            p->lchild=pre;          //建立当前结点的前驱线索  
            p->ltag=1;  
        }  
        else p->ltag=0;  
        if (pre->rchild==NULL)      //后继线索  
        {  
            pre->rchild=p;          //建立前驱结点的后继线索  
            pre->rtag=1;  
        }  
        else pre->rtag=0;  
        pre=p;  
        Thread(p->rchild);          //右子树线索化  
    }  
}  
  
BTNode *CreaThread(BTNode *b)     //中序线索化二叉树  
{  
    BTNode *root;  
    root=(BTNode *)malloc(sizeof(BTNode));  //创建根结点  
    root->ltag=0;  
    root->rtag=1;  
    root->rchild=b;  
    if (b==NULL)                //空二叉树  
        root->lchild=root;  
    else  
    {  
        root->lchild=b;  
        pre=root;               //pre是*p的前驱结点,供加线索用  
        Thread(b);              //中序遍历线索化二叉树  
        pre->rchild=root;       //最后处理,加入指向根结点的线索  
        pre->rtag=1;  
        root->rchild=pre;       //根结点右线索化  
    }  
    return root;  
}  
  
void ThInOrder(BTNode *tb)  
{  
    BTNode *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;  
    }  
}  
void CreateBTNode(BTNode *&b,char *str)     //由str串创建二叉链  
{  
    BTNode *St[MaxSize],*p=NULL;  
    int top=-1,k,j=0;  
    char ch;  
    b=NULL;             //建立的二叉树初始时为空  
    ch=str[j];  
    while (ch!='\0')    //str未扫描完时循环  
    {  
        switch(ch)  
        {  
        case '(':  
            top++;  
            St[top]=p;  
            k=1;  
            break;      //为左节点  
        case ')':  
            top--;  
            break;  
        case ',':  
            k=2;  
            break;                          //为右节点  
        default:  
            p=(BTNode *)malloc(sizeof(BTNode));  
            p->data=ch;  
            p->lchild=p->rchild=NULL;  
            if (b==NULL)                    //p指向二叉树的根节点  
                b=p;  
            else                            //已建立二叉树根节点  
            {  
                switch(k)  
                {  
                case 1:  
                    St[top]->lchild=p;  
                    break;  
                case 2:  
                    St[top]->rchild=p;  
                    break;  
                }  
            }  
        }  
        j++;  
        ch=str[j];  
    }  
}  
BTNode *FindNode(BTNode *b,ElemType x)  //返回data域为x的节点指针  
{  
    BTNode *p;  
    if (b==NULL)  
        return NULL;  
    else if (b->data==x)  
        return b;  
    else  
    {  
        p=FindNode(b->lchild,x);  
        if (p!=NULL)  
            return p;  
        else  
            return FindNode(b->rchild,x);  
    }  
}  
BTNode *LchildNode(BTNode *p)   //返回*p节点的左孩子节点指针  
{  
    return p->lchild;  
}  
BTNode *RchildNode(BTNode *p)   //返回*p节点的右孩子节点指针  
{  
    return p->rchild;  
}  
int BTNodeDepth(BTNode *b)  //求二叉树b的深度  
{  
    int lchilddep,rchilddep;  
    if (b==NULL)  
        return(0);                          //空树的高度为0  
    else  
    {  
        lchilddep=BTNodeDepth(b->lchild);   //求左子树的高度为lchilddep  
        rchilddep=BTNodeDepth(b->rchild);   //求右子树的高度为rchilddep  
        return (lchilddep>rchilddep)? (lchilddep+1):(rchilddep+1);  
    }  
}  
void DispBTNode(BTNode *b)  //以括号表示法输出二叉树  
{  
    if (b!=NULL)  
    {  
        printf("%c",b->data);  
        if (b->lchild!=NULL || b->rchild!=NULL)  
        {  
            printf("(");  
            DispBTNode(b->lchild);  
            if (b->rchild!=NULL) printf(",");  
            DispBTNode(b->rchild);  
            printf(")");  
        }  
    }  
}  
void DestroyBTNode(BTNode *&b)   //销毁二叉树  
{  
    if (b!=NULL)  
    {  
        DestroyBTNode(b->lchild);  
        DestroyBTNode(b->rchild);  
        free(b);  
    }  
}  
#define MaxSize 100  
typedef char ElemType;  
typedef struct node  
{  
    ElemType data;  
    int ltag,rtag;      //增加的线索标记  
    struct node *lchild;  
    struct node *rchild;  
} BTNode;  
void CreateBTNode(BTNode *&b,char *str);        //由str串创建二叉链  
BTNode *FindNode(BTNode *b,ElemType x);     //返回data域为x的节点指针  
BTNode *LchildNode(BTNode *p);  //返回*p节点的左孩子节点指针  
BTNode *RchildNode(BTNode *p);  //返回*p节点的右孩子节点指针  
int BTNodeDepth(BTNode *b); //求二叉树b的深度  
void DispBTNode(BTNode *b); //以括号表示法输出二叉树  
void DestroyBTNode(BTNode *&b);  //销毁二叉树  
void ThInOrder(BTNode *tb);  
BTNode *CreaThread(BTNode *b);  
void Thread(BTNode *&p);  
void DispTBTNode(BTNode *b);  
void CreateTBTNode(BTNode * &b,char *str);
运行结果：