数据结构 - 二叉搜索树

__zz11

已于 2022-11-10 12:15:27 修改

阅读量521

点赞数

分类专栏：数据结构文章标签：数据结构

于 2022-11-10 12:14:33 首次发布

本文链接：https://blog.csdn.net/i777777777777777/article/details/127785885

版权

数据结构专栏收录该内容

17 篇文章 0 订阅

订阅专栏

一、概念

二叉搜索树（BST，Binary Search Tree）

也称二叉排序树，二叉查找树

二叉搜索树：一棵二叉树，可以为空，如果不为空，满足以下性质：

1. 非空左子树的所有键值小于其根节点的键值

2. 非空右子树的所有键值大于其根节点的键值

3. 左右子树都为二叉搜索树

二、实现

//
// Created by yangzilong on 2022/10/30.
//

#ifndef STL_BINARYSEARCHTREE_H
#define STL_BINARYSEARCHTREE_H
#include<iostream>
template <typename K>
struct BSTreeNode
{
    BSTreeNode(const K& key)
        :_key(key), _left(nullptr), _right(nullptr)
    { }
    BSTreeNode<K>* _left;
    BSTreeNode<K>* _right;
    K _key;
};

template <typename K>
class BinarySearchTree {
    typedef BSTreeNode<K> Node;
private:
    Node* _root = nullptr;
public:
    ~BinarySearchTree()
    {
        _Destroy(_root);
    }
    BinarySearchTree() = default;
    BinarySearchTree(const BinarySearchTree<K>& t)
    {
        _root = _Copy(t._root);
    }
    BinarySearchTree<K>& operator=(BinarySearchTree<K> t)
    {
        std::swap(_root, t._root);
        return *this;
    }
private:
    Node* _Copy(Node* root)
    {
        if(root == nullptr)
            return nullptr;
        Node* newNode = new Node(root->_key);
        newNode->_left = _Copy(root->_left);
        newNode->_right = _Copy(root->_right);
        return newNode;
    }
    void _Destroy(Node* root)
    {
        if(root == nullptr)
            return;
        _Destroy(root->_left);
        _Destroy(root->_right);
        delete root;
    }
public:
    // 非递归
    bool Insert(const K& key) {
        // 空树
        if (_root == nullptr) {
            _root = new Node(key);
            return true;
        }
        Node *cur = _root;
        Node *parent = nullptr;
        while (cur) {
            if (cur->_key < key) {
                parent = cur;
                cur = cur->_right;
            } else if (cur->_key > key) {
                parent = cur;
                cur = cur->_left;
            } else {
                return false; // 已经存在了
            }
        }
        if (key > parent->_key) {
            parent->_right = new Node(key);
        } else {
            parent->_left = new Node(key);
        }
        return true;
    }
    bool Find(const K& key)
    {
        Node* cur = _root;
        while(cur)
        {
            if(key > cur->_key)
            {
                cur = cur->_right;
            }
            else if(key < cur->_key)
            {
                cur = cur->_left;
            }
            else
            {
                return true;
            }
        }
        return false;
    }
    bool Erase(const K& key) {
        Node *cur = _root;
        Node *parent = _root;
        while (cur) {
            if (key > cur->_key) {
                parent = cur;
                cur = cur->_right;
            } else if (key < cur->_key) {
                parent = cur;
                cur = cur->_left;
            } else {
                // edition 2
                if(cur->_left == nullptr)
                {
                    if(parent->_left == cur)
                    {
                        parent->_left = cur->_right;
                        delete cur;
                    }
                    else
                    {
                        parent->_right = cur->_right;
                        delete cur;
                    }
                }
                else if(cur->_right == nullptr)
                {
                    if(parent->_left == cur)
                    {
                        parent->_left = cur->_left;
                        delete cur;
                    }
                    else
                    {
                        parent->_right = cur->_left;
                        delete cur;
                    }
                }
                else
                {
                    // 要删除结点的左右均不为空
                    // 去删除结点的右子树中找最小值，替换法删除
                    Node* min = cur->_right;
                    Node* minParent = cur;
                    while(min->_left)
                    {
                        minParent = min;
                        min = min->_left;
                    }
                    std::swap(cur->_key, min->_key);
                    if(min == minParent->_right)
                        minParent->_right = min->_right;
                    else
                        minParent->_left = min->_right;
                    delete min;
                }
                return true;
                // old
//                if (cur->_left == nullptr && cur->_right == nullptr) {
//                    // 叶子节点，直接删除
//                    if (parent->_left->_key == key) {
//                        delete parent->_left;
//                        parent->_left = nullptr;
//                    } else {
//                        delete parent->_right;
//                        parent->_right = nullptr;
//                    }
//                } else if (cur->_left != nullptr && cur->_right != nullptr) {
//                    // 找右子树的最小值，和cur交换值
//                    Node *minParent = cur;
//                    Node *min = cur->_right; // child一定不为nullptr
//                    while (min->_left) {
//                        minParent = min;
//                        min = min->_left;
//                    }
//                    std::swap(cur->_key, min->_key);
//                    if (minParent == cur) {
//                        minParent->_right = min->_right;  // 此时child->_left一定为nullptr
//                        delete min;
//                    } else {
//                        // 此时child和parent_2的关系一定是左子树和父节点
//                        minParent->_left = min->_right;
//                        delete min;
//                    }
//                } else {
//                    Node *child = nullptr;
//                    if (cur->_right != nullptr) {
//                        child = cur->_right;
//                    } else {
//                        child = cur->_left;
//                    }
//                    if (parent->_left != nullptr && parent->_left->_key == key) {
//                        delete parent->_left;
//                        parent->_left = child;
//                    } else {
//                        delete parent->_right;
//                        parent->_right = child;
//                    }
//                }
//                return true;
            }
        }
        return false;
    }
    void InOrder()
    {
        _InOrder(_root);
        std::cout<<std::endl;
    }
private:
    void _InOrder(Node* root)
    {
        if(root == nullptr)
            return;
        _InOrder(root->_left);
        std::cout<<root->_key<<" ";
        _InOrder(root->_right);
    }
    
