线索二叉树threadBinTree

头文件：

#ifndef _THREADBINTREE_H

#define _THREADBINTREE_H
typedef enum{LINK,THREAD}Tag;
template
class BinTree;
template
class BinTreeNode
{
friend BinTree;
public:
BinTreeNode(Type d=Type()):leftChild(NULL),rightChild(NULL),ltag(LINK),rtag(LINK),data(d)
{}
~BinTreeNode()
{}
private:
Type data;
BinTreeNode *leftChild;
BinTreeNode *rightChild;
Tag   ltag;
Tag   rtag;
};
template
class BinTree
{
public:
BinTree(Type ref):root(NULL),refval(ref)
{}
void create_tree(const char *&str)
{
    create_tree(root,str);
}
void create_tree(BinTreeNode *&t,const char *&str)
{
if(*str==refval)
    t=NULL;
    else
    {
        t=new BinTreeNode(*str);
        create_tree(t->leftChild,++str);
        create_tree(t->rightChild,++str);
    }
}
void create_threadBinTree();
void create_threadBinTree(BinTreeNode *&t,BinTreeNode *&pre);
void InOrder()const
{
    InOrder(root);
}
void InOrder(BinTreeNode *t)const
{
    if(t!=NULL)
    {
        InOrder(t->leftChild);
        cout<data<<"  ";
        InOrder(t->rightChild);
    }
}
BinTreeNode* first();
BinTreeNode*first(BinTreeNode*t);
BinTreeNode* last();
BinTreeNode* last(BinTreeNode *t);
BinTreeNode* next(BinTreeNode *cur);
BinTreeNode* prior(BinTreeNode *cur);
void inorder();
void inorder(BinTreeNode *t);
BinTreeNode*parent(BinTreeNode *cur);
BinTreeNode* parent(BinTreeNode *t,BinTreeNode *cur);
~BinTree()
{
    //
}
private:
BinTreeNode *root;
Type refval;
};
template
void BinTree::create_threadBinTree()
{
    BinTreeNode *pre=NULL;
    create_threadBinTree(root,pre);
    pre->rightChild=NULL;
    pre->rtag=THREAD;
}
template
void BinTree::create_threadBinTree(BinTreeNode*&t,BinTreeNode *&pre)
{
    if(t==NULL)
    return ;
        create_threadBinTree(t->leftChild,pre);
        if(t->leftChild==NULL)
        {
            t->leftChild=pre;
            t->ltag=THREAD;
        }
        if(pre!=NULL&&pre->rightChild==NULL)
        {
            pre->rtag=THREAD;
            pre->rightChild=t;
        }
        pre=t;
        create_threadBinTree(t->rightChild,pre);
}
template
BinTreeNode* BinTree::first()
{
    first(root);
}
template
BinTreeNode* BinTree::first(BinTreeNode*t)
{
    if(t==NULL)
    return NULL;
    while(t->ltag==LINK)
    t=t->leftChild;
    return t;
}
template
BinTreeNode* BinTree::last()
{
    last(root);
}
template
BinTreeNode* BinTree::last(BinTreeNode *t)
{
    if(t==NULL)
        return t;
    while(t->rtag==LINK)
        t=t->rightChild;
    return t;
}
template
BinTreeNode* BinTree::prior(BinTreeNode *t)
{
    if(t==NULL)
    return NULL;
    if(t->rtag==THREAD)
    return t->leftChild;
    else
    return first(t->leftChild);
}
template
BinTreeNode* BinTree::next(BinTreeNode*t)
{
    if(t==NULL)
        return NULL;
    if(t->rtag==THREAD)
        return t->rightChild;
    else
        return first(t->rightChild);
}
template
void BinTree::inorder()
{
    inorder(root);
}
template
void BinTree::inorder(BinTreeNode *t)
{
    for(t=first(t);t!=NULL;t=next(t))
        cout<data<<"  ";
        cout< }
template
BinTreeNode* BinTree::parent(BinTreeNode *cur)
{
    parent(root,cur);
}
template
BinTreeNode* BinTree::parent(BinTreeNode *t,BinTreeNode *cur)
{
    if(cur==NULL)
    return NULL;
    if(cur->ltag==THREAD)
        if(cur->leftChild->leftChild==cur||cur->leftChild->rightChild==cur)
        return cur->leftChild;
    if(cur->rtag==THREAD)
        if(cur->rightChild->leftChild==cur||cur->rightChild->rightChild==cur)
        return cur->rightChild;
    if(prior(first(cur->leftChild))!=NULL&&prior(first(cur->leftChild))->rightChild==cur)
    return prior(first(cur->leftChild));
    if((next(last(cur->leftChild))!=NULL)&&next(last(cur->rightChild))->leftChild==cur)
    return next(last(cur->rightChild));
}
#endif

测试文件：test.cpp

#include"./utility.h"
#include"./threadBinTree.h"
int main()
{
BinTree bt('#');
    const    char *ch="ABC##DE##F##G#H##";
    bt.create_tree(ch);
    bt.InOrder();
    cout<     bt.create_threadBinTree();
    bt.first();    
    bt.last();
    bt.prior(bt.last());
    bt.next(bt.next(bt.first()));
    bt.inorder();
    bt.parent(bt.next(bt.first()));
    bt.parent(bt.next(bt.next(bt.next(bt.first()))));
}