C++语法（17）---- 二叉搜索树

news2025/1/22 16:01:27

1.概念

1.父节点的左子树全小于本身

2.父节点的右子树全大于本身

3.左右子树也是二叉搜索树

时间复杂度：O(N)，有可能只有左数，这样就遍历了所有，所有复杂度为N

平衡二叉树的时间复杂度才是：O(logN)

2.模拟

1.数据元素设计

1.一个空间存储数据date

2.两个指针，用于指向左右子树的位置

template<class K>
struct BSTreeNode
{
	BSTreeNode(const K& key)
		:_key(key)
		,_left(nullptr)
		,_right(nullptr)
	{}
	BSTreeNode<K>* _left;
	BSTreeNode<K>* _right;
	K _key;
};

2. 搜索二叉树类的定义

template<class K>
class BSTree
{
private:
	Node* _root = nullptr;
};

3.构造函数，拷贝构造，赋值拷贝

1.构造函数，直接定义空树

2.拷贝构造，取调用私有的copy函数

3.赋值拷贝，直接swap两个地址

copy函数的实现，其实是递归拷贝

1.确认传入参数是二叉搜索树的指针；返回返回头指针

2.如果指向的指针是空，则返回

3.构造函数后再考虑左右，所以实现是靠前序遍历

4.一个节点为单位，指向有数据的节点，则new一个新的指针，数据拷贝

5.new出来的子节点，左树由copy函数构建，右树也由copy函数构建

BSTree()
	:_root(nullptr)
{}

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

BSTree<K>& operator=(BSTree<K> t)
{
	swap(_root, t._root);
	return *this;
}

private:
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;
}

4.析构函数

析构函数，调用Destory函数，再把_root指向空

相同的，Destory也可以通过递归销毁

1.确认传入参数是二叉搜索树的指针；由于销毁所以返回的值不需要

2.如果指向的指针是空，则返回

3.前面的销毁，后面就找不到了；所以我们要到最后再销毁最开始的指针，所以用后后续遍历

4.Destory左右子树

5.走到最后，要销毁指针

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

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

	Destory(root->_left);
	Destory(root->_right);
	delete root;
}

5.二分法实现增删查

由于左小右大，完美符合二分法的实现

Insert

1.如果为空，则更新_root，把节点的数据存储k；如果不为空向下走

2.临时变量cur和parent指针，cur指向开头；随后比较，小左大右；更新parent为旧的cur

3.如果夹在中间的k跟parent与cur存在逻辑矛盾返回false

4.k夹在parent和cur之间，cur位置就是k要存储的位置；cur重新new成数据为k的节点，通过parent指针找到原先的cur，中间插入即可，随后返回true

Find：直接找，二分法，找到了返回true，找不到返回false

Erase：先找到该k数据对于节点，随后请看代码的注释

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

	cur = new Node(k);

	if (parent->_key > k)
			parent->_left = cur;
	else
		parent->_right = cur;

	return true;
}

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

bool Erase(const K& k)
{
	Node* cur = _root;
	Node* parent = nullptr;
	while (cur)
	{
		if (cur->_key < k)
		{
			parent = cur;
			cur = cur->_right;
		}
		else if (cur->_key > k)
		{
			parent = cur;
			cur = cur->_left;
		}
		else
		{
			//删除节点的左子树为空
			//父节点连接节点的右字数
			if (cur->_left == nullptr)
			{
				if (cur == _root)  // 删除的1，2两种情况下，解决parent为空的情况
					_root = cur->_right;
				else
				{
					if (parent->_key > k) //说明cur在parent的左边
						parent->_left = cur->_right;
					else
						parent->_right = cur->_right;
				}
				delete cur;
				return true;
			}
			//删除节点的右子树为空
			//父节点连接节点的左字数
			else if (cur->_right == nullptr)
			{
				if (cur == _root)
					_root = cur->_left;
				else
				{
					if (parent->_key > k) //说明cur在parent的左边
						parent->_left = cur->_left;
					else
						parent->_right = cur->_left;
				}
				delete cur;
				return true;
			}
			else
			{
				Node* pur = cur;
				Node* tmp = Get_Max(cur->_left, pur);
				cur->_key = tmp->_key;
				if (pur->_right == tmp)
					pur->_right = tmp->_left;
				else
					pur->_left = tmp->_right;
				delete tmp;
				return true;
			}
		}
	}
	return false;
}

