搜索二叉树(二叉树进阶)

news2024/12/28 21:04:12

目录

1.二叉搜索树

1.1二叉搜索树概念

1.2二叉搜索树操作

2.3二叉搜索树的实现

2.4二叉搜索树的应用

2.5二叉搜索树的性能分析

1.二叉搜索树

1.1二叉搜索树概念

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

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

1.2二叉搜索树操作

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

1. 二叉搜索树的查找
a、从根开始比较，查找，比根大则往右边走查找，比根小则往左边走查找。
b、最多查找高度次，走到到空，还没找到，这个值不存在。(时间复杂度最坏是O(N),比如所有节点都在右子树或者左子树上面。)

2. 二叉搜索树的插入
插入的具体过程如下：
a. 树为空，则直接新增节点，赋值给root指针
b. 树不空，按二叉搜索树性质查找插入位置，插入新节点

3.二叉搜索树的删除

首先查找元素是否在二叉搜索树中，如果不存在，则返回, 否则要删除的结点可能分下面四种情况：
a. 要删除的结点无孩子结点
b. 要删除的结点只有左孩子结点
c. 要删除的结点只有右孩子结点
d. 要删除的结点有左、右孩子结点

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

情况b：删除该结点且使被删除节点的双亲结点指向被删除节点的左孩子结点--直接删除
情况c：删除该结点且使被删除节点的双亲结点指向被删除结点的右孩子结点--直接删除
情况d：在它的右子树中寻找中序下的第一个结点(关键码最小)，用它的值填补到被删除节点中，再来处理该结点的删除问题--替换法删除

2.3二叉搜索树的实现

//BinarySearchTree.h
#define _CRT_SECURE_NO_WARNINGS 1

#include <iostream>
#include <utility>

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:
	BSTree()
		:_root(nullptr)
	{}

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

	~BSTree()
	{
		Destroy(_root);
	}

	//现代写法：因为operator=是传值调用，过程中调用了拷贝构造形成了t
	//然后通过swap交换他们的内部资源，最后引用返回延长了内部资源的生命周期。
	//防止t出了作用域被销毁时把内部给释放了
	BSTree<K>& operator=(BSTree<K> t)
	{
		swap(_root, t._root);
		return *this;
	}

	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->_right;
			}
			else if (cur->_key > key)
			{
				parent = cur;
				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 (parent->_right == cur)
							parent->_right = cur->_right;
						else
							parent->_left = cur->_right;
					}
				}
				else if (cur->_right == nullptr)//右为空
				{
					if (cur == _root)
						_root = cur->_left;
					else
					{
						if (parent->_right == cur)
							parent->_right = cur->_left;
						else
							parent->_left = cur->_left;
					}
				}
				else//左右不为空
				{
					Node* parent = cur;
					//找替代节点 -- 左子树最大节点
					Node* leftMax = cur->_left;
					while (leftMax->_right)
					{
						parent = leftMax;
						leftMax = leftMax->_right;
					}

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

					if (parent->_left == leftMax)
						parent->_left = leftMax->_left;
					else
						parent->_right = leftMax->_left;

					cur = leftMax;
				}

				delete cur;
				return true;
			}
		}

		return false;
	}

	//二叉搜索树中序遍历出来是有序的
	void InOrder()
	{
		_InOrder(_root);
		cout << endl;
	}

	//以下是递归版本
	bool FindR(const K& key)
	{
		return _FindR(_root, key);
	}

	bool InsertR(const K& key)
	{
		return _InsertR(_root, key);
	}

	bool EraseR(const K& key)
	{
		return _EraseR(_root, key);
	}

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

		Node* copyroot = new Node(root->_key); 
		copyroot->_left = Copy(root->_left);
		copyroot->_right = Copy(root->_right);
		return copyroot;
	}

	void Destroy(Node* root)
	{
		if (root == nullptr)
			return;

		Destroy(root->_left);
		Destroy(root->_right);
		delete root;
		root = nullptr;
	}

	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
		{
			Node* del = root;
			if (root->_left == nullptr)//左为空
				root = root->_right;
			else if (root->_right == nullptr)//右为空
				root = root->_left;
			else//左右不为空
			{
				Node* leftMax = root->_left;
				while (leftMax->_right)
				{
					leftMax = leftMax->_right;
				}
				swap(root->_key, leftMax->_key);
				return _EraseR(root->_left, key);
			}
			delete del;
			return true;
		}
	}

	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;
		}
	}
	
	void _InOrder(Node* root)
	{
		if (root == nullptr)
		{
			return;
		}

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

private:
	Node* _root;
};
//main.cpp
#define _CRT_SECURE_NO_WARNINGS 1

