二叉搜索树的模拟及其实现（c++）

最新推荐文章于 2024-07-12 19:06:42 发布
最新推荐文章于 2024-07-12 19:06:42 发布
阅读量85 收藏
点赞数
分类专栏： 数据结构与算法 文章标签： python 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_65665343/article/details/127732509
版权

 

文章目录

前言

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

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

 

一、二叉搜索树是什么

二叉搜索树是以一棵二叉树来组织的。每个节点是一个对象，包含的属性有left，right，p和key，其中，left指向该节点的左孩子，right指向该节点的右孩子，p指向该节点的父节点，key是它的值，如果某节点的孩子节点或父节点不存在，则相应属性设置为NULL。根节点是树中唯一一个父节点为NULL的节点。

BST中的关键字有如下特征：
假设x为BST里的一个节点：
（1）如果y为x的左子树里的一个节点，那么y.key<=x.key；
（2）如果y为x的右子树里的一个节点，那么y.key>=x.key.
 

二、二叉搜索树的实现

2.1k模型的二叉搜索树的增删查


	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()
		{
			_Destory(_root);
		}
private:

    Node*_root;


};

2.1查找节点

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;

		}

查找的思路还是比较简单的，比节点小就去左边查找，比节点大

就去右边查找

2.2. 插入节点

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

 

 插入的思路其实也不难，先进行查找 查找的值大的话就去右边查找，比他小的话就去左边

查找 ，如果找到空了，就是需要插入的位置， 这里需要主要的点事直接删除可能会引发野指针问题，所以定义了一个父亲指针来保存cur的位置 ,当然还需要判断是插入cur是左是右

2.3. 删除节点（比较难）

	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
				{
					// 开始删除
					// 1、左为空
					// 2、右为空
					// 3、左右都不为空
					if (cur->_left == nullptr)//左为空有两种情况 看图
					{
						if (cur == _root)
						{
							_root = cur->_right;//防止删除根节点
						}
						else
						{
							if (cur == parent->_left)
							{
								//第一种如果cur是父亲的左
								parent->_left = cur->_right;//父亲的左指向我的右
							}
							else
							{
								parent->_right = cur->_right;
							}
						}

						delete cur;
						cur = nullptr;
					}
					else if (cur->_right == nullptr)
					{
						if (_root == cur)
						{
							_root = cur->_left;
						}
						else
						{
							if (cur == parent->_left)
							{
								parent->_left = cur->_left;
							}
							else
							{
								parent->_right = cur->_left;
							}
						}

						delete cur;
						cur = nullptr;
					}
					else
					{
						// 找到右子树最小节点进行替换
						Node* minParent = cur;
						Node* min = cur->_right;
						while (min->_left)
						{
							minParent = min;
							min = min->_left;
						}

						swap(cur->_key, min->_key);
						if (minParent->_left == min)
							minParent->_left = min->_right;
						else
							minParent->_right = min->_right;

						delete min;
					}

					return true;
				}
			}

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

 情况一：独生子女好删除，可以直接拖孤给父亲节点，但需要注意野指针问题

 

第一种删除左为空  ：有两种情况 3可能是父亲的左 ，假设删除的是6 6虽然也是左为空 但是6是父亲的右

所以这里要多做一层判断他到底是父亲的左还是右来分别进行处理。

 

 

当然还需要考虑删除跟节点的情况

 

以上情况处理好后用替换法进行删除就是左子树最大或者右子树最小节点 

2.4.递归实现（查找）


		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)
			{
				 //左边
				_FindR(root->_left, key);
			}
			else
			{
				//找到了
				return true;
			}

		}

和前面不一样的地方是，我们这里返回的是节点的指针。

2.5.递归实现（插入）


		bool _InsertR(Node*&root, const K& key)//引用目的是右指针的别名防止野指针
		{
			if (root == nullptr)
			{
				root = new Node(key);
				return true;
			}
			if (root->_key < key)
			{
				_InsertR(root->_right, key);
			}
			else if (root->_key>key)
			{
				_InsertR(root->_left, key);
			}
			else
			{
				return false;
			}
		}


因为节点

但是这样就会有一个问题：newnode是一个局部变量，我们无法把这个newnode的局部变量连接到整个二叉树的正确位置。换言之，当递归到合适位置的时候，我们不能把newnode和它的父节点链接到一起！


而解决的方案就是在使用引用传参！ 

2.6. 递归实现（删除）


		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* min = root->_right;
					while (min->_left)
					{
						min = min->_left;
					}
					swap(root->_key, min->_key);
					//return EraseR(key);  错的
					return _EraseR(root->_right, key);
				}

				delete del;
				return true;
			}
		}

 2.7.完整代码