6.递归实现增删查

bool _InsertR(Node*& root, const K& k)
	{
		if (root==nullptr)
		{
			root = new Node(k);
			return true;
		}
		if (root->_key < k)
			return _InsertR(root->_right, k);
		else if (root->_key > k)
			return _InsertR(root->_left, k);
		else
			return false;
	}

	bool _Find(Node* root, const K& k)
	{
		if (root == nullptr)
			return false;
		if (root->_key > k)
			_Find(root->_left, k);
		else if (root->_key < k)
			_Find(root->_left, k);
		else
			return true;
	}

	bool _Erase(Node*& root, const K& k)
	{
		if (root == nullptr)
			return false;

		if (root->_key > k)
			_Erase(root->_left, k);
		else if (root->_key < k)
			_Erase(root->_right, k);
		else
		{
			Node* del = root;
			if (root->_left == nullptr)
				root = root->_right;
			else if(root->_right == nullptr)
				root = root->_left;
			else
			{
				Node* minRight = root->_right;
				while (minRight->_left)
				{
					minRight = minRight->_left;
				}
				swap(root->_key, minRight->_key);
				return _Erase(root->_right, k);
			}
			delete del;
			return true;
		}
	}

3.整体实现

template<class K>
struct BSTreeNode
{
	BSTreeNode(const K& key)
		:_key(key)
		,_left(nullptr)
		,_right(nullptr)
	{}
	BSTreeNode<K>* _left;
	BSTreeNode<K>* _right;
	K _key;
};

template<class K>
class BSTree
{
	typedef BSTreeNode<K> Node;
public:
	BSTree()
		:_root(nullptr)
	{}

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

	BSTree<K>& operator=(BSTree<K> t)
	{
		swap(_root, t._root);
		return *this;
	}

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

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

		cur = new Node(k);

		if (parent->_key > k)
			parent->_left = cur;
		else
			parent->_right = cur;

		return true;
	}

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

	bool Erase(const K& k)
	{
		Node* cur = _root;
		Node* parent = nullptr;
		while (cur)
		{
			if (cur->_key < k)
			{
				parent = cur;
				cur = cur->_right;
			}
			else if (cur->_key > k)
			{
				parent = cur;
				cur = cur->_left;
			}
			else
			{
				//删除节点的左子树为空
				//父节点连接节点的右字数
				if (cur->_left == nullptr)
				{
					if (cur == _root)  // 删除的1，2两种情况下，解决parent为空的情况
						_root = cur->_right;
					else
					{
						if (parent->_key > k) //说明cur在parent的左边
							parent->_left = cur->_right;
						else
							parent->_right = cur->_right;
					}
					delete cur;
					return true;
				}
				//删除节点的右子树为空
				//父节点连接节点的左字数
				else if (cur->_right == nullptr)
				{
					if (cur == _root)
						_root = cur->_left;
					else
					{
						if (parent->_key > k) //说明cur在parent的左边
							parent->_left = cur->_left;
						else
							parent->_right = cur->_left;
					}
					delete cur;
					return true;
				}
				else
				{
					Node* pur = cur;
					Node* tmp = Get_Max(cur->_left, pur);
					cur->_key = tmp->_key;
					if (pur->_right == tmp)
						pur->_right = tmp->_left;
					else
						pur->_left = tmp->_right;
					delete tmp;
					return true;
				}
			}
		}
		return false;
	}

	void Print()
	{
		_Print(_root);
		cout << endl;
	}

	/*bool InsertR(const K& k)
	{
		if (_root == nullptr)
		{
			_root = new Node(k);
			return true;
		}
		Node* parent = nullptr;
		return _InsertR(_root, k, parent);
	}*/

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

	bool FindR(const K& k)
	{
		return _Find(_root, k);
	}

	bool EraseR(const K& k)
	{
		return _Erase(_root, k);
	}

