c++修炼之路之二叉搜索树

news2024/9/9 0:09:14

目录

前言

一：二叉搜索树的介绍

 二：二叉搜索树的实现 

1.查找

2.insert(插入)

3.erase(删除)

4.析构函数

5.拷贝构造 

6.赋值重载

7.插入，删除，查找的递归版本 

三：二叉搜索树的应用

四：二叉搜索树的性能

接下来的日子会顺顺利利，万事胜意，生活明朗-----------林辞忧 

前言

对于普通的二叉树去存储管理数据等方面是不如一些容器的，所以学习二叉搜索树这样特殊的树是很有必要的

一：二叉搜索树的介绍

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

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

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

   3.它的左右子树也分别为二叉搜索树

 二：二叉搜索树的实现 

1.查找

如二叉树一样依次循环往下找，直至为空

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
{
public:
	typedef BSTreeNode<K> Node;
    Node* _root=nullptr;

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 cur;
		}
	}
	return false;
}

2.insert(插入)

a. 树为空，则直接新增节点，赋值给root指针

b. 树不空，按二叉搜索树性质查找插入位置，插入新节点

 

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 > cur->_key)
	{
		parent->_left = cur;
	}
	else
	{
		parent->_right = cur;
	}

	return true;
}

3.erase(删除)

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

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

 

 

 

 

bool erase(const K& 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
		{
			//找到了开始删除
			if (cur->_left == nullptr)//左为空
			{
				if (parent == nullptr)
				{
					_root = cur->_right;
				}
				else
				{
					if (parent->_left == cur)
					{
						parent->_left = cur->_right;
					}
					else
					{
						parent->_right = cur->_right;
					}
				}
				delete cur;
			}
			else if (cur->_right == nullptr)//右为空
			{
				if (parent == nullptr)
				{
					_root = cur->_left;
				}
				else
				{
					if (parent->_left == cur)
					{
						parent->_left = cur->_left;
					}
					else
					{
						parent->_right = cur->_left;
					}
				}
				delete cur;
			}
			else if (cur->_left && cur->_right)//左右都不为空--替换法
			{
				//寻找右子树的最左节点
				Node* SubR = cur->_right;
				parent = cur;
				while (SubR->_left)
				{
					parent = SubR;
					SubR = SubR->_left;
				}
				//交换值
				swap(cur->_key, SubR->_key);
				if (parent->_left == SubR)
					parent->_left = SubR->_right;
				else
					parent->_right = SubR->_right;
				delete SubR;
			}
			return true;
		}
	}
	return false;
}

4.析构函数

~BSTree()
{
	Destroy(_root);
}
void Destroy(Node* root)
{
	//后序析构
	if (root == nullptr)
		return;
	Destroy(root->_left);
	Destroy(root->_right);
	delete root;
}

5.拷贝构造 

//拷贝构造
//b1(b2)
BSTree(const BSTree<K>& t)
{
	_root = Copy(t._root);
}

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

6.赋值重载

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

7.插入，删除，查找的递归版本 

bool InsertR(const K& key)
{
	return _InsertR(_root, key);
}
bool FindR(const K& key)
{
	return _FindR(_root, key);
}
bool EraseR(const K& key)
{
	return _EraseR(_root, key);
}

bool _FindR(Node* root, const K& key)
{
	if (root)
	{
		if (key > root->_key)
		{
			return _FindR(root->_right, key);
		}
		else if (key < root->_key)
		{
			return _FindR(root->_left, key);
		}
		else
			return true;
	}
	return false;
}

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

bool _EraseR(Node*& root, const K& key)
{
	if (root)
	{
		if (key > root->_key)
		{
			return _EraseR(root->_right, key);
		}
		else if (key < root->_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 true;
		}
	}
	return false;
}

三：二叉搜索树的应用

