二叉搜索树（KV模型，二叉搜索树删除节点）

1. 二叉搜索树概念

二叉搜索树又称二叉排序树，它或者是一棵空树，或者是具有以下性质的二叉树:
若它的左子树不为空，则左子树上所有节点的值都小于根节点的值
若它的右子树不为空，则右子树上所有节点的值都大于根节点的值
它的左右子树也分别为二叉搜索树

每个子树均满足这个特征。

他可以用来搜索，在我们以前怎么搜索呢，之前的数据结构不仅能存储数据，也能查找数据。最优搜索便是二分查找，但是二分查找前提必须有序，最快的一个排序也是n*logn，并且二分查找必须要在Vector中，头插，中间插，头删，中间删的挪动数据的复杂度也很高。他是一种华而不实的查找方式。而二叉搜索树是一个非常适合用于查找的结构，复杂度为（O（logN）-O(N）之间），最坏是找高度次，而且他天然的一个特性，中序遍历为有序。

2. 二叉搜索树的实现

2.1 插入

插入，大于就去右子树比较，小于就去左子树在比较。需要保证搜索树的性质。
怎么保证呢，我们维护两个节点，parent和cur，在每次走之前，parent保存这次的位置，当key大于当前节点，cur往右走，当key小于当前节点，cur往右走。不允许相等，假如相等直接返回false,cur一直走，当节点为空的时候，再拿key和parent节点的值进行比较，如果小于parent对应的值，则连接在左边，否则连接在右边。

插入的时间复杂度，最坏是O（N）,注意别和，完全二叉树和满二叉树搞混了，因为他可能是单支结构。

所以他不在极端情况下是比链表顺序表要优一些，但是极端情况也只是相同O（N）。所以基于搜索二叉树上又加了一层平衡，比较均匀高度就是可控的，平衡搜索二叉树接近O（logN），看做O(logN)

2.2 查找

明白了二叉搜索树的性质之后，查找也是容易了许多。

当前树不为空

只要给定值大于当前节点的值，往右走，小于当前节点的值往左走，等于就返回这个节点。

当前树为空
返回空值

时间复杂度
最坏与链表相同O（N），假如是优化后的平衡搜索二叉树近似于O(logN)

2.3 遍历

这里我们采用中序，因为它的性质给他带来一种天然的属性，中序遍历的时候是有序的。

左—根---右

这里有个编码的小tips，假如成员函数是递归函数，你要用到私有的成员变量。

但是你在main函数中，无法调用因为你访问不到，私有的root节点。

这时我们可以写一个函数获取root节点，但是这样不好看。我们将这个递归函数做再一次的封装。

这样就好看多了。

打印出来是有序的。

2.4 删除

首先查找元素是否在二叉搜索树中，如果不存在，则返回, 否则要删除的结点可能分下面四种情况：
a. 要删除的结点无孩子结点
b. 要删除的结点只有左孩子结点
c. 要删除的结点只有右孩子结点
d. 要删除的结点有左、右孩子结点(剩余节点)

2.5 被删除节点无孩子节点

2.6 被删除节点只有右孩子(左边为空)

假如要删头，就是一个右单枝二叉树

假如被删除节点是父亲的右节点，将被删除节点的右孩子连接父亲的右节点。

假如被删除节点是父亲的左节点，将被删除节点的右孩子连接至父亲的左节点

2.7 被删除节点只有左孩子（右边为空）

和左边为空的逻辑，一模一样。相对的需要注意左单枝二叉树

2.8 归纳

叶子节点就可以看做，左右为空的任意情况之一，在其中一并判断。

无论将它看做左为空，还是右为空，逻辑都是可以处理。

2.9 被删除节点，左右都不为空

首先这个节点删除不能影响它的性质，直接删除掉，后续的节点怎么连起来呢，很难处理。
所以我们思路得变成，在树中找一个合适的节点，将它覆盖掉。同时又可以保证它的性质不变。
经过研究，我们可以取，被删除节点的，左子树最大值或者右子树最小值。将要删除的节点覆盖。同时可以保证它的性质。

怎么找出左子树的最大值呢？

由于其子树也满足二叉搜索树的性质，所以就是左子树的最右节点。

为什么左子树最大值可以呢？

因为覆盖删除节点的值无非满足两个条件，第一，小于右孩子，第二，大于左孩子。

从左子树挑选，不会出现大于右孩子的（有就不是二叉搜索树了）肯定是小于右孩子的，满足条件1。
但是还要大于左孩子，就需要挑选左子树的最大值即最右节点，才能保证替换后的值大于左子树中的所有值。找到了最右节点，不管是不是叶子节点，他一定是一个右为空的节点（假如右边还有，那他就不是最右了）。

怎么找出右子树的最小值？

由于其子树也满足二叉搜索树的性质，所以就是右子树的最左节点。

为什么右子树的最小值可以呢？
两个条件，第一，小于右孩子，第二，大于左孩子。
从右子树选，一定大于左孩子，而且选的是最小值，所以一定小于右孩子。
同时选定的一定是一个左为空的节点。

示例1

删除6，以找右子树最小值（右子树的最左）为例。

当subMin->left为空停止

把subMin->_key赋值给cur->_key。

由于要删除，所以需要一个smParent,在他每次循环下去，判断其左是否为空时，保存他的上一个
这种情况下，smParent初始值为null没有问题，因为循环下去就会被重新赋值。

删除掉subMin,subMin左边一定为空，右边不一定，由于subMin是smParent的左，所以需要smParent的左连接subMin的右。

示例2

还有隐藏的一个问题，父亲节点不能声明为nullptr，在这种情况下

删除7，找7的右子树最小值。

由于一开始，subMin->left就等于nullptr，所以没有循环进入赋值。后面if语句里还对smParent进行了操作，空指针异常，所以smParent要声明为cur。

3 K模型与KV模型

搜索树，真正的作用是排序。它分为两种模型。
K搜索模型对应STL中的Set,他只有一个值
K-value搜索模型对应STL的map，它存储两个值。

3.1 K模型

K搜索模型，他用来查找“在不在”的问题，例如门禁，在刷卡期间，门禁机器识别你的学号，他就去查找存储结构中你的信息，从而判断。
而且还被用来做排序和去重，当中序的时候天然有序，重复的数据直接不插入

3.2 K模型搜索树实现代码

#include<iostream>
using namespace std;
#pragma once

//K,键值
template<class K>
struct BSTreeNode
{
	K _key;
	struct BSTreeNode<K>* _left;
	struct BSTreeNode<K>* _right;

	BSTreeNode(const K& k)
		:_key(k)
		,_left(nullptr)
		,_right(nullptr)
	{}
};

template<class K>
class BSTree
{
	typedef BSTreeNode<K> Node;
public:
    //插入
	bool Insert(const K& val)
	{
		if (_root == nullptr)
		{
			_root = new Node(val);
			return true;
		}
		Node* parent = nullptr;
		Node* cur = _root;
		while (cur)
		{
			if (val > cur->_key)
			{
				parent = cur;
				cur = cur->_right;
			}
			else if(val < cur->_key)
			{
				parent = cur;
				cur = cur->_left;
			}
			else
			{
				return false;
			}
		}
		//走到这，说明cur为空，parent为他的上一个节点。
		//确定了他的位置，开始和父亲比较，看放左边还是右边
		Node* newNode = new Node(val);
		if (val > parent->_key)
		{
			parent->_right = newNode;
		}
		else//不存在等于情况，等于的话在前面肯定返回false了
		{
			parent->_left = newNode;
		}

		return true;
	}
	//查找（K不允许修改）
	const Node* Find(const K& key)
	{
		Node* cur = root;
		while (cur)
		{

			if (key > cur->_key)
			{
				cur = cur->_right;
			}
			else if (key == cur->_key)
			{
				return cur;
			}
			else
			{
				cur = cur->_left;
			}
		}
		return nullptr;
	}


	//删除
	bool Erase(const K& val)
	{
		Node* parent = nullptr;
		Node* cur = _root;
		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)
					{
						_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)
					{
						cur->_left = _root;
					}
					else
					{
						if (parent->_left == cur)
						{
							parent->_left = cur->_left;
						}
						else
						{
							parent->_right = cur->_left;
						}
					}
					delete cur;
				}
				//两边都有节点
				//右子树最小值(最左)为例
				else
				{
					Node* cur = _root;
					Node* subMin = cur->_right;
					Node* smParent = cur;
					while (subMin->_left)
					{
						smParent = subMin;
						subMin = subMin->_left;
					}
					//覆盖
					cur->_key = subMin->_key;
					//子树的最左节点,父亲根据subMin在哪一边，连接他的右
					if (subMin == smParent->_left)
					{
						//subMin可以看做左为空
						//连上他的右
						smParent->_left = subMin->_right;
					}
					else
					{
						smParent->_right = subMin->_right;
					}
					delete subMin;
				}
				return true;
			}
		}
		return false;
		
	}
	
	//用来递归的子结构
	void _Inorder(Node* root)
	{
		if (root == nullptr)
			return;

			_Inorder(root->_left);
		    cout << root->_key<<" ";
			_Inorder(root->_right);
	}
    //封装起来让外面可以调用
	void Inorder()
	{
		_Inorder(_root);
		cout << endl;
	}
