【C++】——二叉树搜索树

于 2024-09-16 19:36:29 发布
阅读量182 收藏 3
点赞数 7
文章标签： c++ 数据结构 c语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/super_coders/article/details/142264244
版权

文章目录

二叉搜索树的概念

  1. 左子树上所有节点的值都小于等于根节点的值，
    右子树上所有节点的值都大于等于根节点的值
  2. 左右子树也分别为二叉树
  3. 二叉搜索树中可以插入相等的值也可以插入不相等的值，具体看使用场景定义

二叉搜索树基本操作

1. 插入节点

  1. 新节点和根节点进行比较
  2. 如果要插入的值小于当前节点的值，则移动到左子节点
    如果要插入的值大于当前节点的值，则移动到右子节点
  3. 重复上述过程，直到找到一个空位置，然后在该位置插入新节点

2. 查找节点

  1. 从根节点开始比较要查找的值和当前值
  2. 如果要查找的值小于当前节点的值，则移动到当前节点的左子节点
    如果要查找的值大于当前节点的值，则移动到当前节点的右子节点
  3. 重复上述过程， 如果要查找的值等于当前节点的值，则返回当前节点，查找成功

3. 删除节点

  1. 删除的节点是叶子节点：直接删除该节点
  2. 删除的节点只有一个子节点：将其子节点替换到当前该节点
  3. 删除的节点有两个子节点：找到该节点右子树中的最小节点（或左子树中的最大节点），将其值替换到该节点的位置，然后删除该最小节点

二叉搜索树的实现

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

template<class K>
class BSTree
{
	//typedef BSTNode<K> Node;
	using Node = BSTNode<K>;
public:
	
	bool Insert(const K& key)
	{
		if (_root == nullptr) // 如果数为空，直接插入
		{
			_root = new Node(key);
			return true;
		}
		Node* parent = nullptr; // 记录父亲，等会才知道插入位置
		Node* cur = _root; // 从头结点开始对比
		while (cur)
		{
			if (key < cur->_key)
			{
				parent = cur;
				cur = cur->_left;
			}
			else if (key > cur->_key)
			{
				parent = cur;
				cur = cur->_right;
			}
			else
				return false;
		}
		
		cur = new Node(key);
		if (key < parent->_key)
		{
			parent->_left = cur;
		}
		else
		{
			parent->_right = cur;
		}
		return true;
	}
	
	bool Find(const K& key)
	{
		Node* cur = _root;
		while (cur)
		{
			if (key < cur->_key)
			{
				cur = cur->_left;
			}
			else if (key > cur->_key)
			{
				cur = cur->_right;
			}
			else
				return true;
		}
		return false;
	}

	bool Erase(const K& key)
	{
		Node* parent = nullptr;
		Node* cur = _root;
		while (cur) // 先遍历找到要删除的节点
		{
			if (key < cur->_key)
			{
				parent = cur;
				cur = cur->_left;
			}
			else if (key > cur->_key)
			{
				parent = cur;
				cur = cur->_right;
			}
			
			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 // 左右子树都不为空(找到该节点右子树中的最小节点（或左子树中的最大节点），将其值替换到该节点的位置，然后删除该最小节点)
				{
					Node* replaceparent = cur;
					Node* replace = cur->_right;
					while (replace->_left) 
					{
						replaceparent = replace;
						replace = replace->_left;
					}
					cur->_key = replace->_key;
					if(replaceparent->_left == replace) // 如果被替换的是左节点
						replaceparent->_left = replace->_right;
					else
						replaceparent->_right = replace->_right; // 如果被替换的是右节点，例如：删除的是根，并且根的右节点没有左节点了

					delete replace;
				}
				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 << " ";
		_InOrder(root->_right);
	}

	Node* _root = nullptr;
};

二叉搜索树key和key/value

namespace key_value
{
	template<class K, class V>
	struct BSTNode
	{
		K _key;
		V _value;

		BSTNode<K, V>* _left;
		BSTNode<K, V>* _right;

		BSTNode(const K& key, const V& value)
			:_key(key)
			, _value(value)
			, _left(nullptr)
			, _right(nullptr)
		{}
	};

	// Binary Search Tree
	// Key/value
	template<class K, class V>
	class BSTree
	{
		//typedef BSTNode<K> Node;
		using Node = BSTNode<K, V>;
	public:
		// 强制生成构造
		BSTree() = default;

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

		BSTree& operator=(BSTree tmp)
		{
			swap(_root, tmp._root);
			return *this;
		}

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

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

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

			cur = new Node(key, value);
			if (parent->_key < key)
			{
				parent->_right = cur;
			}
			else
			{
				parent->_left = cur;
			}

