二叉树进阶——二叉搜索树（c＋＋实现）

1. 二叉搜索树

1.1 二叉搜索树概念

1.2 二叉搜索树操作

前言：

在数据结构部分我们学习了一部分二叉树的知识，包括二叉树实现堆及堆排序，使用递归实现链式二叉树，其中设计二叉树的应用场景很少，并不是二叉树的实用性弱，而是我们目前掌握的知识不足以使用二叉树来应付大多数应用场景。我们学习基础二叉树的知识很大一部分原因是为了学习进阶二叉树打基础，学习需要循序渐进，二叉树的学习也不是能短时间就掌握的，这一期开始我们就要开始重点介绍一些实用性强的二叉树，有了之前学习二叉树的基础，我们接下来的学习也会更加得心应手。

1. 二叉搜索树

1.1 二叉搜索树概念

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

简单来说，一棵二叉搜索树的每一个根节点都小于它的右孩子且大于它的左孩子。

1.2 二叉搜索树操作

假设我们有一棵二叉搜索树：

插入顺序为：

int a[] = {8, 3, 1, 10, 6, 4, 7, 14, 13};

二叉搜索树的主要操作为：插入，查找，删除，其中删除的难度相对来说更高一些，也是二叉树知识的高频面试点。

1.二叉树的查找

a、从根开始比较，查找，比根大则往右边走查找，比根小则往左边走查找。
b、最多查找高度次，走到到空，还没找到，这个值不存在。

最多查找高度次是不是就意味着二叉搜索树的时间复杂度是O（logN）呢？请看图：

这也是一棵二叉搜索树，但是它的时间复杂度达到了O（N），从这我们也不难看出，二叉搜索树的时间复杂度的快慢依赖结点的插入顺序，这个问题我们是可以解决的，具体过程我们后面章节再讲。

2. 二叉搜索树的插入

插入的具体过程如下：
a. 树为空，则直接新增节点，赋值给root指针
b. 树不空，按二叉搜索树性质查找插入位置，插入新节点

值得注意的是，我们的插入操作每次都需要找到一个空结点，然后将我们要插入的结点插入到这个空结点的位置中。

3. 二叉搜索树的删除

首先查找元素是否在二叉搜索树中，如果不存在，则返回, 否则要删除的结点可能分下面四种情
况：
1. 要删除的结点无孩子结点
2. 要删除的结点只有左孩子结点
3. 要删除的结点只有右孩子结点
4. 要删除的结点有左、右孩子结点
看起来有待删除节点有4中情况，实际情况a可以与情况b或者c合并起来，因此真正的删除过程
如下：
情况b：删除该结点且使被删除节点的双亲结点指向被删除节点的左孩子结点--直接删除
情况c：删除该结点且使被删除节点的双亲结点指向被删除结点的右孩子结点--直接删除
情况d：在它的右子树中寻找中序下的第一个结点(关键码最小)，用它的值填补到被删除节点
中，再来处理该结点的删除问题--替换法删除

可以看到，二叉搜索树需要考虑的情况非常多，总体来说它的逻辑还是比较复杂的，这块知识需要我们反复思考，确保对二叉搜索树有一定的理解。

1.3 二叉搜索树的实现

1.3 1 插入

二叉搜索树的插入分为两种情，一种是在我们插入之前是一棵空树，那么我们就可以直接将要插入的结点看作根节点。另一种情况就是有根节点的情况，我们就正常通过二叉搜索树的流程找到我们要找的空结点，将我们要插入的结点插入到这个位置。在这之前，我们还需要定义一个结点类和一个树类：

结点类：

template<class K>
struct BSTNode
{
	K _key;
	BSTNode<K>* left;
	BSTNode<K>* right;

	BSTNode(const K& key)
		:_key(key)
		,left(nullptr)
		,right(nullptr)
	{}

};

一个结点类中包含左子树，右子树的指针和我们存储的值。

树类：

template<class K>
class BSTree
{
public:
	using Node = BSTNode<K>;
private:

	void _InOrder(const Node* root)
	{
		if (root==nullptr)
		{
			return;
		}

		_InOrder(root->left);
		cout << root->_key << " ";
		_InOrder(root->right);
	}
	Node* _root=nullptr;
};

在树类中，我们将根结点设为私有，防止被改动，同样我们也将二叉树的中序遍历函数设为了私有，我们可以将插入，查找，删除设为公有，让我们可以在类外使用它们。

插入实现：

bool Insert(const K key)
{
	if (_root == nullptr)
	{
		_root = new Node(key);
		return true;
	}

	Node* cur = _root;
	Node* parent = cur;

	while (cur)
	{
		if (cur->_key < key)
		{
			parent = cur;
			cur = cur->right;

		}
		else if (cur->_key > key)
		{
			parent = cur;
			cur = cur->left;
		}
		else
		{
			return false;
		}
	}

	cur = new Node(key);
	if (parent->_key > key)
	{
		parent->left = cur;
		return true;
	}
	else if (parent->_key < key)
	{
		parent->right = cur;
		return true;
	}
}

