二叉搜索树(BST树)的简单实现

 

#include  < stdlib.h >
template < typename T >
class  CBinSTree;

template  < typename T >
class  CTreeNode
{//树节点类
public:
    CTreeNode(const T& item,CTreeNode<T>* lptr = NULL,CTreeNode<T>* rptr = NULL):data(item),left(lptr),right(rptr)
    {
    }
    CTreeNode<T>* Left(void)
    {
        return left;
    }
    CTreeNode<T>* Right(void)
    {
        return right;
    }
    friend class CBinSTree<T>;
public:
    T data;//数据
private:
    CTreeNode<T>* left;//左子树
    CTreeNode<T>* right;//右子树
} ;

template < typename T >
class  CBinSTree  
{//二叉搜索树类
public:
    CBinSTree();
    virtual ~CBinSTree();
    CBinSTree(const CBinSTree<T>& tree);
    CBinSTree<T>& operator = (const CBinSTree<T>& rhs);
    CTreeNode<T>* FindNode(const T& item,CTreeNode<T>* &parent)const;//寻找节点
    void PrintTree();//前序遍历树(非递归)
    void ClearTree();//清空树
    void Insert(const T& item);//插入数据
    void Delete(const T& item);//删除数据
    bool Contains(const T& item);//是否包含数据
    CTreeNode<T>* FindMin()const;//找最小值
    CTreeNode<T>* FindMax()const;//找最大值

protected:
    //辅助函数区
    CTreeNode<T>* GetTreeNode(const T& item,CTreeNode<T>* lptr=NULL,CTreeNode<T>* rptr=NULL);//分配树节点
    void FreeTreeNode(CTreeNode<T>* p);//释放树节点
    void DeleteTree(CTreeNode<T>* t);//删除树
    CTreeNode<T>* CopyTree(CTreeNode<T>* t);//拷贝树
private:
    CTreeNode<T> *root;//二叉搜索树树根
    int size;//树节点个数
} ;

 

#include  " stdafx.h "
#include  " BinSTree.h "
#include  < iostream >
#include  < stack >
using   namespace  std;