1. K模型：K模型即只有key作为关键码，结构中只需要存储Key即可，关键码即为需要搜索到
的值。
比如：给一个单词word，判断该单词是否拼写正确，具体方式如下：
以词库中所有单词集合中的每个单词作为key，构建一棵二叉搜索树
在二叉搜索树中检索该单词是否存在，存在则拼写正确，不存在则拼写错误。
2. KV模型：每一个关键码key，都有与之对应的值Value，即<Key, Value>的键值对。该种方
式在现实生活中非常常见：
比如英汉词典就是英文与中文的对应关系，通过英文可以快速找到与其对应的中文，英
文单词与其对应的中文<word, chinese>就构成一种键值对；
再比如统计单词次数，统计成功后，给定单词就可快速找到其出现的次数，单词与其出
现次数就是<word, count>就构成一种键值对。

改造一份key_value型的二叉搜索树

	template<class K,class V>
	class BSTree
	{
	public:
		typedef struct BSTreeNode<K,V> Node;
		//插入数据
		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)
			{
				parent = cur;
				if (key > cur->_key)
				{
					cur = cur->_right;
				}
				else if (key < cur->_key)
				{
					cur = cur->_left;
				}
				else
				{
					return false;
				}
			}
			cur = new Node(key,value);
			if (parent->_key < cur->_key)
			{
				parent->_right = cur;
			}
			else
			{
				parent->_left = cur;
			}
			return true;
		}
		Node* Find(const K& key)
		{
			if (_root == nullptr)
				return nullptr;

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

			//查找位置删除
			Node* cur = _root;
			Node* parent = nullptr;
			while (cur)
			{
				if (key > cur->_key)
				{
					parent = cur;
					cur = cur->_right;
				}
				else if (key < cur->_key)
				{
					parent = cur;
					cur = cur->_left;
				}
				else
				{
					//左为空
					if (cur->_left == nullptr)
					{
						if (cur == _root)
						{
							_root = _root->_right;
						}
						else
						{
							//判断parent与cur的位置关系
							if (parent->_left == cur)
							{
								parent->_left = cur->_right;
							}
							else
							{
								parent->_right = cur->_right;
							}
						}
						delete cur;
					}
					else if (cur->_right == nullptr)//右为空
					{
						if (cur == _root)
						{
							_root = _root->_left;
						}
						else
						{
							//判断parent与cur的位置关系
							if (parent->_left == cur)
							{
								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 (parent->_left == SubLeft)
						{
							parent->_left = SubLeft->_right;
						}
						else
						{
							parent->_right = SubLeft->_right;
						}
						delete SubLeft;
					}
					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);
		}
		
		Node* _root = nullptr;
	};
};

四：二叉搜索树的性能

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

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

相关文章

精灵图的使用——网页制作技巧

精灵图的使用——网页制作技巧

把许多小图标集中在一张背景透明的图片上&#xff0c;这种图片叫做精灵图&#xff0c;如下图。 在线工具地址&#xff1a;http://www.spritecow.com/ 通过工具可以快速找到图标在精灵图上的坐标位置。 首先&#xff0c;我们打开工具地址&#xff0c;点击第一个按钮。 点击后&am…
阅读更多...
LeetCode 算法：搜索二维矩阵 c++

LeetCode 算法：搜索二维矩阵 c++

原题链接&#x1f517;&#xff1a;搜索二维矩阵 难度&#xff1a;中等⭐️⭐️ 题目 给你一个满足下述两条属性的 m x n 整数矩阵&#xff1a; 每行中的整数从左到右按非严格递增顺序排列。每行的第一个整数大于前一行的最后一个整数。给你一个整数 target &#xff0c;如果…
阅读更多...
实战：ZooKeeper 操作命令和集群部署

实战：ZooKeeper 操作命令和集群部署

ZooKeeper 操作命令 ZooKeeper的操作命令主要用于对ZooKeeper服务中的节点进行创建、查看、修改和删除等操作。以下是一些常用的ZooKeeper操作命令及其说明&#xff1a; 一、启动与连接 启动ZooKeeper服务器&#xff1a; ./zkServer.sh start这个命令用于启动ZooKeeper服务器…
阅读更多...
手搓排序算法：插入排序、选择排序

手搓排序算法：插入排序、选择排序

文章目录 插入排序直接插入排序希尔排序内层循环时间复杂度计算 选择排序直接选择排序优化 堆排序 插入排序 直接插入排序 时间复杂度最差&#xff1a;大的数据都在左边&#xff0c;小的数据在右边&#xff0c;随着有序区间增大&#xff0c;交换次数增多 时间复杂度最优&…
阅读更多...
C#知识|文本文件操作：删除、复制、移动文件的操作

C#知识|文本文件操作：删除、复制、移动文件的操作

哈喽，你好啊，我是雷工！ 接下来学习文件的删除和复制，实际应用场景，当软件具有自动在线更新功能时，需要先检测服务器是否具有更新版本的安装包，如果有的话需要将其复制到本地进行升级安装，如果有勾选自动清理安装包功能的话，还可以将安装包删除。 01 删除文件 实现功能…
阅读更多...
使用MultipartFile来上传单个及多个文件代码示例（前端传参数及后端接收）

使用MultipartFile来上传单个及多个文件代码示例（前端传参数及后端接收）

背景 前端使用vue或vue+vant上传文件 后端java接收MultipartFile和其他参数 一、MultipartFile上传单个文件代码示例 1.1 MultipartFile上传单个文件,不包含其它参数 1.1.1 控制层代码如下： /*** 1、上传单个文件,不包含其它参数* */ @PostMapping( "/upload")…
阅读更多...
docker 建木 发版 （详细教程）

docker 建木 发版 （详细教程）

先创建git仓库 Git勤勉 两种方式上传-CSDN博客 把项目送上去 进入建木 可以接着这个来 dockerfile部署镜像 -&#xff1e;push仓库 -&#xff1e;虚拟机安装建木 -&#xff1e;自动部署化 (详细步骤)-CSDN博客 创建分组项目 开始操作 git 上钩子 前面链接里有这个教…
阅读更多...
MobaXterm tmux 配置妥当

MobaXterm tmux 配置妥当

一、事出有因 缘由&#xff1a;接上篇文章&#xff0c;用Docker搭建pwn环境后&#xff0c;用之前学过的多窗口tmux进行调试程序&#xff0c;但是鼠标滚动的效果不按预期上下翻屏。全网搜索很难找到有效解决办法&#xff0c;最后还是找到了一篇英文文章&#xff0c;解决了&…
阅读更多...
upload-labs靶场练习

upload-labs靶场练习

文件上传函数的常见函数&#xff1a; 在PHP中&#xff0c;‌文件上传涉及的主要函数包括move_uploaded_file(), is_uploaded_file(), get_file_extension(), 和 mkdir()。‌这些函数共同协作&#xff0c;‌使得用户可以通过HTTP POST方法上传文件&#xff0c;‌并在服务器上保存…
阅读更多...
浅谈C语言整型类数据在内存中的存储

浅谈C语言整型类数据在内存中的存储

1、整型类数据 C语言中的整型类数据都归类在整型家族中&#xff0c;其中包括&#xff1a;char、short、int、long、long long这5个大类&#xff0c;而每个大类中又分为两类signed和unsigned,这些都是C语言中的内置类型。以下重点基于char和int这两种类型的数据进行阐述&#x…
阅读更多...
妈吖，看过这个大厂的oracle主键自增，我的信心暴增！信创，国产数据库也能行。

妈吖，看过这个大厂的oracle主键自增，我的信心暴增！信创，国产数据库也能行。

创作不易 只因热爱!! 热衷分享&#xff0c;一起成长! “你的鼓励就是我努力付出的动力” 1.数据库oracle自增主键字段思维导图 在Oracle数据库中&#xff0c;可以通过创建序列&#xff08;SEQUENCE&#xff09;来实现自增功能。但也可以不在数据库中实现&#xff0c;而是通过程…
阅读更多...
Sequential的使用

Sequential的使用

卷积前后尺寸不变的 Padding值计算&#xff1a; padding &#xff08;卷积核尺寸-1&#xff09;/2 Sequential 可以简化代码&#xff1a; def __init__(self):super(Tudui, self).__init__()self.model1 Sequential(Conv2d(3, 32, 5, padding2),MaxPool2d(2),Conv2d(32, 32…
阅读更多...
ctfshow web入门 CMS web477--web479

ctfshow web入门 CMS web477--web479

web477 CMSEazy5.7 不让扫&#xff0c;那就尝试一下admin路由&#xff0c;成功了 admin登录进入后台 也看到了其实 首页可以看到提示 然后去自定义标签打 1111111111";}<?php phpinfo()?>刷新一下预览即可 11";}<?php assert($_POST[g]);?>也可…
阅读更多...
Git和TortoiseGit的安装与使用

Git和TortoiseGit的安装与使用

文章目录 前言一、Git安装步骤查看版本信息 二、TortoiseGit安装中文语言包TortoiseGit 配置不同语言 Git基本原理介绍及常用指令 GitLab添加TortoiseGIT生成SSH Key 前言 Git 提供了一种有效的方式来管理项目的版本&#xff0c;协作开发&#xff0c;以及跟踪和应用文件的变化…
阅读更多...
【FPGA设计】千兆以太网

【FPGA设计】千兆以太网

一. OSI 七层模型 OSI&#xff08;Open Systems Interconnection&#xff09;七层模型是由国际标准化组织&#xff08;ISO&#xff09;制定的一个概念模型&#xff0c;用于描述网络中各部分如何通信。这个模型将网络通信分解为七个不同的层次&#xff0c;每一层都有特定的功能…
阅读更多...
嵌入式学习Day14---C语言进阶

嵌入式学习Day14---C语言进阶

目录 一、构造类型 1.1.结构体 1.存储 2.输入输出&#xff08;传参&#xff09; 3.结构体数组 1.2.共同体&#xff08;联合体&#xff09; 1.格式 2.存储 3.测试一个平台是打端还是小端 1.3.枚举 1.格式 2.特点 二、位运算&#xff08;操作二进制&#xff09; 2.1.&a…
阅读更多...
研究人员在进行文献综述时可能面临哪些挑战以及如何解决这些挑战

研究人员在进行文献综述时可能面临哪些挑战以及如何解决这些挑战

VersaBot一键生成文献综述 对于研究人员来说&#xff0c;进行全面的文献综述可能是一种丰富但具有挑战性的经历。以下是一些常见的障碍以及如何克服这些障碍的技巧&#xff1a; 挑战 1. 信息过载&#xff1a; 已有大量已发表的研究成果&#xff0c;识别、选择和管理相关来源…
阅读更多...
学到了一种新的技巧

学到了一种新的技巧

1、通过erase删除方向&#xff0c;让原本很复杂的代码变得简洁。 2、通过return两个不同类型的答案&#xff0c;使得代码量变得更少。 3、通过bfs将状态转移给后面。 4、这种集成的技巧&#xff0c;根据相同点把不同类的代码组合成一个函数&#xff0c;这种技巧是需要学习的…
阅读更多...
React 的 KeepAlive 实战指南：深度解析组件缓存机制

React 的 KeepAlive 实战指南：深度解析组件缓存机制

Vue 的 Keep-Alive 组件是用于缓存组件的高阶组件&#xff0c;可以有效地提高应用性能。它能够使组件在切换时仍能保留原有的状态信息&#xff0c;并且有专门的生命周期方便去做额外的处理。该组件在很多场景非常有用&#xff0c;比如&#xff1a; tabs 缓存页面 分步表单 …
阅读更多...
C++类与对象-六大成员函数

C++类与对象-六大成员函数

默认成员函数就是用户没有显式实现&#xff0c;编译器会⾃动⽣成的成员函数称为默认成员函数。⼀个空类编译器会默认⽣成8个默认成员函数。本文只介绍其中6个&#xff0c;C11增加两个函数见后续博客。 目录 一、构造函数 1.1 概念 1.2 特性 1.3 使用举例 1.4 初始化列表 1…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023