线索二叉树

#include <iostream>
#include <string.h>
using namespace std;

template<typename Type>
struct ThreadNode
{
    Type data;
    struct ThreadNode<Type> *left;
    struct ThreadNode<Type> *right;

    bool ltag;
    bool rtag;
    ThreadNode(Type d=Type()):data(d),ltag(false),rtag(false),left(NULL),right(NULL){}
};
template<typename Type>
class ThreadTree
{
    public:
    ThreadTree(char *str)
    {
        flogs=‘#‘;
        root=NULL;
        Construct(root,str);
        ThreadNode<Type> *pre = NULL;   
        CreateThread(root,pre);
        pre = root;
        while(pre->right!=NULL)pre=pre->right;
        pre->rtag=true;

    }
    void show()
    {
        show(root);
    }
    void printf()
    {
        printf(root);
    }
    ThreadNode<Type> *parent(Type val)
    {
            return parent(root,val);
    }
    ThreadNode<Type> *Root()
    {
        return root;
    }
    ThreadNode<Type> *First()
    {
        ThreadNode<Type> *p = root;
        while(p->left!=NULL)
            p=p->left;
        return p;
    }
    ThreadNode<Type> *Last()
    {
        ThreadNode<Type> *p = root;
        while(p->right!=NULL)p=p->right;
        return p;
    }
    ThreadNode<Type> *Next(ThreadNode<Type> *t)
    {
        while(t!=NULL)
        {   
        if(t->rtag==true)break;
        t=t->right;
        }
        return t;
    }
    ThreadNode<Type> *Prior(ThreadNode<Type> *t)
    {
        while(t!=NULL)
        {
            if(t->ltag==true)break;
            t=t->left;
        }
        return t;
    }
    ThreadNode<Type> *Find(Type val)
    {
        return Find(root,val);
    }
    void Inorder()//前序遍历
    {
        Inorder(root);
    }
  void preorder()//中序G遍历
    {
        preorder(root);
    }
    void postorder()//后序遍历.
    {
        postorder(root);
    }
    Type visted(ThreadNode<Type> *t)
    {
        return t->data;
    }
    private:
    void postorder(ThreadNode<Type> *t)
    {
        ThreadNode<Type> *p = NULL;
        ThreadNode<Type> *q = NULL;
        while(t->ltag==false || t->rtag==0)//找要遍历的第一个节点.
        {
                if(t->ltag==false)t=t->left;
                else if(t->rtag==false)t=t->right;
        }
        cout<<t->data<<"  ";
        while((p=parent(root,t->data))!=NULL)
        {
            if(p->right==t||p->rtag==true)
            {
                t = p;//判断t是不是右边的节点，是就往回遍历，让t=p。
            }
            else
            {
                t=p->right;//遍历右边的节点.
                while(t->ltag==false || t->rtag==false)
                {
                    if(t->ltag==false)t=t->left;
                    else if(t->rtag==false)t=t->right;  
                }
            }
                cout<<t->data<<"  ";
        }

    }
    void preorder(ThreadNode<Type> *t)
    {
        printf();
    }
    void Inorder(ThreadNode<Type> *t)
    {
        while(t->left!=NULL){cout<<t->data<<"  ";t=t->left;}
        while(t->right!=NULL)
        {
            if(t->rtag==true)
            t=t->right;

            t=t->right;
        //  cout<<t->data<<"  ";
            while(t->ltag!=true)
            {
            cout<<t->data<<"  ";
            t=t->left;
            }
            cout<<t->data<<"  ";
        }
    }
    ThreadNode<Type> *parent(ThreadNode<Type> *t,Type val)
    {
        ThreadNode<Type> *p = Find(val);
        ThreadNode<Type> *q = NULL;
    if(p==root)return NULL; //根节点.
    if(Next(p)->right==NULL)//右边的节点
            {
                q = Prior(p);
                q = q->left;
                while(q!=NULL)
                {
                        if(q->right==p);
                            return q;
                        q=q->right;
                }
            }
         if(Prior(p)->left==NULL || (Prior(p)->left!=NULL && Next(p)->right!=NULL))//左边及中间的节点.
            {
                q = Next(p);
                q=q->right;
                if(q->left==p || q->right==p)return q;
                else
                     q=q->left;
                while(q!=NULL)
                {   
                    if(q->right==p)
                        return q;
                    q=q->right;
    }
            }
    }
 ThreadNode<Type> *Find(ThreadNode<Type> *t,Type val)   
    {
         t = Prior(t);
         while(t!=NULL)
            {
              if(t->data==val)return t;
                    t=t->right;
            }
/*          if(t==NULL)return NULL;
            if((t->left!=NULL && t->left->data==val) || (t->right!=NULL && t->right->data==val))return t;
            else
            {                       
                ThreadNode<Type> *p = Find(t->left,val);
                if(p!=NULL)return p;
                else
                Find(t->right,val);
            }
 */     
    }
 void printf(ThreadNode<Type> *t)
    {
        while(t->left!=NULL)t=t->left;
        while(t!=NULL)
        {
            cout<<t->data<<" ";
            t=t->right;
        }
        cout<<endl;
    }

    void CreateThread(ThreadNode<Type> *&t,ThreadNode<Type> *&pre)
    {
        if(t==NULL)
                return ;
            CreateThread(t->left,pre);  
        if(t->left==NULL)
        {
            t->left = pre;
            t->ltag=true;
        }
    //  pre = t;
        if(pre!=NULL && pre->right==NULL)
        {
            pre->right = t;
            pre->rtag = true;
        }
        pre = t;
        CreateThread(t->right,pre);//奶奶的，最右边的那个节点的rtag搞不定,只能在外面弄了。
    }

    void show(ThreadNode<Type> *&t)//一般二叉树遍历
    {
        if(t)
            cout<<t->data<<" ";
          if(t!=NULL && t->ltag==false)
            show(t->left);
            if(t!=NULL && t->rtag==false)
            show(t->right);
    }
    bool Construct(ThreadNode<Type> *&t,char *&s)//构建二叉树.
    {
        if(*s==‘#‘)
                {
                t=NULL;
                return false;       
                }
         else{
                t=new ThreadNode<Type>(*s);
                Construct(t->left,++s);
                Construct(t->right,++s);
            }
    }
    private:
    Type flogs;
    ThreadNode<Type> *root;
};
int main()
{
    char *p = new char[13];
    memset(p,‘\0‘,13);
    strncpy(p,"ABC##D##E#F##",13);
    ThreadTree<char> tt(p);
    cout<<tt.visted(tt. parent(‘E‘))<<endl;
//  tt.Inorder();//前序遍历.
 // cout<<endl;
//  tt.preorder();//中序遍历
        tt.postorder();//后序遍历.
//  tt.show();      
//  cout<<endl;
//  tt.printf();
    return 0;
}