二叉搜索树C++实现

template<typename Element>
class BinarySearchTree
{
    public:
        BinarySearchTree():root(NULL){}
        BinarySearchTree(const BinarySearchTree& bst):root(NULL)
        {
            operator=(bst);
        }
        virtual ~BinarySearchTree()
        { clear(root); }

        void insert(const Element& e)
        { insert(root, e); }
        void remove(const Element& e)
        { remove(root, e); }
        bool contains(const Element& e) const
        { return contains(root, e); }
        const Element& findMin() const
        { return findMin(root); }
        const Element& findMax() const
        { return findMax(root); }
        bool isEmpty() const
        { return root==NULL; }
        void clear()
        { clear(root); }

        const BinarySearchTree& operator=(const BinarySearchTree& bst)
        {
            if(this!=&bst)
            {
                clear();
                root = clone(bst.root);
            }
            return *this;
        }

    private:
        struct BSTNode
        {
            Element element;
            BSTNode *left;
            BSTNode *right;
            BSTNode(const Element& e, BSTNode *lt, BSTNode *rt):
                element(e), left(lt), right(rt){}
        };
        BSTNode *root;

        BSTNode* clone(BSTNode * t)
        {
            if(t!=NULL)
            {
                return new BSTNode(t->element, clone(t->left), clone(t->right));
            }
            return NULL;
        }
        void clear(BSTNode * &t)
        {
            if(t!=NULL)
            {
                clear(t->left);
                clear(t->right);
                delete t;
            }
            t = NULL;
        }
        void insert(BSTNode * &t, const Element& e)
        {
            if(t!=NULL)
            {
                if(e<t->element)
                {
                    insert(t->left, e);
                }
                else if(e>t->element)
                {
                    insert(t->right, e);
                }
                else
                {
                }
            }
            else
            {
                t = new BSTNode(e, NULL, NULL);
            }
        }
        void remove(BSTNode * &t, const Element& e)
        {
            if(t!=NULL)
            {
                if(e<t->element)
                {
                    remove(t->left, e);
                }
                else if(e>t->element)
                {
                    remove(t->right, e);
                }
                else if(t->left!=NULL&&t->right!=NULL)
                {
                    t->element = findMin(t->right);
                    remove(t->right, t->element);
                }
                else
                {
                    BSTNode *tmp = t;
                    t = t->left!=NULL?t->left:t->right;
                    delete tmp;
                }
            }
        }
        bool contains(BSTNode * t, const Element& e) const
        {
            if(t!=NULL)
            {
                if(e<t->element)
                {
                    return contains(t->left, e);
                }
                else if(e>t->element)
                {
                    return contains(t->right, e);
                }
                else
                {
                    return true;
                }
            }
            else
            {
                return false;
            }
        }
        const Element& findMin(BSTNode* t) const
        {
            return t->left!=NULL?findMin(t->left):t->element;
        }
        const Element& findMax(BSTNode* t) const
        {
            return t->right!=NULL?findMax(t->right):t->element;
        }
};

  注：不支持重复元素。