实现一个普通的二叉搜索树（Binary Search Tree，BST）是学习数据结构和算法的基本练习之一。下面是一个简单的 C++ 类，用于实现基本的二叉搜索树功能，包括插入、查找和删除节点。

#include <iostream>  
// 定义节点结构  
struct TreeNode {  
    int val;  
    TreeNode *left;  
    TreeNode *right;  
    TreeNode(int value) : val(value), left(nullptr), right(nullptr) {}  
};  
class BinarySearchTree {  
public:  
    BinarySearchTree() : root(nullptr) {}  
    // 插入节点  
    void insert(int value) {  
        root = insert(root, value);  
    }  
    // 查找节点  
    bool search(int value) {  
        return search(root, value);  
    }  
    // 删除节点  
    void remove(int value) {  
        root = remove(root, value);  
    }  
    // 中序遍历  
    void inorder() {  
        inorder(root);  
        std::cout << std::endl;  
    }  
private:  
    TreeNode* root;  
    // 插入节点（递归实现）  
    TreeNode* insert(TreeNode* node, int value) {  
        if (node == nullptr) {  
            return new TreeNode(value);  
        }  
        if (value < node->val) {  
            node->left = insert(node->left, value);  
        } else if (value > node->val) {  
            node->right = insert(node->right, value);  
        }  
        return node;  
    }  
    // 查找节点（递归实现）  
    bool search(TreeNode* node, int value) {  
        if (node == nullptr) {  
            return false;  
        }  
        if (value == node->val) {  
            return true;  
        } else if (value < node->val) {  
            return search(node->left, value);  
        } else {  
            return search(node->right, value);  
        }  
    }  
    // 删除节点（递归实现）  
    TreeNode* remove(TreeNode* node, int value) {  
        if (node == nullptr) {  
            return nullptr;  
        }  
        if (value < node->val) {  
            node->left = remove(node->left, value);  
        } else if (value > node->val) {  
            node->right = remove(node->right, value);  
        } else {  
            // 节点只有一个子节点或没有子节点  
            if (node->left == nullptr) {  
                TreeNode* temp = node->right;  
                delete node;  
                return temp;  
            } else if (node->right == nullptr) {  
                TreeNode* temp = node->left;  
                delete node;  
                return temp;  
            }  
            // 节点有两个子节点，找到中序遍历的后继节点  
            TreeNode* temp = minValueNode(node->right);  
            node->val = temp->val;  
            node->right = remove(node->right, temp->val);  
        }  
        return node;  
    }  
    // 找到最小值节点  
    TreeNode* minValueNode(TreeNode* node) {  
        TreeNode* current = node;  
        while (current && current->left != nullptr) {  
            current = current->left;  
        }  
        return current;  
    }  
    // 中序遍历（递归实现）  
    void inorder(TreeNode* node) {  
        if (node != nullptr) {  
            inorder(node->left);  
            std::cout << node->val << " ";  
            inorder(node->right);  
        }  
    }  
};  
int main() {  
    BinarySearchTree bst;  
    bst.insert(50);  
    bst.insert(30);  
    bst.insert(20);  
    bst.insert(40);  
    bst.insert(70);  
    bst.insert(60);  
    bst.insert(80);  
    std::cout << "Inorder traversal: ";  
    bst.inorder();  
    std::cout << "Search 40: " << (bst.search(40) ? "Found" : "Not Found") << std::endl;  
    std::cout << "Search 100: " << (bst.search(100) ? "Found" : "Not Found") << std::endl;  
    std::cout << "Removing 20\n";  
    bst.remove(20);  
    std::cout << "Inorder traversal: ";  
    bst.inorder();  
    return 0;  
}  

代码说明

• TreeNode 结构体用于定义树的节点，每个节点有一个整型数值和指向左右子节点的指针。
• BinarySearchTree 类实现了插入、查找、删除和中序遍历操作。
• insert 函数递归地插入新节点。
• search 函数递归地查找特定值的节点。
• remove 函数处理节点的删除，包括三种情况：没有子节点、一个子节点、两个子节点。
• inorder 函数递归地进行中序遍历并输出节点值。
• 主函数中演示了二叉搜索树的插入、查找、删除和遍历功能。

你可以根据需要扩展该实现，添加更多功能或优化现有功能。