1.3 2 查找

查找的基本逻辑与插入差不多，直到我们找到值相同就返回真，如果走完整棵树都没找到相同的的值，就说明树中没有这个值，返回假：

bool Find(const K key)
{
	if (_root == nullptr)
	{
		return false;
	}

	Node* cur = _root;
	while (cur)
	{
		if (cur->_key > key)
		{
			cur = cur->left;
		}
		else if (cur->_key < key)
		{
			cur = cur->right;
		}
		else
		{
			return true;
		}


	}

	return false;
}

1.3 3删除

删除我们需要考虑四种情况：

（1）左右都为空

（2）左为空

（3）右为空

（4）左右都不为空

1.但是我们可以将第一种与第二种情况合起来看，如果一个结点的左为空，就把它的右结点给父亲结点，这样不论剩下那个结点是空还是不为空都可以解决。

2.另一种是结点的左为空，这种情况的处理方式与第一种一样，只要发现一个结点的左孩子为空，就将它的右孩子给父节点，然后销毁这个结点。

这两种情况还有一种极端情况就是我们要删的是根结点，如果根结点的一个孩子为空，将它的另一个孩子给父亲结点，但是根结点没有父亲结点，那么如果这时将它的一个孩子结点给父亲结点（这时父亲结点为空），程序就会崩溃：

所以我们还需要判断这种情况，如果我们要删除的结点是根结点且只有一个孩子，就可以将它的飞非空孩子结点设为根节点然后再销毁我们要删除的结点。

3.最后一种情况是最复杂的，我们如果要删除一个结点，需要找到该结点的左子树的最右边也就是左子树最大的那个值或者是找到该节点的右子树的最左结点也就是右子树的最小的值来替换然后去删除。

实现：

bool Erase(const K& key)
{
	Node* parent = nullptr;
	Node* cur = _root;
	//t.Erase(7);
	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 (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
			{
				//左右都不为空
				Node* ReplaceParent = cur;
				Node* Replace = cur->right;

				while (Replace->left)
				{
					ReplaceParent = Replace;
					Replace = Replace->left;		
				}


				cur->_key = Replace->_key;
				if (ReplaceParent->left == Replace)
					ReplaceParent->left = Replace->right;
				else
					ReplaceParent->right = Replace->right;
				delete Replace;
			}
			return true;
		}

		
	}
	return false;
}

使用以下代码测试一下：

int a[]= { 8, 3, 1, 10, 6, 4, 7, 14, 13 };

BSTree<int> t;

for (auto e : a)
{
	t.Insert(e);
}

t.InOrder();
t.Insert(16);
t.InOrder();

int ret=t.Find(10);

if (ret != 0)
{
	cout << "找到了" << endl;
}
else
{
	cout << "二叉树中没有该数" << endl;
}

t.Erase(8);
t.InOrder();

来看看效果：

可以看到我们的实现是没有任何问题的，我将完整代码放在下面给需要的小伙伴使用：

BSTree.h :

#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
using namespace std;
template<class K>
struct BSTNode
{
	K _key;
	BSTNode<K>* left;
	BSTNode<K>* right;

	BSTNode(const K& key)
		:_key(key)
		,left(nullptr)
		,right(nullptr)
	{}

};


template<class K>
class BSTree
{
public:
	using Node = BSTNode<K>;

	bool Erase(const K& key)
	{
		Node* parent = nullptr;
		Node* cur = _root;
		//t.Erase(7);
		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 (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
				{
					//左右都不为空
					Node* ReplaceParent = cur;
					Node* Replace = cur->right;

					while (Replace->left)
					{
						ReplaceParent = Replace;
						Replace = Replace->left;		
					}


					cur->_key = Replace->_key;
					if (ReplaceParent->left == Replace)
						ReplaceParent->left = Replace->right;
					else
						ReplaceParent->right = Replace->right;
					delete Replace;
				}
				return true;
			}

			
		}
		return false;
	}
	bool Find(const K key)
	{
		if (_root == nullptr)
		{
			return false;
		}

		Node* cur = _root;
		while (cur)
		{
			if (cur->_key > key)
			{
				cur = cur->left;
			}
			else if (cur->_key < key)
			{
				cur = cur->right;
			}
			else
			{
				return true;
			}


		}

		return false;
	}


	bool Insert(const K key)
	{
		if (_root == nullptr)
		{
			_root = new Node(key);
			return true;
		}

		Node* cur = _root;
		Node* parent = cur;

		while (cur)
		{
			if (cur->_key < key)
			{
				parent = cur;
				cur = cur->right;

			}
			else if (cur->_key > key)
			{
				parent = cur;
				cur = cur->left;
			}
			else
			{
				return false;
			}
		}

		cur = new Node(key);
		if (parent->_key > key)
		{
			parent->left = cur;
			return true;
		}
		else if (parent->_key < key)
		{
			parent->right = cur;
			return true;
		}
	}
	void InOrder()
	{
		_InOrder(_root);
		cout << endl;
	}

