二叉搜索树的 C++ 实现与详解

原创 已于 2025-03-04 00:39:37 修改 · 2.2k 阅读 · 17 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
标签
#数据结构 #c++ #java #开发语言 #算法
于 2025-03-02 12:32:57 首次发布

目录

 

一、引言

二、二叉搜索树的定义

二叉搜索树是一种特殊的二叉树，它满足以下性质：

三、创造二叉搜索树的目的

四、复杂度分析

五、C++ 代码实现

六.代码剖析

1.insert分析

2.erase分析

3.图示

总结

 

一、引言

 

在数据结构的领域中，二叉搜索树（Binary Search Tree，简称 BST）是一种非常重要且常用的数据结构。它具有高效的查找、插入和删除操作性能，在许多实际应用中发挥着关键作用。本文将通过 C++ 代码详细介绍二叉搜索树的实现，并对其关键操作进行深入分析。

二、二叉搜索树的定义

 

二叉搜索树是一种特殊的二叉树，它满足以下性质：

  1. 对于树中的任意一个节点，其左子树中所有节点的值都小于该节点的值。
  2. 对于树中的任意一个节点，其右子树中所有节点的值都大于该节点的值。

三、创造二叉搜索树的目的

高效查找：搜索二叉树的特性是对于树中的每个节点，其左子树中所有节点的值都小于该节点的值，而其右子树中所有节点的值都大于该节点的值。这种特性使得在搜索二叉树中进行查找操作时，可以利用二分查找的思想，平均情况下查找的时间复杂度为O(logn)，其中n是树中节点的数量。相比顺序存储结构（如数组）的顺序查找（时间复杂度为O(n)），以及链表结构的顺序查找，在数据量较大时，搜索二叉树的查找效率更高。

在实现二叉搜索树的时候还发现了一个有趣的特性就是用中序遍历的时候他成有序数列,我称为附带价值。

  

四、复杂度分析

1.在理想情况下，即搜索二叉树是平衡的，树的高度为h=logn（n为节点个数）。每次比较都能将搜索范围缩小一半，类似于二分查找，所以查找操作的时间复杂度为O(logn)。

 

然而，在最坏情况下，比如二叉搜索树退化成了一个单链表（所有节点都只有右子树或左子树），此时树的高度为n，查找操作就需要从根节点依次遍历到目标节点，时间复杂度变为O(n)。

 

五、C++ 代码实现

 

下面是一个简单的二叉搜索树的 C++ 模板类实现：

二叉树的基础：

template <class T>
struct SBtreeNode
{
	T _key;
	SBtreeNode<T>* _left;
	SBtreeNode<T>* _right;
	SBtreeNode(const T& key)
		:_key(key)
		, _left(nullptr)
		, _right(nullptr)
	{

	}
};

实现二叉搜索树：