    // 递归
public:
    bool Find_R(const K& key)
    {
        // 最多找h次，h为树的高度。
        return _Find_R(_root, key);
    }
    bool Insert_R(const K& key)
    {
        return _Insert_R(_root, key);
    }
    bool Erase_R(const K& key)
    {
        return _Erase_R(_root, key);
    }
private:
    bool _Erase_R(Node*& root, const K& key)
    {
        if(root == nullptr)
        {
            // 不存在
            return false;
        }
        if(key < root->_key)
        {
            return _Erase_R(root->_left, key);
        }
        else if(key > root->_key)
        {
            return _Erase_R(root->_right, key);
        }
        else
        {
            // 要删除的就是这个root，这个root实际上是父节点结构体里的right or left指针的别名！！！！！
            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* min = root->_right;
                while(min->_left)
                {
                    minParent = min;
                    min = min->_left;
                }
                std::swap(root->_key, min->_key);
                // 上方交换时，root的key一定比min的key小，因为min在root的右子树中。
                // 此时交换完，root的key在右子树中一定符合二叉搜索树。
                // 并且下方递归调用时，一定会走左为空的情况。
                return _Erase_R(root->_right, key);
//                if(minParent->_left == min)
//                {
//                    minParent->_left = min->_right;
//                }
//                else
//                {
//                    minParent->_right = min->_right;
//                }
//                delete min;
            }
            return true;
        }
    }
    bool _Insert_R(Node*& root, const K& key)
    {
        if(root == nullptr)
        {
            root = new Node(key);
            return true;
        }
        if(key < root->_key)
        {
            // 这里是把结构体里的指针成员传过去，参数用引用接收，改变参数就是改变这里结构体的指针成员。
            return _Insert_R(root->_left, key);
        }
        else if(key > root->_key)
        {
            // 这里是把结构体里的指针成员传过去，参数用引用接收，改变参数就是改变这里结构体的指针成员。
            return _Insert_R(root->_right, key);
        }
        else
        {
            return false;
        }
    }
