【C++进阶】二叉搜索树特性 && 二叉搜索树模拟实现

0.前言（对学习map与set内容的铺垫）

我们之前在c语言部分数据结构初阶就已经讲过二叉树了，为什么那时我们不讲二叉搜索树呢？

这是有原因的，这里讲二叉树进阶是因为：

1.map与set特性需要先铺垫二叉搜索树的概念，理解了二叉搜索树可以更好的理解map与set

2.当时用c语言讲二叉树时没有将进阶，是因为这部分较难，长时间下容易忘记。

3.一些OJ题更适合用c++解决，当时用c语言会比较麻烦，需要动态开辟数组等。

因此有了进阶二叉树部分，是对我们的二叉树进行的收尾总结。

1.二叉搜索树概念

二叉搜索树又称二叉排序树，它或者是一棵空树，或者是具有以下性质的二叉树:

• 若它的左子树不为空，则左子树上所有节点的值都小于根节点的值
• 若它的右子树不为空，则右子树上所有节点的值都大于根节点的值
• 它的左右子树也分别为二叉搜索树

 

2.二叉搜索树操作

2.1 二叉搜索树的查找

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

2.2 二叉搜索树的插入

插入有两种情况需要考虑：

树为空，则直接新增节点，赋值给root指针。

树不为空，则按照二叉搜索树性质查找插入位置，插入新节点。

2.3 二叉搜索树的删除（重点）

首先查找元素是否在二叉搜索树中，如果不存在，则返回, 否则要删除的结点可能分下面四种情况：

• a.要删除的结点为叶子结点
• b.要删除的结点只有左孩子结点
• c.要删除的结点只有右孩子结点
• d.要删除的结点左右孩子结点都有

实际要删除的情况是有三种，a情况可以与b或者c结合，即实际有b,c,d三种情况。

• 情况b：删除该结点且使被删除结点的双亲结点指向被删除结点的左孩子结点 --- 直接删除
• 情况c：删除该结点且使被删除结点的双亲结点指向被删除结点的右孩子结点 --- 直接删除
• 情况d：在它的右子树中找到第一个结点（即val值最小的那个结点）用它的值与需要被删除结点的值替换，再来处理该结点的删除问题 --- 替换法删除

 

3.二叉搜索树的实现

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

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

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

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 (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, val);
		if (parent->_key < key)
		{
			parent->_right = cur;
		}
		else
		{
			parent->_left = cur;
		}
		return true;
	}
	Node* Find(const K& key)
	{
		Node* cur = _root;
		while (cur)
		{
			if (cur->_key < key)
			{
				cur = cur->_right;
			}
			else if (cur->_key > key)
			{
				cur = cur->_left;
			}
			else
			{
				return cur;
			}
		}
		return cur;
	}
	bool Erase(const K& key)
	{
		Node* parent = nullptr;
		Node* cur = _root;
		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 (cur == parent->_left)
						{
							parent->_left = cur->_right;
						}
						else
						{
							parent->_right = cur->_right;
						}
					}
					delete cur;
				}
				else if (cur->_right == nullptr)
				{
					//若删除节点是根节点
					if (cur == _root)
					{
						_root = cur->_left;
					}

					//右为空，父亲指向我的左孩子
					if (cur == parent->_left)
					{
						parent->_left = cur->_left;
					}
					else
					{
						parent->_right = cur->_left;
					}
					delete cur;
				}
				else
				{
					//左右都不为空,替换法删除
					//查找右子树的最左结点替换删除
					Node* rightMinParent = cur;
					Node* rightMin = cur->_right;
					while (rightMin->_left)
					{
						rightMinParent = rightMin;
						rightMin = rightMin->_left;
					}

					swap(cur->_key, rightMin->_key);
					
					if (rightMinParent->_left == rightMin)
						rightMinParent->_left = rightMin->_right;
					else
						rightMinParent->_right = rightMin->_right;
					delete rightMin;
				}
				return true;
			}
		}
		return false;
	}
	void InOrder()
	{
		_InOrder(_root);
		cout << endl;
	}
private:
	Node* _root = nullptr;
	void _InOrder(Node* root)
	{
		if (root == nullptr)
		{
			return;
		}

		_InOrder(root->_left);
		cout << root->_key << " " << root->_val << endl;
		_InOrder(root->_right);
	}

};

void TestBSTree()
{
	/*BSTree<string, string> dict;
	dict.Insert("insert", "插入");
	dict.Insert("erase", "删除");
	dict.Insert("left", "左边");
	dict.Insert("string", "字符串");

	string str;
	while (cin >> str)
	{
		auto ret = dict.Find(str);
		if (ret)
		{
			cout << str << ":" << ret->_val << endl;
		}
		else
		{
			cout << "单词拼写错误" << endl;
		}
	}*/

	string strs[] = { "苹果", "西瓜", "苹果", "樱桃", "苹果", "樱桃", "苹果", "樱桃", "苹果" };
	// 统计水果出现的次
	BSTree<string, int> countTree;
	for (auto str : strs)
	{
		auto ret = countTree.Find(str);
		if (ret == nullptr)
		{
			countTree.Insert(str, 1);
		}
		else
		{
			ret->_val++;
		}
	}
	countTree.InOrder();
}

4.二叉搜索树的应用

• 1. K模型：K模型即只有key作为关键码，结构中只需要存储Key即可，关键码即为需要搜索到的值。

比如：

给一个单词word，判断该单词是否拼写正确，具体方式如下：
以词库中所有单词集合中的每个单词作为key，构建一棵二叉搜索树
在二叉搜索树中检索该单词是否存在，存在则拼写正确，不存在则拼写错误。

• 2. KV模型：每一个关键码key，都有与之对应的值Value，即<Key, Value>的键值对。该种方式在现实生活中非常常见：

比如：

英汉词典就是英文与中文的对应关系，通过英文可以快速找到与其对应的中文，英文单词与其对应的中文<word, chinese>就构成一种键值对；
再比如统计单词次数，统计成功后，给定单词就可快速找到其出现的次数，单词与其出现次数就是<word, count>就构成一种键值对。

 在实现部分写的就是KV模型的模拟实现部分，大家可以参考上面代码。

K模型只需把V去掉就可实现，学会KV模型模拟实现，K模型模拟实现自然也会了。

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

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

 

最优情况下，二叉搜索树为完全二叉树(或者接近完全二叉树)，其比较次数接近为：LogN

最差情况下，二叉搜索树退化为单支树(或者类似单支)，其比较次数接近为：N

问题：如果退化成单支树，二叉搜索树的性能就失去了。那能否进行改进，不论按照什么次序插入关键码，二叉搜索树的性能都能达到最优？那么我们后续章节学习的AVL树和红黑树就可以上场了。

5.二叉树进阶面试题OJ

这些题目更适合使用C++完成，难度也更大一些

1. 二叉树创建字符串。OJ链接
2. 二叉树的分层遍历1。OJ链接
3. 二叉树的分层遍历2。OJ链接
4. 给定一个二叉树, 找到该树中两个指定节点的最近公共祖先 。OJ链接
5. 二叉树搜索树转换成排序双向链表。OJ链接
6. 根据一棵树的前序遍历与中序遍历构造二叉树。 OJ链接
7. 根据一棵树的中序遍历与后序遍历构造二叉树。OJ链接
8. 二叉树的前序遍历，非递归迭代实现 。OJ链接
9. 二叉树中序遍历 ，非递归迭代实现。OJ链接
10. 二叉树的后序遍历 ，非递归迭代实现。OJ链接