二叉搜索树

一颗二叉搜索树【像二分，但不是】
满足条件：左子树比根小，右子树比根大

又可以叫排序二叉树：中序遍历就是排序
 
//二叉搜索树
template<class  K>
struct  BSTreeNode
{
    BSTreeNode<K>*  _left;
    BSTreeNode<K>*  _right;
    K _key;

    BSTreeNode(const K& key)
        :_left(nullptr)
        ,_right(nullptr)
        ,_key(key)
    {}
}；

template<class  K>
class  BSTree
{
    typedef  BSTreeNode<K> Node;
public: 
    bool Insert(const  K&  key)
    {
        if(_root == nullptr)
        {
            _root = new  Node(key);
            return  true;
        }
        Node*  parent = nullptr;
        Node* cur = _root;
        while(cur)
        {
            if(cur->_key<key)
            {
                parent = cur;
                cur = cur -> _right;
            }
            else i f(cur->_key>key)
            {
                parent = cur;
                cur = cur -> _left;
            }
            else
            {
                return false;
            }
        }
        
        cur = new Node(key);
        if(parent->_key  < key)
        {
            parent->_right = cur;
        }
        else
        {
            parent->_left = cur;
        }
        
        return  true;
    }
    
    bool  Find(const K& key)
    {
        if(_root == nullptr)
        {
            _root = new  Node(key);
            return  true;
        }
        Node* cur = _root;
        while(cur)
        {
            if(cur->_key<key)
            {
                cur = cur -> _right;
            }
            else i f(cur->_key>key)
            {
                cur = cur -> _left;
            }
            else
            {
                return true;
            }
        }
                
        return  false;
    } 

    //替换法：找一个节点替代你，左子树最大节点或者右子树最小节点
    bool  Erase(const K&  key)        
    {
        Node*  parent = nullptr;
        Node* cur = _root;
        while(cur)
        {
            if(cur->_key<key)
            {
                parent = cur;
                cur = cur -> _right;
            }
            else i f(cur->_key>key)
            {
                parent = cur;
                cur = cur -> _left;
            }
            else
            {
                if(cur->_left == nullptr)//左为空
                {
                    if(cur == _root)
                    {
                        _root = cur ->_right;
                    }
                    else
                    {
                        if(cur == parent->_left)
                        {
                            parent->_left = cur->_right;
                        }
                        else
                        {
                            parent->right = cur->_right;
                        }

                    }
                    
                    delete cur;
                }    
                else if(cur->_right == nullptr)//右为空
                {
                    if(cur == _root)
                    {
                        _root = cur ->_left;
                    }
                    
                    else
                    {
                        if(cur == parent->_left)
                        {
                            parent->_left = cur->_left;
                        }
                        else
                        {
                            parent->_right = cur->_left;
                        }
    
                        }
                    
                    delete cur;
                }

                else
                {
                    //左右都不为空
                    Node* rightMinParent = cur; 
                    Node*  rightMin  =  cur->_right;
                    while(rightMIn->_left)
                    {
                        rightMinParent = rightMin;
                        rightMin = rightMin->_left;
                    }
                    swap(cur->_key,rightMin->_key);
                    if(rightMinParen->_left == rightMin)
                        rightMinParent->_left = rightMin->_right;
                    else
                        rightMinParent->_right = rightMin->_right;
                    delete  rightMin;
                }
                return true;
            }
        return false;
    }
    
    void  InOrder()
    {
        _InOrder(_root);
    }
private:        //套一层壳
    void  _InOrder(Node*  root )
    {
        if(root==nullptr)
        {
            return;
        } 
        InOrder(_root->_left);
        cout <<  root->_key  << " ";
        InOrder(_root->_right);
    }
    
private:
    Node*  _root  = nullptr;
}；

/
查找：
二分查找
二叉搜索树查找    AVL树和红黑树
哈希查找
跳表
多叉搜索树查找    B树系列

基本都为K模型和KV模型

KV树

 
template<class  K，class  V>
struct  BSTreeNode
{
    BSTreeNode<K,V>*  _left;
    BSTreeNode<K,V>*  _right;
    K _key;
    V _value;

    BSTreeNode(const K& key ,const V&  value)
        :_left(nullptr)
        ,_right(nullptr)
        ,_key(key)
        ,_value(value)
    {}
}；

template<class  K,class V>
class  BSTree
{
    typedef  BSTreeNode<K,V> Node;
public: 
    bool Insert(const  K&  key,const  V&  value)
    {
        if(_root == nullptr)
        {
            _root = new  Node(key,value);
            return  true;
        }
        Node*  parent = nullptr;
        Node* cur = _root;
        while(cur)
        {
            if(cur->_key<key)
            {
                parent = cur;
                cur = cur -> _right;
            }
            else i f(cur->_key>key)
            {
                parent = cur;
                cur = cur -> _left;
            }
            else
            {
                return false;
            }
        }
        
        cur = new Node(key,value);
        if(parent->_key  < key)
        {
            parent->_right = cur;
        }
        else
        {
            parent->_left = cur;
        }
        
        return  true;
    }
    
    Node*  Find(const K& key)
    {
        if(_root == nullptr)
        {
            _root = new  Node(key);
            return  true;
        }
        Node* cur = _root;
        while(cur)
        {
            if(cur->_key<key)
            {
                cur = cur -> _right;
            }
            else i f(cur->_key>key)
            {
                cur = cur -> _left;
            }
            else
            {
                cout << "查无此单词" << endl;
            }
        }
                
        return  cur;
    } 

    //替换法：找一个节点替代你，左子树最大节点或者右子树最小节点
    bool  Erase(const K&  key)        
    {
        Node*  parent = nullptr;
        Node* cur = _root;
        while(cur)
        {
            if(cur->_key<key)
            {
                parent = cur;
                cur = cur -> _right;
            }
            else i f(cur->_key>key)
            {
                parent = cur;
                cur = cur -> _left;
            }
            else
            {
                if(cur->_left == nullptr)//左为空
                {
                    if(cur == _root)
                    {
                        _root = cur ->_right;
                    }
                    else
                    {
                        if(cur == parent->_left)
                        {
                            parent->_left = cur->_right;
                        }
                        else
                        {
                            parent->right = cur->_right;
                        }

                    }
                    
                    delete cur;
                }    
                else if(cur->_right == nullptr)//右为空
                {
                    if(cur == _root)
                    {
                        _root = cur ->_left;
                    }
                    
                    else
                    {
                        if(cur == parent->_left)
                        {
                            parent->_left = cur->_left;
                        }
                        else
                        {
                            parent->_right = cur->_left;
                        }
    
                        }
                    
                    delete cur;
                }

                else
                {
                    //左右都不为空
                    Node* rightMinParent = cur; 
                    Node*  rightMin  =  cur->_right;
                    while(rightMIn->_left)
                    {
                        rightMinParent = rightMin;
                        rightMin = rightMin->_left;
                    }
                    swap(cur->_key,rightMin->_key);
                    if(rightMinParen->_left == rightMin)
                        rightMinParent->_left = rightMin->_right;
                    else
                        rightMinParent->_right = rightMin->_right;
                    delete  rightMin;
                }
                return true;
            }
        return false;
    }
    
    void  InOrder()
    {
        _InOrder(_root);
    }
private:        //套一层壳
    void  _InOrder(Node*  root )
    {
        if(root==nullptr)
        {
            return;
        } 
        InOrder(_root->_left);
        cout <<  root->_key  << " ";
        InOrder(_root->_right);
    }
    
private:
    Node*  _root  = nullptr;
}；

搜索树接近有序插入，会从logN退化成N
所以出现了平衡搜索二叉树