数据结构二叉查找树C++实现

#include <iostream>
using namespace std;
template<class Comparable>
class BinarySearchTree
{
public:
    BinarySearchTree();
    BinarySearchTree(const BinarySearchTree& rhs); //copy constructor
    ~BinarySearchTree(); //destructor

public:
    const Comparable& findMin() const;   //find the minimum value
    const Comparable& findMax() const;   //find the maximum value
    bool contains(const Comparable& x) const; //Determine whether the tree contains x
    bool isEmpty() const;             //Determine whether the tree is empty
    void printTree() const;           //print the binary Tree

    void makeEmpty();                 //make binary tree empty
    void insert(const Comparable& x); //insert a value into binary tree
    void remove(const Comparable& x); //remove a value from binary tree

    const BinarySearchTree& operator= (const BinarySearchTree& rhs); //overload operator =

private:
    struct BinaryNode
    {
        Comparable element;
        BinaryNode* left;   //a pointer to left child
        BinaryNode* right;   // a pointer to right child
        BinaryNode(){}
        BinaryNode(const Comparable& theElem, BinaryNode* lt, BinaryNode* rt) : element(theElem), left(lt), right(rt){}//constructor
    };             //the binary tree node type

    BinaryNode* root; //define the root node
    void insert(const Comparable& x, BinaryNode *&t) const;
    void remove(const Comparable& x, BinaryNode *&t) const;
    BinaryNode* findMin(BinaryNode* t) const;
BinaryNode* findMax(BinaryNode* t) const;
    bool contains(const Comparable& x, BinaryNode* t) const;
    void printTree(BinaryNode* t) const;
    void makeEmpty(BinaryNode *&t) const;
    BinaryNode* clone(BinaryNode *t) const;
};
template<class Comparable>
BinarySearchTree<Comparable>::BinarySearchTree()
{
    root = new BinaryNode(); //constructor construct a tree without subtree
    root = NULL;
}
template<class Comparable>
BinarySearchTree<Comparable>::BinarySearchTree(const BinarySearchTree& rhs)
{
    root = new BinaryNode();
    root = NULL;
    makeEmpty();
    root = clone(rhs.root);
}
template<class Comparable>
BinarySearchTree<Comparable>::~BinarySearchTree()
{
    makeEmpty();
}
template<class Comparable>
const Comparable& BinarySearchTree<Comparable>::findMin() const
{
    return findMin(root)->element;
}
template<class Comparable>
const Comparable& BinarySearchTree<Comparable>::findMax() const
{
    return findMax(root)->element;
}
template<class Comparable>
bool BinarySearchTree<Comparable>::contains(const Comparable& x) const
{
    return contains(x, root);
}
template<class Comparable>
bool BinarySearchTree<Comparable>::isEmpty() const
{
    return root == NULL;
}
template<class Comparable>
void BinarySearchTree<Comparable>::printTree() const
{
    printTree(root);
}
template<class Comparable>
void BinarySearchTree<Comparable>::makeEmpty()
{
    makeEmpty(root);
}
template<class Comparable>
void BinarySearchTree<Comparable>::insert(const Comparable& x)
{
    insert(x, root);
}
template<class Comparable>
void BinarySearchTree<Comparable>::remove(const Comparable& x)
{
    remove(x, root);
}
template<class Comparable>
const BinarySearchTree<Comparable>& BinarySearchTree<Comparable>::operator= (const BinarySearchTree& rhs)
{
    if(this != &rhs)
    {
        makeEmpty();
  root = clone(rhs.root);
    }
    return *this;
}
template<class Comparable>
void BinarySearchTree<Comparable>::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(t -> element < x)
        insert(x, t -> right);
    else
        ;        //do nothing
}
template<class Comparable>
void BinarySearchTree<Comparable>::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;
    }
}
template<class Comparable>
typename BinarySearchTree<Comparable>::BinaryNode* BinarySearchTree<Comparable>::findMin(BinaryNode *t) const
{
    if(t == NULL)
        return NULL;
    if(t -> left == NULL)
        return t;
    return findMin(t -> left);
}
template<class Comparable>
typename BinarySearchTree<Comparable>::BinaryNode* BinarySearchTree<Comparable>::findMax(BinaryNode *t) const
{
    if(t == NULL)
        return NULL;
    if(t -> right == NULL)
        return t;
    return findMax(t -> right);
}
template<class Comparable>
bool BinarySearchTree<Comparable>::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;
}
template<class Comparable>
void BinarySearchTree<Comparable>::makeEmpty(BinaryNode*& t) const
{
    if(t != NULL)
    {
        makeEmpty(t -> left);
        makeEmpty(t -> right);
        delete t;
    }
    t = NULL;
}
template<class Comparable>
void BinarySearchTree<Comparable>::printTree(BinaryNode* t) const
{
    if(t != NULL)
    {
        printTree(t -> left);
        cout << t ->element << "\t";
        printTree(t -> right);
    }
}
template<class Comparable>
typename BinarySearchTree<Comparable>::BinaryNode* BinarySearchTree<Comparable>::clone(BinaryNode *t) const
{
    if(t == NULL)
        return NULL;
    return new BinaryNode(t -> element, clone(t -> left), clone(t -> right));
}
int main()
{
    return 0;
}