			return true;
		}

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

		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->_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
					{
						// 左右都不为空
						// 右子树最左节点
						Node* replaceParent = cur;
						Node* replace = cur->_right;
						while (replace->_left)
						{
							replaceParent = replace;
							replace = replace->_left;
						}

						cur->_key = replace->_key;

						if (replaceParent->_left == replace)
							replaceParent->_left = replace->_right;
						else
							replaceParent->_right = replace->_right;

						delete replace;
					}

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

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

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

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

			Node* newRoot = new Node(root->_key, root->_value);
			newRoot->_left = Copy(root->_left);
			newRoot->_right = Copy(root->_right);
			return newRoot;
		}
	private:
		Node* _root = nullptr;
	};
}
我爱吃福鼎肉片
关注
C++——二叉树搜索树
有时间要学习的博客
05-12 700
前面写了初阶数据结构——二叉树；本文内容是来对它来进行结尾。
C++进阶 —— 二叉树搜索树
NapoleonCoder的博客
12-07 582
二叉搜索树，K、KV模型！
C++——二叉树排序树
博主qq1077644249
02-18 1315
1 二叉搜索树概念 2 二叉搜索树操作与模拟实现 2.1 二叉搜索树的查找 非递归版本 递归版本 2.2 二叉搜索树的插入 非递归版本 递归版本 2.3 二叉搜索树的删除 非递归版本 递归版本 3 二叉搜索树的应用（K模型、KV模型） 4 二叉搜索树的性能分析
【C++】————搜索二叉树
bhbcdxb123的博客
07-22 2018
若它的左子树不为空，则左子树上所有节点的值都小于根节点的值若它的右子树不为空，则右子树上所有节点的值都大于根节点的值它的左右子树也分别为二叉搜索树1.一个冷知识：屏蔽力是一个人最顶级的能力，任何消耗你的人和事，多看一眼都是你的不对。2.你不用变得很外向，内向挺好的，但需要你发言的时候，一定要勇敢。正所谓：君子可内敛不可懦弱，面不公可起而论之。3.成年人的世界，只筛选，不教育。
C++——二叉搜索树
weixin_49449676的博客
11-30 1959
若要删除8，这里采用右树最左节点的替换法，右树的最左节点就是10自己，如果这样写会有错误，while循环都不会进去，minparent就是空，而后面minParent->_left = min->_right;用左子树的最大节1点或右子树的最小节点4，若采用右树的最小节点，交换3和4删除4之后，删除3，但还有一个子节点5，我们让5成为6的左节点。若果要删除跟节点，而且左为空，若要删除8，我们更新根节点即可，让根节点指向10。若果要删除跟节点，而且右为空，若要删除8，让根节点指向3即可。
C++——数据结构——二叉树
qq_50737873的博客
07-26 328
二叉树是每个节点最多有两个子树的树结构，可以是空集，可以只有根节点，可以只有根和左子树，可以只有根和右子树，可以同时有根和左右子树。
c++——二叉搜索树
陌上人如玉，公子世无双。
08-17 364
关联式容器也是用来存储数据的，与序列式容器不同的是，其里面存储的是<key, value>结构的键值对，在数据检索时比序列式容器效率更高。 键值对： 用来表示具有一一对应关系的一种结构，该结构中一般只包含两个成员变量key和value，key代表键值， value表示与key对应的信息。 二叉搜索树： 二叉搜索树又称二叉排序树，它或者是一棵空树，或者是具有以下性质的二叉树： ...
C++ —— 二叉搜索树
原来45的博客
09-17 1106
二叉搜索树概念 二叉搜索树操作 1. 二叉搜索树的查找 2.二叉搜索树的插入 3. 二叉搜索树的删除 二叉搜索树的应用 1. K模型 2. KV模型 二叉搜索树的性能分析 二叉搜索树的实现（K&&KV）和测试（KV）
C++——二叉树
m0_74515566的博客
02-10 680
先铺垫二叉搜索树，而二叉搜索树也是一种树形结构。
C++数据结构——二叉树
caijiandl的博客
07-31 3523
二叉树 项目 项目 项目 项目1 项目2 项目3 计划任务 完成任务 二叉搜索树 二叉搜索树是二叉树的一种特殊形式。 二叉搜索树具有以下性质：每个节点中的值必须大于（或等于）其左侧子树中的任何值，但小于（或等于）其右侧子树中的任何值。 我们将在本章中更详细地介绍二叉搜索树的定义，并提供一些与二叉搜索树相关的习题。 完成本卡片后，你将： 理解二叉搜索树的特性 熟悉在二叉搜索树中的基本操作 理解高度平衡二叉搜索树的概念 二叉搜索树的定义 **二叉搜索树（BST）**是二叉树的一种
数据结构——二叉树的实现.zip
09-18
这个压缩包文件"数据结构——二叉树的实现.zip"显然包含了关于二叉树实现的详细内容，特别是二叉链表和左子右兄弟两种不同的实现方法。 首先，我们来探讨二叉链表的实现。二叉链表是最基础的二叉树存储方式，每个...
数据结构C++——搜索树(1) 二叉搜索树
qq_60987997的博客
07-24 648
搜索树适合于描述字典的树型结构比跳表和散列表有更好、或类似的性能特别对于顺序访问或按排名访问，散列表实现时间性能差，使用搜索树实现会有更好的时间性能可能为空的二叉树一颗非空的二叉搜索树满足特征：每个元素都有一个关键字，且唯一根节点左子树的关键字小于根节点的关键字根节点右子树的关键字大于根节点的关键字根节点的左右子树也是二叉搜索树即：任何节点左子树的关键字小于该节点的关键字，右子树的关键字大于该节点的关键字二叉搜索树——二叉排序树有重复值的二叉搜索树任何节点左子树的关键字。
数据结构C++——搜索树(2) 平衡搜索树
qq_60987997的博客
07-24 765
DEF.AVL树：一种平衡树空二叉树是AVL树如果T是一颗非空的二叉树，TLTRT_L , T_RTL​TR​分别是其左、右子树，当T满足下列条件时，T是一颗AVL树：TLTRT_L , T_RTL​TR​是AVL树∣hL−hR∣≤1∣hL​−hR​∣≤1，h代表子树高度AVL搜索树平衡二叉搜索树、平衡二叉排序树既是二叉搜索树，又是AVL树带索引的AVL搜索既是带索引的二叉搜索树，又是AVL树。
C++ STL中sort函数
weixin_43349440的博客
09-15 169
刷题中经常遇到，用于各种元素排序，可以自定义排序方式，vector、deque适用。详细讲解：https://zhuanlan.zhihu.com/p/36274119。，为避免QuickSort快排的递归调用带来过大的额外负荷，就改用。一旦分段后的数据量小于某个门槛。STL的sort算法，
CF C. Nikita and LCM
qq_74190237的博客
09-13 266
思维题.首先先对数组排序,考虑一种特殊情况,那就是如果数组最大值不能被其他数整除,这代表什么?代表其他数里面有某个质因子,最大值里面没有或者数量不管,所有最小公倍数都会大于最大值.那么其他情况的话,就可以确定所有的数都是最大数的因子,那么形成的最小公倍数也一定是最大数的因子,那么就可以枚举一下最大数的因子,就可以了.给长度为n的数组,求出最长的特殊子数组,如果子数组的最小公倍数不在原数组中,那么就是特殊的.
C++与QML的数据交互
qq_50679120的博客
09-11 523
这里没什么好说的，在C++中组合好json后，通过信号发送到qml中，qml中是可以解析json的。通过Q_PROPERTY属性，可以轻松地在QML中读取和修改数据，并将其更新到C++中，先创建一个类。在QML接收，直接通过data.can_id这样的形式去访问结构体中的元素。这两个也没什么好说的，在C++中直接发送信号就好了，在C++中声明并注册一个结构体。然后发送信号到QML中。
【C++】【网络】【Linux系统编程】单例模式，加锁封装TCP/IP协议套接字
2301_79796701的博客
09-16 920
给系统，表明这个套接字所期望的、还未处理的（即还在等待被接受的连接）连接请求的最大队列长度。换句话说，它告诉系统内核为这个套接字分配多大的空间来存储尚未处理的连接请求。有关套接字编程的细节和更多的系统调用课参考《UNIX环境高级编程》一书，可以在如下网站搜索电子版，该书在第16章详细的介绍了各种接口。我们可以根据自己的需求，用面向对象的思想封装出接口简洁的类。在类似添加一个该类类型的指针，该指针是静态的并且是私有成员。结构体填充，为了使不同的地址格式能和套接字绑定，需要把对应的结构体强转成通用地址结构。
C++_map_set详解
最新发布
2302_77644537的博客
09-16 635
set是按照一定次序存储元素的容器在set中，元素的value也标识它(value就是key，类型为T)，并且每个value必须是唯一的。set中的元素不能在容器中修改(元素总是const)，但是可以从容器中插入或删除它们。在内部，set中的元素总是按照其内部比较对象(类型比较)所指示的特定严格的排序准则（默认是小于）进行排序。set在底层是用二叉搜索树(红黑树)实现的。map是关联容器，它按照特定的次序(按照key来比较)存储由键值key和值value组合而成的元素。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值