private:
	Node* _root = nullptr;
};

#include"BSTree.hpp"


#include"BSTree.hpp"


int main()
{
	BSTree<int> Tree;
	Tree.Insert(5);
	Tree.Insert(4);
	Tree.Insert(1);
	Tree.Insert(8);
	Tree.Insert(6);
	Tree.Inorder();
	
	Tree.Erase(4);
	Tree.Inorder();
	Tree.Erase(5);
	Tree.Inorder();
	Tree.Erase(8);

	Tree.Inorder();
	return 0;
}

3.3 KV模型

K-value，字典模型，输入英文查找中文。
当你插入一个英文（K）的时候，对应的中文(val)也被插入。

相比于K模型，代码逻辑不变，还是以K为依据。将Find中的const去掉，因为Value是可以改变的。然后K值不变，声明的时候加上const。

他依旧可以，1. 查找在不在，2. 排序+去重。

3. 最关键的是他具有字典的特征：

4.统计出现次数

3.4 KV模型搜索树实现代码

#include<iostream>

using namespace std;
#pragma once

//K,键值
template<class K,class V>
struct BSTreeNode
{
	const K _key;
	V _val;
	struct BSTreeNode<K,V>* _left;
	struct BSTreeNode<K,V>* _right;

	BSTreeNode(const K& k,const V& v)
		:_key(k)
		, _val(v)
		,_left(nullptr)
		,_right(nullptr)
	{}
};

