【C++进阶学习】第五弹——二叉搜索树——二叉树进阶及set和map的铺垫

已于 2024-07-02 22:43:30 修改
阅读量3.2k 收藏 119
点赞数 229
分类专栏： 【C++学习】由浅入深 文章标签： 学习 数据结构 c++ 算法
于 2024-07-02 22:31:42 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_80220607/article/details/140137075
版权

二叉树1：深入理解数据结构第一弹——二叉树（1）——堆-CSDN博客

二叉树2：深入理解数据结构第三弹——二叉树（3）——二叉树的基本结构与操作-CSDN博客

二叉树3：深入理解数据结构第三弹——二叉树（3）——二叉树的基本结构与操作-CSDN博客

前言：


在之前我们用C语言实现数据结构时，已经对二叉树进行了系统的学习，但还是有一些内容并没有涉及到，比如今天要讲的二叉搜索树，因为二叉搜索树在C++中有现成的模板库——set和map，并且实现起来较为麻烦，所以我们放到这里来讲，对前面二叉树部分有所遗忘的同学可以在我的主页搜一下之前的文章看一下

目录

一、二叉搜索树的概念

二、二叉搜索树的基本操作

1. 插入节点

2. 查找节点

3. 删除节点

三、二叉搜索树的实现

四、二叉搜索树的应用

五、总结

一、二叉搜索树的概念

二叉搜索树又称二叉排序树，它是一种具有特殊性质的二叉树，它具有以下特点：

1. 有序性：对于树中的每个节点，其左子树中的所有节点的值都小于该节点的值，而其右子树中的所有节点的值都大于该节点的值。

2. 唯一性：树中的每个节点的值都是唯一的，不存在重复的值。

3. 递归性：它的子树也都是二叉树

上面这三种性质，最不好理解的应该是有序性，下面我们通过两个例子来展现这三种性质：

二、二叉搜索树的基本操作

1. 插入节点

插入节点的过程如下：

  • 从根节点开始，比较要插入的值与当前节点的值。
  • 如果要插入的值小于当前节点的值，则移动到左子节点；如果要插入的值大于当前节点的值，则移动到右子节点。
  • 重复上述过程，直到找到一个空位置，然后在该位置插入新节点。
2. 查找节点

查找节点的过程如下：

  • 从根节点开始，比较要查找的值与当前节点的值。
  • 如果要查找的值等于当前节点的值，则返回该节点。
  • 如果要查找的值小于当前节点的值，则移动到左子节点；如果要查找的值大于当前节点的值，则移动到右子节点。
  • 重复上述过程，直到找到目标节点或遍历到空节点。
3. 删除节点

删除节点的过程相对复杂，需要考虑以下几种情况：

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

三、二叉搜索树的实现

template<class T>
struct BSTNode
{
 BSTNode(const T& data = T())
   : _pLeft(nullptr) , _pRight(nullptr), _data(data)
 {}
 BSTNode<T>* _pLeft;
 BSTNode<T>* _pRight;
 T _data;
};
template<class T>
class BSTree
{
 typedef BSTNode<T> Node;
 typedef Node* PNode;
public:
 BSTree(): _pRoot(nullptr)
 {}
 // 自己实现，与二叉树的销毁类似
 ~BSTree();
 // 根据二叉搜索树的性质查找：找到值为data的节点在二叉搜索树中的位置
 PNode Find(const T& data);
 bool Insert(const T& data)
 {
 // 如果树为空，直接插入
 if (nullptr == _pRoot)
 {
 _pRoot = new Node(data);
 return true;
 }
 // 按照二叉搜索树的性质查找data在树中的插入位置
 PNode pCur = _pRoot;
 // 记录pCur的双亲，因为新元素最终插入在pCur双亲左右孩子的位置
 PNode pParent = nullptr;
 while (pCur)
 {
 pParent = pCur;
 if (data < pCur->_data)
比特就业课
 pCur = pCur->_pLeft;
 else if (data > pCur->_data)
 pCur = pCur->_pRight;  // 元素已经在树中存在
 else
 return false;
 }
 // 插入元素
 pCur = new Node(data);
 if (data < pParent->_data)
 pParent->_pLeft = pCur;
 else
 pParent->_pRight = pCur;
 return true;
 }
 bool Erase(const T& data)
 {
 // 如果树为空，删除失败
 if (nullptr == _pRoot)
 return false;
 // 查找在data在树中的位置
 PNode pCur = _pRoot;
 PNode pParent = nullptr;
 while (pCur)
 {
 if (data == pCur->_data)
 break;
 else if (data < pCur->_data)
 {
 pParent = pCur;
 pCur = pCur->_pLeft;
 }
 else
 {
 pParent = pCur;
 pCur = pCur->_pRight;
 }
 }
 // data不在二叉搜索树中，无法删除
 if (nullptr == pCur)
 return false;
 // 分以下情况进行删除，同学们自己画图分析完成
 if (nullptr == pCur->_pRight)
 {
 // 当前节点只有左孩子或者左孩子为空---可直接删除
 }
 else if (nullptr == pCur->_pRight)
 {
 // 当前节点只有右孩子---可直接删除
 }
 else
 {
// 当前节点左右孩子都存在，直接删除不好删除，可以在其子树中找一个替代结点，
比如：
 // 找其左子树中的最大节点，即左子树中最右侧的节点，或者在其右子树中最小的节
点，即右子树中最小的节点
 // 替代节点找到后，将替代节点中的值交给待删除节点，转换成删除替代节点
 }
 return true;
 }
// 自己实现
 void InOrder();
private:
 PNode _pRoot;
};

