二叉查找树简单实现

#ifndef BINARYSEARCHTREE_H
#define BINARYSEARCHTREE_H

#include <iostream>

template <typename Comparable>
class BinarySearchTree
{
    public:
        BinarySearchTree()
        { root = NULL; }
        BinarySearchTree( const BinarySearchTree &rhs )
        { operator=( rhs ); }
        ~BinarySearchTree()
        { makeEmpty(); }

        const Comparable &findMin() const
        {
            BinaryNode *p = findMin( root );
            return p->element;
        }
        const Comparable &findMax() const
        {
            BinaryNode *p = findMax( root );
            return p->element;
        }
        bool contains( const Comparable &x ) const
        { return contains( x,root ); }
        bool iSEmpty() const
        { return root == NULL; }
        void printTree() const
        { printTree( root ); }

        void makeEmpty()
        { makeEmpty( root ); }

        void insert( const Comparable &x )
        { insert( x,root ); }
        void remove( const Comparable &x )
        { remove( x,root ); }

        const BinarySearchTree &operator=( const BinarySearchTree &rhs )
        {
            if ( this != &rhs )
            {
                makeEmpty();
                root = clone( rhs.root );
            }

            return *this;
        }

    private:
        struct BinaryNode
        {
            Comparable element;                     //存放数据
            BinaryNode *left;                       //指向左节点
            BinaryNode *right;                      //指向右节点

            BinaryNode( const Comparable &theElement,BinaryNode *lt,BinaryNode *rt )
            : element( theElement ),left( lt ),right( rt ) { }
        };

        BinaryNode *root;

        void insert( const Comparable &x,BinaryNode *&t )const
        {
            if ( t == NULL )
                t = new BinaryNode( x,NULL,NULL );
            else if ( x < t->element )
                insert( x,t->left );
            else if ( x > t->element )
                insert( x,t->right );
            else
                ;
        }

        void remove( const Comparable &x,BinaryNode *&t )const
        {
            if ( t == NULL )
                return ;
            if ( x < t->element )
                remove( x,t->left );
            else if ( t->element < x )
                remove( x,t->right );
            else if ( t->left != NULL && t->right != NULL )
            {
                t->element = findMin( t->right )->element;
                remove( t->element,t->right );
            }
            else
            {
                BinaryNode *oldNode = t;
                t = ( t->left != NULL ) ? t->left : t->right;
                delete oldNode;
            }
        }

        BinaryNode *findMin( BinaryNode *t )const
        {
            if ( t == NULL )
                return NULL;
            if ( t->left == NULL )
                return t;

            return findMin( t->left );
        }

        BinaryNode *findMax( BinaryNode *t )const
        {
            if ( t != NULL )
                while ( t->right != NULL )
                    t = t->right;

            return t;
        }

        bool contains( const Comparable &x,BinaryNode *t )const
        {
            if ( t == NULL )
                return false;
            else if ( x < t->element )
                return contains( x,t->left );
            else if ( t->element < x )
                return contains( x,t->right );
            else
                return true;
        }

        void makeEmpty( BinaryNode *&t )
        {
            if ( t != NULL )
            {
                makeEmpty( t->left );
                makeEmpty( t->right );
                delete t;
            }
            t = NULL;
        }

        void printTree( BinaryNode *t )const                //先序遍历
        {
            if ( t == NULL )
                return ;

            std::cout << t->element << std::endl;
            printTree( t->left );
            printTree( t->right );
        }

        BinaryNode *clone( BinaryNode *t )const
        {
            if ( t == NULL )
                return NULL;

            return new BinaryNode( t->element,clone( t->left ),clone( t->right ) );
        }
};

#endif // BINARYSEARCHTREE_H

#include <iostream>
#include "BinarySearchTree.h"

using namespace std;

int main()
{
    BinarySearchTree<int> BST;

    if ( BST.iSEmpty() )
        cout << "二叉查找树为空！" << endl;

    cout << "插入数据中。。" << endl;
    BST.insert( 200 );
    BST.insert( 7 );
    BST.insert( 1 );
    BST.insert( 99 );
    BST.insert( 55 );

    cout << "打印二叉树：" << endl;
    BST.printTree();

    cout << "最大值为：" << BST.findMax() << endl;
    cout << "最小值为：" << BST.findMin() << endl;

    int temp;
    cout << "插入一个值:" << endl;
    cin >> temp;

    BST.insert( temp );
    cout << "打印二叉树" << endl;
    BST.printTree();

    return 0;
}