C++进阶（五）二叉搜索树

news2024/11/18 3:27:12

在这里插入图片描述


📘北尘_：个人主页

🌎个人专栏:《Linux操作系统》《经典算法试题 》《C++》 《数据结构与算法》
☀️走在路上，不忘来时的初心

文章目录

  • 一、二叉搜索树概念
  • 二、二叉搜索树操作
  • 三、二叉搜索树的实现
  • 四、二叉搜索树的应用
  • 五、二叉搜索树的性能分析

一、二叉搜索树概念

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

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

在这里插入图片描述

二、二叉搜索树操作

在这里插入图片描述

在这里插入图片描述

  1. 二叉搜索树的查找
    a、从根开始比较，查找，比根大则往右边走查找，比根小则往左边走查找。
    b、最多查找高度次，走到到空，还没找到，这个值不存在。
  2. 二叉搜索树的插入
    插入的具体过程如下：
    a. 树为空，则直接新增节点，赋值给root指针
    b. 树不空，按二叉搜索树性质查找插入位置，插入新节点

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

在这里插入图片描述

三、二叉搜索树的实现

#include<iostream>
using namespace std;

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

	BSTreeNode(const K& key)
		:_left(nullptr)
		,_right(nullptr)
		,_key(key)
	{}
};
template<class K>
class BSTree
{
	typedef BSTreeNode<K> Node;
public:
	bool Insert(const K& key)
	{
		if (_root == nullptr)
		{
			_root = new Node(key);
			return true;
		}

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

		}
		return true;
	}

	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;
	}
	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;
					}
					else
					{
						if (cur == parent->_left)
						{
							parent->_left = cur->_left;
						}
						else
						{
							parent->_right = cur->_left;
						}
					}
					delete cur;
				}
				else
				{
					Node* parent = cur;
					Node* subleft = cur->_right;
					while (subleft->_left)
					{
						parent = subleft;
						subleft = subleft->_left;
				
					}
					swap(cur->_key, subleft->_key);

					if (subleft == parent->_left)
					{
						parent->_left = subleft->_right;
					}
					else
					{
						parent->_right = subleft->_right;
					}
					delete subleft;
				}
				return true;
			}
		}
		return false;
	}
	~BSTree()
	{
		Destory(_root);
	}

	bool EraseR(const K& key)
	{
		return _EraseR(_root, key);
	}
	bool InsertR(const K& key)
	{
		return _InsertR(_root,key);
	}
	bool findR(const K& key)
	{
		return _findR(_root, key);
	}
	void InOrder()
	{
		_InOrder(_root);
		cout << endl;
	}
	BSTree(const BSTree<K>& t)
	{
		_root = Copy(t._root);
	}
	//C++11
	BSTree()
	{}
	
	BSTree<K>& operator=(BSTree<K> t)
	{
		swap(_root,t._root);
		return *this;
	}


private:
	Node* _root = nullptr;
	Node* Copy(Node* root)
	{
		if (root == nullptr)
			return nullptr;

		Node* newRoot = new Node(root->_key);
		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;
		root = nullptr;
	}
	void _InOrder(Node* root)
	{
		if (root == nullptr)
			return;
		_InOrder(root->_left);
		cout << root->_key << " ";
		_InOrder(root->_right);
	}
	bool _InsertR(Node*& root,const K& 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 _findR(Node* root, const K* 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;
		}
	}
	bool _EraseR(Node*& root, const K& 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)
				{
					subleft = subleft->_left;
				}
				swap(subleft->_key, root->_key);

				return _EraseR(root->_right, key);
			}
		}
		return false;
	}
	
};
int main()
{
	int a[] = { 8, 3, 1, 10, 6, 4, 7, 14, 13 };
	BSTree<int> bt;
	for (auto e : a)
	{
		bt.InsertR(e);
	}
	bt.InOrder();

	bt.EraseR(14);
	bt.InOrder();

	bt.EraseR(3);
	bt.InOrder();

	bt.EraseR(8);
	bt.InOrder();

	for (auto e : a)
	{
		bt.EraseR(e);
		bt.InOrder();
	}
	return 0;
}