template <class T>
class SBtree
{
	typedef SBtreeNode<T> Node;
public:
	bool Insert(const T& 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;
			}
		}
		if (parent->_key < key)
		{
			cur = new Node(key);
			parent->_right = cur;
		}
		else
		{
			cur = new Node(key);
			parent->_left = cur;
		}
		return true;
	}
	bool Find(const T& 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 T& key)
	{
		Node* parend=nullptr;
		Node* cur=_root;
		while (cur)
		{
			if (cur->_key < key)
			{
				parend = cur;
				cur = cur->_right;
			}
			else if (cur->_key > key)
			{
				parend = cur;
				cur = cur->_left;
			}
			else
			{
				if (cur->_left == nullptr)
				{
					if (cur == _root)
					{
						_root = cur->_right;
					}
					else
					{
						if (parend->_key < key)
						{
							parend->_right = cur->_right;
						}
						else
						{
							parend->_left = cur->_right;
						}
					}
					delete cur;
				}
				else if(cur->_right == nullptr)
				{
					if (cur == _root)
					{
						_root = cur->_left;
					}
					else
					{
						if (parend->_key < key)
						{
							parend->_right = cur->_left;
						}
						else
						{
							parend->_left = cur->_left;
						}
					}
					delete cur;
				}
				else
				{
					Node* replace = cur->_right;
					Node* replaceparent = cur;
					while (replace->_left)
					{
						replaceparent = replace;
						replace = replace->_left;
					}

					swap(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;
	}
	void _InOrder(Node* root)
	{
		if (root == nullptr)
		{
			return ;
		}
		_InOrder(root->_left);
		cout << root->_key << " ";
		_InOrder(root->_right);
	}

六.代码剖析

在这里我们主要剖析insert和erase

1.insert分析

bool Insert(const T& key)
{
	if (_root == nullptr)
	{
		_root = new Node(key);//根节点为空创造新节点并返回true
		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   //相同返回false
		{
			return false;
		}
	}     
	if (parent->_key < key)//找到这里说明cur已经为空并找好了key要插入的位置
	{
		cur = new Node(key);
		parent->_right = cur;
	}                   
	else
	{
		cur = new Node(key);
		parent->_left = cur;
	}
	return true;
}
  1. 根节点为空的情况：如果二叉搜索树的根节点 _root 为空，说明树为空，此时直接创建一个新节点并将其作为根节点，插入成功并返回 true。
  2. 寻找插入位置：使用两个指针 parent 和 cur 遍历二叉搜索树。cur 用于当前遍历的节点，parent 用于记录 cur 的父节点。在遍历过程中，根据二叉搜索树的性质（左子树节点值小于根节点值，右子树节点值大于根节点值），比较当前节点的值和要插入的值 key 的大小关系，决定向左子树还是右子树继续遍历。如果发现 cur->_key 等于 key，说明该值已经存在于树中，插入失败，返回 false。
  3. 插入新节点：当 cur 为空时，说明已经找到了插入位置，此时根据 parent 的值和 key 的大小关系，将新节点插入到 parent 的左子树或右子树。插入成功后返回 true。

2.erase分析

bool Erase(const T& key)
{
	Node* parend=nullptr;
	Node* cur=_root;
	while (cur)  //为空跳出没有找到且未删除
	{
		if (cur->_key < key)    //若cur的_key小于要插入的key
		{                       //说明key在cur的右子树里
			parend = cur;
			cur = cur->_right;
		}
		else if (cur->_key > key)//若cur的_key大于要插入的key
		{                        //说明key在cur的左子树里
			parend = cur;
			cur = cur->_left;
		}
		else                     //找到
		{
			if (cur->_left == nullptr)//判断是否为单叶子，若为单叶子就好办了
			{                         
				if (cur == _root)     //判断是否为头节点是则直接等于cur_right因为_left那                            
				{                     //一边已经没有东西
					_root = cur->_right;
				}
				else
				{
					if (parend->_key < key)//判断是父节点的左还是右节点
					{
						parend->_right = cur->_right;
					}
					else
					{
						parend->_left = cur->_right;
					}
				}
				delete cur;
			}
			else if(cur->_right == nullptr)//同上//判断是否为单叶子，若为单叶子就好办了
			{                                             
				if (cur == _root)
				{
					_root = cur->_left;
				}
				else
				{
					if (parend->_key < key)//判断是父节点的左还是右节点
					{
						parend->_right = cur->_left;
					}
					else
					{
						parend->_left = cur->_left;
					}
				}
				delete cur;
			}
			else   //上面全判断完还是不满足就说明要删除的节点为双叶子节点
			{
				Node* replace = cur->_right;//找右节点的最小节点
				Node* replaceparent = cur;  //cur就是要删除的节点
				while (replace->_left)     //找右节点的最小节点
				{
					replaceparent = replace;
					replace = replace->_left;
				}

				swap(cur->_key,replace->_key);//交换key

	 			if (replaceparent->_left == replace) //判断是左还是右
					replaceparent->_left = replace->_right;
				else
					replaceparent->_right = replace->_right;

				delete replace; //记得删除
			}
			return true;
		}
	}
	return false;
	}

 

  1. 查找待删除节点：使用两个指针 parent和 cur 从根节点开始遍历二叉搜索树，根据节点键值和目标键值 key 的大小关系，决定向左子树或右子树继续查找，直到找到目标节点或遍历到空节点。
  2. 删除节点：当找到目标节点后，根据该节点的子节点情况进行不同处理：
    • 左子节点为空：直接将该节点的右子节点连接到其父节点相应位置（若该节点为根节点，则更新根节点），然后删除该节点。
    • 右子节点为空：直接将该节点的左子节点连接到其父节点相应位置（若该节点为根节点，则更新根节点），然后删除该节点。
    • 左右子节点都不为空：找到该节点右子树中的最小节点（即右子树中最左边的节点）作为替换节点，将替换节点的值与待删除节点的值交换，然后删除替换节点。
  3. 返回结果：如果成功删除节点，返回 true；若未找到目标节点，返回 false。

3.图示

else                     //找到
		{
			if (cur->_left == nullptr)//判断是否为单叶子，若为单叶子就好办了
			{                         
				if (cur == _root)     //判断是否为头节点是则直接等于cur_right因为_left那                            
				{                     //一边已经没有东西
					_root = cur->_right;
				}
				else
				{
					if (parend->_key < key)//判断是父节点的左还是右节点
					{
						parend->_right = cur->_right;
					}
					else
					{
						parend->_left = cur->_right;
					}
				}
				delete cur;
			}
			else if(cur->_right == nullptr)//同上//判断是否为单叶子，若为单叶子就好办了
			{                                             
				if (cur == _root)
				{
					_root = cur->_left;
				}
				else
				{
					if (parend->_key < key)//判断是父节点的左还是右节点
					{
						parend->_right = cur->_left;
					}
					else
					{
						parend->_left = cur->_left;
					}
				}
				delete cur;
			}

为单节点：

为双节点

else   //上面全判断完还是不满足就说明要删除的节点为双叶子节点
{
	Node* replace = cur->_right;//找右节点的最小节点
	Node* replaceparent = cur;  //cur就是要删除的节点
	while (replace->_left)     //找右节点的最小节点
	{
		replaceparent = replace;
		replace = replace->_left;
	}

		swap(cur->_key,replace->_key);//交换key

	 	if (replaceparent->_left == replace) //判断是左还是右
			replaceparent->_left = replace->_right;
		else
			replaceparent->_right = replace->_right;

		delete replace; //记得删除
	}
		return true;
}

 

 

总结

搜索二叉树是一种强大而灵活的数据结构，它通过巧妙的结构设计实现了高效的数据管理。虽然在最坏情况下性能可能会下降，但通过一些优化策略（如平衡二叉搜索树）可以有效避免这种情况。在实际应用中，搜索二叉树广泛应用于各种领域，为我们提供了快速、可靠的数据处理解决方案。希望通过本文的介绍，你对搜索二叉树有了更深入的理解和认识。

在此我们可以感觉到搜索二叉树还是有很多不足的比如树在极端情况下复杂度为O（N）在此我引出下篇——AVL平衡树实现

最后祝大家生活愉快！

 

usuallyyy
关注
C++ 二叉搜索树的详解与实现
2403_87856518的博客
09-12 854
本文系统介绍了二叉搜索树（BST）及其核心操作。BST是一种左子树节点值均小于根节点、右子树节点值均大于根节点的二叉树。文章详细讲解了查找、插入和删除操作的递归与非递归实现方法，重点分析了删除节点时处理的三种情况（无子节点、单子节点和双子节点）。通过指针引用技巧，递归实现显著简化了代码逻辑。文章还涉及中序遍历、拷贝构造、析构函数等其他操作，并分析了BST的性能特点：最优情况下（接近完全二叉树）操作时间复杂度为O(logn)，最差情况下（退化为单支树）降为O(n)。BST的中序遍历结果有序性使其具有重要应用价
详解二叉搜索树【C++实现】
Tau_Ceti的博客
08-25 597
详解BST
二叉搜索树详解以及C++实现二叉搜索树（递归和非递归）
qq_61635026的博客
07-26 1040
二叉搜索树详解以及C++实现二叉搜索树（递归和非递归）
C++实现二叉搜索树(BST)详解
hello world/linux
09-25 926
V _value;:_key(key){}二叉搜索树是一种高效的数据结构，平均情况下插入、删除和查找操作的时间复杂度均为O(log n)。本文实现了两种版本的二叉搜索树：key结构版本：适用于简单的数据存储和检索key-value结构版本：适用于需要建立映射关系的场景需要注意的是，二叉搜索树的性能高度依赖于树的平衡性。
算法与数据结构之Floyd算法
weixin_73953650的博客
06-20 397
超详细的Floyd算法教程，一看就懂！
多线程编程（一）
m0_62591054的博客
06-16 220
编译时：需加上 -lpthread，链接上对应的线程支持库。
Hermes Agent 技能进化系统拆解：Skill 的元数据结构、自注册加载与退化机制 [07]
Starry-SkyJing的博客
06-22 96
[07] Hermes Agent 技能进化系统拆解：Skill 的元数据结构、自注册加载与退化机制 > TL;DR：Skill 不是静态的文档——它是 Agent 的"程序性记忆"系统。SKILL
C/C++ 数据结构（十一）树
2301_80252792的博客
06-22 240
本文系统介绍了树结构基础与二叉树核心知识。主要内容包括：1.树的基础概念与术语（节点关系、度、深度等）；2.二叉树的数学特性、存储方式（链式/顺序）及堆结构；3.四种遍历算法（前/中/后序递归非递归实现，层序队列实现）；4.常用递归操作（求高、节点计数、插入删除）；5.应用实例（二叉搜索树、四/八叉树的游戏优化原理）。重点强调了完全二叉树与普通二叉树的区别，以及递归在树操作中的核心作用，为数据结构学习提供了完整框架。
算法与数据结构---二叉搜索树(BST)
MzKyle的博客
06-17 1395
二叉搜索树（BST）是一种基于二叉树的有序数据结构，核心特性是左子树节点值小于根节点，右子树节点值大于根节点。本文系统介绍了BST的核心概念与操作实现： 基本定义：BST通过"左小右大"的规则维护有序性，所有操作复杂度为O(h)，h为树高。平衡时h≈log₂n，退化为链表时h=n。 关键操作： 查找：根据值比较选择左右子树路径 插入：在适当位置创建新节点 删除：处理三种情况（无子节点、单子节点、双子节点），最复杂的是用中序前驱/后继替代被删节点 重要特性：中序遍历BST会得到有序序列，这是BST的核心性质。
排序类...
qq_43519774的博客
06-22 194
└── 分配排序类 (核心：利用“多关键字”分配和收集，不依赖比较) ←── 这里补上你问的“基数排序”│ └── 堆排序 (利用堆结构选最值) ←── 这里补上你问的“选择排序”├── 选择排序类 (核心：在待排序列中选出最值，放到最终位置)├── 交换排序类 (核心：通过比较并交换元素位置来排序)├── 插入排序类 (核心：将元素插入到已有序的序列中)│ └── 希尔排序 (本质：多次分组插入排序)│ ├── 简单选择排序 (直接选最值)│ ├── 直接插入排序。
Pulseaudio进阶开发之核心数据结构串联播放链路(三十)
Android系统攻城狮
06-22 453
本篇目的：Pulseaudio进阶开发之11个核心数据结构串联播放链路。
数据结构基础复习——排序算法的关键代码片段
最新发布
2301_80025611的博客
06-22 151
针对数据结构考试中常见的代码填空题，我为你整理了上述核心排序算法的关键代码片段。考试时，出题人通常会挖空或。
Redis 数据结构
土司先生的博客
06-22 211
redis 的 string , list 队列，Set 集，的数据结构讲解
C/C++ 数据结构（十）深搜广搜补充，A*算法
2301_80252792的博客
06-22 163
本文系统介绍了三种经典寻路算法： BFS广度优先搜索：基于队列实现分层扩散，天然保证最短路径，适用于迷宫寻路等场景，通过前驱数组回溯路径。 DFS深度优先搜索：递归实现栈结构，代码简洁但无法保证最优解，适合全图遍历，需注意栈溢出风险。 A*启发式算法：融合实际代价G与启发估值H（曼哈顿/欧式距离），通过Open/Close列表动态筛选路径，兼顾效率与最优性，是游戏和导航领域的工业标准。文中对比了三者特性，并给出完整代码框架及优化方向（如优先队列优化Open列表），突显A*在复杂场景下的综合优势。
【C++】数据结构之图的基本概念
L_0907的博客
06-17 274
本文系统介绍了并查集和图两种重要数据结构。并查集部分详细阐述了其基本概念、逻辑结构（森林表示）与物理存储（数组实现），重点讲解了路径压缩和按秩合并两种优化策略，并通过省份数量、等式方程等LeetCode题目展示了实际应用。图结构部分明确定义按秩合并顶点、边、有向/无向图等核心概念，比较了邻接矩阵和邻接表两种存储方式的优劣，给出了完整的C++实现代码。全文通过理论讲解结合代码实践，为后续学习图的遍历、最小生成树等算法奠定了坚实基础。
C/C++ 数据结构（九）深搜广搜
2301_80252792的博客
06-17 575
本文系统介绍了迷宫寻路算法的核心实现方法。重点分析了深度优先搜索(DFS)和广度优先搜索(BFS)两种算法，分别基于栈和队列实现。DFS采用"一条路走到底"的策略，适用于快速找到可行路径；BFS通过分层扩散确保找到最短路径。文章详细展示了两种算法的代码实现，包括迷宫表示、移动方向处理、越界判断等关键环节。同时探讨了路径记录、拾取所有金币等拓展场景，并比较了两种算法在时间复杂度、空间复杂度和适用场景上的差异。最后简要提及了A*算法等进阶内容，为游戏开发和路径规划提供了实用指导。
我的数据结构1
ChaoZiLL的博客
06-17 292
首先将数组的数据全部进行异或(^)操作，得到一个值a，再将该值与取负(原码取反+1)，得到(-a),将a与(-a)进行与(&)运算得到key值，key值就意味着该组数据中可以从右往左边数第几位为1，在使用key值作为分组的桥梁，是的同一组内的不同值再进行一次异或(^)操作，最后留下来的数就是需要的答案了；礼盒中除了一款撞色搭配的袜子，每种颜色的袜子均有两只。第一种：使用计数排序的思路从而找出缺失的数，但这样的空间复杂度是O(N)，因为要遍历数组，时间复杂度也是O(N)；的所有整数，但其中缺了一个。
ACM CSP竞赛笔记（七）——数据结构-栈与前中后缀表达式
2301_80226956的博客
06-20 197
栈在表达式计算中的应用，包括前缀、后缀表达式的计算方法
【C++】数据结构之图的相关算法
L_0907的博客
06-17 402
本文系统地介绍了图的遍历算法以及相关算法。主要内容包括： BFS、DFS 及其实现。最小生成树算法： Kruskal算法、Prim算法，二者均基于贪心策略，得到全局最优解。最短路径算法： Dijkstra、Bellman-Ford、Floyd-Warshall 算法，并进行了三者的对比与实现。
Pandas 数据分析入门：从数据结构到实战绘图
m0_63267251的博客
06-17 357
本文介绍了Python中强大的数据处理库Pandas的核心功能与应用场景。Pandas基于Numpy构建，具有高效的数据处理能力，特别适合处理单机结构化数据。文章通过实际案例演示了Pandas的基本操作：包括数据加载、查询筛选、索引设置、数据可视化（绘制GDP变化曲线）以及解决中文显示问题。重点讲解了Pandas的两种核心数据结构：DataFrame和Series，其中Series作为一维数组对象，包含索引和数据值两部分。Pandas凭借其灵活的分组、聚合和转换功能，成为数据清洗、分析和处理的理想工具，尤其
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值