四、二叉搜索树的应用

在我们目前的学习中，二叉搜索树最重要的用途就是key--val模型，KV模型就是每一个key值都对应一个val值，这样就形成一个<key,val>键值对，这样的应用在生活中是非常常见的

比如：在菜市场中不同的蔬菜对应着不同的价格；新华词典中，不同的汉字对应着不同的拼音，这些都可以用KV模型来解决

下面是KV模型的实现（没有主函数）：

namespace kv
{
	template<class K,class V>
	struct BSTreeNode
	{
		BSTreeNode<K,V>* _left;
		BSTreeNode<K,V>* _right;
		K _key;
		V _value;

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

	template<class K,class V>
	class BSTree
	{
		typedef BSTreeNode<K,V> Node;
	public:
		//遍历（中序）
		void _InOrder(Node* root)
		{
			if (root == nullptr)
				return;
			_InOrder(root->_left);
			cout << root->_key << ":" << root->_value << endl;
			_InOrder(root->_right);
		}
		void InOrder()
		{
			_InOrder(_root);
			cout << endl;
		}
		///
		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)
			{
				parent = cur;

				if (cur->_key < key)
				{
					cur = cur->_right;
				}
				else if (cur->_key > key)
				{
					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
				{
					// 准备删除  20:15继续
					if (cur->_left == nullptr)
					{//左为空
						if (cur == _root)
						{
							_root = cur->_right;
						}
						else
						{
							if (cur == parent->_left)
							{
								parent->_left = cur->_right;
							}
							else
							{
								parent->_right = cur->_right;
							}
						}

						delete cur;
					}
					else if (cur->_right == nullptr)
					{//右为空
						if (cur == _root)
						{
							_root = cur->_left;
						}
						else
						{
							if (cur == parent->_left)
							{
								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 (subLeft == parent->_left)
							parent->_left = subLeft->_right;
						else
							parent->_right = subLeft->_right;

						delete subLeft;
					}
					return true;
				}
			}

			return false;
		}

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

		//递归版本
		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);
		}
		BSTree(const BSTree<K,V>& t)
		{
			_root = Copy(t._root);
		}
		BSTree<K,V>& operator=(BSTree<K,V> t)
		{
			swap(_root, t._root);
			return *this;
		}
	private:
		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;
		}
		void Destroy(Node*& root)
		{
			if (root == nullptr)
				return;
			Destroy(root->_left);
			Destroy(root->_right);
			delete root;
			root = nullptr;
		}
		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
			{
				if (root->_left == nullptr)
				{
					root = root->_right;
					return true;
				}
				else if (root->_right == nullptr)
				{
					root = root->_left;
					return true;
				}
				else
				{
					Node* subLeft = root->_right;
					while (subLeft->_left)
					{
						subLeft = subLeft->_left;
					}
					swap(root->_key, subLeft->_key);
					return _EraseR(root->_right, key);
				}
			}
		}
		bool _FindR(Node* root, const K& key)
		{
			if (root == nullptr)
			{
				return false;
			}
			if (root->_key < key)
			{
				return root->_right;
			}
			else if (root->_key > key)
			{
				return root->_left;
			}
			else
			{
				return true;
			}
		}
		bool _InsertR(Node*& root, const K& key)
		{
			if (root == nullptr)
			{
				root = new Node(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;
			}
		}
		Node* _root = nullptr;
	};
}

五、总结

以上就是二叉搜索树的主要内容，在代码实现上其实与之前讲的二叉树差别并不是很大，关键在于思路的梳理，这章就先到这了

感谢各位大佬观看，创作不易，还请各位大佬点赞支持！！！

