C++进阶(3): 二叉搜索树

于 2024-10-01 20:50:16 发布
阅读量461 收藏 21
点赞数 17
分类专栏： C++ 文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ffyhyh/article/details/142417799
版权

二叉搜索树的概念

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

  • 若它的左子树不为空，则左子树上所有的节点的值都小于等于 根节点的值
  • 若它的右子树不为空，则右子树上所有的节点的值都大于等于 根节点的值
  • 它的左右子树也分别为二叉搜索树
  • 二叉搜索树可以支持插入相同的值(multimap/multiset)，也可以不支持插入相等的值(map/set)

二叉搜索树的性能分析

  1. 最优的情况：二叉搜索树为完全二叉树(或者接近完全二叉树)，它的高度是：O(log2 N)
  2. 最坏的情况：二叉搜索树退化为单支树(类似于单支)，它的高度是：O(N/2)

所以综合而言二叉搜索树增删改时间复杂度是：O(N)
但是这样的效率显然无法满足我们的需求，后续的博客我将介绍二叉搜索树的变形，平衡二叉树AVL树和红黑树，才能适用于我们在内存在存储和搜索数据。

最好的情况
最坏的情况

二叉搜索树的插入

不用递归，采用更简单的循环

插入的具体步骤如下：

  1. 树为空，则直接新增节点，赋值给root指针
  2. 树不为空，按照二叉搜索树性质，插入值比当前节点大往右走，插入值比当前节点小往左走，找到空位置，插入新节点。
  3. 如果支持插入相同的值，插入值跟当前节点相等的值可以往右走，也可以往走左走，找到空位置，插入新节点(要注意保持逻辑的一致性，插入相同的值不要一会向右走，一会向左走)

二叉搜索树的查找

  1. 从根节点开始比较，查找x，x比根节点的值大则向右边走查找，x比根节点的值小则向左边走查找
  2. 最多查找高度次，走到空时，还没找到x，那么这个值在这个二叉搜索树中不存在
  3. 如果不支持插入相同的值，则找到x后可以直接返回
  4. 如果支持插入相同的值，则意味着可能存在多个x，一般要求查找中序的第一个x

二叉搜索树的删除

首先查找元素是否在二叉搜索树中，如果不存在，则返回false
如果查找元素存在则分为以下四个情况进行分别处理：(假设要删除的节点为N)(分类依据：孩子的个数)

  1. 要删除的节点N左右孩子均为空(即N为叶子节点)
  2. 要删除的节点N左孩子为空，右孩子不为空
  3. 要删除的节点N左孩子不为空，右孩子为空
  4. 要删除的节点N左右孩子均不为空

对于以上四种情况的解决办法：

  1. 把N节点的父亲对应孩子指针指向空，直接删除N节点(1可以和2.3一起处理)
  2. 把N节点的父亲对应孩子指针指向N的右孩子，直接删除N节点
  3. 把N节点的父亲对应孩子指针指向N的左孩子，直接删除N节点
  4. 无法直接删除N节点，因为N的两个孩子无处安放，只能采用替代法将其删除：将N左子树的最大值的节点R(最右节点)或者N右子树的最小值的节点R(最左节点)代替N，因为这两个节点中任意一个，放到N的节点，都满足二叉搜索树的规则。代替N的意思就是N和R的两个节点的值交换，转而变成删除R节点，R节点符合情况2或者情况3，可以直接删除
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

实现代码

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

