【C++进阶】二叉搜索树(BSTree)

​👻内容专栏：C/C++编程
🐨本文概括：二叉搜索树的基本操作(查找、删除、插入)、二叉搜索树的应用，KV模型。
🐼本文作者：阿四啊
🐸发布时间：2023.11.22

一、二叉搜索树

1.1 二叉搜索树的概念

二叉搜索树又称二叉排序树（BST，Binary Search Tree），它或者是一棵空树，或者是具有以下性质的二叉树：

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

1.2 二叉搜索树的基本操作

类的创建

template<class T>
struct BSTreeNode
{
	BSTreeNode<T>* _left;
	BSTreeNode<T>* _right;
	T _key;
	BSTreeNode(const T& key)
		:_left(nullptr)
		,_right(nullptr)
		,_key(key)
	{ }
};
template<class T>
class BSTree
{
public:
	typedef BSTreeNode<T> Node;
private:
	Node* _root = nullptr;
};

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

查找操作

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

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

	Node* cur = _root;
	while (cur != nullptr)
	{
		if (cur->_key < key)
		{
			cur = cur->_right;
		}
		else if (cur->_key > key)
		{
			cur = cur->_left;
		}
		else
		{
			return true;
		}
	}
	return false;
}

插入操作

插入的具体过程如下：
a. 树为空，则直接新增节点，赋值给root指针
b. 树不空，需要定义cur节点指针往后寻找，按二叉搜索树性质查找插入位置，插入新节点。其中我们还需定义一个parent节点指针，是为了让插入的节点在parent节点的左边还是右边。

⚠️注意：二叉搜索树中是不允许出现相等的值的，出现相等情况的值，插入操作返回false即可。

bool Insert(const T& key)
{
	//树为空
	if (_root == nullptr)
	{
		_root = new Node(key);
		return true;
	}

	//树不为空
	Node* parent = nullptr;
	Node* cur = _root;
	while (cur != nullptr)
	{
		if (cur->_key < key)
		{
			parent = cur;
			cur = cur->_right;
		}
		else if (cur->_key > key)
		{
			parent = cur;
			cur = cur->_left;
		}
		else
		{
			return false;
		}
	}
	
	if (parent->_key < key) parent->_right = new Node(key);
	else parent->_left = new Node(key);

	return true;
}

删除操作

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

1. 要删除的结点无孩子结点。
2. 要删除的结点只有左孩子结点。
3. 要删除的结点只有右孩子结点。
4. 要删除的结点有左、右孩子结点。

看起来有待删除节点有4中情况，无孩子结点也可以被分为只有左孩子或者只有孩子的情况，所以实际情况a可以与情况b或者c合并起来，因此真正的删除过程。如下：
情况a：删除该结点且使被删除节点的双亲结点指向被删除节点的左孩子结点 ==>直接删除
情况b：删除该结点且使被删除节点的双亲结点指向被删除结点的右孩子结点 ==>直接删除
情况c：在它的右子树中寻找中序下的最左节点(关键码最小)，用它的值填补到被删除节点中，再来处理该结点的删除问题。或者在它的左子树中寻找最右节点(关键码最大)，用它的值填补到被删除节点中，再来处理该结点的删除问题 ==>替换法删除
直接删除：

替换法删除：

以上替换法两种方法都可行，作者便使用法二，寻找右子树的最左节点(最小节点)进行交换。另外一种方法友友们可以自己实现。

