线索化二叉树的构建与先序，中序遍历(C++版)

贴出学习C++数据结构线索化二叉树的过程，

方便和我一样的新手进行测试和学习

同时欢迎各位大神纠正。

不同与普通二叉树的地方会用背景色填充

//BinTreeNode_Thr.h

enum PointTag
{Link,Thread};

template<typename ElemType>
struct BinTreeNode
{
    ElemType data;                     //数据元素
    PointTag LTag,RTag;                 //左标志，右标志
    BinTreeNode<ElemType> *leftChild;  //指向左孩子的指针
    BinTreeNode<ElemType> *rightChild; //指向右孩子的指针
    //函数构造
    BinTreeNode();
    BinTreeNode(const ElemType &val,
        BinTreeNode<ElemType> *lChild=NULL,
        BinTreeNode<ElemType> *rChild=NULL);
    BinTreeNode<ElemType> &operator =(const BinTreeNode<ElemType> &copy);
};

template<typename ElemType>
BinTreeNode<ElemType>::BinTreeNode()
{
    leftChild=rightChild=NULL;
    LTag=RTag=Link;               //此处初始化为Link，即存在孩子
}

template<typename ElemType>
BinTreeNode<ElemType>::BinTreeNode(const ElemType &val,
                        BinTreeNode<ElemType> *lChild,
                        BinTreeNode<ElemType> *rChild)
{
    data=val;
    LTag=RTag=Link;               //初始化为Link
    leftChild=lChild;
    rightChild=rChild;
}

template<typename ElemType>
BinTreeNode<ElemType> &BinTreeNode<ElemType>::operator =(const BinTreeNode<ElemType> &copy)
{
    data=copy.data;
    leftChild=copy.leftChild;
    rightChild=copy.leftChild;
    LTag=copy.LTag;
    RTag=copy.RTag;
}

//BinaryTree_Thr.h

#include"BinTreeNode_Thr.h"
template<typename ElemType>
class BinaryTree_Thr
{
protected:
    //数据成员
    BinTreeNode<ElemType> *root;
    //辅助函数
    BinTreeNode<ElemType> *CopyTreeHelp(const BinTreeNode<ElemType> *r);//复制二叉树
    void DestroyHelp(BinTreeNode<ElemType> *&r);//销毁r为根的二叉树
    void PreThreadingHelp(BinTreeNode<ElemType> *p,BinTreeNode<ElemType> *&pre);   //先序线索化
    void InThreadingHelp(BinTreeNode<ElemType> *p,BinTreeNode<ElemType> *&pre);   //中序线索化
    void CreateBTreeHelp(BinTreeNode<ElemType> *&r,ElemType pre[],ElemType in[],int,int,int,int);//用中序和先序序列构造树
public:
    BinaryTree_Thr(){root=NULL}//无参构造
    BinaryTree_Thr(BinTreeNode<ElemType> *r){ root=r;}//建立以r为根的二叉树
    virtual ~BinaryTree_Thr();//有指针自定义虚构，且用虚虚构
    BinaryTree_Thr<ElemType> &CreateBTree(ElemType pre[],ElemType in[],int n); //构造树
    void PreTreading();//先序线索化
    void InTreading();//中序线索化
    void PreOrderTraverse_Thr(void (*visit) (const ElemType &))const;                       //先序遍历
    void InOrderTraverse_Thr(void (*visit) (const ElemType &))const;                       //中序遍历
    void LevelOrder(void (*visit) (const ElemType &))const;
    BinaryTree_Thr<ElemType> &operator =(const BinaryTree_Thr<ElemType> &copy);//重载赋值运算符
};


//Copy
template<typename ElemType>
BinTreeNode<ElemType> *BinaryTree_Thr<ElemType>::CopyTreeHelp(const BinTreeNode<ElemType> *r)
{
    BinTreeNode<ElemType> *cur;
    if(r==NULL)   cur=NULL;
    else
    {
        BinTreeNode<ElemType> *lChild=CopyTreeHelp(r->leftChild);//复制左子树
        BinTreeNode<ElemType> *rChild=CopyTreeHelp(r->rightChild);//复制右子树
        cur=new BinTreeNode<ElemType>(r->data,lChild,rChild);
        //复制根节点
    }
    return cur;
}

template<typename ElemType>
void BinaryTree_Thr<ElemType>::InThreadingHelp(BinTreeNode<ElemType> *p,BinTreeNode<ElemType> *&pre)//中序遍历
    {
    if(p)
        {
            if(p->LTag==Link)
                InThreadingHelp(p->leftChild,pre);    //线索化左子树.
            if(!p->leftChild)                 //左孩子空 
            {
                p->LTag=Thread;
                p->leftChild=pre;
            }
            if(!pre->rightChild)             //前驱 的右孩子空
            {
                pre->RTag=Thread;
                pre->rightChild=p;
            }
            pre=p;
            if(p->RTag==Link)
                InThreadingHelp(p->rightChild,pre);  //线索化右子树
        }

    }