四、二叉搜索树的应用

  1. K模型：K模型即只有key作为关键码，结构中只需要存储Key即可，关键码即为需要搜索到
    的值。
    比如：给一个单词word，判断该单词是否拼写正确，具体方式如下：
    以词库中所有单词集合中的每个单词作为key，构建一棵二叉搜索树
    在二叉搜索树中检索该单词是否存在，存在则拼写正确，不存在则拼写错误。
  2. KV模型：每一个关键码key，都有与之对应的值Value，即<Key, Value>的键值对。该种方式在现实生活中非常常见：
    比如英汉词典就是英文与中文的对应关系，通过英文可以快速找到与其对应的中文，英文单词与其对应的中文<word, chinese>就构成一种键值对；
    再比如统计单词次数，统计成功后，给定单词就可快速找到其出现的次数，单词与其出现次数就是<word, count>就构成一种键值对。
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
{
	typedef BSTreeNode<K,V> Node;
public:
	bool Insert(const K& key,const V& value)
	{
		if (_root == nullptr)
		{
			_root = new Node(key,value);
			return true;
		}

		Node* parent = nullptr;
		Node* cur = _root;
		while (cur)
		{
			parent = cur;
			if (cur->_key < key)
			{
				cur = cur->_right;
			}
			else if (cur->_key > key)
			{
				cur = cur->_left;
			}
			else
			{
				return false;
			}
		}
		cur = new Node(key,value);
		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 nullptr;

	}
	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;
					}
					else
					{
						if (cur == parent->_left)
						{
							parent->_left = cur->_left;
						}
						else
						{
							parent->_right = cur->_left;
						}
					}
					delete cur;
				}
				else
				{
					Node* parent = cur;
					Node* subleft = cur->_right;
					while (subleft->_left)
					{
						parent = subleft;
						subleft = subleft->_left;

					}
					swap(cur->_key, subleft->_key);

					if (subleft == parent->_left)
					{
						parent->_left = subleft->_right;
					}
					else
					{
						parent->_right = subleft->_right;
					}
					delete subleft;
				}
				return true;
			}
		}
		return false;
	}
	~BSTree()
	{
		Destory(_root);
	}
	void InOrder()
	{
		_InOrder(_root);
		
	}

