实现二分查树，支持插入、删除、查询操作。

实现二分查树，支持插入、删除、查询操作。

简介：实现二分查树，支持插入、删除、查询操作。

算法思路

算法思路：

二分查树是一种基于二叉树的数据结构，可以支持插入、删除和查询操作。

二分查树中每个节点都具有以下性质：

• 节点的左子树只包含小于当前节点的数。
• 节点的右子树只包含大于当前节点的数。
• 所有左子树和右子树自身也必须是二叉搜索树。

在实现二分查树的过程中，我们可以使用C++中的类来表示节点和树。具体而言，每个节点应包含如下属性：

• 当前节点的值 val；
• 当前节点的左子树 left；
• 当前节点的右子树 right。

在C++实现中还需要提供以下操作：

• 插入元素 insert；
• 删除元素 remove；
• 查询元素 find。

底层数据结构可以使用链表或数组均可。

下面是 C++ 中二分查树的实现代码，每行都添加了详细注释：

#include <iostream>
using namespace std;

// 定义 Tree 类
struct Tree {
    int val;
    Tree* left;
    Tree* right;

    Tree(int v) {
        val = v;
        left = ULL;
        right = ULL;
    }
};

// 定义 BST 类，封装树的所有操作
class BST {
public:
    BST() { root = ULL; } // 初始化

    void insert(int v) { // 插入元素
        root = insertHelper(root, v); // 调用递归函数插入元素
    }

    void remove(int v) { // 删除元素
        root = removeHelper(root, v); // 调用递归函数删除元素
    }

    bool find(int v) { // 查元素
        return findHelper(root, v); // 调用递归函数查元素
    }

private:
    Tree* root; // 根节点

    Tree* insertHelper(Tree* node, int val) { // 辅助函数，插入元素
        if (!node) return new Tree(val); // 如果当前节点为空，则说明可以插入新的节点

        if (val > node->val) node->right = insertHelper(node->right, val);
        else if (val < node->val) node->left = insertHelper(node->left, val);

        return node;
    }

    Tree* removeHelper(Tree* node, int val) { // 辅助函数，删除元素
        if (!node) return ULL; // 如果当前节点为空，说明该元素不存在

        if (val > node->val) node->right = removeHelper(node->right, val);
        else if (val < node->val) node->left = removeHelper(node->left, val);
        else { // 如果到了要删除的元素
            if (!node->left && !node->right) node = ULL; // 如果当前节点没有子节点，则直接删除
            else if (node->left && !node->right) node = node->left; // 如果当前节点只有左子节点，则用左子节点代替当前节点
            else if (node->right && !node->left) node = node->right; // 如果当前节点只有右子节点，则用右子节点代替当前节点
            else { // 如果当前节点既有左子节点又有右子节点，则到其右子树中的最小值，并将其作为新的根节点
                Tree* minode = getMin(node->right);
                node->val = minode->val;
                node->right = removeHelper(node->right, minode->val); // 从右子节点开始寻最小值并删除
            }
        }
        return node;
    }

    bool findHelper(Tree* node, int val) { // 辅助函数，查元素
        if (!node) return false; // 如果当前节点为空，说明该元素不存在

        if (val == node->val) return true;
        else if (val > node->val) return findHelper(node->right, val);
        else return findHelper(node->left, val);
    }

    Tree*getMin(Tree* node) { // 辅助函数，获取当前二分查树的最小值
        while (node->left) {
            node = node->left;
        }
        return node;
    }
};

int main() {
    BST tree; // 创建 BST 结构

    tree.insert(4); // 插入元素
    tree.insert(2);
    tree.insert();
    tree.insert(1);

    if (tree.find()) cout << " exists" << endl; // 查元素，输出“ exists”
    else cout << " does not exist" << endl;

    tree.remove(); // 删除元素

    if (tree.find()) cout << " exists" << endl; 
    else cout << " does not exist" << endl; // 再次查元素，输出“ does not exist”

    return 0;
}

