二叉搜索树(BST树)的实现

二叉搜索树概念

二叉搜索树又称为二叉排序树或者二叉查找树，它可以是一棵空树，或者是具有以下性质的二叉树：

1.若它的左子树不为空，则左子树上所有结点的值都小于根结点的值。

2.若它的右子树不为空，则右子树上所有结点的值都大于根结点的值。

3.它的左右子树也分别是二叉搜索树。

例如，这样的一棵二叉树就是二叉搜索树。

​

在二叉搜索树中，每个结点左子树上所有结点的值都小于该结点的值，右子树上所有结点的值都大于该结点的值，因此对二叉搜索树进行中序遍历(左子树->根->右子树)后，得到的就是升序序列。

二叉搜索树的实现

节点类

要实现二叉搜索树，我们首先需要实现一个节点类：

节点类当中包含三个成员变量：节点值、左指针、右指针。

节点类当中只需实现一个构造函数即可，用于构造指定节点值的节点。

//节点类
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:
    //构造函数
    BSTree();

    //拷贝构造函数
    BSTree(const BSTree<K>& t);

    //赋值运算符重载函数
    BSTree<K>& operator=(BSTree<K> t);

    //析构函数
    ~BSTree();

    //插入函数
    bool Insert(const K& key);

    //删除函数
    bool Erase(const K& key);

    //查找函数
    Node* Find(const K& key);

    //中序遍历
    void InOrder();
private:
    Node* _root; //指向二叉搜索树的根结点
};

构造函数

构造一个空树即可。

//构造函数
BSTree()
    :_root(nullptr)
{}
也可以强制生成默认构造。

BSTree() = default; // 制定强制生成默认构造

拷贝构造函数

我们可以写出一个_Copy的函数然后调用这个函数完成二叉搜索树的深拷贝。

//拷贝树
Node* _Copy(Node* root)
{
    if (root == nullptr) //空树直接返回
        return nullptr;

    Node* copyNode = new Node(root->_key); //拷贝根结点
    copyNode->_left = _Copy(root->_left); //拷贝左子树
    copyNode->_right = _Copy(root->_right); //拷贝右子树
    return copyNode; //返回拷贝的树
}
//拷贝构造函数
BSTree(const BSTree<K>& t)
{
    _root = _Copy(t._root); //拷贝t对象的二叉搜索树
}

析构函数

析构函数完成对象中二叉搜索树结点的释放，注意释放时只能采用后序(左子树->根->右子树)释放(因为根节点必须要最后释放才能保证所有节点都遍历释放)，当二叉搜索树中的结点被释放完后，将对象当中指向二叉搜索树的指针及时置空即可。

//释放树中结点
void _Destory(Node* root)
{
    if (root == nullptr) //空树无需释放
        return;

    _Destory(root->_left); //释放左子树中的结点
    _Destory(root->_right); //释放右子树中的结点
    delete root; //释放根结点
}
//析构函数
~BSTree()
{
    _Destory(_root); //释放二叉搜索树中的结点
    _root = nullptr; //及时置空
}

赋值运算符重载

传统写法

//传统写法
const BSTree<K>& operator=(const BSTree<K>& t)
{
    if (this != &t) //防止自己给自己赋值
    {
        _Destory(_root); //先将当前的二叉搜索树中的结点释放
        _root = _Copy(t._root); //拷贝t对象的二叉搜索树
    }
    return *this; //支持连续赋值
}

现代写法

BSTree<K>& operator=(BSTree<K> t)
{
    swap(_root, t._root);//交换形参和this指针的资源
    return *this;//支持连续赋值
}

编译器接收t的时候自动调用拷贝构造函数，拷贝构造出来的对象t会在该赋值运算符重载函数调用结束时自动析构。

查找函数

根据二叉搜索树的特性，我们在二叉搜索树当中查找指定值的结点的方式如下：

