线索二叉树的创建与销毁（C++数据结构）

【问题描述】

建立线索链表，实质上就是将二叉链表中的空指针改为指向前驱或后继的线索，而前驱或后继的信息只有在遍历该二叉树时才能得到。给定扩展二叉树的前序序列，构建二叉树。然后为这棵二叉树建立中序线索链表，并利用线索链表输出中序遍历结果。

【输入形式】

输入扩展二叉树的前序序列。

【输出形式】

利用线索二叉树输出树的中序遍历序列，并且按照中序顺序输出销毁线索二叉树的过程。

【样例输入】

abd#g###ce##f##  

【样例输出】

Inorder:dgbaecf

Inorder finished. Calling destructer...

delete d

delete g

delete b

delete a

delete e

delete c

delete f

【题目要求】

要求创建二叉树，然后建立线索链表，必须在规定的代码结构中编写，不能修改主函数。 

/*定义中序线索二叉树
运行范例：
abd#g###ce##f##
*/
#include<iostream>
#include<stdio.h>
using namespace std;
 
struct ThreadNode
{
    char data;
    ThreadNode *lchild, *rchild;
    int ltag, rtag;
};
 
class ThreadBiTree
{
private:
    ThreadNode *root;//指向线索链表的头指针
public:
 
    ThreadBiTree()   //构造函数，建立中序线索链表
    {
        root = NULL;
        root = creat(root);
        inThread(root);
    }
    ~ThreadBiTree();                //析构函数，释放各结点的存储空间
    ThreadNode *next(ThreadNode *p);//查找p的后继
    void  inOrder();                //中序遍历线索链表
private:
    ThreadNode *creat(ThreadNode *bt);
    void  destroy(ThreadNode *p);   //线索化，由构造函数调用
    void inThread(ThreadNode *p);   //线索化，由构造函数调用
};
 
//create函数创建二叉树
ThreadNode *ThreadBiTree::creat(ThreadNode *bt)
{
    char ch;
    cin>>ch;
    if(ch=='#'){
        bt=NULL;
    }
    else{
        bt=new ThreadNode;
        bt->data=ch;
        bt->ltag=0;
        bt->rtag=0;
        bt->lchild=creat(bt->lchild);
        bt->rchild=creat(bt->rchild);
    }
    return bt;
}
 
//实现二叉树线索化，这个函数由构造函数调用
void ThreadBiTree::inThread(ThreadNode *p)
{
    static ThreadNode *pre=NULL;
    if(p==NULL){
        return;
    }
    inThread(p->lchild);
    if(p->lchild==NULL){
        p->ltag=1;
        p->lchild=pre;
    }
    if(pre!=NULL){
        pre->rtag=1;
        pre->rchild=p;
    }
    pre=p;
    inThread(p->rchild);
}
 
//查找p的后继
ThreadNode* ThreadBiTree::next(ThreadNode *p)
{
    ThreadNode *q=NULL;
    if(p->rtag==1){
        q=p->rchild;
    }
    else{
        q=p->rchild;
        while(q->ltag==0){
            q=q->lchild;
        }
    }
    return q;
}
 
//中序遍历线索链表
void ThreadBiTree::inOrder()
{
    if(root==NULL){
        return;
    }
    ThreadNode *p;
    p=root;
    while(p->ltag==0){
        p=p->lchild;
    }
    cout<<p->data;
    while(p->rchild!=NULL){
        p=next(p);
        cout<<p->data;
    }
}
 
//析构函数，释放各结点的存储空间
ThreadBiTree::~ThreadBiTree()
{
    destroy(root);
}
 
//destroy函数，由析构函数调用销毁结点
void ThreadBiTree::destroy(ThreadNode *p)
{
    if(p==NULL){
        return;
    }
    ThreadNode *q=NULL;
    while(p->ltag==0){
        p=p->lchild;
    }
    do{
        q=next(p);
        cout<<"delete "<<p->data<<endl;
        delete p;
        p=q;
    }while(q->rchild!=NULL);
    cout<<"delete "<<p->data;
    delete p;
}
 
int main()
{
    ThreadBiTree tree;
    cout << "Inorder:";
    tree.inOrder();
    cout <<endl<< "Inorder  finished.  Calling  destructer..."<<endl;
    return 0;
}

推荐哔哩哔哩懒猫老师数据结构“线索二叉树”视频。