GG Bond.ฺ
关注
专栏目录
【C++进阶学习】第六弹——set和map——体会用C++来构建二叉搜索树
2301_80220607的博客
07-12 4912
【C++进阶学习】第六弹——set和map——数据结构进阶知识点，适合初学者学习！！！
【C++进阶学习】第七弹——AVL树——树形结构存储数据的经典模块
2301_80220607的博客
07-15 2912
【STL深度挖掘】——AVL树的原理和实现，适合初学者仔细阅读观看！！！
C++进阶——二叉搜索树BST
weixin_43635473的博客
04-21 789
C++进阶——二叉搜索树BST
【C++进阶学习】第八弹——红黑树的原理与实现——探讨树形结构存储的最优解
2301_80220607的博客
07-22 2594
【C++进阶】+【高阶数据结构】——红黑树的原理与实现——超详解，适合小白学习了解！！！
C++进阶——二叉搜索树
weixin_51885188的博客
03-03 1277
二叉搜索树 这篇文章主要为大家介绍二叉树搜索树的概念、操作、实现以及它的应用。同时学习二叉搜索树也是在为我们后面学习map与set做铺垫，当我们了解了二叉搜索树的特性后，后面将有助于我们更好的理解map和set的特性 二叉搜索树的概念（特征） 二叉搜索树也称二叉排序树，它或是一棵空树，或者是具有以下性质的二叉树： 若它的左子树不为空，则左子树上所有的节点值都小于根节点的值 若它的右子树不为空，则右子树上所有节点的值都大于根节点的值 它的左右子树也分别为二叉搜索树 int arr[] = {5,3,
二叉树进阶【c++实现】【二叉搜索树的实现】
aaa114514aaaa的博客
09-23 1418
二叉树进阶中二叉搜索树的实现【K模型和KV模型的实现和应用】【二叉搜索树的性能分析】
【数据结构】——二叉搜索树
sjp11的博客
10-31 6560
目录 前言 二叉搜索树的概念 二叉搜索树的操作 树的节点实现 搜索树的基本结构 插入数据 查找 删除 拷贝构造函数 二叉搜索树的应用 前言 在c++中的容器里map和set的学习需要二叉搜索树的铺垫，也为后边的的红黑树和AVL树做铺垫，也就是说，今天主要讲搜索树的基本结构和应用。 二叉搜索树的概念 所有的根节点大于左子树的节点，小于右子树的节点的二叉树就叫做二叉搜索树。 二叉搜索的性质： 如果左子树不为空，则左子树上的所有节点都小于根节点。 如果右子树不为...
【C++进阶：二叉树进阶】二叉搜索树的操作和key模型、key/value模型的实现 | 二叉搜索树的应用 | 二叉搜索树的性能分析
DanceBit的博客
08-27 1561
从这里开始 C++ 的语法就告一段落了。二叉树在前面的数据结构和算法初阶中就讲过，本文取名为二叉树进阶是因为：我们之前说过，普通二叉树单纯的存储数据价值不大，因为仅仅是单纯的存储数据，你不如去使用顺序表和链表这样友善的多。它一定要套一种应用场景，二叉树的其中一个重要的应用场景就是我们本文中要学习的二叉搜索树。二叉搜索树又称搜索二叉树或二叉排序树 (如果你对下图的二叉搜索树中序遍历，你会发现它是有序并且升序的)，我们当前学习的搜索二叉树一般是不允许修改的，不过下面我们会学习搜索二叉树的 key_value 模
【C++】二叉树进阶（二叉搜索树）
是阿建吖！
05-26 1915
这篇文章详细介绍了二叉搜索树（BST）的基本概念、操作、代码实现以及应用。首先，介绍了BST的定义和核心操作，包括查找、插入和删除，并提供了非递归和递归两种实现方式。随后，通过具体的代码示例，展示了BST的节点设置、类框架构建以及查找、插入、中序遍历和删除函数的完整实现。此外，还探讨了BST在实际问题中的应用和性能分析。进阶部分则包含了一系列与二叉树相关的OJ题目，涵盖了从根据遍历序列构造二叉树，到层序遍历、公共祖先查找、BST与双向链表转换等多种场景，希望能够帮助读者深入理解二叉树的结构和应用。
数据结构（四）——二叉搜索树和平衡二叉树
LongXinKou的博客
04-13 1450
文章目录1. 二叉排序树（BST）1.1 二叉排序树的定义1.2 查找1.3 插入1.4 构造1.5 删除2. 二叉平衡树（AVL）2.1 平衡二叉树的定义2.2 插入 1. 二叉排序树（BST） 1.1 二叉排序树的定义 左子树上所有节点的值小于根节点的值。 右子树上所有节点的值大于根节点的值。 对二叉排序树进行中序遍历，可以获得递增的有序序列。 1.2 查找 （1）思想 二叉排序树的查找是从根节点开始，自顶向下比较的过程。 若相等，则查找成功。 当根节点非空时，若小于根节点的值，则在左子树上查找。
【二叉树进阶】AVLTree - 平衡二叉搜索树
codewinter的博客
06-20 2756
二叉搜索树的插入和删除操作都必须先查找，查找效率代表了二叉搜索树中各个操作的效率。但是二叉搜索树有其自身的缺陷，假如往树中插入的元素有序或者接近有序，二叉搜索树就会退化成单支树，时间复杂度为O(N)，因此 map、set 等关联式容器的底层结构是对二叉树进行了平衡处理，即采用平衡二叉搜索树来实现。最优情况下，有 n 个结点的二叉搜索树为完全二叉树，查找效率为：O(log2N)最差情况下，有 n 个结点的二叉搜索树退化为单支树，查找效率为：O(N)平衡二叉搜索树（Self-balancing binary s
数据结构与算法详解——二叉查找树篇（附c++实现代码）
JMasker的博客
05-23 1459
目录二叉树相关概念和术语二叉树特殊类型二叉树的存储链式存储顺序存储二叉树的遍历二叉查找树查找插入删除完整代码 二叉树相关概念和术语   二叉树的递归定义为：二叉树是一棵空树，或者是一棵由一个根节点和两棵互不相交的，分别称作根的左子树和右子树组成的非空树；左子树和右子树又同样都是二叉树。 度：一个节点拥有子树的数目称为结点的度，叶子结点的度为0。 叶子结点：也称为终端结点，没有子树的结点或者度为零的结点。 结点的层次：从根结点开始，假设根结点为第1层，根节点的子结点为第2层，依此类推，如果某一个结点位于第L
六月集训(第20天) —— 二叉搜索树
热门推荐
英雄哪里出来
06-20 1万+
6月的第20天 - 二叉搜索树
数据结构——二叉搜索树PTA习题
流楚丶格念的博客
12-18 1万+
文章目录单选题选择题题解 单选题 题号 题目 答案 1 对二叉搜索树进行什么遍历可以得到从小到大的排序序列？ 中序遍历 2 3 4 5 6 7 8 9 10 选择题题解 1、二叉查找树（Binary Search Tree），（又：二叉搜索树，二叉排序树）它或者是一棵空树，或者是具有下列性质的二叉树： 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值； 若它的右子树不空，则右子树上所有结点的值均大于
ORB-SLAM2源码学习：ORBextractor.cc：IC_Angle 利用灰度质心法求解关键点方向角
2301_76831056的博客
11-01 446
IC_Angle 利用灰度质心法求解关键点方向角并在computeOrientation函数中被调用计算图像中所有特征点的方向。
点云学习笔记3——读取点云文件、进行统计滤波/直通滤波后可视化
qq_64095888的博客
10-29 184
【代码】点云学习笔记3——读取点云文件、进行统计滤波后可视化。
diffusion model 学习笔记
最新发布
wubing's 博客
11-01 602
郎之万公式: 描述了粒子做随机布朗运动 (粒子位置随时间变化的关系), 是一种 SDE, 描述了 由梯度力(即.即我们在无条件模型 DDPM 估计的噪声中添加一个微小的扰动(. 基本上,在采样一半时,基本上预测的。输出的是噪声的估计, 这个估计的噪声。通过上面的公式，我们可以知道，当知道。),就可以作为条件模型的噪声估计.首先,假设我们已经有了一个训练好的。: 每一步中保留的原始信号的比例。的计算有各种不同的方法，). 已经接近于真实的。)影响的系统的时间演化.也就是,我们训练的网络。
jsp web学习二(比较老的啦)
qq_52122048的博客
10-29 1041
JavaBean模式(MVC)适合开发复杂的web应用，在这种模式下，servlet负责处理用户请求，jsp负责数据显示，javabean负责封装数据。Servlet+JSP+JavaBean模式程序各个模块之间层次清晰，web开发推荐采用此种模式。一个良好的JavaWeb项目架构应该具有以上的11个包，这样显得层次分明，各个层之间的职责也很清晰明了，搭建JavaWeb项目架构时，就。
学习力体系
m0_46221544的博客
10-29 343
在一个小镇上，有一位年轻的学者小明，梦想成为一名科 学家。然而，他总是感到学习困难，知识无法长久保持。有一天，他遇到了一位智者，智者告诉他：“学习的力量能够改变命运。”小明意识到，提升学习力是实现梦想的关键，从此开始探索学习方法的旅程。通过以上方法，小明的学习能力不断提升，最后实现了自己的梦想。每个人都可以通过这些方法来加强自身的学习力，迎接更加美好的未来。怎样才能让知识长久保持？如何有效地提升学习力？
算法学习9——二叉搜索树
05-19
二叉搜索树，也叫二叉查找树（BST，Binary Search Tree），是一种特殊的二叉树。相对于普通的二叉树，它有一个特点：所有左子树的节点都比根节点小，所有右子树的节点都比根节点大。因此，它可以快速地进行查找、...
评论 245
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值