若树为空树，则查找失败，返回nullptr。
若key值小于当前结点的值，则应该在该结点的左子树当中进行查找。
若key值大于当前结点的值，则应该在该结点的右子树当中进行查找。
若key值等于当前结点的值，则查找成功，返回对应结点的地址。

非递归实现

//查找函数
Node* Find(const K& key)
{
    Node* cur = _root;//让cur指向根节点
    while (cur)//当根节点不为空，遍历左右子树
    {
        if (key < cur->_key) //key值小于该结点的值
        {
            cur = cur->_left; //在该结点的左子树当中查找
        }
        else if (key > cur->_key) //key值大于该结点的值
        {
            cur = cur->_right; //在该结点的右子树当中查找
        }
        else //找到了值为key的结点
        {
            return cur; //查找成功，返回结点地址
        }
    }
    return nullptr; //树为空或查找失败，返回nullptr
}

递归实现

//递归查找函数的子函数
Node* _FindR(Node* root, const K& key)
{
    if (root == nullptr) //树为空
        return nullptr; //查找失败，返回nullptr

    if (key < root->_key) //key值小于根结点的值
    {
        return _FindR(root->_left, key); //在根结点的左子树当中查找
    }
    else if (key > root->_key) //key值大于根结点的值
    {
        return _FindR(root->_right, key); //在根结点的右子树当中查找
    }
    else //key值等于根结点的值
    {
        return root; //查找成功，返回根结点地址
    }
}
//递归查找函数
Node* FindR(const K& key)
{
    return _FindR(_root, key); //在_root当中查找值为key的结点
}
这里的递归查找用的是后序遍历(左子树->右子树->根)，也可以替换循环顺序用前序和中序来查找。

插入函数

根据二叉搜索树的性质，其插入操作非常简单：

如果是空树，则直接将插入结点作为二叉搜索树的根结点。
如果不是空树，则按照二叉搜索树的性质进行结点的插入：

1.若待插入结点的值小于根结点的值，则需要将结点插入到左子树当中。
2.若待插入结点的值大于根结点的值，则需要将结点插入到右子树当中。
3.若待插入结点的值等于根结点的值，则插入结点失败。
如此进行下去，直到找到与待插入结点的值相同的结点判定为插入失败，或者最终插入到某叶子结点的左右子树当中（即空树当中）。

非递归实现

使用非递归方式实现二叉搜索树的插入函数时，我们需要定义一个parent指针，该指针用于标记待插入结点的父结点，当我们找到待插入结点的插入位置时，可以将待插入结点与其父结点连接起来方便完成插入操作。

//插入函数
bool Insert(const K& key)
{
    if (_root == nullptr) //空树
    {
        _root = new Node(key); //直接申请值为key的结点作为二叉搜索树的根结点
        return true; //插入成功，返回true
    }
    Node* parent = nullptr;
    Node* cur = _root;
    while (cur)//当根节点不为空，遍历左右子树
    {
        if (key < cur->_key) //key值小于当前结点的值
        {
            //往该结点的左子树走
            parent = cur;
            cur = cur->_left;
        }
        else if (key > cur->_key) //key值大于当前结点的值
        {
            //往该结点的右子树走
            parent = cur;
            cur = cur->_right;
        }
        else //key值等于当前结点的值
        {
            return false; //插入失败，返回false
        }
    }

    //此时查找结束，进行插入操作
    cur = new Node(key); //申请值为key的结点
    if (key < parent->_key) //key值小于当前parent结点的值
    {
        parent->_left = cur; //将结点连接到parent的左边
    }
    else //key值大于当前parent结点的值
    {
        parent->_right = cur; //将结点连接到parent的右边
    }
    return true; //插入成功，返回true
}

递归实现

