BST示例代码如下：

#include<iostream>
using namespace std;
class Node {
public:
    int data;
    Node *lchild, *rchild, *father;
    Node(int _data, Node *_father = NULL) {
        data = _data;
        lchild = NULL;
        rchild = NULL;
        father = _father;
    }
    ~Node() {
        if (lchild != NULL) {
            delete lchild;
        }
        if (rchild != NULL) {
            delete rchild;
        }
    }
    void insert(int value) {
        if (value == data) {
            return;
        } else if (value > data) {
            if (rchild == NULL) {
                rchild = new Node(value, this);
            } else {
                rchild->insert(value);
            }
        } else {
            if (lchild == NULL) {
                lchild = new Node(value, this);
            } else {
                lchild->insert(value);
            }
        }
    }
    Node* search(int value) {
        if (data == value) {
            return this;
        } else if (value > data) {
            if (rchild == NULL) {
                return NULL;
            } else {
                return rchild->search(value);
            }
        } else {
            if (lchild == NULL) {
                return NULL;
            } else {
                return lchild->search(value);
            }
        }
    }
    Node* predecessor() {
        Node *temp = lchild;
        while (temp != NULL && temp->rchild != NULL) {
            temp = temp->rchild;
        }
        return temp;
    }
    Node* successor() {
        Node *temp = rchild;
        while (temp != NULL && temp->lchild != NULL) {
            temp = temp->lchild;
        }
        return temp;
    }

};
class BinaryTree {
private:
    Node *root;
public:
    BinaryTree() {
        root = NULL;
    }
    ~BinaryTree() {
        if (root != NULL) {
            delete root;
        }
    }
    void insert(int value) {
        if (root == NULL) {
            root = new Node(value);
        } else {
            root->insert(value);
        }
    }
    bool find(int value) {
        if (root->search(value) == NULL) {
            return false;
        } else {
           return true;
        }
    }
};
int main() {
    BinaryTree binarytree;
    int arr[10] = { 8, 9, 10, 3, 2, 1, 6, 4, 7, 5 };
    for (int i = 0; i < 10; i++) {
        binarytree.insert(arr[i]);
    }
    int value;
    cin >> value;
    if (binarytree.find(value)) {
        cout << "search success!" << endl;
    } else {
        cout << "search failed!" << endl;
    }
    return 0;
}

BST的元素删除

BST节点的前驱与后继搜索

某个BST节点的前驱，即为值比它小的最大的一个节点——进入该节点的左子树，然后不断搜索左子树的右孩子，找到最后的节点即可

Node* predecessor(){
    Node* temp=lchild;
    while(temp!=NULL&&temp->lchild!=NULL){
        temp=temp->lchild;
    }
    return temp;
}

后继也是一样，完全相反即可，此处略

删除度数为0或者1的节点

对于一个非空的节点，首先检查它是否有左孩子或者右孩子——因为该节点度数为0或者1，所以最多只能有一个孩子
对于节点delete_node的孩子temp，首先孩子的父亲设置为delete_node的父亲，然后断开其与delete_node的联系
接下来判断delete_node是其父节点的左孩子还是右孩子，确认之后把temp换上
最后直接删除delete_node
代码如下：

void remove_node(Node* delete_node){ //delete_node的度为0或者1
        Node* temp=NULL;
        if(delete_node->lchild!=NULL){
            temp=delete_node->lchild;
            temp->father=delete_node->father;
            delete_node->lchild=NULL;
        }
        if(delete_node->rchild!=NULL){
            temp=delete_node->rchild;
            temp->father=delete_node->father;
            delete_node->rchild=NULL;
        }
        if(delete_node->father->lchild==delete_node){
            delete_node->father->lchild=temp;
        }
        else{
            delete_node->father->rchild=temp;
        }
        delete delete_node;
    }

删除度数为2的节点

首先找到待删除的节点
如果节点的左孩子存在，就把delete_node设置为节点的前驱
右孩子存在则设定为后继
都不存在则设定为节点自身（此时待删除的节点为叶子节点）
把delete_node的data值赋给原本待删除的节点——相当于将待删除的节点与delete_node调换
最后直接删除delete_node

bool delete_tree(int value){
    Node *delete_node,*current_node;
    current_node=search(value);
    if(current_node==NULL){
          return false;
    }
    if(current_node->lchild!=NULL){
        delete_node=current_node->predecessor();
    }
    else if(current_node->rchild!=NULL){
        delete_node=current_node->successor();
    }
    else{
        delete_node=current_node;
    }
    current_node->data=delete_node->data;
    remove_node(delete_node);
    return true;
}