【C++】探秘二叉搜索树

小羊在奋斗2024-09-21 13:23

🚀个人主页：奋斗的小羊 🚀所属专栏：C++ 很荣幸您能阅读我的文章，诚请评论指点，欢迎欢迎 ~

目录

  • 前言
  • 💥一、二叉搜索树
    • [💥1.1 特点](#💥1.1 特点)
    • [💥1.2 基本操作](#💥1.2 基本操作)
      • [💥1.2.1 插入](#💥1.2.1 插入)
      • [💥1.2.2 查找](#💥1.2.2 查找)
      • [💥1.2.3 删除](#💥1.2.3 删除)
      • [💥1.2.4 中序遍历](#💥1.2.4 中序遍历)
      • [💥1.2.5 二叉搜索树的简单实现](#💥1.2.5 二叉搜索树的简单实现)
    • [💥1.3 二叉搜索树的应用](#💥1.3 二叉搜索树的应用)
      • [💥1.3.1 Key模型](#💥1.3.1 Key模型)
      • [💥1.3.2 Key-Value模型](#💥1.3.2 Key-Value模型)
      • [💥1.3.3 性能分析](#💥1.3.3 性能分析)

前言

本篇文章将介绍一种功能更加强大的二叉树------二叉搜索树。

相比于普通的二叉树，二叉搜索树在很多方面都有优势，尤其是在查找数据上效率明显提高，并且通过中序遍历二叉搜索树它所存储的数据是有序的。

💥一、二叉搜索树

💥1.1 特点

二叉搜索树，是一种特殊的二叉树结构，它或为空树，或者满足以下性质：

  • 左子树性质： 若任意节点的左子树不空，则左子树上所有节点的值均小于它的根节点的值
  • 右子树性质： 若任意节点的右子树不空，则右子树上所有节点的值均大于它的根节点的值
  • 中序遍历性质： 对二叉搜索树进行中序遍历（左根右），则遍历的结果是一个按升序排列的有序序列

二叉搜索树和普通二叉树的框架差不太多，需要一个节点类，再封装一个完成二叉搜索树功能的类就行。

cpp 复制代码 
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 Find(const K& key)
	{}
	
	//插入
	bool Insert(const K& key)
	{}

	//删除
	bool Erase(const K& key)
	{}

	//中序遍历
	void InOrder()
	{}
private:
	//用一个节点指针来管理二叉搜索树，缺省值为nullptr
	Node* _root = nullptr;
};

💥1.2 基本操作

💥1.2.1 插入

  • 树为空： 直接新增节点，连接到根节点上
  • 树不为空： 从根节点开始，将要插入的值与根节点的值进行比较。如果小于根节点的值，则进入左子树继续比较；如果大于根节点的值，则进入右子树继续比较。如果当前节点为空，则在该位置插入新节点。

插入数据要始终保持二叉搜索树的特点。另外二叉搜索树中的数据通常不允许重复

，所以如果要插入的数据在二叉搜索树中已经存在，则插入错误。

| 实现：

cpp 复制代码 
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->_left;
		}
		else if (cur->_key < key)
		{
			parent = cur;
			cur = cur->_right;
		}
		else
		{
			return false;
		}
	}
	if (parent->_key > key)
	{
		parent->_left = new Node(key);
	}
	else
	{
		parent->_right = new Node(key);
	}
}

💥1.2.2 查找

从根开始比较查找，比根大则往右边查找，比根小则往左边查找。最多查找高度次，走到到空还没找到，这个值不存在。

| 实现：

cpp 复制代码 
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;
}
  • 查找过程的平均时间复杂度和最坏时间复杂度分别是O(log n)和O(n)

其中n是树中节点的数量。然而，在最坏的情况下（即树退化为链表时），时间复杂度会变为O(n)。为了保持查找效率，通常会使用平衡二叉搜索树（如AVL树、红黑树等），它们通过自平衡操作来确保树的高度保持在对数级别，在后续的文章中会介绍。

💥1.2.3 删除

在二叉搜索树中删除一个节点是一个稍微复杂的过程，因为它需要确保删除操作后树仍然保持二叉搜索树的属性。

  1. 查找要删除的节点： 首先，通过二叉搜索树的查找操作找到要删除的节点
  2. 处理三种情况：
  • 情况1： 如果要删除的节点是叶子节点，则直接删除该节点，并将其父节点指向它的指针设为nullptr
  • 情况2： 如果要删除的节点只有一个子节点（左子节点或右子节点），则将其父节点指向它的指针重定向到它的子节点，然后删除该节点
  • 情况3： 如果要删除的节点有两个子节点，则可以找到该节点的右子树中的最小节点（或左子树中的最大节点，但通常使用右子树中的最小节点，因为它更简单且保持了树的平衡），然后将该最小节点的值复制到要删除的节点中，并删除右子树中的那个最小节点（这实际上变成了情况1或情况2）

从上面两种不同的情况来看，找到目标节点右子树中的最小节点后，这个最小节点是它父节点的左孩子还是右孩子都是有可能的，所以在替换掉目标节点的值后，删除右子树中的最小节点之前，需要判断一下右子树中的最小节点的孩子是跟在其父节点的左还是右。

| 实现：

cpp 复制代码 
bool Erase(const K& key)
{
	Node* cur = _root;
	Node* parent = nullptr;
	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 (_root->_key == key)
				{
					_root = _root->_right;
				}
				else
				{
					if (parent->_left == cur)
					{
						parent->_left = cur->_right;
					}
					else if (parent->_right == cur)
					{
						parent->_right = cur->_right;
					}
				}
				delete cur;
				cur = nullptr;
				return true;
			}
			else if (cur->_right == nullptr)
			{
				if (_root->_key == key)
				{
					_root = _root->_left;
				}
				else
				{
					if (parent->_left == cur)
					{
						parent->_left = cur->_left;
					}
					else if (parent->_right == cur)
					{
						parent->_right = cur->_left;
					}
				}
				delete cur;
				cur = nullptr;
				return true;
			}
			//有两个孩子
			else
			{
				//用要删除节点的右子树的最小节点代替删除节点
				parent = cur;
				Node* MinNode = cur->_right;
				while (MinNode->_left)
				{
					parent = MinNode;
					MinNode = MinNode->_left;
				}
				cur->_key = MinNode->_key;
				if (parent->_left == MinNode)
				{
					parent->_left = MinNode->_right;
				}
				else
				{
					parent->_right = MinNode->_right;
				}
				delete MinNode;
				return true;
			}
		}
	}
	return false;
}

找到要删除的节点后，删除之前有几个值得特别注意的点：

  • 要删除的节点没有孩子或只有一个孩子可以归为同一种情况处理
  • 要删除的节点可能是当前的根节点，如果是根节点要单独特殊处理，因为根节点没有父节点，和其他节点的删除处理方法不一样
  • 如果目标节点有两个孩子，则需要先找到其右子树中的最小节点，让最小节点的值替换掉目标节点的值，这个最小节点一定是叶子节点或者只有一个右孩子（两种情况可以视为同一情况处理），最小节点的右孩子要根据最小节点是其父节点的左孩子还是右孩子来确定接在哪里

💥1.2.4 中序遍历

二叉搜索树的中序遍历和普通二叉树的中序遍历是一样的。

cpp 复制代码 
void InOrder(const Node* root)
{
	if (root == nullptr)
	{
		return;
	}
	InOrder(root->_left);
	cout << root->_key << " ";
	InOrder(root->_right);
}

但是这样写有一个问题，当我们调用中序遍历函数时，需要传一个二叉搜索树的根节点指针，而_root是BSTree类中的私有成员变量，在类外面不能使用，所以我们需要想一些办法。

既然类的私有成员变量在类外面不能使用，那我们就不在类外面使用了，可以通过函数调用在类里面间接的使用_root成员变量。

cpp 复制代码 
template<class K>
class BSTree
{
	typedef BSTNode<K> Node;
public:
	//查找
	bool Find(const K& key)
	{}
	
	//插入
	bool Insert(const K& key)
	{}

	//删除
	bool Erase(const K& key)
	{}

	//中序遍历
	void InOrder()
	{
		_InOrder(_root);
		cout << endl;
	}
private:
	void _InOrder(const Node* root)
	{
		if (root == nullptr)
		{
			return;
		}
		_InOrder(root->_left);
		cout << root->_key << " ";
		_InOrder(root->_right);
	}
	Node* _root = nullptr;
};

💥1.2.5 二叉搜索树的简单实现

cpp 复制代码 
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 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 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->_left;
			}
			else if (cur->_key < key)
			{
				parent = cur;
				cur = cur->_right;
			}
			else
			{
				return false;
			}
		}
		if (parent->_key > key)
		{
			parent->_left = new Node(key);
		}
		else
		{
			parent->_right = new Node(key);
		}
	}

	bool Erase(const K& key)
	{
		Node* cur = _root;
		Node* parent = nullptr;
		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 (_root->_key == key)
					{
						_root = _root->_right;
					}
					else
					{
						if (parent->_left == cur)
						{
							parent->_left = cur->_right;
						}
						else if (parent->_right == cur)
						{
							parent->_right = cur->_right;
						}
					}
					delete cur;
					cur = nullptr;
					return true;
				}
				else if (cur->_right == nullptr)
				{
					if (_root->_key == key)
					{
						_root = _root->_left;
					}
					else
					{
						if (parent->_left == cur)
						{
							parent->_left = cur->_left;
						}
						else if (parent->_right == cur)
						{
							parent->_right = cur->_left;
						}
					}
					delete cur;
					cur = nullptr;
					return true;
				}
				//有两个孩子
				else
				{
					//用要删除节点的右子树的最小节点代替删除节点
					parent = cur;
					Node* MinNode = cur->_right;
					while (MinNode->_left)
					{
						parent = MinNode;
						MinNode = MinNode->_left;
					}
					cur->_key = MinNode->_key;
					if (parent->_left == MinNode)
					{
						parent->_left = MinNode->_right;
					}
					else
					{
						parent->_right = MinNode->_right;
					}
					delete MinNode;
					return true;
				}
			}
		}
		return false;
	}

	void InOrder()
	{
		_InOrder(_root);
		cout << endl;
	}
