系统性学习C++进阶-第十四讲-二叉搜索树

微露清风2025-12-31 17:40

系统性学习C++进阶-第十四讲-二叉搜索树

  • [1. 二叉搜索树的概念](#1. 二叉搜索树的概念)
  • [2. 二叉搜索树的性能分析](#2. 二叉搜索树的性能分析)
  • [3. 二叉搜索树的插入](#3. 二叉搜索树的插入)
  • [4. 二叉搜索树的查找](#4. 二叉搜索树的查找)
  • [5. 二叉搜索树的删除](#5. 二叉搜索树的删除)
  • [6. 二叉搜索树的实现代码](#6. 二叉搜索树的实现代码)
  • [7. 二叉搜索树 key 和 key/value 使用场景](#7. 二叉搜索树 key 和 key/value 使用场景)
    • [7.1 key搜索场景：](#7.1 key搜索场景：)
    • [7.2 key/value 搜索场景：](#7.2 key/value 搜索场景：)
    • [7.3 key/value 二叉搜索树代码实现](#7.3 key/value 二叉搜索树代码实现)

1. 二叉搜索树的概念

二叉搜索树又称二叉排序树，它或者是⼀棵空树，或者是具有以下性质的⼆叉树:

  • 若它的左子树不为空，则左子树上所有结点的值都小于等于根结点的值

  • 若它的右子树不为空，则右子树上所有结点的值都大于等于根结点的值

  • 它的左右子树也分别为⼆叉搜索树

  • ⼆叉搜索树中可以⽀持插⼊相等的值，也可以不⽀持插⼊相等的值，具体看使用场景定义，后续我们学习 map / set / multimap

    / multiset 系列容器底层就是二叉搜索树，其中 map / set 不支持插入相等值，multimap / multiset 支持插⼊相等值

2. 二叉搜索树的性能分析

最优情况下，二叉搜索树为完全二叉树(或者接近完全二叉树)，其高度为： log2N

最差情况下，二叉搜索树退化为单支树(或者类似单支)，其高度为： N

所以综合而言二叉搜索树增删查改时间复杂度为： O(N)

那么这样的效率显然是⽆法满足我们需求的，我们后续文章会讲解⼆叉搜索树的变形，平衡⼆叉搜索树 AVL树 和 红黑树，

才能适用于我们在内存中存储和搜索数据。

另外需要说明的是，二分查找也可以实现 O(log2N) 级别的查找效率，但是二分查找有两大缺陷：

  1. 需要存储在支持下标随机访问的结构中，并且有序。

  2. 插入和删除数据效率很低，因为存储在下标随机访问的结构中，插入和删除数据⼀般需要挪动数据。

这里也就体现出了平衡⼆叉搜索树的价值。

3. 二叉搜索树的插入

插入的具体过程如下：

  1. 树为空，则直接新增结点，赋值给 root 指针

  2. 树不空，按二叉搜索树性质，插入值比当前结点大往右走，插入值比当前结点小往左走，找到空位置，插⼊新结点。

  3. 如果支持插入相等的值，插入值跟当前结点相等的值可以往右走，也可以往左走，找到空位置，插入新结点。

    （要注意的是要保持逻辑⼀致性，插入相等的值不要⼀会往右走，⼀会往左走）

cpp 复制代码 
int a[] = {8, 3, 1, 10, 6, 4, 7, 14, 13};

1. 插入一个结点值为 16


2. 插入一个结点值为 3

4. 二叉搜索树的查找

  1. 从根开始比较，查找 x ，x 比根的值大则往右边走查找，x 比根值小则往左边走查找。

  2. 最多查找高度次，走到到空，还没找到，这个值不存在。

  3. 如果不支持插入相等的值，找到 x 即可返回

  4. 如果支持插入相等的值，意味着有多个 x 存在，⼀般要求查找中序的第⼀个 x 。

如下图，查找 3 ，要找到 1 的右孩子的那个 3 返回

5. 二叉搜索树的删除

首先查找元素是否在二叉搜索树中，如果不存在，则返回 false 。

如果查找元素存在则分以下四种情况分别处理：（假设要删除的结点为 N ）

  1. 要删除结点 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，可以直接删除。



6. 二叉搜索树的实现代码

cpp 复制代码 
template<class K>
struct BSTNode
{
 	K _key;
 	BSTNode<K>* _left;
 	BSTNode<K>* _right;
 	BSTNode(const K& key)
 	:_key(key)
 	, _left(nullptr)
 	, _right(nullptr)
 	{}
};

// Binary Search Tree
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->_right = cur;
 		}
 		else
 		{
 			parent->_left = cur;
 		}
 		return true;
 	}
 	
 	bool 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 true;
 			}
 		}
 		return false;
 	}
 	
 	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
 			{
 				// 0-1个孩⼦的情况 
 				// 删除情况1 2 3均可以直接删除，改变⽗亲对应孩⼦指针指向即可 
 				if (cur->_left == nullptr)
 				{
 					if (parent == nullptr)
 					{
 						_root = cur->_right;
 					}
 					else
 					{
 						if (parent->_left == cur)
 							parent->_left = cur->_right;
 						else
 							parent->_right = cur->_right;
 					}
 					delete cur;
 					return true;
 				}
 				else if (cur->_right == nullptr)
 				{
 					if (parent == nullptr)
 					{	
 						_root = cur->_left;
 					}
 					else
 					{
 						if (parent->_left == cur)
 							parent->_left = cur->_left;
 						else
 							parent->_right = cur->_left;
 					}
 					delete cur;
 					return true;
 				}
 				else
 				{
 					// 2个孩⼦的情况 
 					// 删除情况4，替换法删除 
 					// 假设这⾥我们取右⼦树的最⼩结点作为替代结点去删除 
 					// 这⾥尤其要注意右⼦树的根就是最⼩情况的情况的处理，对应课件图中删除8的情况 
 					// ⼀定要把cur给rightMinP，否会报错。 
 					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 (root == nullptr)
 		{
 			return;
 		}
 		_InOrder(root->_left);
 		cout << root->_key << " ";
 		_InOrder(root->_right);
 	}
 	
 	Node* _root = nullptr;
};

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

7.1 key搜索场景：

只有 key 作为关键码，结构中只需要存储 key 即可，关键码即为需要搜索到的值，搜索场景只需要判断 key 在不在。

key 的搜索场景实现的二叉树搜索树支持增删查，但是不支持修改，修改 key 破坏搜索树结构了。

下面两个场景适配 key 类型二叉搜索树：

  1. ：小区无人值守车库，小区车库买了车位的业主车才能进小区，那么物业会把买了车位的业主的车牌号录入后台系统，

车辆进入时扫描车牌在不在系统中，在则抬杆，不在则提示非本小区车辆，无法进入。

  1. ：检查⼀篇英文文章单词拼写是否正确，将词库中所有单词放入二叉搜索树，读取文章中的单词，查找是否在⼆叉搜索树中，

不在则波浪线标红提示。

7.2 key/value 搜索场景：

每⼀个关键码 key ，都有与之对应的值 value ，value 可以任意类型对象。树的结构中(结点)除了需要存储 key 还要存储对应的 value，

增 / 删 / 查还是以 key 为关键字走二叉搜索树的规则进行比较，可以快速查找到 key 对应的 value。

key / value的搜索场景实现的二叉树搜索树支持修改，但是不支持修改 key ，修改 key 破坏搜索树性质了，可以修改 value 。

在下面的三个场景中适合使用此类型的搜索二叉树

1：简单中英互译字典，树的结构中 (结点) 存储 key (英文)和 vlaue (中文)，搜索时输⼊英文，则同时查找到了英文对应的中文。

2：商场无人值守车库，入口进场时扫描车牌，记录车牌和入场时间，出口离场时，扫描车牌，查找入场时间，⽤当前时间 - 入场时间计算出停车时长，计算出停车费用，缴费后抬杆，⻋辆离场。

3：统计一篇文章中单词出现的次数，读取⼀个单词，查找单词是否存在，不存在这个说明第⼀次出现，（单词，1），单词存在，则++单词对应的次数。

7.3 key/value 二叉搜索树代码实现

cpp 复制代码 
template<class K, class V>
struct BSTNode
{
 	// pair<K, V> _kv;
	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:
 	BSTree() = default;
 	
 	BSTree(const BSTree<K, V>& t)
 	{
 		_root = Copy(t._root);
 	}
 	
 	BSTree<K, V>& operator=(BSTree<K, V> t)
 	{
 		swap(_root, t._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 (parent == nullptr)
 					{
 						_root = cur->_right;
 					}
 					else
 					{
 						if (parent->_left == cur)
 							parent->_left = cur->_right;
 						else
 							parent->_right = cur->_right;
 					}
 					delete cur;
 					return true;
 				}
 				else if (cur->_right == nullptr)
 				{
 					if (parent == nullptr)
 					{
 						_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 (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;
};

//类型 1
int main()
{
 	BSTree<string, string> dict;
 	//BSTree<string, string> copy = dict;
 	dict.Insert("left", "左边");
 	dict.Insert("right", "右边");
 	dict.Insert("insert", "插⼊");
 	dict.Insert("string", "字符串");
 	string str;
 	while (cin>>str)
 	{
 		auto ret = dict.Find(str);
 		if (ret)
 		{
 			cout << "->" << ret->_value << endl;
 		}
 		else
 		{
 			cout << "⽆此单词，请重新输⼊" << endl;
 		}
 	}
 	return 0;
}

// 类型 2
int main()
{
 	string arr[] = { "苹果", "西⽠", "苹果", "西⽠", "苹果", "苹果", "西⽠", "苹果", "⾹蕉", "苹果", "⾹蕉" };
 	BSTree<string, int> countTree;
 	for (const auto& str : arr)
 	{
 		// 先查找⽔果在不在搜索树中 
 		// 1、不在，说明⽔果第⼀次出现，则插⼊<⽔果, 1> 
 		// 2、在，则查找到的结点中⽔果对应的次数++ 
 		//BSTreeNode<string, int>* ret = countTree.Find(str);
 		auto ret = countTree.Find(str);
 		if (ret == NULL)
 		{
 			countTree.Insert(str, 1);
 		}
 		else
 		{
 			ret->_value++;
 		}
 	}
 	countTree.InOrder();
 	return 0;
}
相关推荐
董世昌412 小时前
强制类型转换和隐式类型转换的区别
开发语言
Fruiticecake2 小时前
Markdown，不用鼠标也能做笔记！
开发语言
brave and determined2 小时前
传感器学习(day19)：ToF传感技术：从测距到三维视觉革命
嵌入式硬件·学习·嵌入式系统·st·tof·嵌入式设计·flightsense
再睡一夏就好2 小时前
多线程并发编程核心：互斥与同步的深度解析及生产者消费者模型两种实现
linux·运维·服务器·jvm·c++·笔记
ulias2122 小时前
多态理论与实践
java·开发语言·前端·c++·算法
幽络源小助理2 小时前
下载安装AndroidStudio配置Gradle运行第一个kotlin程序
android·开发语言·kotlin
蹦蹦跳跳真可爱5892 小时前
Python----大模型（GPT-2模型训练，预测）
开发语言·人工智能·pytorch·python·gpt·深度学习·embedding
复业思维202401083 小时前
Altium Designer (24.2.2)中更改库以及保持器件参数不变
笔记·学习·硬件工程
CDwenhuohuo3 小时前
uniapp去掉手机状态栏 全屏展示
开发语言·javascript·uni-app
热门推荐
01GitHub 镜像站点02从快手“12·22”直播攻击事件看：一次教科书式的业务层饱和攻击03Claude Code Skills 实用使用手册04Linux下V2Ray安装配置指南05jdk21下载、安装（Windows、Linux、macOS）06UV安装并设置国内源07电脑检测软件—图吧工具箱082025 最新教程：注册并切换到美区 Apple ID09【踩坑笔记】50系显卡适配的 PyTorch 安装10Google Antigravity Agent 编辑器操作教程