BSC c++ 代码实现

BSC（Binary Search Tree）是一种常见的数据结构，可以用来实现各种算法和应用。下面是一个简单的C++代码实现：

#include <iostream>
using namespace std;

//定义二叉树节点结构体
struct TreeNode {
    int val;
    TreeNode* left;
    TreeNode* right;
    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};

//定义二叉搜索树结构体
class BST {
private:
    TreeNode* root;

public:
    BST() {
        root = NULL;
    }

    //插入节点
    void insert(int val) {
        TreeNode* node = new TreeNode(val);
        if (!root) {
            root = node;
            return;
        }
        TreeNode* curr = root;
        while (true) {
            if (val < curr->val) {
                if (!curr->left) {
                    curr->left = node;
                    return;
                }
                curr = curr->left;
            }
            else {
                if (!curr->right) {
                    curr->right = node;
                    return;
                }
                curr = curr->right;
            }
        }
    }

    //搜索节点
    bool search(int val) {
        if (!root) {
            return false;
        }
        TreeNode* curr = root;
        while (curr) {
            if (curr->val == val) {
                return true;
            }
            else if (val < curr->val) {
                curr = curr->left;
            }
            else {
                curr = curr->right;
            }
        }
        return false;
    }

    //删除节点
    void remove(int val) {
        if (!root) {
            return;
        }
        TreeNode* curr = root;
        TreeNode* parent = NULL;
        while (curr && curr->val != val) {
            parent = curr;
            if (val < curr->val) {
                curr = curr->left;
            }
            else {
                curr = curr->right;
            }
        }
        if (!curr) {
            return;
        }
        if (!curr->left || !curr->right) {
            TreeNode* child = curr->left ? curr->left : curr->right;
            if (!parent) {
                root = child;
            }
            else if (parent->left == curr) {
                parent->left = child;
            }
            else {
                parent->right = child;
            }
        }
        else {
            TreeNode* succ = curr->right;
            while (succ->left) {
                succ = succ->left;
            }
            int val = succ->val;
            remove(val);
            curr->val = val;
        }
    }

    //中序遍历
    void inorder(TreeNode* node) {
        if (node) {
            inorder(node->left);
            cout << node->val << " ";
            inorder(node->right);
        }
    }

    void inorder() {
        inorder(root);
    }
};

int main() {
    BST tree;
    tree.insert(5);
    tree.insert(3);
    tree.insert(7);
    tree.insert(1);
    tree.insert(9);
    tree.inorder(); //输出 1 3 5 7 9
    cout << endl;

    cout << tree.search(3) << endl; //输出 1
    cout << tree.search(6) << endl; //输出 0

    tree.remove(7);
    tree.inorder(); //输出 1 3 5 9
    cout << endl;

    return 0;
}

这段代码实现了二叉搜索树的基本操作，包括插入节点、搜索节点、删除节点以及中序遍历。你可以根据自己的需求进行更改和扩展。