//递归插入函数的子函数
bool _InsertR(Node*& root, const K& key) //注意引用
{
    if (root == nullptr) //空树
    {
        root = new Node(key); //直接申请值为key的结点作为树的根结点
        return true; //插入成功，返回true
    }

    if (key < root->_key) //key值小于根结点的值
    {
        return _InsertR(root->_left, key); //应将结点插入到左子树当中
    }
    else if (key > root->_key) //key值大于根结点的值
    {
        return _InsertR(root->_right, key); //应将结点插入到右子树当中
    }
    else //key值等于根结点的值
    {
        return false; //插入失败，返回false
    }
}
//递归插入函数
bool InsertR(const K& key)
{
    return _InsertR(_root, key); //调用子函数进行插入
}

删除函数

二叉搜索树的删除函数是最难实现的，若是在二叉树当中没有找到待删除结点，则直接返回false表示删除失败即可，但若是找到了待删除结点，此时就有以下三种情况：

1.待删除结点的左子树为空（待删除结点的左右子树均为空包含在内）。

2.待删除结点的右子树为空。

3.待删除结点的左右子树均不为空。

1、待删除结点的左子树为空

若待删除结点的左子树为空，那么当我们在二叉搜索树当中找到该结点后，只需先让其父结点指向该结点的右孩子结点，然后再将该结点释放便完成了该结点的删除，进行删除操作后仍保持二叉搜索树的特性。

2、待删除结点的右子树为空

若待删除结点的右子树为空，那么当我们在二叉搜索树当中找到该结点后，只需先让其父结点指向该结点的左孩子结点，然后再将该结点释放便完成了该结点的删除，进行删除操作后仍保持二叉搜索树的特性。

3.待删除结点的左右子树均不为空

若待删除结点的左右子树均不为空，那么当我们在二叉搜索树当中找到该结点后，可以使用替换法进行删除。
可以将让待删除结点左子树当中值最大的结点，或是待删除结点右子树当中值最小的结点代替待删除结点被删除（下面都以后者为例），然后将待删除结点的值改为代替其被删除的结点的值即可。而代替待删除结点被删除的结点，必然左右子树当中至少有一个为空树，因此删除该结点的方法与前面说到的情况一和情况二的方法相同。

注意

只能是待删除结点左子树当中值最大的结点，或是待删除结点右子树当中值最小的结点代替待删除结点被删除，因为只有这样才对搜索二叉树结构改变程度最小，才能使得进行删除操作后的二叉树仍保持二叉搜索树的特性。

非递归实现

对于二叉搜索树删除函数的实现，在删除左右子树均不为空的结点时有两种不同的思路，因此实现删除函数的方法有以下两种。

方法一

在遇到待删除结点的左右子树均不为空的情况时，采用的处理方法如下：

1.使用minParent标记待删除结点右子树当中值最小结点的父结点。
2.使用minRight标记待删除结点右子树当中值最小的结点。
当找到待删除结点右子树当中值最小的结点时，先将待删除结点的值改为minRight的值，之后直接判断此时minRight是minParent的左孩子还是右孩子，然后对应让minParent的左指针或是右指针转而指向minRight的右孩子（注意：minRight的左孩子为空），最后将minRight结点进行释放即可。