public:

	bool Insert(const K& key)
	{
		if (_root == nullptr)
		{
			_root = new Node(key);
			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);
		if (parent->_key > key)
		{
			parent->_left = cur;
		}
		else
		{
			parent->_right = cur;
		}

		return true;
	}

	bool Find(const K& key)
	{
		Node* cur = _root;
		while (cur)
		{
			if (cur->_key > key)
			{
				cur = cur->_left;
			}
			else if (cur->_key < key)
			{
				cur = cur->_right;
			}
			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->_left;
			}
			else if (cur->_key < key)
			{
				parent = cur;
				cur = cur->_right;
			}
			else
			{
				if (nullptr == cur->_left)
				{
					if (parent == nullptr)
					{
						_root = cur->_right;
					}
					else
					{
						if (parent->_left == cur)
						{
							parent->_left = cur->_right;
						}
						else if (parent->_right = cur)
						{
							parent->_right = cur->_right;
						}
					}

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

					delete cur;
					return true;
				}
				else
				{
					Node* leftMaxP = cur;
					Node* leftMax = cur->_left;

					while (leftMax->right)
					{
						leftMaxP = leftMax;
						leftMax = leftMax->_right;
					}

					cur->_key = leftMax->_key;

					if (leftMaxP->_left == leftMax)
					{
						leftMaxP->_left = leftMax->_left;
					}
					else
					{
						leftMaxP->_right = leftMax->_left;
					}

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

private:
	Node* _root = nullptr;
};

二叉搜索树key和key/value使用场景

key搜索场景

只有key作为关键码，在二叉树结构中只需要存储key即可，搜索场景只需要判断key在不在。key的搜索场景支持二叉树的增删查，而不支持二叉树的修改，会破坏二叉树的结构。

key/value搜索场景

每一个关键码key，都有与它对应的值value，value可以是任何类型对象。树的结构中(每个节点)除了需要存储key，还需要存储value，增/删/查还是以key为关键字走二叉树的规则进行比较，可以快速找到与key对应的value。并且key/value的搜索场景支持了二叉树的修改，但是仍然不可以修改key，只可以修改value。

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 K& value)
			:_key(key)
			, _value(value)
			, _left(nullptr)
			, _right(nullptr)
		{}
	};

	//搜索二叉树：
	template<class K, class V>

	class BSTree
	{
		typedef BSTNode<K, V> Node;
	public:

		BSTree() = default;

		BSTree(const BSTree<K, V>& m)
		{
			_root = Copy(m._root);
		}

		BSTree<K, V>& operator=(BSTree<K, V> m)
		{
			swap(_root, m._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->_left;
				}
				else if (cur->_key < key)
				{
					cur = cur->_right;
				}
				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->_left;
				}
				else if (cur->_key < key)
				{
					parent = cur;
					cur = cur->_right;
				}
				else
				{
					if (nullptr == cur->_left)
					{
						if (nullptr == parent)
						{
							_root = cur->_right;
						}
						else
						{
							if (parent->_left == cur)
							{
								parent->_left = cur->_right;
							}
							else
							{
								parent->_right = cur->_right;
							}
						}

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

						delete cur;
						return true;
					}
					else
					{
						Node* rightMinP = cur;
						Node* rightMin = cur->_right;
						while (rightMin->_left)
						{
							rightMinP = rightMin;
							rightMin = rightMin->_left;
						}

						cur->_key = rightMin->_key;

						if (rightMinP->_left == rightMin)
						{
							rightMinP->_left = rightMin->_right;
						}
						else
						{
							rightMinP->_right = rightMin->_right;

						}

						delete rightMin;
						return true;
					}
				}
			}
			return false;
		}

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

	private:

		void _InOrder(Node* root)
		{
			if (nullptr == root)
			{
				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 (nullptr == root)
			{
				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;
	};
ffyhyh
关注
专栏目录
C++_进阶：二叉搜索树
Lvision2的博客
08-17 790
对有n个结点的二叉搜索树，若每个元素查找的概率相等，则二叉搜索树平均查找长度是结点在二叉搜索树的深度的函数，4. 当**树不为空(root!= nullptr )**时，，再来处理该结点的删除问题–替换法删除。情况3比前两种复杂一点，需要在它的。先查找元素是否在二叉搜索树中，插入和删除操作都必须先查找，再实现二叉搜索树本体。
【C++进阶】探秘二叉搜索树
小羊的博客
09-18 1863
二叉搜索树的底层实现
【C++进阶03】二叉搜索树
2302_76421042的博客
12-28 1526
中序遍历二叉搜索树会得到一个有序序列所以二叉搜索树又称二叉排序树它可以是一棵空树二叉搜索树没有相同值的节点二叉搜索树支持增删查，不支持改修改会破坏二叉搜索树跟节点比左子树大右子树小的结构。
C++进阶：二叉搜索树
QinMou
09-16 1151
另外，⼆分查找也可以实现O(logN) 级别的查找效率，但是⼆分查找有两⼤缺陷： 1. 需要存储在⽀持下标随机访问的结构中，并且有序。 2. 插⼊和删除数据效率很低，因为存储在下标随机访问的结构中，插⼊和删除数据⼀般需要挪动数 据。 这⾥也就体现出了平衡⼆叉搜索树的价值。
C++进阶知识3 二叉搜索树
最新发布
Yusei_0523的博客
09-29 691
1. ⼆叉搜索树的概念 2. ⼆叉搜索树的性能分析 3. ⼆叉搜索树的插⼊ 4. ⼆叉搜索树的查找 5. ⼆叉搜索树key和key/value使⽤场景 5.1 key搜索场景： 5.2 key/value搜索场景：
★ C++进阶篇 ★ 二叉搜索树
2302_80328146的博客
09-21 1536
★ C++进阶篇 ★ 二叉搜索树
二叉树进阶：二叉搜索树
2301_80468112的博客
07-17 601
二叉搜索树又称二叉排序树，它或者是一棵空树，或者是具有以下性质的二叉树:树的雏形： 1.2 二叉搜索树操作 int a[] = {8, 3, 1, 10, 6, 4, 7, 14, 13};1. 二叉搜索树的查找a、从根开始比较，查找，比根大则往右边走查找，比根小则往左边走查找。b、最多查找高度次，走到到空，还没找到，这个值不存在。 2. 二叉搜索树的插入插入的具体过程如下：a. 树为空，则直接新增节点，赋值给root指针b. 树不空，按二叉搜索树性质查找插入位置，插入新节点 1. 二叉
c++进阶--二叉搜索树模拟实现
jolly0514的博客
08-08 361
一、二叉搜索树1.二叉搜索树概念二叉搜索树又称为二叉排序树，它或者是一颗空树，或者具有以下性质的二叉树：若它的左子树不为空，则左子树上所有节点的值都小于根节点的值若它的右子树不为空，则右子树上所有节点的值都大于根节点的值左、右子树都是二叉搜索树2.二叉搜索树操作1.二叉搜索树的查找从根节点开始比较，查找，如果比根节点值大，往右走查找，比根节点值小，往左走查找最多查找高度次，走到空节点还没找到，则说明这个值在树中不存在。2.二叉搜索树的插入若为空树，则直接新增节点，赋值给root指针。
【C++进阶】详解二叉搜索树
weixin_64906519的博客
03-13 779
当二叉搜索树退化为单支树时，其查找的优势就会失去，那么解决办法就是我们后面会讲的AVL树和红黑树了，所以我们要先掌握二叉搜索树，因为这些都是在此之上的知识。希望大家都能掌握并且可以持续关注，我会带来更多的C++知识。
C++进阶：STL之树形结构的关联式容器2（底层结构相关：二叉搜索树）
碧瑶的博客呀
10-22 304
底层结构 二叉搜索树 1、概念： 二叉搜索树又称二叉排序树，它可以是一棵空树，或者是具有以下性质的二叉树： 若它的左子树不为空，则左子树上所有节点的值都小于根节点的值 若它的右子树不为空，则右子树上所有节点的值都大于根节点的值 它的左右子树也分别为二叉搜索树 2、二叉搜索树的操作 （1）先实现构造 （2）查找：给定一个值data，如果data等于根结点的值，返回true表示找到了，如果data&...
【进阶数据结构】二叉搜索树&经典习题讲解
East-sunrise的博客
03-20 1011
二叉搜索树 —— 轻易找到你想要的
【C++进阶之路】第三篇：二叉搜索树 & kv模型
Captain_ldx的博客
10-26 323
二叉搜索树概念、操作、实现；二叉搜索树的应用-kv模型；二叉搜索树的性能分析；
【二叉搜索树进阶】：平衡增长的优雅实现技巧
二叉搜索树（BST）是一种特殊的二叉树，它不仅能够存储数据，还能高效地执行数据的插入、查找和删除操作。其核心是每个节点都遵循这样的规则：对于任意节点N，其左子树上的所有节点的值都小于等于N的值，而其右子树...
【二叉树进阶】AVLTree - 平衡二叉搜索树
codewinter的博客
06-20 2717
二叉搜索树的插入和删除操作都必须先查找，查找效率代表了二叉搜索树中各个操作的效率。但是二叉搜索树有其自身的缺陷，假如往树中插入的元素有序或者接近有序，二叉搜索树就会退化成单支树，时间复杂度为O(N)，因此 map、set 等关联式容器的底层结构是对二叉树进行了平衡处理，即采用平衡二叉搜索树来实现。最优情况下，有 n 个结点的二叉搜索树为完全二叉树，查找效率为：O(log2N)最差情况下，有 n 个结点的二叉搜索树退化为单支树，查找效率为：O(N)平衡二叉搜索树（Self-balancing binary s
【C++】红黑树的封装——同时实现map和set
Mesar的博客
09-27 648
学习map和set，深入了解底层，通过模拟实现，学习高效数据结构与容器的关系，也帮助我们更好了解和使用容器
c++ 使用 Graham 扫描的凸包（Convex Hull using Graham Scan）
csdn_aspnet的专栏
09-26 1105
对于剩余的点，我们跟踪最近的三个点，并找到它们形成的角度。如果这些点的方向（按相同顺序考虑它们）不是逆时针的，我们丢弃 c，否则我们保留它。因此，第六步逐个处理点需要 O(n) 时间，假设堆栈操作需要 O(1) 时间。总体复杂度为 O(n) + O(nLogn) + O(n) + O(n)，即 O(nLogn)。在每个步骤中，算法都会检查添加到凸包中的最后两个点是否形成右转。格雷厄姆扫描算法是一种简单而有效的算法，用于计算一组点的凸包。凸包用于各种计算几何算法，例如查找最近的点对和计算一组点的直径。
求n的阶乘的相反数（c语言）
scy2429828663的博客
09-26 416
【代码】求n的阶乘的相反数（c语言）
【YOLOv8改进[SPPF]】使用SPPFCSPC替换SPPF模块 + 含全部代码和详细修改方式
静谧、淡雅
09-29 194
【YOLOv8改进[SPPF]】使用SPPFCSPC替换SPPF模块 + 含全部代码和详细修改方式
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值