目录
[3.1 中序遍历](#3.1 中序遍历)
[3.2 插入](#3.2 插入)
[3.3 查找](#3.3 查找)
[3.4 删除](#3.4 删除)
[4.1 key搜索场景](#4.1 key搜索场景)
[4.2 key/value搜索场景](#4.2 key/value搜索场景)
[4.3 key_value结构的实现](#4.3 key_value结构的实现)
[4.4 拷贝构造和析构](#4.4 拷贝构造和析构)
由于 map 和 set 的底层是红黑树 ，包括后面要讲的 AVL 树 (平衡二叉搜索树)，为了方便理解，我们先来讲解二叉搜索树，因为红黑树和 AVL 树都是在二叉搜索树的前提下实现的。
1、二叉搜索树的概念
二叉搜索树又称二叉排序树，它或者是一棵空树，或者是具有以下性质的二叉树：
- 若它的左子树不为空，则左子树上所有结点的值都小于等于根结点的值
- 若它的右子树不为空，则右子树上所有结点的值都大于等于根结点的值
- 它的左右子树也分别为二叉搜索树
⼆叉搜索树中可以支持插入相等的值，也可以不支持插人相等的值，具体看使用场景定义，后续我们学习 map / set / multimap / multiset 系列容器底层就是二叉搜索树，其中 map / set 不之持插入相等值，multimap / multiset 支持插如相等值。
2、二叉搜索树的性能分析
二叉搜索树最多查找高度次。因此二叉搜索树的性能取决的树的高度。
- 最优情况下，二叉搜索树为完全⼆叉树(或者接近完全⼆叉树)，其高度为： log2 N
- 最差情况下，⼆叉搜索树退化为单⽀树(或者类似单⽀)，其⾼度为： N
所以综合而言二叉搜索树增删查改时间复杂度为： O (N)
那么这样的效率显然是无法满足我们需求的，我们后续需要继续讲解⼆叉搜索树的变形，平衡二叉搜索树( AVL 树)和红黑树，才能适用于我们在内存中存储和搜索数据。
另外需要说明的是，二分查找 也可以实现 O (log2 N) 级别的查找效率，但是二分查找有两大缺陷：
需要存储在支持下标随机访问的结构中，并且有序。
插入和删除数据效率很低，因为存储在下标随机访问的结构中，插入和删除数据一般需要挪动数据。
这里也就体现出了平衡⼆叉搜索树的价值。
3、二叉搜索树的实现
首先我们要管理每个节点的数据以及它的左右孩子，所以我们先封装一个树节点类，用来管理节点的数据和左右孩子，其次我们要把每个树节点统一管理，所以还需要再封装一个树类，用来管理所有节点。
cpp
template<class K>
struct BSTreeNode
{
BSTreeNode(const K& key)
:_key(key)
,_left(nullptr)
,_right(nullptr)
{}
K _key;
BSTreeNode<K>* _left;
BSTreeNode<K>* _right;
};
template<class K>
class BSTree
{
//typedef BSTreeNode<K> Node;
using Node = BSTreeNode<K>;
public:
private:
Node* _root = nullptr;
};3.1 中序遍历
因为 _root 是私有成员，所以我们可以这样多套一层调用。
cpp
void Inorder()
{
_Inorder(_root);
cout << endl;
}
void _Inorder(const node* root)
{
if (root == nullptr)
{
return;
}
_Inorder(root->left);
cout << root->_key << " ";
_Inorder(root->right);
}
3.2 插入
插入的具体过程如下：
- 树为空，则直接新增结点，赋值给 root 指针
- 树不空，按二叉搜索树性质，插入值比当前结点大往右走，插入值比当前结点小往左左，找到空位置，插入新结点。
- 如果支持插入相等的值，插入值跟当前结点相等的值可以往右走，也可以往左走，找到空位置，插入新结点。（要注意的是要保持逻辑⼀致性，插入相等的值不要⼀会往右走，⼀会往左走）
cpp
bool Insert(const k& x)
{
if (_root == nullptr)//插入根节点
{
_root = new node(x);
return true;
}
node* cur = _root;
node* parent = nullptr;//记录父亲节点
while (cur)
{
//介质不冗余
/*if (x < cur->_key)
{
parent = cur;
cur = cur->left;
}
else if (x > cur->_key)
{
parent = cur;
cur = cur->right;
}
else
{
return false;
}*/
//介质冗余
if (x <= cur->_key)//相等插入左子树
{
parent = cur;
cur = cur->left;
}
else if (x > cur->_key)
{
parent = cur;
cur = cur->right;
}
}
if (x > parent->_key)
{
parent->right = new node(x);
}
else//相等插入左子树
{
parent->left = new node(x);
}
return true;
}
3.3 查找
查找的具体过程如下：
- 从根开始比较，查找 x，x 比根的值大则往右边走查找，x 比根值小则往左边走查找。
- 最多查找高度次，走到空，还没找到，这个值不存在。
- 如果不支持插入相等的值，找到 x 即可返回
- 如果支持插入相等的值，意味着有多个 x 存在，一般要求查找中序的第一个 x。
cpp
bool Find(const k& x)
{
node* cur = _root;
while (cur)
{
if (x < cur->_key)//节点在左子树
{
cur = cur->left;
}
else if (x > cur->_key)//节点在右子树
{
cur = cur->right;
}
else
{
return true;//找到target
}
}
return false;
}
3.4 删除
首先查找元素是否在二叉搜索树中，如果不存在，则返回 false。
如果查找元素存在则分以下四种情况分别处理：（假设要删除的结点为 N）
- 要删除结点 N 的左右孩子均为空
- 要删除的结点 N 的左孩子为空，右孩子结点不为空
- 要删除的结点 N 的右孩子为空，左孩子结点不为空
- 要删除的结点 N 的左右孩子结点均不为空
如果删除根节点直接修改 _root，再删除节点即可。
cpp
bool Erase(const k& x)
{
node* cur = _root;
node* parent = nullptr;
while (cur)
{
if (x < cur->_key)
{
parent = cur;
cur = cur->left;
}
else if (x > cur->_key)
{
parent = cur;
cur = cur->right;
}
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;
return true;
}
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;
return true;
}
else
{
// 策略：找右子树的最小节点（最左节点）作为替代节点
node* replaceparent = cur; // 替代节点的父节点，初始化为待删除节点，防止进不去循环
node* replace = cur->right; // 替代节点初始化为待删除节点的右孩子
while (replace->left)//寻找右子树的最小节点
{
replaceparent = replace;
replace = replace->left;
}
cur->_key = replace->_key;// 用替代节点的键值覆盖待删除节点的键值
// 处理替代节点的连接：替代节点只有右子树（或为空）
// 判断替代节点是其父节点的左/右孩子
if (replace == replaceparent->left)
{
replaceparent->left = replace->right;
}
else
{
replaceparent->right = replace->right;
}
delete replace;
return true;
}
}
}
return false;
}
4、二叉搜索树key和key/value结构
4.1 key搜索场景
只有 key 作为关键码，结构中只需要存储 key 即可，关键码即为需要搜索到的值，搜索场景只需要判断 key 在不在。key 的搜索场景实现的二叉树搜索树支持增删查，但是不支持修改，修改 key 破坏搜索树结构了。
- 场景1：小区无人值守车库，小区车库买了车位的业主车才能进小区，那么物业会把买了车位的业主的车牌号录入后台系统，车辆进入时扫描车牌在不在系统中，在则抬杆，不在则提示非本小区车辆，无法进入。
- 场景2：检查一篇英文章单词拼写是否正确，将词库中所有单词放入二叉搜索树，读取文章中的单 词，查找是否在二叉搜索树中，不在则波浪线标红提示
4.2 key/value搜索场景
每一个关键码 key，都有与之对应的值 value，即 <key, value> ，value 可以是任意类型对象。树的结构中(结点)除了需要存储 key 还要存储对应的 value，增/删/查还是以 key 为关键字走二叉搜索树的规则进行比较，可以快速查找到 key 对应的 value。key/value 的搜索场景实现的二叉树搜索树支持修改，但是不支持修改 key，修改 key 破坏搜索树性质了，可以修改 value。
- 场景1：简单中英互译字典，树的结构中(结点)存储 key (英⽂)和 vlaue (中文)，搜索时输入英文，则同时查找到了英文对应的中文。
- 场景2：商场无人值守车库，入口进场时扫描车牌，记录车牌和入场时间，出口离场时，扫描车牌，查找入场时间，⽤ 当前时间 - 入场时间 计算出停车时长，计算出停车费用，缴费后抬杆，车辆离场。
- 场景3：统计⼀篇文章中单词出现的次数，读取⼀个单词，查找单词是否存在，不存在这个说明第⼀次出现，（单词，1），单词存在，则 ++单词对应的次数。
4.3 key_value结构的实现
结构的定义：
cpp
//key_value结构
template<class k, class v>
struct BSTNode
{
using node = BSTNode<k, v>;
k _key;
v _value;
node* left;
node* right;
BSTNode(const k& key, const v& value)
:_key(key)
, _value(value)
, left(nullptr)
, right(nullptr)
{}
};
template<class k, class v>
class BSTree
{
using node = BSTNode<k, v>;
public:
private:
node* _root = nullptr;
};查找和删除：逻辑不需要改变。但是如果想知道查找的节点的 value 可以返回节点指针。同时如果允许介质冗余的话，那就需要查找中序的第一个，所以我们相同值时，先保留，继续去左子树查找即可。
插入：只需要多插入一个 value 值即可，逻辑不变。
cpp
bool Insert(const k& x, const v& v)
{
if (_root == nullptr)//插入根节点
{
_root = new node(x, v);
return true;
}
node* cur = _root;
node* parent = nullptr;//保留父亲节点
while (cur)
{
/*介质不冗余*/
if (x < cur->_key)
{
parent = cur;
cur = cur->left;
}
else if (x > cur->_key)
{
parent = cur;
cur = cur->right;
}
else
{
return false;
}
//介质冗余
//if (x <= cur->_key)//相等插入到左子树
//{
// parent = cur;
// cur = cur->left;
//}
//else if (x > cur->_key)
//{
// parent = cur;
// cur = cur->right;
//}
}
if (x > parent->_key)
{
parent->right = new node(x, v);
}
else//相等插入左子树
{
parent->left = new node(x, v);
}
return true;
}
4.4 拷贝构造和析构
我们这里还要显式实现一下拷贝构造和析构，因为这里需要深拷贝资源，且在析构时要把每个 new 出来的树节点都要释放掉。
拷贝构造就直接 new 构造根节点，再让根节点连接递归构造的左右子树即可。注意如果按照插入的思路构造，那就必须是层序遍历节点插入，否则拷贝出来的子树就不一样。
cpp
BSTree(const BSTree<k,v>& x)
{
_root = Copy(x._root);
}
node* Copy( node* x)
{
if (x == nullptr)
{
return x;
}
node* root = new node(x->_key, x->_value);
root->left =Copy(x->left);
root->right = Copy(x->right);
return root;
}析构：这里先析构左右子树在析构根节点即可。
cpp
void Destory(const node* root)
{
if (root == nullptr)
{
return ;
}
Destory(root->left);
Destory(root->right);
delete root;
}
~BSTree()
{
Destory(_root);
_root = nullptr;
}赋值重载：这里先拷贝 tmp，然后交换 _root 指针，函数结束后析构 tmp 空间。
cpp
BSTree<k, v>& operator = (BSTree<k, v> tmp)
{
swap(_root,tmp._root);
return *this;
}