#pragma once
#include<iostream>
using namespace std;

namespace zdc
{

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

		void Inorder()
		{
			return _Inorder(_root);
			cout << endl;
		}

		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
				{
					// 开始删除
					// 1、左为空
					// 2、右为空
					// 3、左右都不为空
					if (cur->_left == nullptr)//左为空有两种情况 看图
					{
						if (cur == _root)
						{
							_root = cur->_right;//防止删除根节点
						}
						else
						{
							if (cur == parent->_left)
							{
								//第一种如果cur是父亲的左
								parent->_left = cur->_right;//父亲的左指向我的右
							}
							else
							{
								parent->_right = cur->_right;
							}
						}

						delete cur;
						cur = nullptr;
					}
					else if (cur->_right == nullptr)
					{
						if (_root == cur)
						{
							_root = cur->_left;
						}
						else
						{
							if (cur == parent->_left)
							{
								parent->_left = cur->_left;
							}
							else
							{
								parent->_right = cur->_left;
							}
						}

						delete cur;
						cur = nullptr;
					}
					else
					{
						// 找到右子树最小节点进行替换
						Node* minParent = cur;
						Node* min = cur->_right;
						while (min->_left)
						{
							minParent = min;
							min = min->_left;
						}

						swap(cur->_key, min->_key);
						if (minParent->_left == min)
							minParent->_left = min->_right;
						else
							minParent->_right = min->_right;

						delete min;
					}

					return true;
				}
			}

			return false;
		}

		


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

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

		bool EarseR()
		{
			return _EraseR(_root, key);
		}


		~Bstree()
		{
			_Destory(_root);
		}

		Bstree() = default;//强制编译器生成默认构造

		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* copyRoot = new Node(root->_key);
			copyRoot->_left = _Copy(root->_left);//左c节点拷贝左节点

			copyRoot->_right = _Copy(root->_right);

			return copyRoot;
			
		}



		void _Destory(Node*&root)
		{
			//后序销毁
			if (root == nullptr)
			{
				return;
			}
			_Destory(root->_left);
			_Destory(root->_right);
			delete root;
		}

		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* min = root->_right;
					while (min->_left)
					{
						min = min->_left;
					}
					swap(root->_key, min->_key);
					//return EraseR(key);  错的
					return _EraseR(root->_right, 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)
			{
				_InsertR(root->_right, key);
			}
			else if (root->_key>key)
			{
				_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)
			{
				 //左边
				_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=nullptr;//根节点初始化为0

	};



}

总结：二叉查找树的优点:
二叉排序树是一种比较有用的折衷方案.
数组的搜索比较方便,可以直接用下标,但删除或者插入某些元素就比较麻烦.
链表与之相反,删除和插入元素很快,但查找很慢。
二叉排序树就既有链表的好处,也有数组的好处。
在处理大批量的动态的数据是比较有用.
二叉查找树的缺点:
顺序存储可能会浪费空间(在非完全二叉树的时候)，但是读取某个指定的节点的时候效率比较高O(0)
链式存储相对二叉树比较大的时候浪费空间较少，但是读取某个指定节点的时候效率偏低O(nlogn)
 