/**/ //////////////////////////////////////////////////////////////////////
//  Construction/Destruction
/**/ //////////////////////////////////////////////////////////////////////
template < typename T >
CBinSTree < T > ::CBinSTree()
{
    this->root = NULL;
    this->size = 0;
}
template < typename T >
CBinSTree < T > ::CBinSTree( const  CBinSTree < T >&  tree)
{
    root = this->CopyTree(tree.root);
    this->size = tree.size;
}
template < typename T >
CBinSTree < T > :: ~ CBinSTree()
{
    this->ClearTree();
}
template < typename T >
CBinSTree < T >&  CBinSTree < T > :: operator   =  ( const  CBinSTree < T >&  rhs)
{
    if(this==&rhs)
        return *this;
    this->ClearTree();
    root = this->CopyTree(rhs.root);
    size = rhs.size;
    return *this;
}
template < typename T >
CTreeNode < T >*  CBinSTree < T > ::GetTreeNode( const  T &  item,CTreeNode < T >*  lptr,CTreeNode < T >*  rptr)
{
    CTreeNode<T>* p;
    p = new CTreeNode<T>(item,lptr,rptr);
    if(p==NULL)
    {
        cerr<<"分配内存失败!"<<endl;
        exit(1);
    }
    return p;
}
template < typename T >
CTreeNode < T >*  CBinSTree < T > ::FindMin() const
{
    CTreeNode<T> *t = root;
    while(t->left!=NULL)
    {
        t = t->left;
    }
    return t;
}
template < typename T >
CTreeNode < T >*  CBinSTree < T > ::FindMax() const
{
    CTreeNode<T> *t = root;
    while(t->right!=NULL)
    {
        t = t->right;
    }
    return t;
}
template < typename T >
bool  CBinSTree < T > ::Contains( const  T &  item)
{
    CTreeNode<T> *p;
    return (this->FindNode(item,p)!=NULL);
}
template < typename T >
CTreeNode < T >*  CBinSTree < T > ::CopyTree(CTreeNode < T >*  t)
{
    CTreeNode<T> *newnode,*newlptr,*newrptr;
    if(t==NULL)
        return NULL;
    if(t->Left()!=NULL)
        newlptr = CopyTree(t->Left());
    else
        newlptr = NULL;
    if(t->Right()!=NULL)
        newrptr = CopyTree(t->Right());
    else
        newrptr = NULL;
    newnode = GetTreeNode(t->data,newlptr,newrptr);
    return newnode;
}
template < typename T >
void  CBinSTree < T > ::FreeTreeNode(CTreeNode < T >*  p)
{
    delete p;
    p = NULL;
}
template < typename T >
void  CBinSTree < T > ::DeleteTree(CTreeNode < T >*  t)
{
    if(t!=NULL)
    {
        DeleteTree(t->Left());
        DeleteTree(t->Right());
        FreeTreeNode(t);
    }
}
template < typename T >
void  CBinSTree < T > ::ClearTree()
{
    DeleteTree(root);
    root = NULL;
}
template < typename T >
CTreeNode < T >*  CBinSTree < T > ::FindNode( const  T &  item,CTreeNode < T >*   & parent) const
{
    CTreeNode<T> *t = root;
    parent = NULL;
    while(t!=NULL)
    {
        if(item==t->data)
            break;
        else
        {
            parent = t;
            if(item<t->data)
                t = t->Left();
            else 
                t = t->Right();
        }
    }
    return t;
}
template < typename T >
void  CBinSTree < T > ::Insert( const  T &  item)
{
    CTreeNode<T>* t = root,*parent = NULL,*newnode;
    while(t!=NULL)
    {
        parent = t;
        if(item<t->data)
            t = t->Left();
        else
            t = t->Right();
    }
    newnode = this->GetTreeNode(item);
    if(parent==NULL)
        root = newnode;
    else if(item<parent->data)
        parent->left = newnode;
    else
        parent->right = newnode;
    size++;
}
template < typename T >
void  CBinSTree < T > ::Delete( const  T &  item)
{
    CTreeNode<T> *pDNode,*pRNode,*pParNode;
    if((pDNode = this->FindNode(item,pParNode))==NULL)
        return;
    if(pDNode->left==NULL)
        pRNode = pDNode->right;
    else if(pDNode->right==NULL)
        pRNode = pDNode->left;
    else
    {
        CTreeNode<T> *pParOfRNode = pDNode;
        pRNode = pDNode->left;
        while(pRNode->right!=NULL)
        {
            pParOfRNode = pRNode;
            pRNode = pRNode->right;
        }
        if(pParOfRNode==pDNode)
        {
            pRNode->right = pDNode->right;
        }
        else
        {
            pParOfRNode->right = pRNode->left;
            pRNode->left = pDNode->left;
            pRNode->right = pDNode->right;
        }
    }
    if(pParNode==NULL)
        root = pRNode;
    else if(pDNode->data<pParNode->data)
        pParNode->left = pRNode;
    else
        pParNode->right = pRNode;
    this->FreeTreeNode(pDNode);
    this->size--;

}
template < typename T >
void  CBinSTree < T > ::PrintTree()
{
    stack<CTreeNode<T>* > s;
    CTreeNode<T>* p = root;
    while (p!=NULL || !s.empty())
    {
        while (p!=NULL)             //遍历左子树
        {
            cout<<p->data<<endl;
            s.push(p);
            p=p->Left();
        }//endwhile
        
        if (!s.empty())
        {
            p=s.top();
            s.pop();
            p=p->Right();            //通过下一次循环实现右子树遍历
        }//endif   
    }
}

 

//  test.cpp : Defines the entry point for the console application.
//

#include  " stdafx.h "
#include  " BinSTree.cpp "
#include  < iostream >
using   namespace  std;

CBinSTree < int >*  MakeSampleTree()
{//示例BST树
    CBinSTree<int> *tree1 = new CBinSTree<int>();
    int a = 5;
    tree1->Insert(a);
    tree1->Insert(30);
    tree1->Insert(65);
    tree1->Insert(25);
    tree1->Insert(35);
    tree1->Insert(50);
    tree1->Insert(10);
    tree1->Insert(28);
    tree1->Insert(26);
    tree1->Insert(33);
    return tree1;
}

int  main( int  argc,  char *  argv[])
{
    CBinSTree<int> *tree1 = MakeSampleTree();
    tree1->PrintTree();
    std::cout<<"删除节点30:"<<endl;
    tree1->Delete(30);
    tree1->PrintTree();
    cout<<tree1->Contains(40)<<endl;
    CTreeNode<int> *p = tree1->FindMin();
    cout<<p->data<<endl;
    return 0;
}