//    bool _Insert_R(Node* root, const K& key)
//    {
//        if(root == nullptr)
//        {
//            _root = new Node(key);
//            return true;
//        }
//        if(root->_key < key && root->_right == nullptr)
//        {
//            root->_right = new Node(key);
//            return true;
//        }
//        else if(root->_key > key && root->_left == nullptr)
//        {
//            root->_left = new Node(key);
//            return true;
//        }
//        else if(root->_key > key)
//        {
//            return _Insert_R(root->_left, key);
//        }
//        else if(root->_key < key)
//        {
//            return _Insert_R(root->_right, key);
//        }
//        else
//        {
//            return false;
//        }
//    }
    bool _Find_R(Node* root, const K& key)
    {
        if(root == nullptr)
            return false;
        if(root->_key > key)
        {
            return _Find_R(root->_left, key);
        }
        else if(root->_key < key)
        {
            return _Find_R(root->_right, key);
        }
        else
        {
            return true;
        }
    }
};

以上包含二叉搜索树的递归版与非递归版的插入，删除，查找。以及拷贝构造和析构的实现。

唯一值得注意的就是删除了

非递归删除

先找到该结点，同时注意要记录要删除结点的父节点。

分情况：

1. 要删除结点的左右为空，即叶子结点

2. 要删除结点的左为空

3. 要删除结点的右为空

4. 要删除结点的左右都为空

1可以和2或3其中之一合并。

若要删除结点（cur）的左为空，则将cur的右赋值给parent的左或右（取决于cur是parent的左还是右）

若要删除结点（cur）的右为空，则将cur的左赋值给parent的左或右（取决于cur是parent的左还是右）

                    // 要删除结点的左右均不为空
                    // 去删除结点的右子树中找最小值，替换法删除
                    Node* min = cur->_right;
                    Node* minParent = cur;
                    while(min->_left)
                    {
                        minParent = min;
                        min = min->_left;
                    }
                    std::swap(cur->_key, min->_key);
                    if(min == minParent->_right)
                        minParent->_right = min->_right;
                    else
                        minParent->_left = min->_right;
                    delete min;

若要删除结点（cur）的左右均不为空，则查找cur的右子树中的最小结点（min），即图中的while循环），采用交换法，将cur的key和min的key交换（此时min的值放在cur的位置是符合二叉搜索树的性质的），此时要删除的结点就转换为了min。

注意，此时要判断，min是cur的右结点还是右节点的左子树的某个结点。也就是while循环有没有执行。

转换为上图，也就是

若删除3（cur），则4是min，min是minparent的左。

若删除8（cur），则10是min，min是minparent的右。

不管怎样，min的左一定为空，直接将min的右（空or非空）赋值给min的左或右即可（取决于min是minparent的左还是右）

递归删除

bool _Erase_R(Node*& root, const K& key)
    {
        if(root == nullptr)
        {
            // 不存在
            return false;
        }
        if(key < root->_key)
        {
            return _Erase_R(root->_left, key);
        }
        else if(key > root->_key)
        {
            return _Erase_R(root->_right, key);
        }
        else
        {
            // 要删除的就是这个root，这个root实际上是父节点结构体里的right or left指针的别名！！！！！
            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* min = root->_right;
                while(min->_left)
                {
                    minParent = min;
                    min = min->_left;
                }
                std::swap(root->_key, min->_key);
                // 上方交换时，root的key一定比min的key小，因为min在root的右子树中。
                // 此时交换完，root的key在右子树中一定符合二叉搜索树。
                // 并且下方递归调用时，一定会走左为空的情况。
                return _Erase_R(root->_right, key);
//                if(minParent->_left == min)
//                {
//                    minParent->_left = min->_right;
//                }
//                else
//                {
//                    minParent->_right = min->_right;
//                }
//                delete min;
            }
            return true;
        }
    }

除了是基于递归实现的，这里的基本原理和非递归一样，只是在交换完cur和min的key之后，直接在cur的右子树中删除key即可（此时key在min结点中）。最终会递归到左子树为空的情况，因为min->left == nullptr