private:

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

	/*bool _InsertR(Node* root, const K& k, Node* &parent)
	{
		Node* cur = root;
		if (cur != nullptr)
		{
			if (cur->_key > k)
			{
				parent = cur;
				_InsertR(cur->_left, k, parent);
			}
			else if (cur->_key < k)
			{
				parent = cur;
				_InsertR(cur->_right, k, parent);
			}
		}
		else
		{
			cur = new Node(k);
			if (parent->_key > k)
				parent->_left = cur;
			else
				parent->_right = cur;
			return true;
		}
		if (root->_key == k)
			return false;
	}*/

	//进阶思路----引用的使用
	bool _InsertR(Node*& root, const K& k)
	{
		if (root==nullptr)
		{
			root = new Node(k);
			return true;
		}
		if (root->_key < k)
			return _InsertR(root->_right, k);
		else if (root->_key > k)
			return _InsertR(root->_left, k);
		else
			return false;
	}

	bool _Find(Node* root, const K& k)
	{
		if (root == nullptr)
			return false;
		if (root->_key > k)
			_Find(root->_left, k);
		else if (root->_key < k)
			_Find(root->_left, k);
		else
			return true;
	}

	bool _Erase(Node*& root, const K& k)
	{
		if (root == nullptr)
			return false;

		if (root->_key > k)
			_Erase(root->_left, k);
		else if (root->_key < k)
			_Erase(root->_right, k);
		else
		{
			Node* del = root;
			if (root->_left == nullptr)
				root = root->_right;
			else if(root->_right == nullptr)
				root = root->_left;
			else
			{
				Node* minRight = root->_right;
				while (minRight->_left)
				{
					minRight = minRight->_left;
				}
				swap(root->_key, minRight->_key);
				return _Erase(root->_right, k);
			}
			delete del;
			return true;
		}
	}

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

		Destory(root->_left);
		Destory(root->_right);
		delete root;
	}

	Node* Get_Max(Node* root, Node* &parent)
	{
		while (root->_right)
		{
			parent = root;
			root = root->_right;
		}
		return root;
	}

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

private:
	Node* _root = nullptr;
};

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

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

相关文章

Postman抓包教程

Postman抓包教程

目录 什么是抓包&#xff1f; 如何使用 Postman 进行抓包 查看历史抓包数据 使用抓包数据进行接口测试和开发 抓包技巧和注意事项 什么是抓包&#xff1f; 在计算机网络中&#xff0c;抓包是指捕获网络流量的过程。抓包工具可以截获进出计算机网络的数据流&#xff0c;并将…
阅读更多...
反向传播推导+numpy实现

反向传播推导+numpy实现

很久没有看深度学习了&#xff0c;忘了好多东西。本来想着推导一下&#xff0c;后来发现自己不会了。 再看看以前写的代码&#xff0c;又避开了最终的东西&#xff0c;于是决定重新推导一下。 数据的说明 首先&#xff0c;我们要做一个回归的任务&#xff0c;我们使用numpy随…
阅读更多...
5.Java循环控制语句

5.Java循环控制语句

Java循环控制语句 循环是Java中应用最为广泛的一个知识点&#xff0c;所以也是很需要掌握的。所谓循环&#xff0c;即通过判断条件&#xff0c;重复执行一段代码&#xff0c;根据条件的变化&#xff0c;来确定代码是否执行&#xff0c;执行次数。 一、循环结构 1、while循环…
阅读更多...
Java IO常用操作详解（代码示例）

Java IO常用操作详解（代码示例）

概览 Java I/O操作指的是数据的输入/输出操作。 Java的I/O操作类在java.io包中&#xff0c;主要分以下几种&#xff1a; 基于字节操作的I/O接口&#xff1a; InputStream和OutputStream基于字符操作的I/O接口&#xff1a; Writer和Reader基于磁盘操作的I/O接口&#xff1a; …
阅读更多...
5个令人惊艳的AI项目，开源了。。