private:
	void _InOrder(const Node* root)
	{
		if (root == nullptr)
		{
			return;
		}
		_InOrder(root->_left);
		cout << root->_key << " ";
		_InOrder(root->_right);
	}
	Node* _root = nullptr;
};

💥1.3 二叉搜索树的应用

💥1.3.1 Key模型

在K模型中，每个节点仅存储一个关键码（即Key），这个关键码用于确定节点在树中的位置，并满足二叉搜索树的性质。

  • 查找： 给定一个关键码，在二叉搜索树中查找是否存在对应的节点。查找过程从根节点开始，根据关键码与节点关键码的比较结果，决定是向左子树查找还是向右子树查找，直到找到对应的节点或确定不存在该关键码。
  • 应用场景： 可以用来拼写检查， 在文本编辑器或浏览器中，可以使用二叉搜索树的K模型来存储字典中的单词，以便快速检查用户输入的单词是否存在拼写错误。

我们上面实现的二叉搜索树就是一个简单的Key模型。

💥1.3.2 Key-Value模型

定义：

  • KV模型中的每个节点包含一个键值（Key）和一个数据值（Value），键值用于确定节点在树中的位置，数据值用于存储节点的附加信息
  • 节点的键值仍然必须满足二叉搜索树的性质，但数据值可以是任意类型或对象