墨白1357
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
二叉查找树 减治法——C++代码
05-24
在C++中实现二叉查找树，一般会定义一个结构体或类来表示树节点，包括键、值和子节点指针。然后，提供一系列成员函数来执行基本操作，如`insert`（插入）、`search`（查找）、`delete`（删除）。以下是C++实现二叉...
二叉搜索树（C#，C++）
10-11
在C++和C#这两种编程语言中实现二叉搜索树，我们需要关注以下关键点： 1. **数据结构定义**：首先，要定义一个表示节点的类或结构体，它包含键、值、左子节点和右子节点的引用。在C++中，可以定义为`struct Node`，...
codeforces 675D 模拟构建二叉排序树
liyunlonghere
05-17 529
D. Robin Hood time limit per test 1 second memory limit per test 256 megabytes input standard input output standard output We all know the impressive story of Robin Hood
二叉排序树和平衡二叉树
菜鸟进化史
10-26 4271
二叉排序树又称二叉查找树，亦称二叉搜索树。 二叉排序树或者是一颗空树，或者是具有下列性质的二叉树： （1）若左子树不空，则左子树上所有结点的值均小于它的根节点的值； （2）若右子树不空，则右子树所有结点的值均大于或等于它的根结点的值； （3）左、右子树也分别为二叉排序树 平衡二叉树： 又称为AVL树，它具有以下特征： 它是一棵空树或它的左右两个子树的高度差（称为平衡因子）
C++：二叉搜索树模拟实现（KV模型）
Zhenyu_Coder的博客
02-08 3631
二叉搜索树又称二叉排序树，作为map、set以及红黑树的底层数据结构基础，对于后续模拟实现封装相关解决具体重要意义。同时二叉搜索树分为Key模型和KV模型，在生活中也具有广泛应用，比如英汉字典，通过英文查找对应中文等等。本篇博客将着手二叉搜索树的底层原理，模拟实现二叉搜索树。
模拟实现二叉搜索树超详解（C++）
m0_67430750的博客
05-06 728
模拟实现二叉搜索树，包括了递归和非递归两种版本。
C++二叉搜索树模拟实现
kkbca的博客
11-01 236
二叉搜索树讲解+模拟实现 Key模型和Ker-Value模型
【C++】二叉搜索树
m0_62179366的博客
10-24 1961
二叉搜索树的简单应用及实现。
二叉搜索树（数组实现）
m0_73604812的博客
02-07 414
二叉搜索树（数组实现）
【C++】二叉搜索树模拟实现（两种方法删除节点）
m0_62572672的博客
11-05 789
4.二叉树的删除（方法二：较为推荐）用引用结合递归的方式，具体逻辑没有变化，不过用引用简化了处理指针指向的问题，唯一注意的一点是在交换值之后递归的时候不能直接从根节点开始找。需要手动给出要删除节点所在子树的根节点，不然是找不到的。
C++ 二叉搜索树BinarySearchTree
冰果滴的博客
07-30 997
二叉搜索树是为学习map和set做的铺垫，了解了二叉搜索树的特性，有助于更好的理解map和set。
二叉搜索树介绍和模拟实现
DR5200的博客
11-07 383
文章目录一.二叉搜索树概念 一.二叉搜索树概念 二叉搜索树又称二叉排序树，它或者是一棵空树，或者是具有以下性质的二叉树: (1). 若它的左子树不为空，则左子树上所有节点的值都小于根节点的值 (2). 若它的右子树不为空，则右子树上所有节点的值都大于根节点的值 (3). 它的左右子树也分别为二叉搜索树 二叉搜索树之所以被称作搜索树是因为该结构适合用来查找，如在上图中我们想要查找10，根节点为11，所以我们直接去11的左半部分找，7 < 10，所以我们去7的右半部分找，9 < 10，所以我们去9
功能非常齐全的二叉搜索树C++源码
10-05
本资源提供了C++实现的二叉搜索树，具有丰富的功能。首先，模版化的设计使得这个二叉搜索树可以适应不同类型的元素，不仅仅局限于整型或字符型，这样就大大增加了其灵活性和可复用性。模版类通常包含泛型编程的概念...
二叉排序树样例程序
04-09
二叉排序树的样例程序，数组模拟二叉排序树，包括插入、遍历等操作。
基于最优二叉搜索树的用户登录系统模拟
05-13
AVL，用户登录系统
【持续集成_05课_Linux部署SonarQube及结合开发项目部署】
最新发布
weixin_42333261的博客
07-12 157
前置条件：sonarQube不能使用root账号进行启动，所以需要创建普通用户及。3）CMD上传qube文件-不能传到home路径下哦。2）添加用户、组名、密码。4）检查并解压上传的包。
面试题 21：解释 Python 中的 help() 函数和 dir() 函数？
专注于全栈开发领域
07-10 779
在Python中，help()和dir()是两个非常有用的内置函数，它们可以帮助开发者更好地了解Python对象和模块。
Nginx七层（应用层）反向代理：UWSGI代理uwsgi_pass篇
jclee95的个人博客
07-10 1099
Nginx提供了多种应用层反向代理支持，包括proxy_pass、uwsgi_pass、fastcgi_pass和scgi_pass等。其中，proxy_pass指令可以接受一个URL参数，用于实现对HTTP/HTTPS协议的反向代理；uwsgi_pass用于代理到uWSGI应用服务器；fastcgi_pass用于代理到FastCGI服务器；而scgi_pass则用于代理到SCGI（Simple Common Gateway Interface）应用。这些指令使Nginx能够灵活地处理不同类型的后端服务和应
聊聊如何在内网下构建大模型微调环境
python1234567_的博客
07-12 830
LlamaFactory新版更新后，还是比较方便，只是说llamafactory-cli命令的确是有点蒙，踩个坑就好了。对于LlamaFactory微调来说，本身不难，毕竟都是配置；主要是在内网环境下的依赖包拉取安装是真麻烦，但其实也还好。走一遍的话，还是可以学到很多的。​。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

墨白1357

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值