5个令人惊艳的AI项目，开源了。。

大家好&#xff0c;我是 Jack。 今天清明&#xff0c;小伙伴们都去哪里玩了&#xff1f; 上个月我已经出去浪过了&#xff0c;清明就老实在家歇着了。 翻看了一些最近热点的开源项目&#xff0c;发现还是 AIGC 的天下。 今天&#xff0c;我将继续着重挑选几个近期的优质开源…
阅读更多...
2023第十四届蓝桥杯C++B组菜鸡的落幕

2023第十四届蓝桥杯C++B组菜鸡的落幕

时隔几天&#xff0c;终于还是忍不住来复盘一下蓝桥杯了&#xff0c;还记得去年参加做下填空&#xff0c;再做对个把编程&#xff0c;后面不会的大题打打表混混分&#xff0c;最后就能混个省奖&#xff0c; 这回估计凉透了,填空没对似乎&#xff0c;编程也没对几个&#xff0c;…
阅读更多...
Kettle8.2.0连接Hive3.1.2(踩坑，亲测有效)

Kettle8.2.0连接Hive3.1.2(踩坑，亲测有效)

这是目前遇到的最简单但最头疼的安装&#xff0c;因为是在公司之前用过的服务器上进行安装测试&#xff0c;加上又使用比较新的版本&#xff0c;结果踩了不少坑。Kettle连接Hive这个坑&#xff0c;从2023年4月11日下午开始&#xff0c;一致到2023年4月12日中午才弄好&#xff0…
阅读更多...
uni-app常用配置

uni-app常用配置

保存自动格式化 工具》设置》编辑器设置》保存时自动格式化 JS语法检查 安装eslint-js插件eslint-js - DCloud 插件市场 用于校验js和html中的js代码https://ext.dcloud.net.cn/plugin?id2037工具》设置》插件配置》eslint-js 启用实时校检 Vue语法检查 安装eslint-vue插…
阅读更多...
【星界探索——通信卫星】铱星：从“星光坠落”到“涅槃重生”，万字长文分析铱星卫星系统市场

【星界探索——通信卫星】铱星：从“星光坠落”到“涅槃重生”，万字长文分析铱星卫星系统市场

【星界探索——通信卫星】铱星&#xff1a;从“星光坠落”到“涅槃重生”一、铱星简介二、铱星系统设计思路2.1 工作原理2.2 铱星布局三、铱星优势四、发展历程五、第一代铱星公司的破产原因分析5.1 终端和资费价格高昂&#xff0c;市场用户群体小5.2 财务危机5.3 市场分析不足…
阅读更多...
一文吃透低代码平台源代码交付的重要性（避坑指南）

一文吃透低代码平台源代码交付的重要性（避坑指南）

一、前言 作为这两年IT界的风口&#xff0c;低代码在众人眼里已经不是什么陌生的概念。 对标于传统的纯代码开发&#xff0c;低代码是一种快速开发软件&#xff08;应用程序&#xff09;的方法&#xff0c;平台通过对大量功能与场景做提前封装&#xff0c;使得用户可以在可视…
阅读更多...
MySQL开发05-MySQL开发规范

MySQL开发05-MySQL开发规范

文章目录1、命名规范2、表设计规范3、索引规范4、SQL语句规范5、SQL脚本规范6、数据架构规范7、配置文件建议8、其他规范9、总结1、命名规范 命名应有意义&#xff0c;包括库名、表名、用户名等&#xff0c;以使用方便记忆、描述性强的可读性名称为第一准则&#xff0c;尽量避…
阅读更多...
Docker网络案例

Docker网络案例

bridge 是什么 Docker 服务默认会创建一个 docker0 网桥（其上有一个 docker0 内部接口），该桥接网络的名称为docker0，它在内核层连通了其他的物理或虚拟网卡，这就将所有容器和本地主机都放到同一个物理网络。Docker 默认指定了 docker0 接口 的 IP 地址和子网掩码，让主机…
阅读更多...
C#基础复习

