当前位置： 首页 > article >正文

★ C++进阶篇 ★ 二叉搜索树

article 2024/11/14 8:21:25

Ciallo～(∠・ω< )⌒☆ ~ 今天，我将继续和大家一起学习C++进阶篇第三章----二叉搜索树 ~

 

❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️

澄岚主页：椎名澄嵐-CSDN博客

C++基础篇专栏：★ C++基础篇 ★_椎名澄嵐的博客-CSDN博客

C++进阶篇专栏：★ C++进阶篇 ★_椎名澄嵐的博客-CSDN博客

❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️

目录

一  二叉搜索树的概念

二  二叉搜索树的性能分析

三  二叉搜索树的实现

3.1 二叉搜索树的基础结构

3.2 二叉搜索树的插入

3.3 二叉搜索树的中序遍历

3.4 二叉搜索树的查找

3.5 二叉搜索树的删除

四  二叉搜索树key和key/value使用场景

4.1 key搜索场景

4.2 key/value搜索场景

一  二叉搜索树的概念

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

  • 若它的左子树不为空，则左子树上所有结点的值都小于等于根结点的值
  • 若它的右子树不为空，则右子树上所有结点的值都大于等于根结点的值
  • 它的左右子树也分别为⼆叉搜索树
  • 二叉搜索树中可以⽀持插⼊相等的值，也可以不⽀持插⼊相等的值

二  二叉搜索树的性能分析

最优情况下，⼆叉搜索树为完全⼆叉树(或者接近完全⼆叉树)，其高度为： O(log N)

最差情况下，⼆叉搜索树退化为单⽀树(或者类似单⽀)，其⾼度为： O( N/2 )

综合而言⼆叉搜索树增删查改时间复杂度为： O(N)

这样的效率显然是⽆法满⾜我们需求的，后续我们会继续学习⼆叉搜索树的变形，平衡二叉搜索树AVL树和红黑树，才能适⽤于我们在内存中存储和搜索数据。

三  二叉搜索树的实现

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
{
	// typedef BSTNode<K> Node;
	using Node = BSTNode<K>; // 相同效果

public:
	// ...

private:
	Node* _root = nullptr;
};

3.2 二叉搜索树的插入

  • 树为空，则直接新增结点，赋值给root指针
  • 树不空，按⼆叉搜索树性质，插⼊值比1当前结点大往右走，插入值⽐当前结点小往左走，找到空位置，插⼊新结点。
  • 如果⽀持插⼊相等的值，插⼊值跟当前结点相等的值可以往右⾛，也可以往左⾛，找到空位置，插⼊新结点。
bool _Insert(const K& key)
{
	// 树为空，则直接新增结点，赋值给root指针
	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->_right;
		}
		// 插入值比当前结点小往左⾛
		else if (cur->_key > key)
		{
			parent = cur;
			cur = cur->_left;				
		}
		else
		{
			return false;
		}
	}
	// 到空位置，插⼊新结点
	cur = new Node(key);
	if (key > parent->_key)
	{
		parent->_right = cur;
	}
	else
	{
		parent->_left = cur;
	}
	return true;
}

 

3.3 二叉搜索树的中序遍历

public:
	void InOrder()
	{
		_InOrder(_root);
	}

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

因为私有的成员函数调用时要传root变量，而root变量是私有的，所以要再写一个公有的函数在类里拿到root调用私有的中序遍历。

3.4 二叉搜索树的查找

  • 从根开始比较，查找x，x比根的值大则往右查找，x比根值小则往左查找。
  • 最多查找高度次，⾛到到空，还没找到，这个值不存在。
  • 如果不支持插⼊相等的值，找到x即可返回
  • 如果支持插⼊相等的值，意味着有多个x存在，⼀般要求查找中序的第⼀个x。
bool 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 true;
		}
	}
	return false;
}

3.5 二叉搜索树的删除

⾸先查找元素是否在二叉搜索树中，如果不存在，则返回false。

查找元素存在时有四种情况：

  • 要删除结点N左右孩子均为空
  • 要删除的结点N左孩子位空，右孩子结点不为空

解决方案：把N结点的⽗亲对应孩⼦指针指向N的右孩⼦，直接删除N结点

  • 要删除的结点N右孩子位空，左孩子结点不为空

解决方案：把N结点的⽗亲对应孩⼦指针指向N的左孩⼦，直接删除N结点

  • 要删除的结点N左右孩子结点均不为空

解决方案：⽆法直接删除N结点，因为N的两个孩⼦⽆处安放，只能⽤替换法删除。找N左⼦树的值最⼤结点R(最右结点)或者N右⼦树的值最⼩结点R(最左结点)替代N，因为这两个结点中任意⼀个，放到N的位置，都满⾜⼆叉搜索树的规则。替代N的意思就是N和R的两个结点的值交换，转⽽变成删除R结点，R结点符合情况2或情况3，可以直接删除。

