【C++】：二叉树进阶 --- 搜索二叉树

24k纯甄

于 2024-07-15 12:54:43 发布

阅读量1.1k

点赞数 83

文章标签： c++ 开发语言

本文链接：https://blog.csdn.net/2301_77900444/article/details/140411515

版权

点击跳转至文章：【C/数据结构与算法】：树和二叉树

🚀前言

二叉树在前面C数据结构阶段已经讲过，本节取名二叉树进阶是因为：
(1) map和set特性需要先铺垫二叉搜索树，而二叉搜索树也是一种树形结构

(2) 二叉搜索树的特性了解，有助于更好的理解map和set的特性

因此本节借二叉树搜索树，对二叉树部分进行收尾总结。

一，二叉搜索树

1.1 二叉搜索树概念

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

(1) 若它的左子树不为空，则左子树上所有节点的值都小于根节点的值；

(2) 若它的右子树不为空，则右子树上所有节点的值都大于根节点的值；

(3) 它的左右子树也分别为二叉搜索树；

(4) 搜索二叉树的中序遍历是有序的

在这里插入图片描述

二，二叉搜索树的应用

2.1 K模型

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

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

2.2 KV模型

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

(1) 比如英汉词典就是英文与中文的对应关系，通过英文可以快速找到与其对应的中文，英文单词与其对应的中文<word, chinese>就构成一种键值对；

(2) 再比如统计单词次数，统计成功后，给定单词就可快速找到其出现的次数，单词与其出现次数就是<word, count>就构成一种键值对。

三，K模型的代码实现

在这里插入图片描述

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

3.1 K模型的节点结构和类结构

K模型即只有key作为关键码，结构中只需要存储Key即可。

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
{
	typedef BSTNode<K> Node;
public:
	//……

private:
	Node* _root = nullptr;
};

3.2 查找操作

(1) 从根开始比较，查找，比根大则往右边走查找，比根小则往左边走查找。

(2) 最多查找高度次，走到到空，还没找到，这个值不存在。

代码实现如下：

bool Find(const K& key)
{
	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;
}

3.3 插入操作

插入的具体过程如下：
(1) 树为空，则直接新增节点，赋值给root指针；

(2) 树不空，按二叉搜索树性质查找插入位置，插入新节点；

在这里插入图片描述

代码实现如下：

bool Insert(const K& key)
{
	// 如果树为空，直接插入
	if (_root == nullptr)
	{
		_root = new Node(key);
		return true;
	}
	
	//按照二叉搜索树的性质查找key在树中的插入位置
	Node* cur = _root;
	
	//记录cur的双亲，因为新元素最终插入在cur双亲左右孩子的位置
	Node* parent = nullptr;
	
	while (cur)
	{
		if (cur->_key > key)
		{
			parent = cur;
			cur = cur->_left;
		}
		else if (cur->_key < key)
		{
			parent = cur;
			cur = cur->_right;
		}
		else   //元素已经在树中存在
			return false;
	}
	cur = new Node(key);

	//链接时要判断链接在左还是右
	if (parent->_key > key)
		parent->_left = cur;
	else
		parent->_right = cur;

	return true;
}

3.4 删除操作

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

a. 要删除的结点无孩子结点
b. 要删除的结点只有左孩子结点
c. 要删除的结点只有右孩子结点
d. 要删除的结点有左、右孩子结点

看起来有待删除节点有4中情况，实际情况a可以与情况b或者c合并起来，因此真正的删除过程如下：

情况b：删除该结点且使被删除节点的双亲结点指向被删除节点的左孩子结点–直接删除

情况c：删除该结点且使被删除节点的双亲结点指向被删除结点的右孩子结点–直接删除

情况d：在它的右子树中寻找中序下的第一个结点(关键码最小)，用它的值填补到被删除节点
中，再来处理该结点的删除问题–替换法删除

在这里插入图片描述

(1) 情况a可以与情况b或者c合并起来的图解：
一般情况：

在这里插入图片描述
特殊情况：

(2) 两个孩子的情况图解：

在这里插入图片描述

代码实现如下：

