了解搜索二叉树（BST）及其应用

template <class T>
struct BSTreeNode
{
    BSTreeNode(const T& key):left(nullptr),right(nullptr)
    {
        value = key;
    }
    BSTreeNode<T>* left;
    BSTreeNode<T>* right;
    T value;
};

搜索二叉树构建如下：

template <class T>
class BSTree
{
    typedef BSTreeNode<T> Node;
public:
    BSTree() = default;//强制生成构造
    BSTree(const BSTree<T>& t){}
    ~BSTree(){}
    BSTree<T>& operator=(BSTree<T> t){}
    //查找
    bool find(const T& key){}
    //插入值
    bool Insert(const T& key){}  
    //删除
    bool Erase(const T& key){}
private:
    Node* root = nullptr;
};

拷贝构造函数

public：  
    BSTree(const BSTree<T>& t)
    {
        Copy(t.root);
    }
private：
    Node* Copy(Node* root)
    {
        if (root == nullptr)
            return nullptr;
        Node* newroot = new Node(root->value);
        newroot->left = Copy(root->left);
        newroot->right = Copy(root->right);
        return newroot;
    }

析构函数

public： 
   ~BSTree()
    {
        Destroy(root);
    }
private：
    void Destroy(Node* root)
    {
        if (root == nullptr) return;
        Destroy(root->left);
        Destroy(root->right);
        delete root;
    }

赋值运算符重载

 public：
    BSTree<T>& operator=(BSTree<T> t)
    {
        swap(root, t.root);
        return *this;
    }

查找

public：
    bool find(const T& key)
    {
        return _find(root, key);
    }
private：
    bool _find(Node* root, const T& key)
    {
        if (root == nullptr) return false;
        if (root->value < key)
            return _find(root->right, key);
        else if (root->value > key)
            return _find(root->left, key);
        else return true;
    }

插入

public：
    bool Insert(const T& key)
    {
        return _Insert(root,key);
    }
private：
    bool _Insert(Node*& root, const T& key)
    {
        if (root == nullptr)
        {
            root = new Node(key);
            return true;
        }
        if (root->value < key)
        {
            return _Insert(root->right, key);
        }
        else if (root->value > key)
        {
            return _Insert(root->left, key);
        }
        else return false;
    }

删除

public：
    bool Erase(const T& key)
    {
        _Erase(root, key);
    }
private：
    bool _Erase(Node*& root, const T& key)
    {
        if (root == nullptr)
        {
            return false;
        }
        if (root->value < key)
        {
            return _Erase(root->right, key);
        }
        else if (root->value > key)
        {
            return _Erase(root->left, key);
        } 
        else
        {
            Node* del = root;
            if (root->left == nullptr)
            {
                root = root->right;
            }
            else if (root->right == nullptr)
            {
                root = root->left;
            }
            else
            {
                Node* leftmax = root->left;
                while (leftmax->right)
                {
                    leftmax = leftmax->right;
                }
                swap(root->value, leftmax->value);
                return _Erase(root->left, key);
            }
            delete del;
            return true;
        }
    }

2.KV模型

每一个关键码key，都有与之对应的value，即<key,value>的键值对。比如：英汉词典的英文和中文，<word,Chinese>就构成一种键值对。

节点结构如下：

template <class K,class V>
struct BSTreeNode
{
    BSTreeNode(const K& key, const V& value)
        :left(nullptr)
        ,right(nullptr)
        ,_key(key)
        ,_value(value)
    {}
     
    BSTreeNode<K,V>* left;
    BSTreeNode<K,V>* right;
    K _key;
    V _value;
};

树的构建和上面类似，需要注意的是：

1.插入（Insert）和删除（Erase）时，只需要将value自增或自减，value为1时的删除以及不存在现有key值时的插入才需要删除或者插入节点。

2.涉及查找的操作仍然根据key来进行判断。

总结

搜索二叉树是一种重要的数据结构，在许多应用领域发挥着重要作用。通过将较小值保持在左侧，较大值保持在右侧的有序结构，搜索二叉树实现了快速查找、有序性和高效的插入删除操作。它在数据库索引、字典和单词查找、范围查找以及平衡二叉搜索树等多个应用场景中发挥着关键作用。希望通过本文的介绍，你对搜索二叉树有了更深入的了解。如果你有任何问题，欢迎留言讨论。