BST的一个实现

#include<iostream>
using namespace std;
template<typename type>
class BinNode                           //结点的抽象类ADT
{
public:
    virtual type&val()=0;               //取结点值
    virtual void setval(const type&)=0; //设置结点值
    virtual BinNode*left()const=0;      //返回左孩子结点指针
    virtual BinNode*right()const=0;     //返回右孩子结点指针
    virtual void setleft(BinNode*)=0;   //设置左孩子结点
    virtual void setright(BinNode*)=0;  //设置右孩子结点
    virtual bool isleaf()=0;            //是否为叶结点（在下面没实现）
};
//*****************************************//
//*****************************************//
template<typename type>
class BinNodePtr:public BinNode<type>   //实例结点类
{
private:
    type it;                            //结点元素
    BinNodePtr*lc;                      //左孩子
    BinNodePtr*rc;                      //右孩子
public:
    BinNodePtr(){lc=rc=NULL;}
    BinNodePtr(const type&it_,BinNodePtr*l=NULL,BinNodePtr*r=NULL)
    {it=it_;lc=l;rc=r;}
    ~BinNodePtr(){}
    type&val(){return it;}
    void setval(const type&it_){it=it_;}
    BinNode<type>*left()const{return lc;}
    BinNode<type>*right()const{return rc;}
    void setleft(BinNode<type>*l){lc=(BinNodePtr*)l;}    //强制转换指针
    void setright(BinNode<type>*r){rc=(BinNodePtr*)r;}
    bool isleaf(){return (lc==NULL)&&(rc==NULL);}
};
//******************************************************//
//********************************************************//
template<typename type>
class BST                                           //二叉搜索树
{
private:
    BinNode<type>*root;  //树的根
    int nodecount;
    void clearhelp(BinNode<type>*subroot)           //辅助清空函数
    {
        if(subroot==NULL)return;     //用后序遍历，
        clearhelp(subroot->left());  //先清空左子树
        clearhelp(subroot->right()); //再清空右子树
        delete subroot;              //最后清空自身
    }
    BinNode<type>*inserthelp(BinNode<type>*subroot,const type&elem)  //辅助插入函数，返回的是插入数据后的树根
    {
        if(subroot==NULL)  //空则建新结点，代替空的位置
        {
            BinNode<type>*temp=new BinNodePtr<type>(elem,NULL,NULL);
            subroot=temp;
        }
        else if(elem<subroot->val())
            subroot->setleft(inserthelp(subroot->left(),elem));
        else
            subroot->setright(inserthelp(subroot->right(),elem));
        return subroot;//对于每一次的检查，都把当前指针返回给上一次检查，用于连接。
    }
    BinNode<type>*deletemin(BinNode<type>*subroot,BinNode<type>*&min)//删除最小值，返回的是树根
    {
        if(subroot->left==NULL){min=subroot;return subroot->right;}
        else
        {
            subroot->setleft(deletemin(subroot->left(),min));
            return subroot;
        }
    }
    BinNode<type>*removehelp(BinNode<type>*subroot,const type&key,BinNode<type>*&elem)//辅助删除某结点
    {
        if(subroot==NULL)return NULL;
        else if(key<subroot->val())
            subroot->setleft(removehelp(subroot->left(),key,elem));
        else if(key>subroot->val())
            subroot->setright(removehelp(subroot->right(),key,elem));
        else
        {
            BinNode<type>*temp;
            elem=subroot;
            if(subroot->left()==NULL)
                subroot=subroot->right();
            else if(subroot->right()==NULL)
                subroot=subroot->right();
            else
            {
                subroot->setright(deletemin(subroot->right(),temp));
                type te=subroot->val();
                subroot->setval(temp->val());
                temp->setval(te);
                elem=temp;
            }
        }
        return subroot;
    }
    bool findhelp(BinNode<type>*subroot,const type&key,type&elem)const//辅助查找某值是否存在
    {
        if(subroot==NULL)return false;
        else if(key<subroot->val())
            return findhelp(subroot->left(),key,elem);
        else if(key>subroot->val())
            return findhelp(subroot->right(),key,elem);
        else{elem=subroot->val();return true;}
    }
    void printhelp(BinNode<type>*subroot,int level)const  //打印，中序遍历
    {
        if(subroot==NULL)return;
        printhelp(subroot->left(),level+1);
        for(int i=0;i<level;i++)
            cout<<" ";
        cout<<subroot->val()<<endl;
        printhelp(subroot->right(),level+1);
    }
//***************************************************//
//****************************************************//
public:
    BST(){root=NULL;nodecount=0;}
    ~BST(){clearhelp(root);}
    void clear() //清空树
    {
        clearhelp(root);root=NULL;nodecount=0;
    }
    bool insert(const type&elem) //插入数据
    {
        root=inserthelp(root,elem);
        nodecount++;
        return true;
    }
    bool remove(const type&key,type&elem)//需要删除的值是key
    {
        BinNode<type>*t=NULL;
        root=removehelp(root,key,t);
        if(t==NULL)return false;
        elem=t->val();
        nodecount--;
        delete t;
        return true;
    }
    bool removeany(type&elem) //删除最小值
    {
        if(root==NULL)return false;
        BinNode<type>*t;
        root=deletemin(root,t);
        elem=t->val();
        delete t;
        nodecount--;
        return true;
    }
    bool find(const type&key,type&elem)const //看特定数值是否存在
    {
        return findhelp(root,key,elem);
    }
    int size(){return nodecount;}  //树结点数目
    void print()const //中序遍历打印
    {
        if(root==NULL)cout<<"the BST is empty"<<endl;
        else printhelp(root,0);
    }
};
int main()
{
    BST<int>bst;
    int a[8]={37,24,32,72,42,40,42,120};
    for(int i=0;i<8;i++)bst.insert(a[i]);
    bst.print();
}