应用场景：

  • 简单词典： 在英汉词典中，英文单词作为Key，其对应的中文解释作为Value。用户可以通过输入英文单词快速找到其对应的中文含义
  • 车库收费： 车进入车库时存储车牌号作为Key，进入的时间作为Value，当车从车库出来时按车牌号查找对应进入车库的时间
  • 计数器： 在需要统计元素出现次数的场景中，可以将元素作为Key，其出现的次数作为Value

这里我们以上面实现的二叉搜索树为基础，实现一个简单词典的KV模型。

cpp 复制代码 
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)
	{}
};

template<class K, class V>
class BSTree
{
	typedef BSTNode<K, V> Node;
public:
	Node* 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 cur;
			}
		}
		return nullptr;
	}
	bool Insert(const K& key, const V& value)
	{
		if (_root == nullptr)
		{
			_root = new Node(key, value);
			return true;
		}
		Node* cur = _root;
		Node* parent = nullptr;
		while (cur)
		{
			if (cur->_key > key)
			{
				parent = cur;
				cur = cur->_left;
			}
			else if (cur->_key < key)
			{
				parent = cur;
				cur = cur->_right;
			}
			else
			{
				return false;
			}
		}
		if (parent->_key > key)
		{
			parent->_left = new Node(key, value);
		}
		else
		{
			parent->_right = new Node(key, value);
		}
	}

	bool Erase(const K& key)
	{
		Node* cur = _root;
		Node* parent = nullptr;
		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 (_root->_key == key)
					{
						_root = _root->_right;
					}
					else
					{
						if (parent->_left == cur)
						{
							parent->_left = cur->_right;
						}
						else if (parent->_right == cur)
						{
							parent->_right = cur->_right;
						}
					}
					delete cur;
					cur = nullptr;
					return true;
				}
				else if (cur->_right == nullptr)
				{
					if (_root->_key == key)
					{
						_root = _root->_left;
					}
					else
					{
						if (parent->_left == cur)
						{
							parent->_left = cur->_left;
						}
						else if (parent->_right == cur)
						{
							parent->_right = cur->_left;
						}
					}
					delete cur;
					cur = nullptr;
					return true;
				}
				//有两个孩子
				else
				{
					//用要删除节点的右子树的最小节点代替删除节点
					parent = cur;
					Node* MinNode = cur->_right;
					while (MinNode->_left)
					{
						parent = MinNode;
						MinNode = MinNode->_left;
					}
					cur->_key = MinNode->_key;
					if (parent->_left == MinNode)
					{
						parent->_left = MinNode->_right;
					}
					else
					{
						parent->_right = MinNode->_right;
					}
					delete MinNode;
					return true;
				}
			}
		}
		return false;
	}

	void InOrder()
	{
		_InOrder(_root);
		cout << endl;
	}
