二叉搜索树
Posted 2021dragon
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了二叉搜索树相关的知识，希望对你有一定的参考价值。
文章目录
二叉搜索树的概念
二叉搜索树又称为二叉排序树，它或者是一棵空树，或者是具有以下性质的二叉树：
- 若它的左子树不为空，则左子树上所有结点的值都小于根结点的值。
- 若它的右子树不为空，则右子树上所有结点的值都大于根结点的值。
- 它的左右子树也分别是二叉搜索树。
例如，下面就是一棵二叉搜索树：
由于二叉搜索树中，每个结点左子树上所有结点的值都小于该结点的值，右子树上所有结点的值都大于该结点的值，因此对二叉搜索树进行中序遍历后，得到的是升序序列也就不难理解了。
二叉搜索树的实现
结点类
要实现二叉搜索树，我们首先需要实现一个结点类：
- 结点类当中包含三个成员变量：结点值、左指针、右指针。
- 结点类当中只需实现一个构造函数即可，用于构造指定结点值的结点。
//结点类
template<class K>
struct BSTreeNode
{
K _key; //结点值
BSTreeNode<K>* _left; //左指针
BSTreeNode<K>* _right; //右指针
//构造函数
BSTreeNode(const K& key = 0)
:_key(key)
, _left(nullptr)
, _right(nullptr)
{}
};
各函数接口总览+小技巧
二叉搜索树需要实现的函数接口如下：
//二叉搜索树
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; //指向二叉搜索树的根结点
};
小技巧
为了在实现其他接口的过程中方便随时检查，最好实现一个二叉搜索树的中序遍历接口，当我们对二叉搜索树进行一次操作后，可以调用中序遍历接口对二叉搜索树进行遍历，若二叉搜索树进行操作后的遍历结果仍为升序，则可以初步判断所实现的接口是正确。
//中序遍历的子函数
void _InOrder(Node* root)
{
if (root == nullptr)
return;
_InOrder(root->_left); //遍历左子树
cout << root->_key << " "; //遍历根结点
_InOrder(root->_right); //遍历右子树
}
//中序遍历
void InOrder()
{
_InOrder(_root);
cout << endl;
}
构造函数
构造函数非常简单，构造一个空树即可。
//构造函数
BSTree()
:_root(nullptr)
{}
拷贝构造函数
拷贝构造函数也并不难，拷贝一棵和所给二叉搜索树相同的树即可。
//拷贝树
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对象的二叉搜索树
}
注意： 拷贝构造函数完成的是深拷贝。
赋值运算符重载函数
对于赋值运算符重载函数，下面提供两种实现方法：
传统写法
完成所给二叉搜索树的拷贝即可。
//传统写法
const BSTree<K>& operator=(const BSTree<K>& t)
{
if (this != &t) //防止自己给自己赋值
{
_root = _Copy(t._root); //拷贝t对象的二叉搜索树
}
return *this; //支持连续赋值
}
现代写法
赋值运算符重载函数的现代写法非常精辟，函数在接收右值时并没有使用引用进行接收，因为这样可以间接调用BSTree的拷贝构造函数完成拷贝构造。我们只需将这个拷贝构造出来的对象的二叉搜索树与this对象的二叉搜索树进行交换，就相当于完成了赋值操作，而拷贝构造出来的对象t会在该赋值运算符重载函数调用结束时自动析构。
//现代写法
BSTree<K>& operator=(BSTree<K> t) //编译器接收右值的时候自动调用拷贝构造函数
{
swap(_root, t._root); //交换这两个对象的二叉搜索树
return *this; //支持连续赋值
}
注意： 这里传统写法和现代写法完成的都是深拷贝。
析构函数
析构函数完成对象中二叉搜索树结点的释放，注意释放时采用后序释放，当二叉搜索树中的结点被释放完后，将对象当中指向二叉搜索树的指针及时置空即可。
//释放树中结点
void _Destory(Node* root)
{
if (root == nullptr) //空树无需释放
return;
_Destory(root->_left); //释放左子树中的结点
_Destory(root->_right); //释放右子树中的结点
delete root; //释放根结点
}
//析构函数
~BSTree()
{
_Destory(_root); //释放二叉搜索树中的结点
_root = nullptr; //及时置空
}
插入函数
根据二叉搜索树的性质，其插入操作非常简单：
- 如果是空树，则直接将插入结点作为二叉搜索树的根结点。
- 如果不是空树，则按照二叉搜索树的性质进行结点的插入。
若不是空树，插入结点的具体操作如下：
- 若待插入结点的值小于根结点的值，则需要将结点插入到左子树当中。
- 若待插入结点的值大于根结点的值，则需要将结点插入到右子树当中。
- 若待插入结点的值等于根结点的值，则插入结点失败。
如此进行下去，直到找到与待插入结点的值相同的结点判定为插入失败，或者最终插入到某叶子结点的左右子树当中（即空树当中）。
动图演示：
非递归实现
使用非递归方式实现二叉搜索树的插入函数时，我们需要定义一个parent指针，该指针用于标记待插入结点的父结点。
这样一来，当我们找到待插入结点的插入位置时，才能很好的将待插入结点与其父结点连接起来。
但是需要注意在连接parent和cur时，需要判断应该将cur连接到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
}
递归实现
递归实现二叉搜索树的插入操作也是很简单的，但是要特别注意的一点就是，递归插入函数的子函数接收参数root时，必须采用引用接收，因为只有这样我们才能将二叉树当中的各个结点连接起来。
//递归插入函数的子函数
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、待删除结点的左右子树均不为空
若待删除结点的左右子树均不为空，那么当我们在二叉搜索树当中找到该结点后，可以使用替换法进行删除。
可以将让待删除结点左子树当中值最大的结点，或是待删除结点右子树当中值最小的结点代替待删除结点被删除（下面都以后者为例），然后将待删除结点的值改为代替其被删除的结点的值即可。而代替待删除结点被删除的结点，必然左右子树当中至少有一个为空树，因此删除该结点的方法与前面说到的情况一和情况二的方法相同。
注意只能是待删除结点左子树当中值最大的结点，或是待删除结点右子树当中值最小的结点代替待删除结点被删除，因为只有这样才能使得进行删除操作后的二叉树仍保持二叉搜索树的特性。
动图演示：
非递归实现
对于二叉搜索树删除函数的实现，在删除左右子树均不为空的结点时有两种不同的思路，因此实现删除函数的方法有以下两种。
方法一：
方法一在遇到待删除结点的左右子树均不为空的情况时，采用的处理方法如下：
- 使用minParent标记待删除结点右子树当中值最小结点的父结点。
- 使用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的值，若逻辑顺序颠倒，则会导致在调用删除函数删除minRight结点时在二叉树当中存在两个满足要求的待删除结点。
- 非递归删除函数方法二和方法一在实现上只有一点不同，那就是处理待删除结点左右子树均不为空时的处理思路。
- 对于非递归删除函数的方法一和方法二来说，建议使用方法一，因为非递归删除函数方法二在删除左右子树均不为空的结点时，当找到minRight后还需要从二叉搜索树的根结点开始，重新遍历二叉树删除minRight结点。
递归实现
递归实现二叉搜索树的删除函数的思路如下：
- 若树为空树，则结点删除失败，返回false。
- 若所给key值小于树根结点的值，则问题变为删除左子树当中值为key的结点。
- 若所给key值大于树根结点的值，则问题变为删除右子树当中值为key的结点。
- 若所给key值等于树根结点的值，则根据根结点左右子树的存在情况不同，进行不同的处理。
而因为当待删除结点的左右子树均不为空时，处理方法有两种，所以删除函数的递归实现也有两种方法。
方法一：
方法一在遇到待删除结点的左右子树均不为空的情况时，采用的处理方法如下：
- 使用minParent标记根结点右子树当中值最小结点的父结点。
- 使用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以上是关于二叉搜索树的主要内容，如果未能解决你的问题，请参考以下文章
代码随想录Day20-Leetcode654.最大二叉树，617.合并二叉树，700.二叉搜索树中的搜索，98.验证二叉搜索树