二叉搜索树（BST）的模拟实现

news2024/11/19 1:36:04

序言：

构造一棵二叉排序树的目的并不是为了排序，而是为了提高查找效率、插入和删除关键字的速度，同时二叉搜索树的这种非线性结构也有利于插入和删除的实现。

二叉搜索树的表示及相关算法_雨纷飞-CSDN博客

目录

（一）BST的定义

（二）二叉搜索树操作

1、BST的查找

2、BST的插入

3、BST的删除

（三）二叉排序树的实现（非递归）

1、查找实现

2、插入实现

3、删除实现

（四）二叉排序树的实现（递归）

1、查找操作

2、插入操作

3、删除操作

（五）其他操作

1、析构

2、构造和拷贝构造

3、赋值重载

（六）总结

（一）BST的定义

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

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

（二）二叉搜索树操作

我以下图这棵二叉树为例，给大家进行有关二叉树操作的讲解：

1、BST的查找

思想：

  1. 二叉搜索树的查找是从根节点开始的，沿某个分支逐层的向下比较的过程；
  2. 若二叉排序树非空，先将给定值与根节点的关键字进行比较，若相等则查找成功；
  3. 若不等，如果小于根节点的关键字，则在根节点的左子树上进行查找；
  4. 否则，就在根节点的右侧进行查找。这显然是一个递归的过程！！

举例：

  1. 例如，对于上述二叉树我想要查找值为【6】的结点。
  2. 首先 6 与根节点 8 进行比较，由于 6<8 ，因此需要在根节点8的左子树中继续查找；
  3. 由于 3<6，因此在结点 3 的右子树中进行查找，最后查询成功。

2、BST的插入

二叉排序树作为一种动态树表，其特点是树的结构通常不是一次生成的，而是在查找过程中存在关键字值等于给定值的结点时再进行插入的。

插入结点的过程如下：

  1. 若原二叉排序树为空，则直接插入；
  2. 否则，若关键字 k 小于根结点值左子树；
  3. 若关键字 k 大于根结点值，则插入到右子树；

插入的结点一定是一个新添加且是查找失败时的查找路径上访问的最后一个结点的左孩子或右孩子。

3、BST的删除

在二叉排序树中删除一个结点时，不能把以该结点为根的子树上的结点都删除，必须先删除结点从存储二叉排序树的链表上摘下，将因删除结点而断开的二叉链表重新链接起来，确保二叉排序树的性质不会丢失。

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

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

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

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

（三）二叉排序树的实现（非递归）

1、查找实现

代码如下:

//查找操作
	bool Find(const K& key)
	{
		Newnode* cur = _root;
		while (cur)
		{
			if (cur->_key < key) {
				cur = cur->_right;
			}
			else if (cur->_key > key) {
				cur = cur->left;
			}
			else {
				return true;
			}
		}
		return false;
	}

2、插入实现

代码如下:

    //插入操作
	bool Insert(const K& key)
	{
		if (_root == nullptr)
		{
			_root = new Newnode(key);
			return true;
		}

		Newnode* parent = nullptr;
		Newnode* cur = _root;
		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 Newnode(key);
		if (parent->_key < key)
		{
			parent->_right = cur;
		}
		else
		{
			parent->_left = cur;
		}

		return true;
	}

3、删除实现

代码如下:

//删除操作
	bool Erase(const K& key)
	{
		Newnode* parent = nullptr;
		Newnode* 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->_left == cur)
						{
							parent->_left = cur->_right;
						}
						else
						{
							parent->_right = cur->_right;
						}
					}

					delete cur;
				}

				//不存在右
				else if (cur->_right == nullptr) {
					if (cur == _root)
					{
						_root = cur->_left;
					}
					else {
						if (parent->_left = cur)
						{
							parent->_left = cur->_left;
						}
						else
						{
							parent->_right = cur->_left;
						}
					}
					delete cur;
				}
				//左右均存在
				else {
					// 找右树最小节点替代，也可以是左树最大节点替代
					Newnode* pminRight = cur;
					Newnode* minRight = cur->_right;
					while (minRight->_left)
					{
						pminRight = minRight;
						minRight = minRight->_left;
					}

					cur->_key = minRight->_key;

					if (pminRight->_left == minRight) {
						pminRight->_left = minRight->_right;
					}
					else {
						pminRight->_right = minRight->_right;
					}
					delete minRight;
				}
				return true;
			}
		}
		return false;
	}