在上述代码中，我们创建了 Tree 和 BST 两个数据结构，其中 Tree 表示树节点，BST 则封装了所有的二分查树操作。具体而言，代码实现插入、删除和查三个基本操作。

需要注意的是，在删除节点时，由于需要从源码中任意位置删除一个节点，因此需要考虑多种情况，例如节点只有一个儿子、节点没有儿子等情况。为了解决这些问题，我们可以采用递归方式依次寻右子树的最小值。（当然也可以采用其他方式，比如迭代）。

• Java版本

class Treeode {
    int val;        // 节点存储的值
    Treeode left;  // 左子节点
    Treeode right; // 右子节点

    public Treeode(int v) {
        val = v;
        left = null;
        right = null;
    }
}

class BST {
    Treeode root; // 根节点

    public BST() {
        root = null;
    }

    // 插入元素
    public void insert(int val) {
        root = insertHelper(root, val);
    }

    // 删除元素
    public void remove(int val) {
        root = removeHelper(root, val);
    }

    // 查元素
    public boolean find(int val) {
        return findHelper(root, val);
    }

    // 辅助函数，插入元素
    private Treeode insertHelper(Treeode node, int val) {
        if (node == null) return new Treeode(val);    // 如果当前节点为空，则插入新节点

        if (val > node.val)
            node.right = insertHelper(node.right, val); // 插入到右子树中
        else if (val < node.val)
            node.left = insertHelper(node.left, val);   // 插入到左子树中

        return node;
    }

    // 辅助函数，删除元素
    private Treeode removeHelper(Treeode node, int val) {
        if (node == null) return null;  // 没有到该节点

        if (val > node.val)
            node.right = removeHelper(node.right, val);
        else if (val < node.val)
            node.left = removeHelper(node.left, val);
        else {  // 到删除的节点
            if (node.left == null && node.right == null)  // 没有左右子树，直接删除即可
                node = null;
            else if (node.left != null && node.right == null)
                node = node.left;   // 只有左子树，用左子树代替当前节点
            else if (node.right != null && node.left == null)
                node = node.right;  // 只有右子树，用右子树代替当前节点
            else {  // 左右子树都存在，寻右子树中的最小值并用其代替当前节点
                Treeode minode = getMin(node.right);
                node.val = minode.val;
                node.right = removeHelper(node.right, minode.val);
            }
        }

        return node;
    }

    // 辅助函数，查元素
    private boolean findHelper(Treeode node, int val) {
        if (node == null) return false; // 未到该节点

        if (val == node.val) return true;
        else if (val > node.val)
            return findHelper(node.right, val); // 在右子树中查
        else
            return findHelper(node.left, val);  // 在左子树中查
    }

    // 辅助函数，获取当前二分查树的最小值
    private Treeode getMin(Treeode node) {
        while (node.left != null) {
            node = node.left;
        }
        return node;
    }
}

public class Main {
    public static void main(String[] args) {
        BST tree = new BST();   // 创建 BST 结构

        tree.insert(4); // 插入元素
        tree.insert(2);
        tree.insert();
        tree.insert(1);

        if (tree.find())
            println(" exists");  // 查元素，输出“ exists”
        else
            println(" does not exist");

        tree.remove(); // 删除元素

        if (tree.find())
            println(" exists");
        else
            println(" does not exist"); // 再次查元素，输出“ does not exist”
    }
}

在上述代码实现中，我们定义了 Tree 和 BST 类，其中 Tree 表示二分查树的节点，BST 则封装了所有的操作。具体而言，代码实现了插入、删除和查三个基本操作。

需要注意的是，在删除节点时需要考虑多种情况，例如节点只有一个儿子、节点没有儿子等情况。为了解决这些问题，我们可以采用递归方式依次寻右子树的最小值，并将其作为新的根节点。（当然也可以使用其他搜索方法，比如迭代）。