bool Erase(const K& key)
{
	// 如果树为空，删除失败
	if (nullptr == _pRoot)
	  return false;
 	
 	// 查找key在树中的位置
	Node* cur = _root;
	Node* parent = nullptr;
	while (cur)
	{
		if (cur->_key > key)
		{
			parent = cur;
			cur = cur->_left;
		}
		else if (cur->_key < key)
		{
			parent = cur;
			cur = cur->_right;
		}
		else
		{
			//删除
			//0-1个孩子
			if (cur->_left == nullptr)
			{
				//只有左孩子或左孩子为空，父亲指向右
				if (parent == nullptr)
				{
					_root = cur->_right;
				}
				else
				{
					if (cur == parent->_left)
						parent->_left = cur->_right;
					else
						parent->_right = cur->_right;
				}

				delete cur;
				return true;
			}
			else if (cur->_right == nullptr)
			{
				//只有右孩子或右孩子为空，父亲指向左
				if (parent == nullptr)
				{
					_root = cur->_left;
				}
				else
				{
					if (cur == parent->_left)
						parent->_left = cur->_left;
					else
						parent->_right = cur->_left;
				}

				delete cur;
				return true;
			}
			else
			{
				//2个孩子
				//代替法：在树中找一个值代替该位置，仍要满足特性
				//策略：左子树中最大的，或右子树中最小的

				//这里找右子树中最小的
				Node* rightMin = cur->_right;
				Node* rightMinParent = cur;
				while (rightMin->_left)
				{
					rightMinParent = rightMin;
					rightMin = rightMin->_left;
				}

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

				//判断链接方向
				if (rightMin == rightMinParent->_left)
					rightMinParent->_left = rightMin->_right;
				else
					rightMinParent->_right = rightMin->_right;

				delete rightMin;
				return true;
			}
		}
	}
	return false;
}

3.5 打印操作

搜索二叉树的中序遍历是有序的。

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);
	}

3.6 测试函数

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

	t.Inorder();

	t.Erase(3);
	t.Inorder();

	t.Erase(4);
	t.Inorder();

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

3.7 完整代码

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
{
	typedef BSTNode<K> Node;
public:
	bool Find(const K& key)
	{
		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 = nullptr;
		while (cur)
		{
			if (cur->_key > key)
			{
				parent = cur;
				cur = cur->_left;
			}
			else if (cur->_key < key)
			{
				parent = cur;
				cur = cur->_right;
			}
			else
				return false;
		}
		cur = new Node(key);

		//链接时要判断链接在左还是右
		if (parent->_key > key)
			parent->_left = cur;
		else
			parent->_right = cur;

		return true;
	}

	bool Erase(const K& key)
	{
	
		// 如果树为空，删除失败
		if (nullptr == _pRoot)
			return false;
			 
		Node* cur = _root;
		Node* parent = nullptr;
		while (cur)
		{
			if (cur->_key > key)
			{
				parent = cur;
				cur = cur->_left;
			}
			else if (cur->_key < key)
			{
				parent = cur;
				cur = cur->_right;
			}
			else
			{
				//删除
				//0-1个孩子
				if (cur->_left == nullptr)
				{
					//左为空，父亲指向右
					if (parent == nullptr)
					{
						_root = cur->_right;
					}
					else
					{
						if (cur == parent->_left)
							parent->_left = cur->_right;
						else
							parent->_right = cur->_right;
					}

					delete cur;
					return true;
				}
				else if (cur->_right == nullptr)
				{
					//右为空，父亲指向左
					if (parent == nullptr)
					{
						_root = cur->_left;
					}
					else
					{
						if (cur == parent->_left)
							parent->_left = cur->_left;
						else
							parent->_right = cur->_left;
					}

					delete cur;
					return true;
				}
				else
				{
					//2个孩子
					//代替法：在树中找一个值代替该位置，仍要满足特性
					//策略：左子树中最大的，或右子树中最小的

					//这里找右子树中最小的
					Node* rightMin = cur->_right;
					Node* rightMinParent = cur;
					while (rightMin->_left)
					{
						rightMinParent = rightMin;
						rightMin = rightMin->_left;
					}

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

					//判断链接方向
					if (rightMin == rightMinParent->_left)
						rightMinParent->_left = rightMin->_right;
					else
						rightMinParent->_right = rightMin->_right;

					delete rightMin;
					return true;
				}
			}
		}
		return false;
	}

	void Inorder()
	{
		_Inorder(_root);
		cout << endl;
	}
private:
	void _Inorder(Node* root)
	{
		if (root == nullptr)
			return;

		_Inorder(root->_left);
		cout << root->_key << " ";
		_Inorder(root->_right);
	}
private:
	Node* _root = nullptr;
};