template<typename ElemType>
void BinaryTree_Thr<ElemType>::PreThreadingHelp(BinTreeNode<ElemType> *p,BinTreeNode<ElemType> *&pre)//先序遍历
    {
    if(p)
        {
            if(!p->leftChild)                 //左孩子空 
            {
                p->LTag=Thread;
                p->leftChild=pre;
            }
            if(!pre->rightChild)             //前驱 的右孩子空
            {
                pre->RTag=Thread;
                pre->rightChild=p;
            }
            pre=p;
            if(p->LTag==Link)
                PreThreadingHelp(p->leftChild,pre);    //线索化左子树.
            if(p->RTag==Link)
                PreThreadingHelp(p->rightChild,pre);  //线索化右子树
        }

    }

template<typename ElemType>
void BinaryTree_Thr<ElemType>::DestroyHelp(BinTreeNode<ElemType> *&r)
{
    if(r!=NULL)
    {
        if(r->LTag==Link)
            DestroyHelp(r->leftChild);
        if(r->RTag==Link)
            DestroyHelp(r->rightChild);
        delete r;
        r=NULL;
    }
}

//虚构
template<typename ElemType>
BinaryTree_Thr<ElemType>::~BinaryTree_Thr()
{
    DestroyHelp(root);
}

template<typename ElemType>
//Thr为头节点，T为根.
void BinaryTree_Thr<ElemType>::InTreading()
{
    BinTreeNode<ElemType> *pre=root;
    InThreadingHelp(root,pre);    //中序线索化
    if(pre->rightChild==NULL)
        pre->RTag=Thread;       //处理最后一个节点
}

template<typename ElemType>
void BinaryTree_Thr<ElemType>::PreTreading()
{
    BinTreeNode<ElemType> *pre=root;
    PreThreadingHelp(root,pre);    //先序线索化
    if(pre->rightChild==NULL)
        pre->RTag=Thread;       //处理最后一个节点
}

template<typename ElemType>
void print(const ElemType &e )
{
    cout<<e<<" ";
}

template<typename ElemType>
void BinaryTree_Thr<ElemType>::InOrderTraverse_Thr(void (*visit) (const ElemType &))const
{
    visit=print;
    if(root!=NULL){
        BinTreeNode<ElemType> *p=root;            //p指向根
        while(p->LTag==Link)  p=p->leftChild;     //左走至最左下角
        while(p)
        {
            (*visit)(p->data);       //访问结点元素
            if(p->RTag==Thread)      //右孩子为线索，则p指向后继
            {
                p=p->rightChild;
            }
            else    //右孩子存在
            {
                p=p->rightChild;     //遍历右孩子
                while(p->LTag==Link)
                    p=p->leftChild;
            }
        }
    }
}

template<typename ElemType>
void BinaryTree_Thr<ElemType>::PreOrderTraverse_Thr(void (*visit) (const ElemType &))const
{
    visit=print;
    if(root!=NULL){
        BinTreeNode<ElemType> *p=root;        //p指向根
        while(p)
        {
            (*visit)(p->data);
            if(p->RTag==Thread)
                p=p->rightChild;
            else
            {
                if(p->LTag==Link)
                    p=p->leftChild;
                else
                    p=p->rightChild;
            }
        }
    }
}

template<typename ElemType>
void BinaryTree_Thr<ElemType>::CreateBTreeHelp(BinTreeNode<ElemType> *&r,
                                           ElemType pre[],ElemType in[],
                                           int preLeft,int preRight,int inLeft,int inRight)

{
    if(preLeft>preRight||inLeft>inRight)
        r=NULL;
    else
    {
        r=new BinTreeNode<ElemType>(pre[preLeft]);//生成根结点
        int mid=inLeft;
        while(in[mid]!=pre[preLeft])
            mid++;
        CreateBTreeHelp(r->leftChild,pre,in,preLeft+1,preLeft+mid-inLeft,inLeft,mid-1);        //这里如果不懂建议自己画图手工实现一遍。
        CreateBTreeHelp(r->rightChild,pre,in,preLeft+mid-inLeft+1,preRight,mid+1,inRight);
    }
}

template<typename ElemType>
//构造树
BinaryTree_Thr<ElemType>& BinaryTree_Thr<ElemType>::CreateBTree(ElemType pre[],ElemType in[],int n)
{
    BinTreeNode<ElemType> *r;   //根
    CreateBTreeHelp(r,pre,in,0,n-1,0,n-1);
    //return BinaryTree<ElemType>(r);//，不能这么返回，Error:不应该返回局部变量的地址
    *this = BinaryTree_Thr<ElemType>(r);
    return *this;
}

#include<queue>
template<typename ElemType>
void BinaryTree_Thr<ElemType>::LevelOrder(void (*visit) (const ElemType &))const
{    //队列实现
    visit=print;
    queue<BinTreeNode<ElemType> *> q;
    BinTreeNode<ElemType> *t=root;
    if(t!=NULL) q.push(t);                //根非空，入队
    while(!q.empty())                //队不空
    {
        t=q.front();
        q.pop();                    //出队
        (*visit)(t->data);          //一层一层进行遍历，无法理解还是自己画图实现一遍
        if(t->leftChild)
            q.push(t->leftChild);  //遍历左孩子
        if(t->rightChild)           
            q.push(t->rightChild); //遍历右孩子
    }

}

//operator =
template<typename ElemType>
BinaryTree_Thr<ElemType> &BinaryTree_Thr<ElemType>::operator=(const BinaryTree_Thr<ElemType> &copy)
{
    if(&copy!=this)
    {
        DestroyHelp(root);
        root=CopyTreeHelp(copy.root);
    }
    return *this;
}