private:

	void _InOrder(const Node* root)
	{
		if (root==nullptr)
		{
			return;
		}

		_InOrder(root->left);
		cout << root->_key << " ";
		_InOrder(root->right);
	}
	Node* _root=nullptr;
};

Test.cpp :

#define _CRT_SECURE_NO_WARNINGS 1
#include"BSTree.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();
	t.Insert(16);
	t.InOrder();

	int ret=t.Find(10);

	if (ret != 0)
	{
		cout << "找到了" << endl;
	}
	else
	{
		cout << "二叉树中没有该数" << endl;
	}

	t.Erase(8);
	t.InOrder();
}

2.二叉搜索树的应用

1. K模型：K模型即只有key作为关键码，结构中只需要存储Key即可，关键码即为需要搜索到
的值。
比如：给一个单词word，判断该单词是否拼写正确，具体方式如下：
(1)以词库中所有单词集合中的每个单词作为key，构建一棵二叉搜索树
(2)在二叉搜索树中检索该单词是否存在，存在则拼写正确，不存在则拼写错误。

2. KV模型：每一个关键码key，都有与之对应的值Value，即<Key, Value>的键值对。该种方
式在现实生活中非常常见：
(1)比如英汉词典就是英文与中文的对应关系，通过英文可以快速找到与其对应的中文，英
文单词与其对应的中文<word, chinese>就构成一种键值对；
(2)再比如统计单词次数，统计成功后，给定单词就可快速找到其出现的次数，单词与其出
现次数就是<word, count>就构成一种键值对。

// 改造二叉搜索树为KV结构
template<class K, class V>
struct BSTNode
{
BSTNode(const K& key = K(), const V& value = V())
   : _pLeft(nullptr) , _pRight(nullptr), _key(key), _Value(value)
{}
BSTNode<T>* _pLeft;
BSTNode<T>* _pRight;
K _key;
   V _value
};
template<class K, class V>
class BSTree
{
typedef BSTNode<K, V> Node;
typedef Node* PNode;
public:
BSTree(): _pRoot(nullptr){}
PNode Find(const K& key);
bool Insert(const K& key, const V& value)
bool Erase(const K& key)
private:
PNode _pRoot;
};
void TestBSTree3()
{
// 输入单词，查找单词对应的中文翻译
BSTree<string, string> dict;
dict.Insert("string", "字符串");
dict.Insert("tree", "树");
dict.Insert("left", "左边、剩余");
dict.Insert("right", "右边");
dict.Insert("sort", "排序");
// 插入词库中所有单词
string str;
while (cin>>str)
{
BSTreeNode<string, string>* ret = dict.Find(str);
if (ret == nullptr)
{
cout << "单词拼写错误，词库中没有这个单词:" <<str <<endl;
}
else
{
cout << str << "中文翻译:" << ret->_value << endl;
}
}
}
void TestBSTree4()
{
// 统计水果出现的次数
string arr[] = { "苹果", "西瓜", "苹果", "西瓜", "苹果", "苹果", "西瓜",
"苹果", "香蕉", "苹果", "香蕉" };
BSTree<string, int> countTree;
for (const auto& str : arr)
{
// 先查找水果在不在搜索树中
// 1、不在，说明水果第一次出现，则插入<水果, 1>
// 2、在，则查找到的节点中水果对应的次数++
//BSTreeNode<string, int>* ret = countTree.Find(str);
auto ret = countTree.Find(str);
if (ret == NULL)
{
countTree.Insert(str, 1);
}
else
{
ret->_value++;
}
}
countTree.InOrder();
}

3. 二叉搜索树的性能分析

插入和删除操作都必须先查找，查找效率代表了二叉搜索树中各个操作的性能。

对有n个结点的二叉搜索树，若每个元素查找的概率相等，则二叉搜索树平均查找长度是结点在二
叉搜索树的深度的函数，即结点越深，则比较次数越多。
但对于同一个关键码集合，如果各关键码插入的次序不同，可能得到不同结构的二叉搜索树：

最优情况下，二叉搜索树为完全二叉树(或者接近完全二叉树)，其平均比较次数为：$log_2 N$
最差情况下，二叉搜索树退化为单支树(或者类似单支)，其平均比较次数为：$\frac{N}{2}$
问题：如果退化成单支树，二叉搜索树的性能就失去了。那能否进行改进，不论按照什么次序插
入关键码，二叉搜索树的性能都能达到最优？那么我们后续章节学习的AVL树和红黑树就可以上
场了。

本章完。