目录
认识二叉搜索树：
二叉搜索树（BST，Binary Search Tree）又称二叉排序树，二叉查找树，主要功能是排序，去重，查找一个值是否存在。
二叉搜索树在普通二叉树的特性上加上了一点，也就是每个根节点，左子树的值始终比根节点的值小，右子树的值始终比根节点的值要大。
这样做的好处是什么呢？当我们在这颗树中查找某个值时，若这个值比根小就往左走，若这个值比根大就往右走，也就是说，我们最少走高度次，就能找到它，根据二叉树特性：n = 2^h - 1,n表示节点数，h表示高度，换算一下，h = log(n+1)，所以我们查找一个数的时间复杂度就为O(logn),这个时间复杂度是个什么概念呢？若有10亿个数据在树里，当我们查找时，最坏查找30次就能找到，因为2的30次方约等于10亿，相比我们遍历一遍，最坏情况需要查找10亿次，所以它的含金量就不必我多说了。
模拟实现：
节点结构体构建：
树中的每个节点，我使用结构体来存储：
接下来就可以开始构建类模板了：
insert（插入）:
注意：二叉搜索树一般不允许数据冗余，所以如果插入树中已有的值，则插入失败
思路：用cur找到插入的位置， 将要插入的值和根节点作比较，会出现3种情况，1，比根节点小，cur往左走，2，比根节点大，cur往右走，3，与根节点相等，插入失败。我们每次移动cur都要用parent记录它父节点的位置，这样当找到应该插入的位置时，用parent的左子树或者右子树指向它。
bool insert(const K& val)
{
if (_root == nullptr)//若原来树为空
{
_root = new node(val);
return true;
}
node* cur = _root;
node* parent = nullptr;
while (cur)//开始找插入位置
{
if (val < cur->_val)
{
parent = cur;
cur = parent->left;
}
else if (val > cur->_val)
{
parent = cur;
cur = parent->right;
}
else
{
return false;
}
}
cur = new node(val);
if (val > parent->_val)
{
parent->right = cur;
}
else
{
parent->left = cur;
}
}find（查找）：
思路：这个简单，被查找的值比根节点小就往左走，比根节点大就往右走，相等返回true，走到空节点还没找到就返回false：
bool find(const K& val)
{
node* cur = _root;
while (cur)
{
if (val > cur->_val)
{
cur = cur->right;
}
else if (val < cur->_val)
{
cur = cur->left;
}
else
{
return true;
}
}
return false;
}erase（删除）（重点）：
思路：
在二叉搜索树中删除一个值，先找到这个值所在的节点，删除这个节点后，返回true，找不到返回false，这个被删除的节点肯定不能空出来，还是要它组成一颗二叉搜索树，我们在删除的时候就会遇到这几种情况：
1，要删除的节点的左子树为空，我们只需将要删除的节点的父节点指向该左子树就行，右子树同理：
如图所示：
我们要删除1，因为1只有一个孩子，所以我们只需要将3的左子树指向1的孩子就行。不过要注意，当要删除的就是最上面的根节点时，也就是父节点为空，如下图删除13时，这时需要特判的，我们只需将根节点改成那个唯一的孩子就行。
2.要删除的节点，左右孩子都存在
这时要删除这个节点就有点复杂了，就需要使用替代法删除，看下图这个场景，当我们要删除3：
替代法删除， 就是在被删除节点的左右子树中找到能在这个位置占得住脚的值来替换掉这个位置，所以现在主要就是到底哪些值是能在被删除节点的位置站的住脚。如上图，也就是要比1大比6小。
这些值就是，左子树的最大节点和右子树的最小节点，原理不再多说，想必看上图应该都能体会出来，上图左子树的最大节点是2，右子树的最小节点是4，都能在3的位置占住脚，所以我们只需要随便找到一个，这里我找右子树的最小值，找到后交换右子树最小值和需要删除节点的值，再让右子树最小值的父节点的左子树指向右子树最小值的右一个孩子就行（因为左孩子肯定为空，不然它就不是右子树的最小值），然后删除右节点最小值位置的节点，。
为了帮助理解来模拟一下：
1.找到右子树的最小值4及它的父亲节点：
2.交换需要删除的节点和左子树最小值的值：
3.再让右子树最小值的父节点的左子树指向右子树最小值的右一个孩子：
4.最后删除RIghtMin所在的节点：
最后达成预期！
注意有特殊情况，需要特判！当右子树的最小值就是右子树的第一个根时，如下图删除3时
这时右子树的最小节点就是第一个根6，此时当我们走到上面模拟的第三步后就会出现这样的情况：
画圈部分直接被抛弃掉了，而且还会造成内存泄漏。
解决方法很简单，只需简单用if判断一下这种情况即可，如果RightMinparent->right==RightMin，就让RightMinparent->right=RightMin->right, 如果RightMinparent->left==RightMin,就让RightMinparent->left=RightMin->right.
bool Erase(const K& key)
{
Node* parent = nullptr;
Node* cur = _root;
while (cur)
{
if (cur->_key < key)
{
parent = cur;
cur = cur->_right;
}
else if (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)//找右子树的最小节点放在rightMin中
{
rightMinParent = rightMin;
rightMin = rightMin->_left;
}
swap(cur->_key, rightMin->_key);//找到后交换
if (rightMinParent->_left == rightMin)//特判
rightMinParent->_left = rightMin->_right;
else
rightMinParent->_right = rightMin->_right;
delete rightMin;
}
return true;
}
}
return false;
}全部代码：
#pragma once
#include<string>
template<class T>
struct BSTNode
{
BSTNode<T>* left;//左子树
BSTNode<T>* right;//右子树
T _val;//值
BSTNode(T& val)//构造函数
:left(nullptr)
, right(nullptr)
, _val(val);
{}
};
template<class K>
class BSTree
{
typedef BSTNode<K> node;
public:
bool insert(const K& val)
{
if (_root == nullptr)//若原来树为空
{
_root = new node(val);
return true;
}
node* cur = _root;
node* parent = nullptr;
while (cur)//开始找插入位置
{
if (val < cur->_val)
{
parent = cur;
cur = parent->left;
}
else if (val > cur->_val)
{
parent = cur;
cur = parent->right;
}
else
{
return false;
}
}
cur = new node(val);
if (val > parent->_val)
{
parent->right = cur;
}
else
{
parent->left = cur;
}
}
bool find(const K& val)
{
node* cur = _root;
while (cur)
{
if (val > cur->_val)
{
cur = cur->right;
}
else if (val < cur->_val)
{
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 if (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)//找右子树的最小节点放在rightMin中
{
rightMinParent = rightMin;
rightMin = rightMin->_left;
}
swap(cur->_key, rightMin->_key);//找到后交换
if (rightMinParent->_left == rightMin)//特判
rightMinParent->_left = rightMin->_right;
else
rightMinParent->_right = rightMin->_right;
delete rightMin;
}
return true;
}
}
return false;
}
private:
node* _root = nullptr;
};
3532
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