#include"BinarySearchTree.h"

//迭代版
void TestBSTree1()
{
	int a[] = { 8,3,1,10,6,4,7,14,13 };
	BSTree<int> t;

	for (auto e : a)
	{
		t.Insert(e);
	}
	BSTree<int> t1;
	t1 = t;
	t.InOrder();

	t.Erase(4);
	t.InOrder();

	t.Erase(6);
	t.InOrder();

	t.Erase(7);
	t.InOrder();

	t.Erase(3);
	t.InOrder();

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

//递归版
void TestBSTree2()
{
	int a[] = { 8,3,1,10,6,4,7,14,13 };
	BSTree<int> t;

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

	BSTree<int> t1(t);

	t1 = t;
	t.InOrder();
	t1.InOrder();

	t.EraseR(4);
	t.InOrder();
}

int main()
{
	TestBSTree1();

	return 0;
}

2.4二叉搜索树的应用

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

//main.cpp
void TestBSTree1()
{
	bit::BSTree<string, string> dict;
	dict.InsertR("insert", "插入");
	dict.InsertR("sort", "排序");
	dict.InsertR("right", "右边");
	dict.InsertR("date", "日期");

	string str;
	while (cin >> str)
	{
		bit::BSTreeNode<string, string>* ret = dict.FindR(str);
		if (ret)
		{
			cout << ret->_value << endl;
		}
		else
		{
			cout << "无此单词" << endl;
		}
	}
}

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

//main.cpp
void TestBSTree2()
{
	string arr[] = { "苹果", "西瓜", "苹果", "西瓜", "苹果", "苹果", "西瓜","苹果", "香蕉", "苹果", "香蕉", };
	bit::BSTree<string, int> countTree;
	for (auto& str : arr)
	{
		auto ret = countTree.FindR(str);
		if (ret == nullptr)
		{
			countTree.InsertR(str, 1);
		}
		else
		{
			ret->_value++;
		}
	}

	countTree.InOrder();
}

使用递归或者迭代写的二叉搜索树进行以下修改：

//BinarySearchTree.h
#define _CRT_SECURE_NO_WARNINGS 1

#pragma once
#include <iostream>
#include <utility>

using namespace std;

namespace bit
{
	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:
		BSTree()
			:_root(nullptr)
		{}

		//二叉搜索树中序遍历出来是有序的
		void InOrder()
		{
			_InOrder(_root);
			cout << endl;
		}

		Node* FindR(const K& key)
		{
			return _FindR(_root, key);
		}

		bool InsertR(const K& key, const V& value)
		{
			return _InsertR(_root, key, value);
		}

		bool EraseR(const K& key)
		{
			return _EraseR(_root, key);
		}

	private:
		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
			{
				Node* del = root;
				if (root->_left == nullptr)//左为空
				{
					root = root->_right;
				}
				else if (root->_right == nullptr)//右为空
				{
					root = root->_left;
				}
				else//左右不为空
				{
					Node* leftMax = root->_left;
					while (leftMax->_right)
					{
						leftMax = leftMax->_right;
					}

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

					return _EraseR(root->_left, key);
				}

				delete del;
				return true;
			}
		}

		bool _InsertR(Node*& root, const K& key, const V& value)
		{
			if (root == nullptr)
			{
				root = new Node(key, value);
				return true;
			}

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

		Node* _FindR(Node* root, const K& key)
		{
			if (root == nullptr)
				return nullptr;

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

		void _InOrder(Node* root)
		{
			if (root == nullptr)
			{
				return;
			}

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

	private:
		Node* _root;
	};
}

2.5二叉搜索树的性能分析

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

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

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

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

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

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

相关文章

mac安装nvm管理工具遇到的问题和解决方法

mac安装nvm管理工具遇到的问题和解决方法

nvm 是一款可以管理多版本node的工具&#xff0c;因为是刚买没多久的电脑之前用的都是windows&#xff0c;昨天折腾了一下午终于倒腾好了 第一步&#xff1a; 卸载电脑已有的node&#xff1b;访问nvm脚本网址&#xff0c;另存为到电脑上任何目录&#xff0c;我是放在桌面上的…
阅读更多...
OSPF技术入门(第三十四课)

OSPF技术入门(第三十四课)

1 OSPF的介绍 OSPF是一种链路状态路由协议，主要用于IP网络中的路由选择。它是一种开放协议，能够在不同的网络设备之间进行通信。OSPF利用链路状态数据库来描述网络拓扑结构，并通过Dijkstra算法计算出最短路径。它支持按照精确度划分的路由优先级，以及多个相等的路径，并能自…
阅读更多...
微服务分布式搜索引擎 ElasticSearch 查询文档

微服务分布式搜索引擎 ElasticSearch 查询文档

文章目录 ⛄引言一、DSL查询文档⛅DSL 查询分类 二、DSL查询实例⛅全文检索查询⏰精确查询⚡地理坐标查询⌚复合查询 ⛵小结 ⛄引言 本文参考黑马 分布式Elastic search Elasticsearch是一款非常强大的开源搜索引擎&#xff0c;具备非常多强大功能&#xff0c;可以帮助我们从海…
阅读更多...
服务器数据恢复-断电导致ext4文件系统文件丢失的数据恢复案例

服务器数据恢复-断电导致ext4文件系统文件丢失的数据恢复案例

服务器数据恢复环境&#xff1a; 一台服务器挂载一台存储设备&#xff0c;存储中划分一个Lun&#xff1b;服务器操作系统是Linux centos&#xff0c;EXT4文件系统。 服务器故障&分析&#xff1a; 意外断电导致服务器操作系统无法启动&#xff0c;系统在修复后可以正常启动&…
阅读更多...
竞赛项目 深度学习的动物识别

竞赛项目 深度学习的动物识别

文章目录 0 前言1 背景2 算法原理2.1 动物识别方法概况2.2 常用的网络模型2.2.1 B-CNN2.2.2 SSD 3 SSD动物目标检测流程4 实现效果5 部分相关代码5.1 数据预处理5.2 构建卷积神经网络5.3 tensorflow计算图可视化5.4 网络模型训练5.5 对猫狗图像进行2分类 6 最后 0 前言 &#…
阅读更多...
在Ubuntu中使用Docker启动MySQL8的天坑

在Ubuntu中使用Docker启动MySQL8的天坑

写在前面 简介&#xff1a; lower_case_table_names 是mysql设置大小写是否敏感的一个参数。 1.参数说明&#xff1a; lower_case_table_names0 表名存储为给定的大小和比较是区分大小写的 lower_case_table_names 1 表名存储在磁盘是小写的&#xff0c;但是比较的时候是不区…
阅读更多...
CMAKE生成exe文件时运行时有cmd窗口

CMAKE生成exe文件时运行时有cmd窗口

1、运行exe执行文件 会有cmd弹窗 2、解决方法 只需要在cmakelists.txt中添加set(CMAKE_CXX_FLAGS “-mwindows”) 或者在cmake时指定编译参数cmake -DCMAKE_CXX_FLAGS"-mwindows"即可 如果用的是c而不是c&#xff0c;就只需把CXX改为C 重新编译打包运行后没有cmd弹…
阅读更多...
centos自动同步北京时间

centos自动同步北京时间

1、安装ntpdate服务 yum -y install ntpdate 2、加入自动任务计划 查找ntpdate的路径&#xff1a; which ntpdate 复制这个路径。 编辑自动任务计划并加入ntpdate&#xff1a; crontab -e # 每小时第30分钟同步AD域控时间 30 * * * * /usr/sbin/ntpdate -u 192.168.2.8 > …
阅读更多...
超低成本FPGA JTAG方案

超低成本FPGA JTAG方案

今天给大家带来一款超低成本的FPGA JTAG方案&#xff0c;硬件核心是用树莓派Pico&#xff0c;使用相关芯片自己制作JTAG则非常便宜&#xff0c;RP2040某宝的报价只有4元&#xff0c;所以自己制作成本非常低廉&#xff0c;当然使用Pico成本也不是很高&#xff0c;所以今天就以Pi…
阅读更多...
ChineseChess

ChineseChess

外卖中国象棋的梗。 外卖免单题&#xff1a; 如图&#xff0c;红棋先行&#xff0c;至少几步绝杀黑房&#xff08;黑房尽量不让自己输&#xff09;&#xff1f; ChineseChess.java 【帅】是左出还是右出&#xff0c;取决于&#xff0c;上图黑方那边的【士】 如图&#xff0c…
阅读更多...
datax抽取库名带点的表遇到的问题

datax抽取库名带点的表遇到的问题

一、描述任务 使用Datax抽取mysql中的数据到hive的wedw_ods层中&#xff0c;mysql的库名为&#xff1a;b.p.n.p 表名为&#xff1a;bene_group 二、datax.json脚本生成 因为datax的脚本是自动生成的&#xff0c;生成的格式如下&#xff1a; {"core": {},"jo…
阅读更多...
竞赛项目 深度学习手势识别算法实现 - opencv python

竞赛项目 深度学习手势识别算法实现 - opencv python

文章目录 1 前言2 项目背景3 任务描述4 环境搭配5 项目实现5.1 准备数据5.2 构建网络5.3 开始训练5.4 模型评估 6 识别效果7 最后 1 前言 &#x1f525; 优质竞赛项目系列&#xff0c;今天要分享的是 &#x1f6a9; 深度学习手势识别算法实现 - opencv python 该项目较为新颖…
阅读更多...
中国信息安全测评中心CISP家族认证一览

中国信息安全测评中心CISP家族认证一览

随着国家对网络安全的重视&#xff0c;中国信息安全测评中心根据国家政策、未来趋势、重点内容陆续增添了很多CISP细分认证。 今日份详细介绍&#xff0c;部分CISP及其子品牌相关认证内容&#xff0c;一定要收藏哟&#xff01; 校园版CISP NISP国家信息安全水平考试&#xff…
阅读更多...
如何用SOLIDWORKS Simulation 避免共振现象

如何用SOLIDWORKS Simulation 避免共振现象

零件都有它的固有振动频率&#xff0c;称之为共振频率。当零部件的固有频率和激励频率相近时&#xff0c;对零部件的破坏是非常严重的&#xff0c;这就是我们说的共振。频率分析是设计师日常工作常见的设计验证。 今天给大家分享的是Simulation的频率分析操作方法&#xff1a; …
阅读更多...
黑马头条项目学习--Day3: 自媒体文章发布

黑马头条项目学习--Day3: 自媒体文章发布

Day3: 自媒体文章发布 Day3: 自媒体文章发布1) 素材管理-图片上传a) 前期微服务搭建b) 具体实现 2) 素材管理-图片列表a) 接口定义b) 具体实现 3) 素材管理-照片删除/收藏a) 图片删除a1) 接口定义a2) 代码实现 b) 收藏与取消b1) 接口定义b2) 代码实现 4) 文章管理-频道列表查询…
阅读更多...
前端面试自我介绍

