二叉查找树

二叉查找树的结构和普通二叉树相同。它要么是空树，要么满足：对任意结点，如果左子树不为空，则左子树上所有结点的权值都小于该结点的权值；如果右子树不为空，则右子树上所有结点的权值都大于该结点的权值。在二叉查找树中，任意结点的左子树和右子树都是一棵二叉查找树。一般而言，二叉树上结点的权值都是唯一的。

基本操作：

//二叉查找树
//结点定义
template <typename Type> class Node {
public:
    Type data;
    Node *lchild,*rchild,*parent;
    //parent is NULL by default
    Node(Type _data, Node<Type> *_parent=NULL) {
        data=_data;
        lchild=NULL;
        rchild=NULL;
        parent=_parent;
    }
    //no need to delete parent because all nodes are already deleted by delete method recursively
    ~Node() {
        if(lchild!=NULL){
            delete lchild;
        }
        if(rchild!=NULL){
            delete rchild;
        }
    }


    void insert(Type value) {
        //do not allow repeated element
        if(data==value){
            return;
        }
        else if(value>data){
            if(rchild==NULL){
                rchild=new Node<Type>(value,this);
            }
            else{
                rchild->insert(value);
            }
        }
        //value<data
        else{
            if(lchild==NULL){
                lchild=new Node<Type>(value,this);
            }
            else{
                lchild->insert(value);
            }
        }
    }


    Node* search(Type value) {
        if(data==value){
            return this;
        }
        else if(value>data){
            if(rchild==NULL){
                return NULL;
            }
            else{
                rchild->search(value);
            }
        }
        //value<data
        else{
            if(lchild==NULL){
                return NULL;
            }
            else{
                lchild->search(value);
            }
        }
    }

    //inorder_print
    void print() {
        if(lchild!=NULL){
            lchild->print();
        }
        cout<<data<<" ";
        if(rchild!=NULL){
            rchild->print();
        }
    }

    //only for nodes with children
    Node<Type> * predecessor() {
        Node<Type> *temp = lchild;
        //the most right element in its left child tree
        while (temp != NULL && temp->rchild != NULL) {
            temp = temp->rchild;
        }
        return temp;
    }

    //only for nodes with children
    Node<Type> * successor() {
        Node<Type> *temp = rchild;
        //the most left elemnent in its right child tree
        while (temp != NULL && temp->lchild != NULL) {
            temp = temp->lchild;
        }
        return temp;
    }

    //remove_node for leaf nodes or nodes with only one child
    void remove_node(Node<Type> *delete_node) {
        Node<Type> *temp = NULL;
        if (delete_node->lchild != NULL) {
            temp = delete_node->lchild;
            //the successor of delete_node is the father of delete_node
            temp->father = delete_node->father;
        }
        if (delete_node->rchild != NULL) {
            temp = delete_node->rchild;
            //the predecessor of delete_node is the father of delete_node
            temp->father = delete_node->father;
        }
        if(delete_node->father!=NULL){
            //if delete_node is the left child
            if (delete_node->father->lchild == delete_node) {
                delete_node->father->lchild = temp;
            } else {
                delete_node->father->rchild = temp;
            }
        }
        //set them to NULL to prevent deleting the entire tree
        delete_node->lchild = NULL;
        delete_node->rchild = NULL;
        delete delete_node;
    }

    //the complete version of deleting a node
    //make use of the remove_node method
    bool delete_node(Type value){
        Node<Type> *delete_node,*current_node;
        //find the target node
        current_node=search(value);
        if(current_node==NULL){
            return false;
        }
        //replacing the current_node with either its predecessor or successor
        if(current_node->lchild!=NULL){
            delete_node=current_node->predecessor();
        }
        else if(current_node->rchild!=NULL){
            delete_node=current_node->successor();
        }
        //else it must be a leaf node, which we can just remove it using remove_node
        else{
            delete_node=current_node;
        }
        //replace value and delete the predecessor/successor
        current_node->data=delete_node->data;
        remove_node(delete_node);
        return true;
    }
};


template <typename Type> class BinaryTree {
private:
    Node<Type> *root;
public:
    BinaryTree() {
        root=NULL;
    }
    ~BinaryTree() {
        delete root;
    }
    void insert(Type value) {
        if(root==NULL){
            root=new Node<Type>(value);
        }
        else root->insert(value);
    }
    bool find(Type value) {
        if(root==NULL){
            return false;
        }
        else{
            if(root->search(value)==NULL){
                return false;
            }
            else{
                return true;
            }
        }
    }
    void print() {
        if(root!=NULL){
            root->print();
        }
    }

    bool delete_node(Type value){
        if(root==NULL){
            return false;
        }
        return root->delete_node(value);
    }
};