//删除函数（方法一）
bool Erase(const K& key)
{
    Node* parent = nullptr; //标记待删除结点的父结点
    Node* cur = _root; //标记待删除结点
    while (cur)
    {
        if (key < cur->_key) //key值小于当前结点的值
        {
            //往该结点的左子树走
            parent = cur;
            cur = cur->_left;
        }
        else if (key > cur->_key) //key值大于当前结点的值
        {
            //往该结点的右子树走
            parent = cur;
            cur = cur->_right;
        }
        else //找到了待删除结点
        {
            if (cur->_left == nullptr) //待删除结点的左子树为空
            {
                if (cur == _root) //待删除结点是根结点，此时parent为nullptr
                {
                    _root = cur->_right; //二叉搜索树的根结点改为根结点的右孩子即可
                }
                else //待删除结点不是根结点，此时parent不为nullptr
                {
                    if (cur == parent->_left) //待删除结点是其父结点的左孩子
                    {
                        parent->_left = cur->_right; //父结点的左指针指向待删除结点的右子树即可
                    }
                    else //待删除结点是其父结点的右孩子
                    {
                        parent->_right = cur->_right; //父结点的右指针指向待删除结点的右子树即可
                    }
                }
                delete cur; //释放待删除结点
                return true; //删除成功，返回true
            }
            else if (cur->_right == nullptr) //待删除结点的右子树为空
            {
                if (cur == _root) //待删除结点是根结点，此时parent为nullptr
                {
                    _root = cur->_left; //二叉搜索树的根结点改为根结点的左孩子即可
                }
                else //待删除结点不是根结点，此时parent不为nullptr
                {
                    if (cur == parent->_left) //待删除结点是其父结点的左孩子
                    {
                        parent->_left = cur->_left; //父结点的左指针指向待删除结点的左子树即可
                    }
                    else //待删除结点是其父结点的右孩子
                    {
                        parent->_right = cur->_left; //父结点的右指针指向待删除结点的左子树即可
                    }
                }
                delete cur; //释放待删除结点
                return true; //删除成功，返回true
            }
            else //待删除结点的左右子树均不为空
            {
                //替换法删除
                Node* minParent = cur; //标记待删除结点右子树当中值最小结点的父结点
                Node* minRight = cur->_right; //标记待删除结点右子树当中值最小的结点
                //寻找待删除结点右子树当中值最小的结点
                while (minRight->_left)
                {
                    //一直往左走
                    minParent = minRight;
                    minRight = minRight->_left;
                }
                cur->_key = minRight->_key; //将待删除结点的值改为minRight的值
                //注意一个隐含条件：此时minRight的_left为空
                if (minRight == minParent->_left) //minRight是其父结点的左孩子
                {
                    minParent->_left = minRight->_right; //父结点的左指针指向minRight的右子树即可
                }
                else //minRight是其父结点的右孩子
                {
                    minParent->_right = minRight->_right; //父结点的右指针指向minRight的右子树即可
                }
                delete minRight; //释放minRight
                return true; //删除成功，返回true
            }
        }
    }
    return false; //没有找到待删除结点，删除失败，返回false
}

方法二

在找到待删除结点右子树当中值最小的结点后，先将minRight的值记录下来，然后再重新调用删除函数删除二叉树当中的minRight，当minRight被删除后再将原待删除结点的值改为minRight的值，这样也完成了左右子树均不为空的结点的删除。