template<class K,class V>
class BSTree
{
	typedef BSTreeNode<K,V> Node;
public:
	bool Insert(const K& key,const V& val)
	{
		if (_root == nullptr)
		{
			_root = new Node(key,val);
			return true;
		}
		Node* parent = nullptr;
		Node* cur = _root;
		while (cur)
		{
			if (key > cur->_key)
			{
				parent = cur;
				cur = cur->_right;
			}
			else if(key < cur->_key)
			{
				parent = cur;
				cur = cur->_left;
			}
			else
			{
				return false;
			}
		}
		//走到这，说明cur为空，parent为他的上一个节点。
		//确定了他的位置，开始和父亲比较，看放左边还是右边
		Node* newNode = new Node(key,val);
		if (key > parent->_key)
		{
			parent->_right = newNode;
		}
		else//不存在等于情况，等于的话在前面肯定返回false了
		{
			parent->_left = newNode;
		}

		return true;
	}
	//不允许改
	 Node* Find(const K& key)
	{
		Node* cur = _root;
		while (cur)
		{

			if (key > cur->_key)
			{
				cur = cur->_right;
			}
			else if (key == cur->_key)
			{
				return cur;
			}
			else
			{
				cur = cur->_left;
			}
		}
		return nullptr;
	}


	//用来递归的子结构
	void _Inorder(Node* root)
	{
		if (root == nullptr)
			return;

			_Inorder(root->_left);
		    cout << root->_key<<" : "<<root->_val;
			cout << endl;
			_Inorder(root->_right);
	}
    //封装起来让外面可以调用
	void Inorder()
	{
		_Inorder(_root);
		cout << endl;
	}
private:
	Node* _root = nullptr;
};

#include"BSTree.hpp"
#include<string>

int main()
{

	
	/*BSTree<string, string> dict;
	dict.Insert("apple", "苹果");
	dict.Insert("orange", "橘子");
	dict.Insert("people", "人");
	dict.Insert("student", "学生");
	dict.Insert("milk", "牛奶");
	dict.Insert("paper", "卫生纸");
	dict.Insert("paper", "啦啦啦");
	dict.Insert("Big apple", "苹果");
	dict.Inorder();*/
	//string str;
	//while (cin >> str)
	//{
	//	BSTreeNode<string, string>* ret = dict.Find(str);
	//	if (ret)
	//	{
	//		cout << ret->_val << endl;
	//	}
	//	else
	//	{
	//		cout << "字典中不存在"<< endl;
	//	}
	//	
	//}
	string strArry[] = { "苹果", "香蕉", "西瓜", "西瓜", "香蕉" };
	//前面存名字，后面存次数
	BSTree<string, int> countTree;
	for (auto& str : strArry)
	{
		auto ret = countTree.Find(str);
		if (ret == nullptr)
		{
			//没有就插入,第一次插入str和1
		  	countTree.Insert(str, 1);
		}
		else
		{
			//第二次往上，就++次数
			ret->_val++;
		}
	}
	countTree.Inorder();

	return 0;
}