四，KV模型的代码实现

KV模型的代码与K模型的有很多相似之处，只是在节点，查找和插入的细节处有一些改变。

4.1 K模型的节点结构和类结构

节点里多存了一个value值，但是value不参与二叉树的规则。

template<class K, class V>
struct BSTNode
{
	K _key;
	V _value;
	BSTNode<K, V>* _left;
	BSTNode<K, V>* _right;

	BSTNode(const K& key, const V& value)
		:_key(key)
		,_value(value)
		, _left(nullptr)
		, _right(nullptr)
	{}
};


template<class K, class V>
class BSTree
{
	typedef BSTNode<K, V> Node;
public:
	//……

private:
	Node* _root = nullptr;
};

4.2 查找操作

如果找到了，就返回该节点的位置。

Node* Find(const K& key)
{
	Node* cur = _root;
	while (cur)
	{
		if (cur->_key > key)
			cur = cur->_left;
		else if (cur->_key < key)
			cur = cur->_right;
		else
			return cur;
	}
	return cur;
}

4.3 插入操作

要把value值也放入到节点中。

bool Insert(const K& key, const V& value)
{
	if (_root == nullptr)
	{
		_root = new Node(key, value);
		return true;
	}
	Node* cur = _root;
	Node* parent = nullptr;
	while (cur)
	{
		if (cur->_key > key)
		{
			parent = cur;
			cur = cur->_left;
		}
		else if (cur->_key < key)
		{
			parent = cur;
			cur = cur->_right;
		}
		else
			return false;
	}
	cur = new Node(key, value);

	//链接时要判断链接在左还是右
	if (parent->_key > key)
		parent->_left = cur;
	else
		parent->_right = cur;

	return true;
}

4.4 删除操作

删除操作的代码实现与K模型的一模一样，见上文。

4.5 打印操作

打印操作也是按中序遍历，由于可以统计次数，细节上有改变。

public:
	void Inorder()
	{
		_Inorder(_root);
		cout << endl;
	}
private:
	void _Inorder(Node* root)
	{
		if (root == nullptr)
			return;

		_Inorder(root->_left);
		cout << root->_key << ":" << root->_value << endl;
		_Inorder(root->_right);
	}

4.6 测试函数

(1) 输入单词，查找是否存在，存在就输出对应中文

void Test2()
{
	BSTree<string, string> dict;
	dict.Insert("string", "字符串");
	dict.Insert("left", "左边");
	dict.Insert("apple", "苹果");

	//输入单词，查找是否存在，存在就输出对应中文
	string str;
	
	//连续输入字符串:ctrl z + 回车 结束
	while (cin >> str)
	{
		auto ret = dict.Find(str);
		if (ret)
			cout << ret->_value << endl;
		else
			cout << "无此单词，请重新输入";
	}
}

在这里插入图片描述

(2) 统计字符串出现的个数

先查找水果在不在搜索树中，
a. 不在，说明水果第一次出现，则插入<水果, 1>
b. 在，则查找到的节点中水果对应的次数++

void Test3()
{
	//统计字符串出现的个数
	string arr[] = {"西瓜", "苹果", "西瓜", "苹果", "西瓜", "苹果", "苹果", "西瓜","苹果", "香蕉", "苹果","西瓜", "香蕉","草莓"};

	BSTree<string, int> countTree;
	for (const auto& str : arr)
	{
		auto ret = countTree.Find(str);

		//没找到时，说明不存在，就插入1；找到了，就个数+1
		if (ret == nullptr)
			countTree.Insert(str, 1);
		else
			ret->_value++;
	}

	countTree.Inorder();
}

在这里插入图片描述

4.7 完整代码

template<class K, class V>
struct BSTNode
{
	K _key;
	V _value;
	BSTNode<K, V>* _left;
	BSTNode<K, V>* _right;

	BSTNode(const K& key, const V& value)
		:_key(key)
		,_value(value)
		, _left(nullptr)
		, _right(nullptr)
	{}
};