bool Erase(const T& key)
{
	//树为空
	if (_root == nullptr)
	{
		return false;
	}

	Node* parent = nullptr;
	Node* cur = _root;
	while (cur != nullptr)
	{
		if (cur->_key < key)
		{
			parent = cur;
			cur = cur->_right;
		}
		else if (cur->_key > key)
		{
			parent = cur;
			cur = cur->_left;
		}
		else
		{
			//准备删除操作
			//情况b 要删除的结点只有右孩子结点
			if (cur->_left == nullptr)
			{
				if (cur == _root)
				{
					_root = cur->_right;
				}
				else
				{
					//左子树中
					if (cur == parent->_left)
					{
						parent->_left = cur->_right;
					}
					else
					//右子树中
					{
						parent->_right = cur->_right;
					}
				}	
			}
			else if (cur->_right == nullptr)
			//情况a 要删除的结点只有左孩子结点
			{
				if (cur == _root)
				{
					_root = cur->_left;
				}
				else
				{
					//左子树中
					if (cur == parent->_left)
					{
						parent->_left = cur->_left;
					}
					else
						//右子树中
					{
						parent->_right = cur->_left;
					}
				}
			}
			else
			//情况c 要删除的结点有左、右孩子结点
			{
				//右子树的最小节点(最左节点)
				Node* parent = cur;
				//parent为什么初始化为cur，因为在删除根节点时为特例，否则会出现循环进不去，出现空指针解引用
				Node* subLeft = cur->_right;
				while (subLeft->_left != nullptr)
				{
					parent = subLeft;
					subLeft = subLeft->_left;
				}

				swap(cur->_key, subLeft->_key);

				if (parent->_left == subLeft)
				{
					parent->_left = subLeft->_right;
				}
				else
				{
					parent->_right = subLeft->_right;
				}
			}
			return true;
		}
	}
	return false;
}

我们可以在类中手写一个中序遍历，验证删除操作是否正确。
中序遍历

public:
void InOrder()
{
	_InOrder(_root);
	cout << endl;
}
private:
void _InOrder(Node* root)
{
	if (root == nullptr)
	{
		return;
	}
	_InOrder(root->_left);
	cout << root->_key << " ";
	_InOrder(root->_right);
}

在main函数中进行验证

int main()
{
	int a[] = { 8, 3, 1, 10, 6, 4, 7, 14, 13 };
	BSTree<int> bt;
	for (auto e : a)
	{
		bt.Insert(e);
	}
	bt.InOrder();

	//删除14
	bt.Erase(14);
	bt.InOrder();
	//删除3
	bt.Erase(3);
	bt.InOrder();
	//删除8
	bt.Erase(8);
	bt.InOrder();

	return 0;
}

验证结果：

1 3 4 6 7 8 10 13 14
1 3 4 6 7 8 10 13
1 4 6 7 8 10 13
1 4 6 7 10 13

1.3 二叉搜索树的基本操作(递归版本)

查找操作

public:
bool FindR(const T& key)
	{
		return _FindR(_root, key);
	}
private:
bool _FindR(Node* root, const T& key)
{
	if (root == nullptr)
	{
		return false;
	}
	if (root->_key < key)
	{
		return _FindR(root->_right, key);
	}
	else if (root->_key > key)
	{
		return _FindR(root->_left, key);
	}
	else
	{
		return true;
	}
}

插入操作

我们发现你插入操作的难点在于如何进行链接节点，这里我们只需在形参部分给Node* root添加上&之后，这一点很巧妙，然后我们执行root = new Node(key)，就能成功链接新插入的节点。不懂的友友们可以试着画一画递归展开细节图。

public:
bool InsertR(const T& key)
{
	return _InsertR(_root, key);
}
private:
bool _InsertR(Node*& root, const T& key)
{
	if (root == nullptr)
	{
		root = new Node(key);
		return true;
	}

	if (root->_key < key)
	{
		return _InsertR(root->_right, key);
	}
	else if (root->_key > key)
	{
		return _InsertR(root->_left, key);
	}
	else
	{
		return false;
	}
}

删除操作

这里删除操作和插入操作类似，如果删除节点然后链接，一样使用了巧妙的引用操作。