private:
	void _InOrder(const Node* root)
	{
		if (root == nullptr)
		{
			return;
		}
		_InOrder(root->_left);
		cout << root->_key << " " << root->_value << endl;
		_InOrder(root->_right);
	}
	Node* _root = nullptr;
};

💥1.3.3 性能分析

KV模型的二叉搜索树在查找、插入和删除操作上的性能通常取决于树的高度 。在最坏的情况下（即树蜕化为单边树时），这些操作的时间复杂度会退化为O(n)。

可以使用平衡二叉搜索树来提高性能：

  • AVL树： 任何节点的两个子树的高度最大差别为一，这通过自平衡操作（如左旋、右旋）来维持
  • 红黑树： 一种自平衡二叉查找树，它通过每个节点附加一个表示颜色的位（红色或黑色）和通过确保树满足某些性质（如从根到叶子的最长的可能路径不多于最短的可能路径的两倍长）来保持平衡

关于平衡二叉搜索树的介绍还请在我专栏 C++ 中查找相关文章。

在平均情况下，这些操作的时间复杂度可以接近O(log n)，这使得KV模型的二叉搜索树成为一种高效的数据结构。

本篇文章的学习就到这了，如果您觉得在本文中有所收获，还请留下您的三连支持哦~

相关推荐
AI第一基地5 分钟前
推荐系统-电商直播 多目标排序算法探秘
人工智能·深度学习·排序算法·transformer·知识图谱·word2vec
叫我：松哥5 分钟前
基于机器学习的癌症数据分析与预测系统实现，有三种算法，bootstrap前端+flask
前端·python·随机森林·机器学习·数据分析·flask·bootstrap
KookeeyLena87 分钟前
如何限制任何爬虫爬取网站的图片
开发语言·c++·爬虫
我是瓦力7 分钟前
球形包围框-Bounding Sphere-原理-代码实现
人工智能·python·深度学习·计算机视觉·3d
开MINI的工科男8 分钟前
【笔记】自动驾驶预测与决策规划_Part1_自动驾驶决策规划简介
人工智能·笔记·自动驾驶
网络研究院12 分钟前
企业急于采用人工智能，忽视了安全强化
网络·人工智能·安全·工具·风险·企业
jndingxin14 分钟前
OpenCV特征检测(3)计算图像中每个像素处的特征值和特征向量函数cornerEigenValsAndVecs()的使用
人工智能·opencv·计算机视觉
m_Molly20 分钟前
vs2022配置opencv==4.9.0(C++)
c++·opencv
byxdaz21 分钟前
基于OpenCV的YOLOv5图片检测
人工智能·opencv·yolo
jndingxin22 分钟前
OpenCV特征检测(4)检测图像中的角点函数cornerHarris()的使用
人工智能·opencv·计算机视觉
热门推荐
01RAG 实践- Ollama+RagFlow 部署本地知识库02组基轨迹建模 GBTM的介绍与实现（Stata 或 R）032024年高教社杯数学建模国赛C题超详细解题思路分析04软件工程从理论到实践客观题汇总(头歌第一章至第八章)05苍穹外卖面试总结06【2024数模国赛赛题思路公开】国赛B题思路丨附可运行代码丨无偿自提07CCF-CSP认证考试 202406-3 文本分词 100分题解08yolov8实战第五天——yolov8+ffmpg实时视频流检测并进行实时推流——（推流，保姆教学）09【2024高教社杯全国大学生数学建模竞赛】B题 生产过程中的决策问题——解题思路 代码 论文10实战 | 基于YOLOv9和OpenCV实现车辆跟踪计数（步骤 + 源码）