目录
我们在最开始学习二叉树的时候，最开始接触的就是堆，但那个结构上并不是真正的二叉树，后来又借助链表实现了真正的结构上的二叉树，二叉树不仅仅只是在OJ题上刁难我们，其实当实现了一定的节点逻辑之后，也可以形成效率极高的数据结构，这个二叉树就是搜索二叉树。
搜索二叉树概念
对于一颗搜索二叉树来说，它的节点内存储的值遵循如下的规则
- 右子树节点的值一定大于当前节点的值
- 左子树节点的值一定小于当前节点的值
而对于其结构来说
- 搜索二叉树不允许已存在于二叉树内部的值再次插入
- 搜索二叉树的左右子树也必须是搜索二叉树
- 数据插入的顺序不同，搜索二叉树的形状也会不同
这样的结构让搜索二叉树的效率在平衡的情况下效率变得非常的高
- 最优情况下，二叉搜索树为完全二叉树(或者接近完全二叉树)，其平均比较次数为：log_2 N
但是当插入数据是有序的时候，搜索二叉树会退化成单叉树
- 最差情况下，二叉搜索树退化为单支树(或者类似单支)，其平均比较次数为：N
其整体的树结构以及逻辑就差不多如上所述了，接下来就是模拟实现。
模拟实现搜索二叉树
插入函数实现
首先先定义一下节点的结构，我们加入模板。
template<class K>
struct BSNode
{
BSNode<K>* _left;
BSNode<K>* _right;
K _key;
BSNode(K val = K())
:_left(nullptr)
, _right(nullptr)
, _key(val)
{}
};接着我们实现插入函数，逻辑并不困难，总结如下：
- 树为空，则直接新增节点，赋值给root指针
- 树不空，按二叉搜索树性质查找插入位置，插入新节点
- 插入有成功与失败一说，假如插入的值已存在于树内，则插入失败
- 以K值为判定条件插入左子树或者右子树，比K大插右子树，比K小插左子树
- 需要额外创建一个父节点来链接节点。
//以K值为判定条件插入左子树或者右子树，比K大插右子树，比K小插左子树
//若遇到相等的，插入失败，不插
bool Insert(const K& val)
{
if (_root == nullptr)
{
_root = new Node(val);
return true;
}
Node* cur = _root;
Node* parent = cur;
while (cur)
{
//比K小，往左子树走
if (val < cur->_key)
{
parent = cur;
cur = cur->_left;
}
//比K大，往右子树走
else if (val > cur->_key)
{
parent = cur;
cur = cur->_right;
}
//相等，插入不了，返回一个false
else
{
return false;
}
}
//跳出while时，也就是遇到空了，新建一个节点赋值然后链接节点
if (parent->_key < val)
parent->_right = new Node(val);
else if (parent->_key > val)
parent->_left = new Node(val);
return true;
}插入函数实现（递归）
二叉树的插入也可以是递归，毕竟二叉树的结构本身就适合递归
递归的逻辑：
- 终止条件：遇到了空，那么就是到位了，或者说一个空节点,创建节点准备链接
- 本次递归应该做的事：检查当前插入的值是否大于K，大于走右树，小于走左树
- 返回的信息：同循环版本，返回true Or false
但是这里有个问题，想要在类内部实现递归轻而易举，直接传递根节点即可，但是它的访问限定符是私有，这意味着我们无法在类外部调用这个递归插入，所以我们还需要额外实现一个GetRoot或者是私有的内嵌递归函数来获取到根。
其中，传递的形参必须是引用，因为递归的栈帧问题，要 是想要在递归的途中链接节点之间的指针，还需要额外的parent的节点，但会让程序变得冗杂，一个引用则可以非常巧妙地解决问题，因为正好上一层传递下来的引用就是父节点的别名，直接链接即可。
同样的，借助二级指针也是可以实现的，但是完全比不上引用。
bool InsertR(const K& val)
{
return _InsertR(_root, val);
}
private:
bool _InsertR(Node*& root,const K& val)
{
//假如走到了空，那么就是到位了，或者是一个空树,创建节点准备链接
if (root == nullptr)
{
root = new Node(val);
return true;
}
//大于，向右走
if (val > root->_key)
return _InsertR(root->_right, val);
else if (val < root->_key)
return _InsertR(root->_left, val);
else
return false;
}查找函数实现
查找的逻辑同插入没什么区别，也可以实现递归版本，在这里就不列出逻辑了。
//查找函数，找到了返回true，找不到返回false
bool Find(const K& val)
{
Node* cur = _root;
while (cur)
{
//大于就向右边找
if (val > cur->_key)
cur = cur->_right;
//小于就向左边查找
else if (val < cur->_key)
cur = cur->_left;
//相等就找着了
else
return true;
}
//没找着
return false;
}删除函数实现
删除的情况较多且有些复杂，逻辑如下：
删除有三种情况
- 删一个有孩子的节点，若其左为空，把右边给父节点，
- 若右边为空，则把左边的孩子给父节点
- 删一个带有多个孩子的节点，比较复杂,需要替换删除，期间也需要注意删除根的情况,找右子树的最小节点，也就是右子树的最左边的节点与被删除的节点交换，然后删去右子树最左节点。
情况1,2 示意图
情况3示意图,图中示意为替换法逻辑，还需要额外处理删除根节点的情况。
那么代码实现如下
bool erase(const K& val)
{
Node* cur = _root;
Node* parent = nullptr;
while (cur)
{
if (val > cur->_key)
{
parent = cur;
cur = cur->_right;
}
else if (val < cur->_key)
{
parent = cur;
cur = cur->_left;
}
//相等就找到了，找到后进行删除
else
{
//左孩子为空,右孩子为空，以及左右都不为空,其中这三种情况下，还需要特殊处理删除根节点的时候
//其中只有一个孩子的情况下，只需要托孤即可
if (cur->_left == nullptr)
{
//如果左孩子为空，那么先判断一下是不是根节点。
if (cur == _root)
{
//是根节点，直接让cur-的右边做根
_root = cur->_right;
}
//删的不是根，直接托孤给parent
else
{
//需要被托孤的是到
if (parent->_left == cur)
parent->_left = cur->_right;
else
parent->_right = cur->_right;
}
delete cur;
cur = nullptr;
}
//有左孩子，没右孩子
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;
cur = nullptr;
}
//左右孩子都不是空，需要替换删除，期间也需要注意删除根的情况
else
{
//找右子树的最小节点，也就是右子树的最左边
//先找最小值，有根判根
//留一个parent，以防止min后面还有节点
Node* minparent = cur;
Node* min = cur->_right;
while (min->_left)
{
minparent = min;
min = min->_left;
}
cur->_key = min->_key;
//给完跟在删除min之前还要把min后面的节点都街上
if (minparent->_left == min)
minparent->_left = min->_right;
else
minparent->_right = min->_right;
delete min;
min = nullptr;
}
return true;
}
}
//没找着
return false;
}删除函数实现（递归）
主体逻辑同循环版本差不太多，需要注意的是替换法删除的部分，可以很巧妙的再次调用一次递归去删除被替换的节点。
bool _earseR(Node*& root, const K& val)
{
if (root == nullptr)
return false;
if (root->_key > val)
{
return _earseR(root->_left, val);
}
else if(root->_key < val)
{
return _earseR(root->_right, val);
}
else//找到了
{
//叶子节点无需特殊处理，在处理单子树的过程中顺带解决了
//没有左孩子,那么一定有右孩子,直接链接右孩子到父节点,这种情况是根节点的完全没有左子树，也就是直接更新根
//用一个节点保存前根，
Node* del = root;
if (root->_left == nullptr)
{
root = root->_right;
}
else if (root->_right == nullptr)
{
root = root->_left;
}
else//交换，但是走的是递归，可以很巧妙的交换两个节点的值，然后再走递归去删掉替死鬼。
{
Node* min = root->_right;
while (min->_left)
min = min->_left;
swap(root->_key, min->_key);
return _earseR(root->_right, val);
}
delete del;
del = nullptr;
return true;
}
}
Node* _root = nullptr;
};中序遍历实现
这块就没啥好说的，除了记得需要额外内嵌一个递归函数。
void InOrder()
{
Node* root = GetRoot();
_inorder(root);
}
void _inorder(Node* _root)
{
if (_root == nullptr)
{
return;
}
_inorder(_root->_left);
cout << _root->_key << " ";
_inorder(_root->_right);
}拷贝构造函数实现
由于搜索二叉树的插入顺序会对形状产生影响，我们使用递归来对其节点挨个拷贝。
//拷贝构造
//拷贝构造走一个前序遍历构建，走一个递归。每前序遍历一个节点就新建一个节点
BSTree(const BSTree<K>& t2)
{
_root = Copy(t2._root);
}
// 1.终止条件?走到空结束
// 2.这次递归应该完成的任务？创建节点，
// 3.返回的信息？返回节点的指针，空反指针并将节点链接起来
//
Node* Copy(Node* root)
{
if (root == nullptr)
return nullptr;
//这层的任务，新建节点。
Node* newRoot = new Node(root->_key);
newRoot->_left = Copy(root->_left);
newRoot->_right = Copy(root->_right);
return newRoot;
}析构函数实现
//析构函数
~BSTree()
{
Destory();
_root = nullptr;
}
//销毁
void Destory()
{
while (_root)
erase(_root->_key);
}
赋值重载
同vector一样，我们使用摇人打工法实现赋值重载。
BSTree<K>& operator = (const BSTree<K> t)
{
if (t == this)
return *this;
swap(_root, t._root);
return *this;
}那么以上就是一个具有最基本功能的搜索二叉树了，接下来我们尝试实现一下其KV结构。
KV结构，也就是类似于Pair的结构，一个Key绑定对应的Val，通过对比Key来找到对应的Val。
template<class K, class V>
class KVTree
{
public:
typedef KVNode<K,V> Node;
bool Insert(const K& key,const V& val)
{
if (_root == nullptr)
{
_root = new Node(key,val);
return true;
}
Node* cur = _root;
Node* parent = cur;
while (cur)
{
//比K小，往左子树走
if (key < cur->_key)
{
parent = cur;
cur = cur->_left;
}
//比K大，往右子树走
else if (key > cur->_key)
{
parent = cur;
cur = cur->_right;
}
//相等，插入不了，返回一个false
else
{
return false;
}
}
//跳出while时，也就是遇到空了，新建一个节点赋值然后链接节点
if (parent->_key < key)
{
parent->_right = new Node(key,val);
}
else if (parent->_key > key)
{
parent->_left = new Node(key,val);
}
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;
}
void InOrder()
{
Node* root = GetRoot();
_inorder(root);
}
void _inorder(Node* _root)
{
if (_root == nullptr)
return;
_inorder(_root->_left);
cout << _root->_key << ":"<< _root->_val<<endl;
_inorder(_root->_right);
}
private:
Node* GetRoot()
{
return _root;
}
Node* _root = nullptr;
};
借助一个统计水果出现的次数来测试一下
void TextKVtree1()
{
KVTree<string, int> KV;
string str[] ={ "菠萝","荔枝","草莓","菠萝","菠萝" ,"西瓜" ,"草莓" ,"橙子" ,"荔枝" ,"牛油果" ,"西瓜" ,"西瓜" };
for (auto& e : str)
{
KVNode<string, int>* ret = KV.Find(e);
if (ret)
{
ret->_val++;
}
else
{
KV.Insert(e,1);
}
}
KV.InOrder();
}
如上就是一个二叉搜索树的基本实现