private:
	Node* _root = nullptr;
	
	void Destory(Node*& root)
	{

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

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

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

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

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

在这里插入图片描述

最优情况下，二叉搜索树为完全二叉树(或者接近完全二叉树)，其平均比较次数为：
O（logN）
最差情况下，二叉搜索树退化为单支树(或者类似单支)，其平均比较次数为：O（N）

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

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1395872.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

（人才测评）招聘数据分析师的入职测评方案

（人才测评）招聘数据分析师的入职测评方案

现在是一个大数据的时代&#xff0c;我们的车载导航、淘宝购物、包括人才招聘、都是大数据的产物&#xff0c;然而光靠数据堆积是没用的&#xff0c;所以如何高效的进行数据挖掘与分析&#xff0c;就成了每一件企业思考的问题。 一、 数据分析师的基本工作标准 1、 平时需要…
阅读更多...
【vue2】状态管理之 Vuex

【vue2】状态管理之 Vuex

文章目录 一、介绍1、概念 2、工作示意图3、安装4、简单示例 二、核心1、State1.1 组件中获取 Vuex 的状态1.2 mapState 辅助函数1.3 对象展开运算符 2、Getter2.1 基本使用2.2 通过属性访问2.3 通过方法访问2.4 mapGetters 辅助函数 3、Mutation3.1 定义 mutation3.2 commit 提…
阅读更多...
C++初阶类与对象（三）：详解复制构造函数和运算符重载

C++初阶类与对象（三）：详解复制构造函数和运算符重载

上次介绍了构造函数和析构函数&#xff1a;C初阶类与对象&#xff08;二&#xff09;&#xff1a;详解构造函数和析构函数 今天就来接着介绍新的内容&#xff1a; 文章目录 1.拷贝构造函数1.1引入和概念1.2特性 2.赋值运算符重载2.1运算符重载2.2放在哪里2.3运算符重载示例2.3.…
阅读更多...
WebRTC视频会议/视频客服系统EasyRTC进入会议室密码验证的开发与实现

WebRTC视频会议/视频客服系统EasyRTC进入会议室密码验证的开发与实现

基于WebRTC技术的EasyRTC视频会议系统&#xff0c;建设目标是让用户随时随地、快捷方便地进行视频会议&#xff0c;并根据行业需求有针对性地提供多样化、个性化功能&#xff0c;该系统是覆盖全球的实时音视频开发平台&#xff0c;支持一对一、一对多等视频通话&#xff0c;极大…
阅读更多...
Vray渲染效果图材质参数设置

Vray渲染效果图材质参数设置

渲染是创造出引人入胜视觉效果的关键步骤&#xff0c;在视觉艺术领域尤为重要。不过&#xff0c;渲染作为一个资源密集型的过程&#xff0c;每当面对它时&#xff0c;我们往往都会遭遇到时间消耗和资源利用的巨大挑战。幸运的是&#xff0c;有几种方法能够帮助我们优化渲染&…
阅读更多...
mac PyCharm 使用conda环境

mac PyCharm 使用conda环境

1 使用conda创建虚拟环境 conda create -n test6 python3.9 -y conda activate test62 选择conda环境 本地 选择已经存在的conda环境 右下角会显示现在的环境。
阅读更多...
Android中矩阵Matrix实现平移，旋转，缩放和翻转的用法详细介绍

Android中矩阵Matrix实现平移，旋转，缩放和翻转的用法详细介绍

一&#xff0c;矩阵Matrix的数学原理 矩阵的数学原理涉及到矩阵的运算和变换&#xff0c;是高等代数学中的重要概念。在图形变换中&#xff0c;矩阵起到关键作用&#xff0c;通过矩阵的变换可以改变图形的位置、形状和大小。矩阵的运算是数值分析领域的重要问题&#xff0c;对…
阅读更多...
Go新项目-Golang使用RemoteAddr()获取远程主机地址的注意事项（9）

Go新项目-Golang使用RemoteAddr()获取远程主机地址的注意事项（9）

一、问题描述 http.Request 下的方法RemoteAddr() 可以获取客户端的地址和端口号&#xff0c;最近的一个项目中用到了这个方法。 使用过程中一直都没有什么问题&#xff0c;但是当项目上线之后就发现不管怎么获取ip&#xff0c;客户端地址都是127.0.0.1 。 对于这个问题一直…
阅读更多...
Rust之旅 - Rust概念、Windows安装、环境配置

Rust之旅 - Rust概念、Windows安装、环境配置

&#x1f339;作者主页&#xff1a;青花锁 &#x1f339;简介&#xff1a;Java领域优质创作者&#x1f3c6;、Java微服务架构公号作者&#x1f604; &#x1f339;简历模板、学习资料、面试题库、技术互助 &#x1f339;文末获取联系方式 &#x1f4dd; 系列专栏目录 [Java项目…
阅读更多...
VirtualBox安装openSUSE-Leap-15.5虚拟机并配置网络

VirtualBox安装openSUSE-Leap-15.5虚拟机并配置网络

VirtualBox安装openSUSE-Leap-15.5虚拟机并配置网络 适用于在VirtualBox平台上安装openSUSE-Leap-15.5虚拟机。 1. 安装准备 1.1 安装平台 Windows 11 1.2. 软件信息 软件名称软件版本安装路径Oracle VM VirtualBoxVirtualBox-7.0.12-159484D:\softwareopenSUSE-Leapopen…
阅读更多...
跨Android、iOS、鸿蒙多平台框架ArkUI-X

跨Android、iOS、鸿蒙多平台框架ArkUI-X

ArkUI是一套构建分布式应用界面的声明式UI开发框架。它使用极简的UI信息语法、丰富的UI组件、以及实时界面预览工具&#xff0c;帮助您提升移动应用界面开发效率30%。您只需使用一套ArkTS API&#xff0c;就能在Android、iOS、鸿蒙多个平台上提供生动而流畅的用户界面体验。 一…
阅读更多...
上门服务系统|上门服务小程序|上门服务系统的发展趋势

上门服务系统|上门服务小程序|上门服务系统的发展趋势

在现代社会&#xff0c;人们的生活节奏越来越快&#xff0c;对于更加便捷的服务需求也随之增加。正是基于这一背景&#xff0c;上门服务系统应运而生&#xff0c;并且迅速发展壮大。那么&#xff0c;上门服务系统的发展趋势又是怎样的呢&#xff1f; 首先&#xff0c;上门服务系…
阅读更多...
中国联通助力吴江元荡生态岸线打造5G+自动驾驶生态长廊

中国联通助力吴江元荡生态岸线打造5G+自动驾驶生态长廊

吴江&#xff0c;素有“鱼米之乡”“丝绸之府”的美誉&#xff0c;其地理位置优越&#xff0c;地处太湖之滨。近年来&#xff0c;随着长三角生态绿色一体化发展示范区&#xff08;以下简称“示范区”&#xff09;的建立&#xff0c;元荡更是声名大噪&#xff0c;成为众多游客心…
阅读更多...
如何无公网ip使用Potplayer访问群晖NAS中储存的本地资源【内网穿透】

如何无公网ip使用Potplayer访问群晖NAS中储存的本地资源【内网穿透】

文章目录 本教程解决的问题是&#xff1a;按照本教程方法操作后&#xff0c;达到的效果是&#xff1a;1 使用环境要求&#xff1a;2 配置webdav3 测试局域网使用potplayer访问webdav3 内网穿透&#xff0c;映射至公网4 使用固定地址在potplayer访问webdav ​ 国内流媒体平台的内…
阅读更多...
企业设计图纸安全、企业设计图纸安全软件

企业设计图纸安全、企业设计图纸安全软件

设计图纸对于企业的重要性不言而喻&#xff0c;因此保障设计图纸的安全显得尤为重要。以下是企业设计图纸安全需要注意的几个方面&#xff1a; 访问控制&#xff1a;只有授权人员才能访问设计图纸&#xff0c;需要通过账号密码或者其他验证方式进行身份认证。 加密传输&#…
阅读更多...
【单片机】改写DS2431芯片的地址码，地址ROM，DS2431芯片解密

【单片机】改写DS2431芯片的地址码，地址ROM，DS2431芯片解密

对DS2431里面的128字节可以进行任意读写&#xff0c;方式可以看这里&#xff1a;https://blog.csdn.net/x1131230123/article/details/132248958 但DS2431芯片的地址码是光刻不可修改的&#xff0c;所以只有使用模拟芯片。 原理&#xff1a; https://www.dianyuan.com/article…
阅读更多...
3D可视化：陶瓷烧制的未来之路

3D可视化：陶瓷烧制的未来之路

陶瓷&#xff0c;这一古老的艺术形式&#xff0c;见证了中华文明的辉煌。然而&#xff0c;随着时代的变迁&#xff0c;传统的陶瓷烧制过程正面临着诸多挑战。如何将这门千年技艺传承下去&#xff0c;并在现代社会中焕发新的光彩&#xff1f;3D可视化技术为我们打开了一扇通往未…
阅读更多...
【Kafka】Kafka介绍、架构和概念

【Kafka】Kafka介绍、架构和概念

目录 Kafka介绍Kafka优势Kafka应用场景Kafka基本架构和概念ProducerConsumer/Consumer GroupBrokerZooKeeperTopicPartitionReplicasOffsetsegment Kafka介绍 Kafka是是一个优秀的分布式消息中间件&#xff0c;关于常用的消息中间件对比可参考文章&#xff1a;消息中间件概述。…
阅读更多...
前端npm install时node-sass无法下载导致构建失败

前端npm install时node-sass无法下载导致构建失败

如图node-sass出错 解决方案 # linux SASS_BINARY_SITEhttps://npm.taobao.org/mirrors/node-sass/ npm install node-sass # window set SASS_BINARY_SITEhttps://npm.taobao.org/mirrors/node-sass&& npm install node-sass 将node-sass重新设置一下&#xff0c;然…
阅读更多...
ELK 分离式日志（1）

ELK 分离式日志（1）

目录 一.ELK组件 ElasticSearch&#xff1a; Kiabana&#xff1a; Logstash&#xff1a; 可以添加的其它组件&#xff1a; ELK 的工作原理&#xff1a; 二.部署ELK 节点都设置Java环境: 每台都可以部署 Elasticsearch 软件&#xff1a; 修改elasticsearch主配置文件&…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023