C#基础复习

语句 目录 语句 switch&#xff1a; 跳转语句 标签语句 标签&#xff1a; 标签语句的作用域 goto语句 using 语句 资源的包装使用 using 语句示例&#xff1a; 多个资源和嵌套 语句是描述某个类型或让程序执行某个动作的源代码指令 块在语法上算作一个单条嵌入语句。任何语…
阅读更多...
【cmake学习】搭建一个简单的cmake工程（初级版）

【cmake学习】搭建一个简单的cmake工程（初级版）

目录 1、工程框架介绍 2、编写CMakeLists.txt (1) 限制cmake最低版本、工程命名 (2) 引入头文件目录 (3) 引入库目录&#xff08;可选&#xff09; (4) 引入源文件 (5) 生成可执行文件 / 生成动静态库 (6) 链接库文件&#xff08;可选&#xff09; 3、完整CMakeLists…
阅读更多...
uefi 内存管理

uefi 内存管理

PEI 阶段 PEI 阶段最为重要的结构是HOB, 初始化内存服务前&#xff0c;PEI 申请的内存其实是插入到FV 文件 也就是FLASH 里面去运行。 在此状态下&#xff0c;FLASH 可读不可写&#xff0c;所以是不能使用全局变量的。如果有需要模块间共享信息&#xff0c;需要申请HOB. HO…
阅读更多...
gtkmm给组件添加css

gtkmm给组件添加css

设置方式 使用CSS分为两步&#xff0c;1:为组件设这css名称&#xff0c;2:加载样式表。 样式表我们写在文件中就行&#xff08;似乎也可以从字符串加载&#xff0c;不过不推荐&#xff09;。 1. 设置css名称 使用gtk的接口&#xff1a;gtk_widget_class_set_css_name()。 这…
阅读更多...
rk3568点亮E-ink

rk3568点亮E-ink

rk3568 Android11/12 适配 E-ink “EINK”是英语ElectronicInk的缩写。翻译成中文为“电子墨水”。电子墨水由数百万个微胶囊(Microcapsules)所构成&#xff0c;微胶囊的大小约等同于人类头发的直径。每个微胶囊里含有电泳粒子──带负电荷的白色以及带正电荷的黑色粒子&#…
阅读更多...
Ubuntu 交叉编译Windows 版本的ffmpeg最佳实践

Ubuntu 交叉编译Windows 版本的ffmpeg最佳实践

之前介绍在Windows上采用msys2+minGW或者cygwin在Windows编译方法。很多读者觉得在Windows搭建一个类Linux比较麻烦或者说方法不够通用，本文就介绍在流行的Linux发行版Ubuntu上编译window版本的ffmpeg。即介绍一种通用办法来编译Windows版本ffmpeg，该方法可以推广到android，…
阅读更多...
算法 贪心4 || 860.柠檬水找零 406.根据身高重建队列 452. 用最少数量的箭引爆气球

算法 贪心4 || 860.柠檬水找零 406.根据身高重建队列 452. 用最少数量的箭引爆气球

860.柠檬水找零 很简单的一题&#xff0c;完全是常识题 class Solution { public:bool lemonadeChange(vector<int>& bills) {unordered_map<int,int> map;for(int i 0; i < bills.size(); i){map[bills[i]];if(bills[i] ! 5){if(map[5] 0) return fals…
阅读更多...
【Linux】程序中获取和设置cpu和mem相关信息

【Linux】程序中获取和设置cpu和mem相关信息

这里是目录一、CPU和MEM信息1.1、CPU信息1.1.1、CPU核心数1.1.2、CPU频率读取和调整1.1.3、CPU温度1.2、MEM信息二、C程序读取CPU和MEM信息三、测试写在前面&#xff1a; 记录一下日常&#xff0c;之前有做过相关工作&#xff0c;但是没有记录下来&#xff0c;因此写一写文章。…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023