template<class K, class V>
class BSTree
{
	typedef BSTNode<K, V> Node;
public:
	Node* Find(const K& key)
	{
		Node* cur = _root;
		while (cur)
		{
			if (cur->_key > key)
				cur = cur->_left;
			else if (cur->_key < key)
				cur = cur->_right;
			else
				return cur;
		}
		return cur;
	}

	bool Insert(const K& key, const V& value)
	{
		if (_root == nullptr)
		{
			_root = new Node(key, value);
			return true;
		}
		Node* cur = _root;
		Node* parent = nullptr;
		while (cur)
		{
			if (cur->_key > key)
			{
				parent = cur;
				cur = cur->_left;
			}
			else if (cur->_key < key)
			{
				parent = cur;
				cur = cur->_right;
			}
			else
				return false;
		}
		cur = new Node(key, value);

		//链接时要判断链接在左还是右
		if (parent->_key > key)
			parent->_left = cur;
		else
			parent->_right = cur;

		return true;
	}

	bool Erase(const K& key)
	{
		Node* cur = _root;
		Node* parent = nullptr;
		while (cur)
		{
			// 如果树为空，删除失败
			if (nullptr == _pRoot)
				return false;
			
			if (cur->_key > key)
			{
				parent = cur;
				cur = cur->_left;
			}
			else if (cur->_key < key)
			{
				parent = cur;
				cur = cur->_right;
			}
			else
			{
				//删除
				//0-1个孩子
				if (cur->_left == nullptr)
				{
					//左为空，父亲指向右
					if (parent == nullptr)
					{
						_root = cur->_right;
					}
					else
					{
						if (cur == parent->_left)
							parent->_left = cur->_right;
						else
							parent->_right = cur->_right;
					}

					delete cur;
					return true;
				}
				else if (cur->_right == nullptr)
				{
					//右为空，父亲指向左
					if (parent == nullptr)
					{
						_root = cur->_left;
					}
					else
					{
						if (cur == parent->_left)
							parent->_left = cur->_left;
						else
							parent->_right = cur->_left;
					}

					delete cur;
					return true;
				}
				else
				{
					//2个孩子
					//代替法：在树中找一个值代替该位置，仍要满足特性
					//策略：左子树中最大的，或右子树中最小的

					//这里找右子树中最小的
					Node* rightMin = cur->_right;
					Node* rightMinParent = cur;
					while (rightMin->_left)
					{
						rightMinParent = rightMin;
						rightMin = rightMin->_left;
					}

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

					//判断链接方向
					if (rightMin == rightMinParent->_left)
						rightMinParent->_left = rightMin->_right;
					else
						rightMinParent->_right = rightMin->_right;

					delete rightMin;
					return true;
				}
			}
		}
		return false;
	}

	void Inorder()
	{
		_Inorder(_root);
		cout << endl;
	}
private:
	void _Inorder(Node* root)
	{
		if (root == nullptr)
			return;

		_Inorder(root->_left);
		cout << root->_key << ":" << root->_value << endl;
		_Inorder(root->_right);
	}
private:
	Node* _root = nullptr;
};

五，二叉搜索树的性能分析

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

对有n个结点的二叉搜索树，若每个元素查找的概率相等，则二叉搜索树平均查找长度是结点在二叉搜索树的深度的函数，即结点越深，则比较次数越多。

但对于同一个关键码集合，如果各关键码插入的次序不同，可能得到不同结构的二叉搜索树：

在这里插入图片描述

最优情况下，二叉搜索树为完全二叉树(或者接近完全二叉树)，其平均比较次数为： $O(log_2 N)$

最差情况下，二叉搜索树退化为单支树(或者类似单支)，其平均比较次数为： $O({N}{})$

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

24k纯甄

关注

83
点赞
踩
58

收藏

觉得还不错? 一键收藏
54
评论
【C++】：二叉树进阶 --- 搜索二叉树

二叉树在前面C数据结构阶段已经讲过，本节取名二叉树进阶是因为：(1)map和set特性需要先铺垫二叉搜索树，而二叉搜索树也是一种树形结构(2) 二叉搜索树的特性了解，有助于更好的理解map和set的特性因此本节借二叉树搜索树，对二叉树部分进行收尾总结。
复制链接

扫一扫