bool Erase(const K& key)
{
	Node* cur = _root;
	Node* parent = nullptr;
	while (cur)
	{
		if (key < cur->_key)
		{
			parent = cur;
			cur = cur->_left;
		}
		else if (key > cur->_key)
		{
			parent = cur;
			cur = cur->_right;
		}
		else // 删除
		{
			if (cur->_left == nullptr) // 左为空
			{
				if (cur == _root) // 若删左为空时的根
				{
					_root = cur->_right; // 原根的右结点给根
				}
				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;
				}
				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;
}

四  二叉搜索树key和key/value使用场景

4.1 key搜索场景

只有key作为关键码，结构中只需要存储key即可，关键码即为需要搜索到的值，搜索场景只需要判断key在不在。key的搜索场景实现的⼆叉树搜索树⽀持增删查，但是不⽀持修改，修改key破坏搜索树结构了。

  • 场景1：⼩区⽆⼈值守⻋库，⼩区⻋库买了⻋位的业主⻋才能进⼩区，那么物业会把买了⻋位的业主的⻋牌号录⼊后台系统，⻋辆进⼊时扫描⻋牌在不在系统中，在则抬杆，不在则提⽰⾮本⼩区⻋辆，⽆法进⼊。
  • 场景2：检查⼀篇英⽂⽂章单词拼写是否正确，将词库中所有单词放⼊⼆叉搜索树，读取⽂章中的单词，查找是否在⼆叉搜索树中，不在则波浪线标红提⽰。

4.2 key/value搜索场景

每⼀个关键码key，都有与之对应的值value，value可以任意类型对象。树的结构中(结点)除了需要存储key还要存储对应的value，增/删/查还是以key为关键字⾛⼆叉搜索树的规则进⾏⽐较，可以快速查找到key对应的value。key/value的搜索场景实现的⼆叉树搜索树⽀持修改，但是不⽀持修改key，修改key破坏搜索树结构了，可以修改value。

  • 场景1：简单中英互译字典，树的结构中(结点)存储key(英⽂)和vlaue(中⽂)，搜索时输⼊英⽂，则同时查找到了英⽂对应的中⽂。
  • 场景2：商场⽆⼈值守⻋库，⼊⼝进场时扫描⻋牌，记录⻋牌和⼊场时间，出⼝离场时，扫描⻋牌，查找⼊场时间，⽤当前时间-⼊场时间计算出停⻋时⻓，计算出停⻋费⽤，缴费后抬杆，⻋辆离场。
namespace key_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
	{
		using Node = BSTNode<K, V>;
	public:
		// 强制生成构造
		BSTree = default;

		BSTree(const BSTree& t)
		{
			_root = Copy(t._root);
		}

		~BSTree()
		{
			Destory(_root);
			_root = nullptr;
		}

		BSTree& operator=(BSTree tmp)
		{
			swap(_root, tmp._root);
			return *this;
		}

		Node* Copy(Node* root)
		{
			if (root == nullptr)
				return nullptr;
			Node* newRoot = new Node(root->_key, root->_value);
			newRoot->_left = Copy(root->_left);
			newRoot->_right = Copy(root->_right);
			return newRoot;
		}

		void Destory(Node* root)
		{
			if (root == nullptr)
			{
				return;
			}
			Destory(root->_left);
			Destory(root->_right);
			delete root;
		}


		bool Insert(const K& key, const V& value)
		{
			// 树为空，则直接新增结点，赋值给root指针
			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->_right;
				}
				// 插入值比当前结点小往左⾛
				else if (cur->_key > key)
				{
					parent = cur;
					cur = cur->_left;
				}
				else
				{
					return false;
				}
			}
			// 到空位置，插⼊新结点
			cur = new Node(key, value);
			if (key > parent->_key)
			{
				parent->_right = cur;
			}
			else
			{
				parent->_left = cur;
			}
			return true;
		}

		bool Erase(const K& key)
		{
			Node* cur = _root;
			Node* parent = nullptr;
			while (cur)
			{
				if (key < cur->_key)
				{
					parent = cur;
					cur = cur->_left;
				}
				else if (key > cur->_key)
				{
					parent = cur;
					cur = cur->_right;
				}
				else // 删除
				{
					if (cur->_left == nullptr) // 左为空
					{
						if (cur == _root) // 若删左为空时的根
						{
							_root = cur->_right; // 原根的右结点给根
						}
						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;
						}
						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;
		}

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

		void InOrder()
		{
			_InOrder(_root);
			cout << endl;
		}

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

~ 完 ~


http://www.kler.cn/a/318713.html

相关文章：

  • 软件测试面试2024最新热点问题
  • 使用Matlab建立随机森林
  • 24/11/12 算法笔记＜强化学习＞ Policy Gradient策略梯度
  • DeBiFormer实战：使用DeBiFormer实现图像分类任务（二）
  • wafw00f源码详细解析
  • DApp开发：定制化解决方案与源码部署的一站式指南
  • service 命令：管理系统服务
  • AI学习指南深度学习篇-Adagrad超参数调优与性能优化
  • C语言 | Leetcode C语言题解之第435题无重叠区间
  • 编译原理3——词法分析
  • Pytest-如何将allure报告发布至公司内网
  • 微生物多样性数据的可视化技巧
  • 新能源汽车数据大全（产销数据\充电桩\专利等）
  • brpc之io事件分发器
  • 【会议征稿通知】第三届图像处理、计算机视觉与机器学习国际学术会议(ICICML 2024)
  • Java使用Map数据结构配合函数式接口存储方法引用
  • 洛谷P2571.传送带
  • request库的使用 | get请求
  • 微软Active Directory：组织身份与访问管理的基石
  • 字符串——String
  • 量子计算如何引发第四次工业革命——解读加来道雄的量子物理观
  • Android平台使用VIA创建语音交互应用
  • 【ArcGIS微课1000例】0122：经纬网、方里网、参考格网绘制案例教程
  • 0基础带你入门Linux之使用
  • 初识C#（一）
  • 2.以太网