//删除函数（方法二）
bool Erase(const K& key)
{
    Node* parent = nullptr; //标记待删除结点的父结点
    Node* cur = _root; //标记待删除结点
    while (cur)
    {
        if (key < cur->_key) //key值小于当前结点的值
        {
            //往该结点的左子树走
            parent = cur;
            cur = cur->_left;
        }
        else if (key > cur->_key) //key值大于当前结点的值
        {
            //往该结点的右子树走
            parent = cur;
            cur = cur->_right;
        }
        else //找到了待删除结点
        {
            if (cur->_left == nullptr) //待删除结点的左子树为空
            {
                if (cur == _root) //待删除结点是根结点，此时parent为nullptr
                {
                    _root = cur->_right; //二叉搜索树的根结点改为根结点的右孩子即可
                }
                else //待删除结点不是根结点，此时parent不为nullptr
                {
                    if (cur == parent->_left) //待删除结点是其父结点的左孩子
                    {
                        parent->_left = cur->_right; //父结点的左指针指向待删除结点的右子树即可
                    }
                    else //待删除结点是其父结点的右孩子
                    {
                        parent->_right = cur->_right; //父结点的右指针指向待删除结点的右子树即可
                    }
                }
                delete cur; //释放待删除结点
                return true; //删除成功，返回true
            }
            else if (cur->_right == nullptr) //待删除结点的右子树为空
            {
                if (cur == _root) //待删除结点是根结点，此时parent为nullptr
                {
                    _root = cur->_left; //二叉搜索树的根结点改为根结点的左孩子即可
                }
                else //待删除结点不是根结点，此时parent不为nullptr
                {
                    if (cur == parent->_left) //待删除结点是其父结点的左孩子
                    {
                        parent->_left = cur->_left; //父结点的左指针指向待删除结点的左子树即可
                    }
                    else //待删除结点是其父结点的右孩子
                    {
                        parent->_right = cur->_left; //父结点的右指针指向待删除结点的左子树即可
                    }
                }
                delete cur; //释放待删除结点
                return true; //删除成功，返回true
            }
            else //待删除结点的左右子树均不为空
            {
                //替换法删除
                Node* minRight = cur->_right; //标记待删除结点右子树当中值最小的结点
                //寻找待删除结点右子树当中值最小的结点
                while (minRight->_left)
                {
                    //一直往左走
                    minRight = minRight->_left;
                }
                K minKey = minRight->_key; //记录minRight结点的值
                Erase(minKey); //minRight代替待删除结点被删除
                cur->_key = minKey; //将待删除结点的值改为代替其被删除的结点的值，即minRight
            }
        }
    }
    return false; //没有找到待删除结点，删除失败，返回false
}

对于非递归删除函数的方法一和方法二来说，建议使用方法一，因为非递归删除函数方法二在删除左右子树均不为空的结点时，当找到minRight后还需要从二叉搜索树的根结点开始，重新遍历二叉树删除minRight结点，效率上不如方法一。

递归实现

递归实现二叉搜索树的删除函数的思路如下：

若树为空树，则结点删除失败，返回false。
若所给key值小于树根结点的值，则问题变为删除左子树当中值为key的结点。
若所给key值大于树根结点的值，则问题变为删除右子树当中值为key的结点。
若所给key值等于树根结点的值，则根据根结点左右子树的存在情况不同，进行不同的处理。

当待删除结点的左右子树均不为空时，处理方法有两种，所以删除函数的递归实现也有两种方法：

方法一

在遇到待删除结点的左右子树均不为空的情况时，采用的处理方法如下：

1.使用minParent标记根结点右子树当中值最小结点的父结点。
2.使用minRight标记根结点右子树当中值最小的结点。
当找到根结点右子树当中值最小的结点时，先根结点的值改为minRight的值，之后直接判断此时minRight是minParent的左孩子还是右孩子，然后对应让minParent的左指针或是右指针转而指向minRight的右孩子（注意：minRight的左孩子为空），最后将minRight结点进行释放即可。

//递归删除函数的子函数(方法一)
bool _EraseR(Node*& root, const K& key)
{
    if (root == nullptr) //空树
        return false; //删除失败，返回false

    if (key < root->_key) //key值小于根结点的值
        return _EraseR(root->_left, key); //待删除结点在根的左子树当中
    else if (key > root->_key) //key值大于根结点的值
        return _EraseR(root->_right, key); //待删除结点在根的右子树当中
    else //找到了待删除结点
    {
        if (root->_left == nullptr) //待删除结点的左子树为空
        {
            Node* del = root; //保存根结点
            root = root->_right; //根的右子树作为二叉树新的根结点
            delete del; //释放根结点
        }
        else if (root->_right == nullptr) //待删除结点的右子树为空
        {
            Node* del = root; //保存根结点
            root = root->_left; //根的左子树作为二叉树新的根结点
            delete del; //释放根结点
        }
        else //待删除结点的左右子树均不为空
        {
            Node* minParent = root; //标记根结点右子树当中值最小结点的父结点
            Node* minRight = root->_right; //标记根结点右子树当中值最小的结点
            //寻找根结点右子树当中值最小的结点
            while (minRight->_left)
            {
                //一直往左走
                minParent = minRight;
                minRight = minRight->_left;
            }
            root->_key = minRight->_key; //将根结点的值改为minRight的值
            //注意一个隐含条件：此时minRight的_left为空
            if (minRight == minParent->_left) //minRight是其父结点的左孩子
            {
                minParent->_left = minRight->_right; //父结点的左指针指向minRight的右子树即可
            }
            else //minRight是其父结点的右孩子
            {
                minParent->_right = minRight->_right; //父结点的右指针指向minRight的右子树即可
            }
            delete minRight; //释放minRight
        }
        return true; //删除成功，返回true
    }
}
//递归删除函数
bool EraseR(const K& key)
{
    return _EraseR(_root, key); //删除_root当中值为key的结点
}