bool EraseR(const T& key)
{
	return _EraseR(_root, key);
}
private:
bool _EraseR(Node*& root,const T& key)
{
	if (root == nullptr) return false;

	if (root->_key < key)
	{
		return _EraseR(root->_right, key);
	}
	else if (root->_key > key)
	{
		return _EraseR(root->_left, key);
	}
	else
	{
		//删除
		if (root->_left == nullptr)
		{
			Node* del = root;
			root = root->_right;
			delete del;
		}
		else if (root->_right == nullptr)
		{
			Node* del = root;
			root = root->_left;
			delete del;
		}
		else
		{
			//在右子树中寻找最左节点(最小节点)
			Node* subLeft = root->_right;
			while (subLeft->_left != nullptr)
			{
				subLeft = subLeft->_left;
			}

			swap(root->_key, subLeft->_key);

			//转换成在子树中去递归删除
			return _EraseR(root->_right, key);
		}
	}
}

这里要着重说明一下删除左右孩子都存在的节点，该如何去递归操作，举例说明删除3，我们利用循环去找删除节点右子树中的最左节点，找到之后交换两个节点的值，那么subLeft节点如何删除？这里我们不再使用parent节点，然后条件判断，我们可以转换成在交换前的右子树中去递归删除，如下图，蓝色圆圈标记。

1.4 二叉搜索树的应用

1. K模型：K模型即只有key作为关键码，结构中只需要存储Key即可，关键码即为需要搜索到的值。
   比如：给一个单词word，判断该单词是否拼写正确，具体方式如下：
   以词库中所有单词集合中的每个单词作为key，构建一棵二叉搜索树在二叉搜索树中检索该单词是否存在，存在则拼写正确，不存在则拼写错误。
   1.2部分我们实现的就是K模型的底层基本能逻辑。

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

// 改造二叉搜索树为KV结构
template<class K, class V>
struct BSTreeNode
{
	BSTreeNode<K, V>* _left;
	BSTreeNode<K, V>* _right;
	K _key;
	V _value;
	BSTreeNode(const K& key, const V& value)
		:_left(nullptr)
		, _right(nullptr)
		, _key(key)
		, _value(value)
	{ }
};
template<class K, class V>
	class BSTree
	{
	public:
		typedef BSTreeNode<K, V> Node;

		bool Insert(const K& key, const V& value);
		Node* Find(const K& key);
		void InOrder();
		bool Erase(const K& key);
	private:
		Node* _root = nullptr;
	};
//KV模型
//1.英汉词典
int main()
{
	Key_Vaule::BSTree<string, string> dictionary;
	dictionary.Insert("sort", "排序");
	dictionary.Insert("left", "左边");
	dictionary.Insert("right", "右边");
	dictionary.Insert("insert", "插入");
	dictionary.Insert("erase", "删除");

	string str;
	while (cin >> str)
	{
		Key_Vaule::BSTreeNode<string, string>* ret = dictionary.Find(str);
		if (ret)
		{
			//找到单词输出
			cout << ret->_value << endl;
		}
		else
		{
			//未找到单词
			cout << "No words found!" << endl;
		}
	}
}

//2统计单词次数
int main()
{
	// 统计水果出现的次数
	string arr[] = { "苹果", "西瓜", "苹果", "西瓜", "苹果", "苹果", "西瓜", "苹果", "香蕉", "苹果", "香蕉" };
	Key_Vaule::BSTree<string, int> countWords;
	for (auto& e : arr)
	{
		Key_Vaule::BSTreeNode<string, int>* ret = countWords.Find(e);
		if (ret == nullptr)
		{
			countWords.Insert(e, 1);
		}
		else
		{
			ret->_value++;
		}
	}

	countWords.InOrder();

	return 0;
}

1.5 二叉搜索树的性能分析

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

最优情况下，二叉搜索树为完全二叉树(或者接近完全二叉树)，其平均比较次数为：$lo{g}_{2}N$。
最差情况下，二叉搜索树退化为单支树(或者类似单支)，其平均比较次数为：$\frac{N}{2}$。

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

二、二叉搜索树源码

👉😉 gitee ==> 二叉搜索树的基本实现及二叉搜索树的应用(K模型、KV模型)