二叉搜索树(不支持重复元素)----模板（C++实现）

#include<iostream>
#include<windows.h>
#include<queue>
#include<cassert>
using namespace std;
template <typename Key,typename Value>
class BST{
    //不支持重复元素~~二叉搜索树~
private:
    struct Node
    {
        Key key;
        Value value;
        Node *right;
        Node *left;

        Node(Key key,Value value){
            this->key = key;
            this->value = value;
            this->left = this->right = NULL;
        }
        
        Node(Node* node){
            this->key = node->key;
            this->value = node->value;
            this->left =  node->left;
            this->right = node->right;
        }
    };
    Node *root;
    int count;
    Node* insert(Node* node, Key key,Value value){
        //向以node为根的二叉搜索树中插入节点（key,value)
        //返回插入新节点后的二叉搜索树的根
        if(node==NULL){
            count++;
            return new Node(key,value);
        }
        if(key==node->key)
            node->value = value;
        else if(key<node->key)
            node->left = insert(node->left,key,value);
        else
            node->right = insert(node->right,key,value);
    }
    bool contain(Node *node,Key key){
        //查看以node为根的二叉搜索树中是否包含键值为key的节点
        if(node == NULL)
            return false;
        if(key == node->key)
            return true;
        else if(key > node->key)
            return contain(node->right,key);
        else
            return contain(node->left,key);        
    }
    Value* search(Node *node,Key key){
        //查找某个key值包含的信息
        if(node == NULL)
            return NULL;
        if(key == node->key)
            return &(node->value);
        else if(key > node->key)
            return search(node->right,key);
        else
            return search(node->left,key);  
    }
    void PreOrder(Node *node){
        if(node != NULL){
            cout<<node->key<<endl;
            PreOrder(node->left);
            PreOrder(node->right);
        }
    }
    void InOrder(Node *node){
        if(node != NULL){
            InOrder(node->left);
            cout<<node->key<<endl;
            InOrder(node->right);
        }
    }
    void PostOrder(Node *node){
        if(node != NULL){
            PostOrder(node->left);
            PostOrder(node->right);
            cout<<node->key<<endl;
        }
    } 
    void destroy(Node *node){
        //后序摧毁这个树
        if(node!=NULL){
            destroy(node->left);
            destroy(node->right);
            delete node;
            count--;
        }
    }
    Node* minimum(Node *node){
        //寻找最小值
        if(node->left == NULL)
            return node;
        return minimum(node->left);
    }
    Node* maxmum(Node *node){
        //寻找最大值
        if(node->right == NULL)
            return node;
        return minimum(node->right);
    }
    Node* RemoveMin(Node *node){
    //删除掉以node为根的二分搜索树中的最小节点
    //返回删除节点后新的二分搜索树的根
        if(node->left == NULL){
            Node* rightNode =  node->right;
            delete node;
            count--;
            return rightNode;
        }
        node ->left = RemoveMin(node->left);
        return node;
    }
    Node* RemoveMax(Node *node){
    //删除掉以node为根的二分搜索树中的最大节点
    //返回删除节点后新的二分搜索树的根
        if(node->right == NULL){
            Node* leftNode =  node->left;
            delete node;
            count--;
            return leftNode;
        }
        node ->left = RemoveMax(node->left);
        return node;
    }
    Node* Remove(Node* node,Key key){
        if(node==NULL)
            return NULL;
        if(key<node->key){
            node->left = Remove(node->left,key);
            return node;
        }
        else if(key>node->key){
            node->right = Remove(node->right,key);
            return node;
        }
        else{//key == node->key
            if(node->left==NULL){
                Node *rightNode = node->right;
                delete node;
                count--;
                return rightNode;
            }
            if(node->right==NULL){
                Node *leftNode = node->left;
                delete node;
                count--;
                return leftNode;
            }
            Node *delNode = node;
            Node *successor = new Node(minimum(node->right));
            count ++;
            //为了消除bug创造一个新的构造函数
            successor->right = RemoveMin(node->right);
            successor->left = node->left;
            delete delNode;
            count--;
            return successor;
        }
        
    }
public:
    BST(){
        root = NULL;
        count = 0;
    }
    int size(){
        return count;
    }
    bool isEmpty(){
        return count==0;
    }
    void insert(Key key,Value value){
        root = insert(root,key,value);
    }
    bool contain(Key key){
        return contain(root,key);
    }
    Value* search(Key key){
        return search(root,key);
    }
    void PreOrder(){ //前序遍历
        PreOrder(root);
    }
    void InOrder(){//中序遍历(可以排序)
        InOrder(root);
    }
    void PostOrder(){ // 后序遍历(可以释放二叉树)
        PostOrder(root);
    }
    void LevelOrder(){//层序遍历
        queue<Node*> q;
        q.push(root);
        while(!q.empty()){
            Node *node = q.front();
            q.pop();
            cout<<node->key<<endl;
            if(node->left)
                q.push(node->left);
            if(node->right)
                q.push(node->right);
        }
    }
    Key minimum(){
        assert(count!=0);
        Node*minNode = minimum(root);
        return minNode->key;
    }
    Key maxmum(){
        assert(count!=0);
        Node*maxNode = maxmum(root);
        return maxNode->key;
    }
    void RemoveMin(){
        if(root)
            root = RemoveMin(root);
    }
    void RemoveMax(){
        if(root)
            root = RemoveMax(root);
    }
    void Remove(Key key){
        root = Remove(root , key);
    }
    ~BST(){
        destroy(root);
    }
};
int main(){
system("pause");
}