（四）二叉排序树的实现（递归）

递归实现都比较容易，只要大家掌握到了思想，我相信实现起来就是很容易的。

1、查找操作

    //查找操作
	bool _FindR(Newnode* root, const K& key)
	{
		if (root == nullptr)
			return false;

		if (root->_key == key)
			return true;

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

2、插入操作

        //插入操作
		bool _InsertR(Newnode*& root, const K& key)
		{
			if (root == nullptr) {
				root = new Newnode(key);
				//root = new BSTree<K>(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;
			}
		}

验证操作：

3、删除操作

        //删除操作
		bool _EraseR(Newnode*& root,const K& key)
		{
			if (root == nullptr) {
				root = new Newnode(key);
				return true;
			}

			if (root->_key < key)
			{
				return _EraseR(root->_right, key);
			}
			else if (root->_key > key)
			{
				return _EraseR(root->_left, key);
			}
			else
			{
				Newnode* del = root;

				if (root->_left == nullptr)
				{
					root = root->_right;
				}
				else if (root->_right == nullptr)
				{
					root = root->_left;
				}
				else
				{
					Newnode* maxleft = root->_left;
					while (maxleft->_left)
					{
						maxleft = maxleft->_right;
					}
					swap(root->_key, maxleft->_key);

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

				return true;
			}
		}

验证操作：

（五）其他操作

1、析构

析构同样的使用递归来进行解决（当然也可以使用循环）。具体如下

代码实现：

    //销毁操作
	void Destroy(Newnode*& root)
	{
		if (root == nullptr)
			return;

		Destroy(root->_left);
		Destroy(root->_right);

		delete root;
		root = nullptr;
	}

2、构造和拷贝构造

首先如果我想在搜索二叉树的对象进行拷贝构造能够实现吗？具体如下：

 【说明】

  1. 我们发现是可以的，虽然我们没写；
  2. 这是因为拷贝构造属于默认成员函数，编译器会自动生成（注意;默认生成是属于浅拷贝）

【注意】 

  • 需要注意：当我们写了析构函数之后程序就会出问题；
  • 因为搜索二叉树涉及资源申请，如果是浅拷贝，在析构的时候就会对一块空间析构两次

所以此时就需要写一个深拷贝的拷贝构造函数（递归版本）

Newnode* Copy(Newnode* root)
{
	if (root == nullptr)
		return nullptr;

	Newnode* newRoot = new Newnode(root->_key);
	newRoot->_left = Copy(root->_left);
	newRoot->_right = Copy(root->_right);
	return newRoot;
}

 此时因为有了拷贝构造，编译器就不会生成默认的构造函数了，就需要我们自己写（C++11提供了一个关键字——default，可以强制编译器生成默认构造）

BinarySearchTree() = default; // 制定强制生成默认构造

此时，它就会走初始列表用缺省值去初始化：

3、赋值重载

  • 最后实现一下赋值重载的操作：
BinarySearchTree<K>& operator=(BinarySearchTree<K> t)
{
	swap(_root, t._root);
	return *this;
}

代码演示：

【代码总结】

  • BSTree.h：
#pragma once

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

		BSTree(const K& key)
			: _left(nullptr)
			, _right(nullptr)
			, _key(key)
		{}
	};


	template<class K>
	class BinarySearchTree
	{
		typedef BSTree<K> Newnode;
	public:

		BinarySearchTree() = default; // 制定强制生成默认构造

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

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

		~BinarySearchTree()
		{
			Destroy(_root);
		}

		//插入操作
		bool Insert(const K& key)
		{
			if (_root == nullptr)
			{
				_root = new Newnode(key);
				return true;
			}

			Newnode* parent = nullptr;
			Newnode* cur = _root;
			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 Newnode(key);
			if (parent->_key < key)
			{
				parent->_right = cur;
			}
			else
			{
				parent->_left = cur;
			}

			return true;
		}

		//查找操作
		bool Find(const K& key)
		{
			Newnode* 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)
		{
			Newnode* parent = nullptr;
			Newnode* 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->_left == cur)
							{
								parent->_left = cur->_right;
							}
							else
							{
								parent->_right = cur->_right;
							}
						}

						delete cur;
					}

					//不存在右
					else if (cur->_right == nullptr) {
						if (cur == _root)
						{
							_root = cur->_left;
						}
						else {
							if (parent->_left = cur)
							{
								parent->_left = cur->_left;
							}
							else
							{
								parent->_right = cur->_left;
							}
						}
						delete cur;
					}
					//左右均存在
					else {
						// 找右树最小节点替代，也可以是左树最大节点替代
						Newnode* pminRight = cur;
						Newnode* minRight = cur->_right;
						while (minRight->_left)
						{
							pminRight = minRight;
							minRight = minRight->_left;
						}

						cur->_key = minRight->_key;

						if (pminRight->_left == minRight) {
							pminRight->_left = minRight->_right;
						}
						else {
							pminRight->_right = minRight->_right;
						}
						delete minRight;
					}
					return true;
				}
			}
			return false;
		}

		///
		// 递归版本

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

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

		protected:

			Newnode* Copy(Newnode* root)
			{
				if (root == nullptr)
					return nullptr;

				Newnode* newRoot = new Newnode(root->_key);
				newRoot->_left = Copy(root->_left);
				newRoot->_right = Copy(root->_right);
				return newRoot;
			}
			//销毁操作
		void Destroy(Newnode*& root)
		{
			if (root == nullptr)
				return;

			Destroy(root->_left);
			Destroy(root->_right);

			delete root;
			root = nullptr;
		}

		

		//查找操作
		bool _FindR(Newnode* root, const K& key)
		{
			if (root == nullptr)
				return false;

			if (root->_key == key)
				return true;

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

		
		//插入操作
		bool _InsertR(Newnode*& root, const K& key)
		{
			if (root == nullptr) {
				root = new Newnode(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 _EraseR(Newnode*& root, const K& key)
		{
			if (root == nullptr) {
				root = new Newnode(key);
				return true;
			}

			if (root->_key < key)
			{
				return _EraseR(root->_right, key);
			}
			else if (root->_key > key)
			{
				return _EraseR(root->_left, key);
			}
			else
			{
				Newnode* del = root;

				if (root->_left == nullptr)
				{
					root = root->_right;
				}
				else if (root->_right == nullptr)
				{
					root = root->_left;
				}
				else
				{
					Newnode* maxleft = root->_left;
					while (maxleft->_left)
					{
						maxleft = maxleft->_right;
					}
					swap(root->_key, maxleft->_key);

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

				return true;
			}
		}

		

		//中序遍历
		void _Inorder(Newnode* root)
		{
			if (root == nullptr) {
				return;
			}

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


	private:
		Newnode* _root = nullptr;
	};

（六）总结

以上便是关于二叉搜索树的模拟实现。感谢大家的观看与支持！！！

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

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

相关文章

刘汝佳の树状数组详解

刘汝佳の树状数组详解

引入 二叉索引树&#xff0c;也叫树状数组是一种便于数组单点修改和区间求和的数据结构 主要根据下标的lowbit值来建树 至于lowbit(x)&#xff0c;则是(x)&(-(x))&#xff0c;也就是一个二进制数从右边数第一个1代表的数 #define lowbit(x) ((x)&(-(x)))基础树状数组…
阅读更多...
GF(2)上矩阵秩的快速计算

GF(2)上矩阵秩的快速计算

https://github.com/mhostetter/galois/issues
阅读更多...
uniapp发布插件显示components/xxx文件没找到，插件格式不正确

uniapp发布插件显示components/xxx文件没找到，插件格式不正确

uniapp发布插件显示components/xxx文件没找到&#xff0c;插件格式不正确 将插件文件这样一起选中&#xff0c;然后右键压缩成zip文件&#xff0c;而不是外层文件压缩
阅读更多...
亚马逊、美客多卖家如何运营，养号技巧和硬件要求有哪些？

亚马逊、美客多卖家如何运营，养号技巧和硬件要求有哪些？

流量等于销量、等于利润&#xff0c;没有流量&#xff0c;一切都是白搭&#xff0c; 流量是一切销量的前提&#xff0c;我们平时做的优化、推广也是为了引入流量。所有亚马逊卖家都在围着一个目标而努力&#xff0c;那就是流量。那么亚马逊新卖家该如何引流呢? 我们需要从以下…
阅读更多...
无涯教程-Perl - 条件判断

无涯教程-Perl - 条件判断

以下是在大多数编程语言中找到的典型判断结构的概述- Perl编程语言提供以下类型的条件语句。 Sr.No.Statement & 描述1 if statement if语句由布尔表达式和一个或多个语句组成。 2 if...else statement在 if语句之后可以是可选的 else语句。 3 if...elsif...else statemen…
阅读更多...
如何将镜像体积海量缩减

如何将镜像体积海量缩减

点击上方蓝色字体&#xff0c;选择“设为星标” 回复”云原生“获取基础架构实践 镜像的传统构建 我们随便找个Golang代码项目作为案例&#xff0c;来开始构建一个镜像。下面我们以我的一个实战项目开始讲解&#xff1a;https://gitee.com/damon_one/uranus。 第一步&#xff1…
阅读更多...
uC-OS2 V2.93 STM32L476 移植：系统移植篇

uC-OS2 V2.93 STM32L476 移植：系统移植篇

前言 上一篇已经 通过 STM32CubeMX 搭建了 NUCLEO-L476RG STM32L476RG 的 裸机工程&#xff0c;并且下载了 uC-OS2 V2.93 的源码&#xff0c;接下来&#xff0c;开始系统移植 开发环境 win10 64位 Keil uVision5&#xff0c;MDK V5.36 uC-OS2 V2.93 开发板&#xff1a;NUC…
阅读更多...
机器学习深度学习——从全连接层到卷积

机器学习深度学习——从全连接层到卷积

&#x1f468;‍&#x1f393;作者简介&#xff1a;一位即将上大四&#xff0c;正专攻机器学习的保研er &#x1f30c;上期文章&#xff1a;机器学习&&深度学习——非NVIDIA显卡怎么做深度学习&#xff08;坑点排查&#xff09; &#x1f4da;订阅专栏&#xff1a;机器…
阅读更多...
D. Different Arrays

D. Different Arrays

Problem - 1783D - Codeforces 思路&#xff1a; 这是一个计数问题&#xff0c;我们要统计不同数组的个数&#xff0c;可以用dp&#xff0c;让f[i][j]表示只考虑前i个&#xff0c;并且结尾为j的情况&#xff0c;那么转移方程为我们枚举i&#xff0c;与枚举前一个是多少&#xf…
阅读更多...
电脑安装新系统不知道去哪里下载，看我就够了

电脑安装新系统不知道去哪里下载，看我就够了

大家在日常生活中肯定都会遇到电脑安装系统的需求&#xff0c;如果去微软官方购买正版的系统又很贵&#xff0c;又不太想花这个冤枉钱&#xff0c;这个时候我们就不得不去网上查找一些免费好用的系统&#xff0c;可是百度一下&#xff0c;或者Google一下&#xff0c;各种下载系…
阅读更多...
【css】css设置表格样式-边框线合并

【css】css设置表格样式-边框线合并

<style> table, td, th {border: 1px solid black;//设置边框线 }table {width: 100%; }td {text-align: center;//设置文本居中 } </style> </head> <body><table><tr><th>Firstname</th><th>Lastname</th><t…
阅读更多...
【uniapp】样式合集

【uniapp】样式合集

1、修改uni-data-checkbox多选框的样式为单选框的样式 我原先是用的单选&#xff0c;但是单选并不支持选中后&#xff0c;再次点击取消选中&#xff1b;所以我改成了多选&#xff0c;然后改变多选样式&#xff0c;让他看起来像单选 在所在使用的页面上修改样式即可 <uni-d…
阅读更多...
1-搭建一个最简单的验证平台UVM，已用Questasim实现波形！

1-搭建一个最简单的验证平台UVM，已用Questasim实现波形！

UVM-搭建一个最简单的验证平台&#xff0c;已用Questasim实现波形 1&#xff0c;背景知识2&#xff0c;".sv"文件搭建的UVM验证平台&#xff0c;包括代码块分享3&#xff0c;Questasim仿真输出&#xff08;1&#xff09;compile all&#xff0c;成功&#xff01;&…
阅读更多...
kubernetes 集群利用 efk 收集容器日志

kubernetes 集群利用 efk 收集容器日志

文章目录 [toc]前情提要制作 centos 基础镜像准备 efk 二进制文件部署 efk 组件配置 namespace配置 gfs 的 endpoints配置 pv 和 pvc部署 elasticsearchefk-cmefk-svcefk-sts 部署 filebeatfilebeat-cmfilebeat-ds 部署 kibanakibana-cmkibana-svckibana-dp使用 nodeport 访问 …
阅读更多...
免费快速下载省市区县行政区的Shp数据

免费快速下载省市区县行政区的Shp数据

摘要&#xff1a;一般非专业的GIS应用通常会用到省市等行政区区划边界空间数据做分析&#xff0c;本文简单介绍了如何在互联网上下载省&#xff0c;市&#xff0c;区县的shp格式空间边界数据&#xff0c;并介绍了一个好用的在线数据转换工具&#xff0c;并且开源。 一、首先&am…
阅读更多...
图卷积网络（GCN）和池化

图卷积网络（GCN）和池化

一、说明 GCN&#xff08;Graph Convolutional Network&#xff09;是一种用于图形数据处理和机器学习的神经网络架构。GCN 可以在图形中捕获节点之间的关系&#xff0c;从而能够更好地处理图形数据。GCN 可以沿着图形上的边缘执行滤波器操作&#xff0c;将每个节点的特征向量进…
阅读更多...
OA是什么意思？OA系统是什么

OA是什么意思？OA系统是什么

阅读本文您可以了解&#xff1a;1、OA是什么&#xff1b;2、OA系统是什么&#xff1b;3、OA系统有什么功能 一、OA是什么 当提到OA&#xff0c;我们通常指的是"Office Automation"&#xff08;办公自动化&#xff09;。 办公自动化指的是在办公室环境中使用计算机技…
阅读更多...
培训系统中的技术创新与发展趋势

培训系统中的技术创新与发展趋势

随着互联网和信息技术的快速发展&#xff0c;培训系统也进入了一个全新的时代。传统的面对面培训逐渐被在线培训所取代&#xff0c;培训系统中的技术创新和发展成为了推动整个行业发展的关键因素。 1. VR和AR技术的应用 虚拟现实&#xff08;VR&#xff09;和增强现实&#x…
阅读更多...
并查集和哈希表的实现

并查集和哈希表的实现

并查集和哈希表的实现 文章目录 并查集和哈希表的实现1.并查集的功能2.并查集的基本原理3.并查集的实现 哈希表&#xff08;hash&#xff09;1.拉链法2.开放寻址法方法流程代码演示 3,字符串哈希 1.并查集的功能 1.将两个集合进行合并 2.询问两个元素是否在一个集合里面 2.并…
阅读更多...
js中exec与match的区别

js中exec与match的区别

const regex1 RegExp(f(o.?),g); const str1 table foatball, fobsball; let array1; let array2; array1 regex1.exec(str1) array2 str1.match(regex1)console.log(array1, array1); console.log(array2, array2); //没有g的情况下,都是找到第一个匹配,并且如果有分组,…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023