方法二

在找到待删除结点右子树当中值最小的结点后，先将minRight的值记录下来，然后再重新调用递归删除函数的子函数从当前根结点的右子树开始，删除右子树当中的minRight，当minRight被删除后再将根结点的值改为minRight的值，这样也完成了左右子树均不为空的结点的删除。

//递归删除函数的子函数（方法二）
bool _EraseR(Node*& root, const K& key)
{
    if (root == nullptr) //空树
        return false; //删除失败，返回false

    if (key < root->_key) //key值小于根结点的值
        return _EraseR(root->_left, key); //待删除结点在根的左子树当中
    else if (key > root->_key) //key值大于根结点的值
        return _EraseR(root->_right, key); //待删除结点在根的右子树当中
    else //找到了待删除结点
    {
        if (root->_left == nullptr) //待删除结点的左子树为空
        {
            Node* del = root; //保存当前根结点
            root = root->_right; //根的右子树作为二叉树新的根结点
            delete del; //释放根结点
        }
        else if (root->_right == nullptr) //待删除结点的右子树为空
        {
            Node* del = root; //保存根结点
            root = root->_left; //根的左子树作为二叉树新的根结点
            delete del; //释放根结点
        }
        else //待删除结点的左右子树均不为空
        {
            Node* minRight = root->_right; //标记根结点右子树当中值最小的结点
            //寻找根结点右子树当中值最小的结点
            while (minRight->_left)
            {
                //一直往左走
                minRight = minRight->_left;
            }
            K minKey = minRight->_key; //记录minRight结点的值
            _EraseR(root->_right, minKey); //删除右子树当中值为minkey的结点，即删除minRight
            root->_key = minKey; //将根结点的值改为minRight的值
        }
        return true; //删除成功，返回true
    }
}
//递归删除函数
bool EraseR(const K& key)
{
    return _EraseR(_root, key); //删除_root当中值为key的结点
}

注意

递归删除函数的方法二和方法一在处理待删除结点左右子树均不为空时的处理思路不同。

对于递归删除函数的方法一和方法二来说，建议使用方法二，因为方法二在删除左右子树均不为空的结点时，当找到minRight后就无需从二叉搜索树的根结点开始，重新遍历二叉树删除minRight结点了，并且递归删除函数方法二写法的可读性更高。

二叉搜索树的应用
K模型，即只有key作为关键码，结构中只需存储key即可，关键码即为需要搜索到的值。

比如：给定一个单词，判断该单词是否拼写正确。具体方式如下：

以单词集合中的每个单词作为key，构建一棵二叉搜索树。
在二叉搜索树中检索该单词是否存在，存在则拼写正确，不存在则拼写错误。
KV模型
KV模型，对于每一个关键码key，都有与之对应的值value，即<key, value>的键值对。

比如：英汉词典就是英文与中文的对应关系，即<word, Chinese>就构成一种键值对。具体方式如下：

以<单词, 中文含义>为键值对，构建一棵二叉搜索树。注意：二叉搜索树需要进行比较，键值对比较时只比较key。
查询英文单词时，只需给出英文单词就可以快速找到与其对应的中文含义。