前端面试自我介绍

前端面试自我介绍精选篇1 各位面试官大家好&#xff0c;我叫__&#xff0c;就读于__大学__学&#xff0c;大学本科学历&#xff0c;我的求职意向是与金融专业相关的职位&#xff0c;本人拥有较强的学习能力&#xff0c;能快速适应工作环境&#xff0c;兴趣爱好广泛&#xff0c…
阅读更多...
nginx文件共享、服务状态和location模块的配置介绍

nginx文件共享、服务状态和location模块的配置介绍

一.文件共享功能 1.清空html目录下文件并新建你要共享的文件 2.修改nginx.conf文件&#xff0c;开启autoindex功能 3.测试 二.状态模块 1.修改nginx.conf文件 2.测试 &#xff08;1&#xff09;使用刚才定义的IP/nginx_status进行访问 &#xff08;2&#xff09;status参…
阅读更多...
Qt应用开发(基础篇)——工具箱 QToolBox

Qt应用开发(基础篇)——工具箱 QToolBox

一、前言 QToolBox类继承于QFrame&#xff0c;QFrame继承于QWidget&#xff0c;是Qt常用的基础工具部件。 框架类QFrame介绍 QToolBox工具箱类提供了一列选项卡窗口&#xff0c;当前项显示在当前选项卡下面&#xff0c;适用于分类浏览、内容展示、操作指引这一类的使用场景。 二…
阅读更多...
点的复合运动

点的复合运动

一、问题所在 对于复合运动中的牵连运动一直很蒙&#xff0c;之前做题的时候都是靠经验&#xff0c;比如圆盘选择圆心做动系原点、连杆选择牵连点做原点等&#xff0c;今天重新整理了一下。 牵连运动的定义是动系相对于定系的运动&#xff0c;这个定义就很模糊。如果是指动系…
阅读更多...
MySQL之 show profile 相关总结

MySQL之 show profile 相关总结

MySQL之 show profile 相关总结 MySQL官网show profile介绍&#xff1a;https://dev.mysql.com/doc/refman/8.0/en/show-profile.html 1. 简介 show profile 和 show profiles 命令用于展示SQL语句的资源使用情况&#xff0c;包括CPU的使用&#xff0c;CPU上下文切换&#xf…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023