二叉搜索树
一、二叉搜索树的概念
二叉搜索树又称二叉排序树（也可以叫做搜索二叉树、排序二叉树，二叉和搜索/排序的顺序无所谓），它是一棵空树，或者是具有以下4个性质的二叉树：
若它的左子树不为空，则左子树上所有结点的值都小于等于根结点的值。
若它的右子树不为空，则右子树上所有结点的值都大于等于根结点的值。
它的左右子树也分别为二叉搜索树。
二叉搜索树中可以支持插入相等的值，也可以不支持插入相等的值，具体看使用场景定义，后续我们学习map/set/multimap/multiset系列容器底层就是二叉搜索树，其中map/set不支持插入相等值，multimap/multiset支持插入相等值。（相等的值插入的地方在左边还是在右边是不确定的，在后面的学习中有一个旋转的概念，由于旋转控制二叉树平衡，就算相等的值统一插入在右边，那么也有可能被旋转到左边。）
二叉搜索树的性质：
- 二叉搜索树很适合查找/搜索。对比之前在数组、链表中查找一个值是要遍历整个结构的，也就是暴力查找。而二叉搜索树搜索一个值不需要暴力查找。例如查找7，搜索过程如下：
再比如，查找12，查找过程如下：
一直到空，所以没有查找到12。也就是说最多查找次数是"高度"次，不需要遍历整棵树了，所以最多查找次数理论上是比遍历的O(n)要小的（理解记忆O(logn)小于O(n)）。最好的情况是一进来就搜索到了，查找次数是1次。
- 二叉搜索树走中序遍历（左根右）是升序的，所以又叫做二叉排序树。
那么二叉搜索树查找的时间复杂度是O(logn)吗？
二、二叉搜索树的性能分析
最优情况下，二叉搜索树为完全二叉树(或者接近完全二叉树)，其高度为： logN
最差情况下，二叉搜索树退化为单支树(或者类似单支)，其高度为： N
所以综合而言二叉搜索树增删查改时间复杂度为： O(N)
那么这样的效率显然是无法满足我们需求的，我们后续需要继续讲解二叉搜索树的变形，平衡（左右均匀，logn，（接近）完全二叉树）二叉搜索树：AVL树和红黑树，才能适用于我们在内存中存储和搜索数据。
另外需要说明的是，二分查找也可以实现 O(log2 N) 级别的查找效率，但是二分查找有两大缺陷：
- 需要存储在支持下标随机访问的结构中，并且有序。
- 插入和删除数据效率很低，因为存储在下标随机访问的结构中，插入和删除数据一般需要挪动数据。
这里也就体现出了平衡二叉搜索树的价值。
logn是个很好的复杂度了，假设n为1000，那么最多只需10次就能搜索（2^10 = 1024），而O(n)需要搜索1000次；n为1000000，最多需要20次搜索；n为10亿，最多需要30次搜索。比O(n)好很多。
三、二叉搜索树的插入
插入的具体过程如下：
- 树为空，则直接新增结点，赋值给root指针。
- 树不空，按二叉搜索树性质，插入值比当前结点大往右走，插入值比当前结点小往左走，找到空位置，插入新结点。
- 如果支持插入相等的值，插入值跟当前结点相等的值可以往右走，也可以往左走，找到空位置，插入新结点。（要注意的是要保持逻辑一致性，插入相等的值不要一会往右走，一会往左走）
注意：若写循环就能实现就没有必要写递归。
int a[] = {8, 3, 1, 10, 6, 4, 7, 14, 13};
二叉搜索树这里一般把被比较的值的类型叫做关键字（Key），模板参数取首字母K。
构造：用默认生成的构造就可以，用缺省值初始化
// BinarySearchTree.h
template<class K>
struct BSTreeNode
{
BSTreeNode<K>* _left;
BSTreeNode<K>* _right;
K _key;
};
template<class K>
class BSTree
{
typedef BSTreeNode<K> Node;
public:
private:
Node* _root = nullptr;// 缺省值初始化
};
Insert：
为什么带返回值，因为默认写的是不支持冗余的（不支持插入相等的值）。
不能直接这么写，cur是局部变量，new一个Node空间给cur，cur出了作用域就会被销毁，会有内存泄漏的风险，并且cur指向的新的结点也找不到了：
解决办法：parent变量记录cur的父结点，刚开始parent是根结点的父（初始化为nullptr）。用parent和新节点连接。
二叉搜索树的形状与插入值的先后顺序有关，同样的值按不同的顺序插入得到的形状结果是不一样的。例如，按序插入1、2、3与按序插入2、1、3：
所以二叉搜索树若按照有序插入（或接近于有序插入），就会退化成一个很差的结构。
Insert后，不知道结果对不对，所以利用中序遍历验证。但是参数是私有的根结点，在类外访问不了。其实二叉树递归算法中，通常都把根结点作为递归参数传递，但是根结点都为私有成员。解决方法：写个公有的getroot函数。更推荐的方法是套一层，调用的是不需要传参的公有函数，在函数体里完成递归、传递私有成员参数。
// BinarySearchTree.h
#include <iostream>
using namespace std;
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* cur = _root;
Node* parent = nullptr;
while (cur)
{
if (cur->_key > key)
{
parent = cur;
cur = cur->_left;
}
else if (cur->_key < key)
{
parent = cur;
cur = cur->_right;
}
else
{
return false;
}
}
cur = new Node(key);
if (key > parent->_key)
{
parent->_right = cur;
}
else
{
parent->_left = cur;
}
return true;
}
void InOrder()
{
_InOrder(_root);
cout << endl;
}
private:
void _InOrder(Node* root)
{
if (root == nullptr)
{
return;
}
_InOrder(root->_left);
cout << root->_key << " ";
_InOrder(root->_right);
}
private:
Node* _root = nullptr;// 缺省值初始化
};
// Test.cpp
#include "BinarySearchTree.h"
int main()
{
int a[] = { 8, 3, 1, 10, 6, 4, 7, 14, 13 };
BSTree<int> t;
for (auto e : a)
{
t.Insert(e);
}
t.InOrder();
return 0;
}
四、二叉搜索树的查找
- 从根开始比较，查找x，x比根的值大则往右边走查找，x比根值小则往左边走查找。
- 最多查找高度次，若走到空还没找到，则这个值不存在。
- 如果不支持插入相等的值，找到x即可返回。
- 如果支持插入相等的值，意味着有多个x存在，一般要求查找中序的第一个x。如下图，查找3，要找到1的右孩子的那个3返回。
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;
}
int main()
{
int x = 0;
while (cin >> x)
{
if (t.Find(x))
{
cout << x << "存在" << endl;
}
else
{
cout << x << "不存在" << endl;
}
}
return 0;
}
所有的流插入都可以写在while里while(cin >> x){}，流插入cin >> x返回的是isteram类型的对象，布尔值、整型、指针可以作为条件逻辑判断。那这个对象怎么去做条件逻辑判断呢？这个涉及C++的特性，后面到类型转换时才会讲解，先简单了解一下，本质会去调用operator bool，会把istream转换成一个bool值，默认这个bool值都为真（条件逻辑判断为假的情况：要求输入整型但是输入字符、整型串中带有字符时，流标志就会报错，返回false。正常输入，想结束循环输入，本质就是输入EOF，输入标识ctrl+z+换行，流标志就会改为false）。继承istream类的ifstream、istringstream类也都可以转成bool值。
五、二叉搜索树的删除
首先查找元素是否在二叉搜索树中，如果不存在，则返回false。
如果查找元素存在则分以下四种情况分别处理：（假设要删除的结点为N）
- 要删除的结点N左右孩子均为空。
- 要删除的结点N左孩子为空，右孩子结点不为空。
- 要删除的结点N右孩子为空，左孩子结点不为空。
- 要删除的结点N左右孩子结点均不为空。
对应以上四种情况的解决方案：
- 把N结点的父亲对应孩子指针指向空，直接删除N结点（情况1可以当成2或者3处理，效果是一样的）。
- 把N结点的父亲对应孩子指针指向N的右孩子，直接删除N结点。
- 把N结点的父亲对应孩子指针指向N的左孩子，直接删除N结点。
- 无法直接删除N结点，因为N的两个孩子无处安放，只能用替换法删除。找N的左子树中的值最大结点R（最右结点，说明R的右结点为空）或者N的右子树中的值最小结点R（最左结点，说明R的左结点为空）替代N，因为这两个结点中任意一个放到N的位置，都满足二叉搜索树的规则。替代N的意思就是N和R的两个结点的值交换，转而变成删除R结点，R结点符合情况2或情况3，可以直接删除。
以上四种情况其实是三种情况，情况1可以当成2或3处理。以cur是parent的左/右孩子为删除后的连接做判断依据。若只知道cur的左/右孩子是否为空，直接与父结点连接的话，会不知道是父亲的左孩子还是右孩子做连接：
cur的左孩子为空：若cur是父亲的右结点，则让父亲的右孩子指向cur的右孩子；若cur是父亲的左结点，则让父亲的左孩子指向cur的右孩子。
cur的右孩子为空：若cur是父亲的左结点，则让父亲的左孩子指向cur的左孩子；若cur是父亲的右结点，则让父亲的右孩子指向cur的左孩子。
cur的左右孩子都不为空：统一找右子树的最小结点（minRight）吧。这么看minRight一定是pMinRight的左边，但是实际不是的。
bool Erase(const K& key)
{
Node* parent = nullptr;
Node* cur = _root;
while (cur)
{
if (cur->_key > key)
{
parent = cur;
cur = cur->_left;
}
else if (cur->_key < key)
{
parent = cur;
cur = cur->_right;
}
else
{
// 准备删除，三种情况
if (cur->_left == nullptr)
{
if (parent->_left == cur)
{
parent->_left = cur->_right;
}
else
{
parent->_right = cur->_right;
}
delete cur;
}
else if (cur->_right == nullptr)
{
if (parent->_left == cur)
{
parent->_left = cur->_left;
}
else
{
parent->_right = cur->_left;
}
delete cur;
}
else
{
// cur左右孩子都不为空
Node* pminRight = nullptr;
Node* minRight = cur->_right;
while (minRight->_left)
{
pminRight = minRight;
minRight = minRight->_left;
}
swap(minRight->_key, cur->_key);
pminRight->_left = minRight->_right;
delete minRight;
}
return true;
}
}
return false;
}
当前代码还有一些问题，情况4样例中删除3是没有问题的，但是删除8就会有问题了。会出现对空指针的解引用pminRight->_left。
两个特殊处理：
1、情况4，当删除的结点是根结点且minRight的左孩子为空时，循环没进去，那么minRight就是最左结点，此时minRight的父亲就是cur，即Node* pminRight = cur;。
2、我们理所当然地认为minRight就是其父结点的左孩子，但是这里循环没进去，minRight却是其父结点的右孩子。需要加个判断。
还会有一个问题，只不过这个问题不容易被发现，直接说结论。这个错误怎么测试出来呢？把几种删除的情况都测试到位，问题一定会出现，代码最后会崩掉。
int main()
{
t.Erase(8);
t.InOrder();
t.Erase(14);
t.InOrder();
t.Erase(3);
t.InOrder();
for (auto e : a)
{
t.Erase(e);
t.InOrder();
}
return 0;
}
错误原因：当要删除的结点为根结点，且这个根结点的左孩子为空时。由于根结点没有父结点，就会发生对空指针的解引用，这时应该让_root指向cur的右孩子。同理，当要删除的结点为根结点，且这个根结点的右孩子为空时也是同样的思路。
两种写法都可以，但是推荐第二种，逻辑更自洽，因为根结点没有父亲：
//if (parent == nullptr)
if (_root == cur)
{}
bool Erase(const K& key)
{
Node* parent = nullptr;
Node* cur = _root;
while (cur)
{
if (cur->_key > key)
{
parent = cur;
cur = cur->_left;
}
else if (cur->_key < key)
{
parent = cur;
cur = cur->_right;
}
else
{
// 准备删除，三种情况
if (cur->_left == nullptr)
{
//if (parent == nullptr)
if (_root == cur)
{
_root = cur->_right;
}
else
{
if (parent->_left == cur)
{
parent->_left = cur->_right;
}
else
{
parent->_right = cur->_right;
}
}
delete cur;
}
else if (cur->_right == nullptr)
{
if (cur == _root)
{
_root = cur->_left;
}
else
{
if (parent->_left == cur)
{
parent->_left = cur->_left;
}
else
{
parent->_right = cur->_left;
}
}
delete cur;
}
else
{
// cur左右孩子都不为空
Node* pminRight = cur;
Node* minRight = cur->_right;
while (minRight->_left)
{
pminRight = minRight;
minRight = minRight->_left;
}
swap(minRight->_key, cur->_key);
if (pminRight->_left == minRight)
{
pminRight->_left = minRight->_right;
}
else
{
pminRight->_right = minRight->_right;
}
delete minRight;
}
return true;
}
}
return false;
}
六、拓展：二叉搜索树的拷贝构造、析构、赋值运算符重载。
析构函数本身没有参数，不方便走递归。调用后序遍历析构。
~BSTree()
{
Destroy(_root);
_root = nullptr;
}
void Destroy(Node* root)
{
if (root == nullptr)
{
return;
}
Destroy(root->_left);
Destroy(root->_right);
delete root;
}
浅拷贝运行时（此时还没有自己写析构）没有问题：
但在自己写完析构函数后再运行，程序崩溃了。同一块空间二次析构了，所以必须自己写深拷贝。
若不写深拷贝，直接新建一棵树再遍历原来的树把结点插入呢？但是同一棵树的遍历方式（前/中/后序遍历）不同就会导致插入值的顺序不同，插入值的顺序不同就会导致拷贝初始化出来的二叉搜索树与原来的树的形状不一样。
前序递归的拷贝结点（深拷贝）：
BSTree(const BSTree<K>& t)
{
_root = Copy(t._root);
}
Node* Copy(Node* root)
{
if (root == nullptr)
return nullptr;
Node* copy = new Node(root->_key);
copy->_left = Copy(root->_left);
copy->_right = Copy(root->_right);
return copy;
}
但是写完拷贝构造后，默认的构造函数就不能自动生成了，因为自己实现了一个构造，拷贝构造也是一种构造。可以写一个空的构造或者用C++11的关键字default（默认），强制生成的作用，这里就是默认的构造函数没有自动生成，default强制让它生成。
BSTree() = default;
//BSTree()
//{}
赋值运算符重载：
BSTree<K>& operator=(BSTree<K> t)
{
swap(_root, t._root);
return *this;
}
补充：类模板的类名不能作为类型，例如BSTree t;，必须带上模板参数才能是类型BSTree<int> t;，但是在类里面可以不带模板参数，算是一种特殊处理，库里面很多都是这样写的。但是建议还是带上模板参数，因为从语法的角度看更健全。
template<class K>
class BSTree
{
// ...
public:
// ...
//BSTree(const BSTree<K>& t)
BSTree (const BSTree& t)
{// ...}
//BSTree<K>& operator=(BSTree<K> t)
BSTree& operator=(BSTree t)
{// ...}
// ...
};
二叉搜索树的实现代码
// BinarySearchTree.h
namespace key
{
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() = default;
//BSTree()
//{}
BSTree(const BSTree<K>& t)
//BSTree(const BSTree& t)
{
_root = Copy(t._root);
}
BSTree<K>& operator=(BSTree<K> t)
//BSTree& operator=(BSTree t)
{
swap(_root, t._root);
return *this;
}
Node* Copy(Node* root)
{
if (root == nullptr)
return nullptr;
Node* copy = new Node(root->_key);
copy->_left = Copy(root->_left);
copy->_right = Copy(root->_right);
return copy;
}
~BSTree()
{
Destroy(_root);
_root = nullptr;
}
void Destroy(Node* root)
{
if (root == nullptr)
{
return;
}
Destroy(root->_left);
Destroy(root->_right);
delete root;
}
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->_left;
}
else if (cur->_key < key)
{
parent = cur;
cur = cur->_right;
}
else
{
return false;
}
}
cur = new Node(key);
if (key > parent->_key)
{
parent->_right = cur;
}
else
{
parent->_left = cur;
}
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* parent = nullptr;
Node* cur = _root;
while (cur)
{
if (cur->_key > key)
{
parent = cur;
cur = cur->_left;
}
else if (cur->_key < key)
{
parent = cur;
cur = cur->_right;
}
else
{
// 准备删除，三种情况
if (cur->_left == nullptr)
{
//if (parent == nullptr)
if (_root == cur)
{
_root = cur->_right;
}
else
{
if (parent->_left == cur)
{
parent->_left = cur->_right;
}
else
{
parent->_right = cur->_right;
}
}
delete cur;
}
else if (cur->_right == nullptr)
{
if (cur == _root)
{
_root = cur->_left;
}
else
{
if (parent->_left == cur)
{
parent->_left = cur->_left;
}
else
{
parent->_right = cur->_left;
}
}
delete cur;
}
else
{
// cur左右孩子都不为空
Node* pminRight = cur;
Node* minRight = cur->_right;
while (minRight->_left)
{
pminRight = minRight;
minRight = minRight->_left;
}
swap(minRight->_key, cur->_key);
if (pminRight->_left == minRight)
{
pminRight->_left = minRight->_right;
}
else
{
pminRight->_right = minRight->_right;
}
delete minRight;
}
return true;
}
}
return false;
}
void InOrder()
{
_InOrder(_root);
cout << endl;
}
private:
void _InOrder(Node* root)
{
if (root == nullptr)
{
return;
}
_InOrder(root->_left);
cout << root->_key << " ";
_InOrder(root->_right);
}
private:
Node* _root = nullptr;// 缺省值初始化
};
}
七、二叉搜索树的应用
二叉搜索树key和key/value使用场景
1、key搜索场景
只有key作为关键码，结构中只需要存储key即可，关键码即为需要搜索到的值，key搜索场景只需要判断key在不在。key的搜索场景实现的二叉树搜索树支持增删查，但是不支持修改，修改key就破坏搜索树结构了，我们刚刚写的二叉搜索树的实现代码就是key搜索场景，这也是为什么刚刚没有实现删除算法的原因。
场景1：小区无人值守车库，小区车库买了车位的业主，他的车才能进小区，那么物业会把买了车位的业主的车牌号录入后台系统，车辆进入时扫描车牌在不在系统中，在则抬杆，不在则提示非本小区车辆，无法进入。
场景2：检查一篇英文章单词拼写是否正确，将词库中所有单词放入二叉搜索树，读取文章中的单词，查找是否在二叉搜索树中，不在则波浪线标红提示。
2、key/value搜索场景
用命名空间隔离key搜索场景与key_value搜索场景。key_value结构就增加一个模板参数V，其他地方都不变。删除算法只与key有关，与value无关。查找算法几乎没怎么改变。
每一个关键码key，都有与之对应的值value，value可以任意类型对象。树的结构中(结点)除了需要存储key还要存储对应的value，增/删/查还是以key为关键字走二叉搜索树的规则进行比较，可以快速查找到key对应的value。key/value的搜索场景实现的二叉树搜索树支持修改，但是不支持修改key，修改key破坏搜索树性质了，可以修改value。
- 场景1：简单中英互译字典，树的结构中(结点)存储key(英文)和vlaue(中文)，搜索时输入英文，则同时查找到了英文对应的中文。
int main()
{
key_value::BSTree<string, string> dict;
//BSTree<string, string> copy = dict;
dict.Insert("left", "左边");
dict.Insert("right", "右边");
dict.Insert("insert", "插⼊");
dict.Insert("string", "字符串");
string str;
while (cin >> str)
{
auto ret = dict.Find(str);// 返回结点
if (ret)
{
cout << "->" << ret->_value << endl;
}
else
{
cout << "无此单词，请重新输入" << endl;
}
}
return 0;
}
场景2：商场无人值守车库，入口进场时扫描车牌，记录车牌（key）和入场时间（value），出口离场时，扫描车牌，查找入场时间，用当前时间-入场时间计算出停车时长，计算出停车费用，缴费后抬杆，车辆离场。（这种场景实际用数据库实现，因为要长期存储。若用搜索树实现是存储在内存中的，遇到系统/程序崩溃会重启，数据都不存在了，这里就用搜索树实现一个简单临时的。）
大概过程：BSTree<string，Date>（车牌号，时间），这个时间要比之前我们实现的更复杂，加上时分秒。
车辆进入：Insert(“闽B 00001”, 入场时间);
车辆出库：Node* ret = Find(“闽B 00001”);
出场时间 - ret->value 得出停车的时间场景3：统计一篇文章中单词出现的次数，读取一个单词，查找单词是否存在，不存在说明这个单次是第一次出现，（单词，1），单词存在，则++单词对应的次数。统计水果出现的次数：
BSTree<string，int>
int main()
{
string arr[] = { "苹果", "西瓜", "苹果", "西瓜", "苹果", "苹果", "西瓜", "苹果", "香蕉", "苹果", "香蕉" };
key_value::BSTree<string, int> countTree;
for (const auto& str : arr)
{
// 先查找⽔果在不在搜索树中
// 1、不在，说明⽔果第⼀次出现，则插⼊<⽔果, 1>
// 2、在，则查找到的结点中⽔果对应的次数++
// 不能用Node*，因为它是私有的，类外面不能用，改成公有的就能用了。类型写全或者在知道类型的情况下用auto。
//key_value::BSTreeNode<string, int>* ret = countTree.Find(str);
auto ret = countTree.Find(str);
if (ret == NULL)
{
countTree.Insert(str, 1);
}
else
{
ret->_value++;
}
}
countTree.InOrder();
return 0;
}
key/value二叉搜索树的代码实现
namespace key_value
{
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:
BSTree() = default;
//BSTree()
//{}
BSTree(const BSTree<K, V>& t)
//BSTree(const BSTree& t)
{
_root = Copy(t._root);
}
BSTree<K, V>& operator=(BSTree<K, V> t)
//BSTree& operator=(BSTree t)
{
swap(_root, t._root);
return *this;
}
Node* Copy(Node* root)
{
if (root == nullptr)
return nullptr;
Node* copy = new Node(root->_key, root->_value);
copy->_left = Copy(root->_left);
copy->_right = Copy(root->_right);
return copy;
}
~BSTree()
{
Destroy(_root);
_root = nullptr;
}
void Destroy(Node* root)
{
if (root == nullptr)
{
return;
}
Destroy(root->_left);
Destroy(root->_right);
delete root;
}
bool Insert(const K& key, const V& value)
{
if (_root == nullptr)
{
_root = new Node(key, value);
return true;
}
Node* cur = _root;
Node* parent = nullptr;
while (cur)
{
if (cur->_key > key)
{
parent = cur;
cur = cur->_left;
}
else if (cur->_key < key)
{
parent = cur;
cur = cur->_right;
}
else
{
return false;
}
}
cur = new Node(key, value);
if (key > parent->_key)
{
parent->_right = cur;
}
else
{
parent->_left = cur;
}
return true;
}
Node* 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 cur;
}
}
return nullptr;
}
bool Erase(const K& key)
{
Node* parent = nullptr;
Node* cur = _root;
while (cur)
{
if (cur->_key > key)
{
parent = cur;
cur = cur->_left;
}
else if (cur->_key < key)
{
parent = cur;
cur = cur->_right;
}
else
{
// 准备删除，三种情况
if (cur->_left == nullptr)
{
//if (parent == nullptr)
if (_root == cur)
{
_root = cur->_right;
}
else
{
if (parent->_left == cur)
{
parent->_left = cur->_right;
}
else
{
parent->_right = cur->_right;
}
}
delete cur;
}
else if (cur->_right == nullptr)
{
if (cur == _root)
{
_root = cur->_left;
}
else
{
if (parent->_left == cur)
{
parent->_left = cur->_left;
}
else
{
parent->_right = cur->_left;
}
}
delete cur;
}
else
{
// cur左右孩子都不为空
Node* pminRight = cur;
Node* minRight = cur->_right;
while (minRight->_left)
{
pminRight = minRight;
minRight = minRight->_left;
}
swap(minRight->_key, cur->_key);
if (pminRight->_left == minRight)
{
pminRight->_left = minRight->_right;
}
else
{
pminRight->_right = minRight->_right;
}
delete minRight;
}
return true;
}
}
return false;
}
void InOrder()
{
_InOrder(_root);
cout << endl;
}
private:
void _InOrder(Node* root)
{
if (root == nullptr)
{
return;
}
_InOrder(root->_left);
cout << root->_key << ":" << root->_value << endl;
_InOrder(root->_right);
}
private:
Node* _root = nullptr;// 缺省值初始化
};
}