【C++】二叉搜索数

Shingmc32025-07-26 14:33

1.二叉搜索树概念

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

  • 若它的左子树不为空，则左子树 上所有结点的值都小于等于根结点的值
  • 若它的右子树不为空，则右子树 上所有结点的值都大于等于根结点的值
  • 它的左右子树也分别为二叉搜索树
  • 二叉搜索树中可以支持插入相等的值，也可以不支持插入相等的值，具体看使用场景定义，map/set/multimap/multiset系列容器底层就是⼆叉搜索树，其中map/set不支持插入相等值，multimap/multiset支持插入相等值

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

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

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

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

补充二分查找

二分查找也可以实现O(log2 N) 级别的查找效率，但是二分查找有两缺陷：

  1. 需要存储在支持下标随机访问的结构中，并且有序
  2. 插入和删除数据效率很低，因为存储在下标随机访问的结构中，插⼊和删除数据⼀般需要挪动数据

3. 二叉搜索树的插入

插⼊的具体过程如下：

  1. 树为空，则直接新增结点，赋值给root指针
  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，可以直接删除（考虑N是头节点情况，如下图删除8，则实现父节点一开始不能设为nullptr

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

实现代码

cpp 复制代码 
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);
	}
private:
	Node* _root = nullptr;
};

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

7.1 key搜索场景

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

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

7.2 key/value搜索场景

每一个关键码key，都有与之对应的值value，value可以任意类型对象。

树的结构中(结点)除了需要存储key还要存储对应的value，增/删/查还是以key为关键字走二叉搜索树的规则进行比较，可以快速查找到key对应的value。

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

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

实现代码

cpp 复制代码 
#pragma once
namespace key_value {

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

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

	template<class K, class V>
	class BSTree {
		typedef BSTreeNode<K, V> Node;
	public:
		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;
					}
				}
				cur = new Node(key, value);
				if (parent->_key>key)
				{
					parent->_left = cur;
				}
				else
				{
					parent->_right = 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* 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
				{
					//删除
					if (cur->_right = nullptr)
					{
						if (cur == _root)
						{
							_root = _root->_left;
						}
						else
						{
							if (parent->_right = cur)
							{
								parent->_right = cur->_left;
							}
							else
							{
								parent->_left = cur->_left;
							}
						}
						delete cur;
					}
					else if (cur->_left = nullptr)
					{
						if (cur = _root)
						{
							_root = cur->__right;
						}
						else
						{
							if (parent->_left = cur)
							{
								parent->_left = cur->_right;
							}
							if (parent->_right = cur)
							{
								parent->_right = cur->_right;
							}
						}
						delete cur;
					}
					else
					{
						//两个孩子
						Node* minright = cur;
						Node* minrightparent = cur;
						while (cur->_left)
						{
							minrightparent = minright;
							minright = minright->_left;
						}
						cur->_key = minright->_key;
						//minrightparent->_left = nullptr;
						//错误！！！遗漏情况
						if (minrightparent->_left == minright)
						{
							minrightparent->_left = minright->_right;
						}
						else
						{
							minrightparent->_right = minright->_right;
						}
						delete minright;
					}
					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);
		}

		Node* _root = nullptr;
	};

}
//main函数
	string arr[] = { "苹果","香蕉","香蕉","西瓜", "苹果", "西瓜", "苹果", "苹果", "西瓜",
"苹果", "香蕉", "苹果", "香蕉","香蕉","香蕉" };
	key_value::BSTree<string, int> countTree;
	for (auto& e : arr)
	{
		auto ret = countTree.Find(e);
		if (ret == nullptr)
		{
			countTree.Insert(e, 1);
		}
		else
		{
			ret->_value++;
		}
	}
	countTree.InOrder();
相关推荐
悦悦子a啊1 小时前
Python之--集合
开发语言·python·编程
JNU freshman1 小时前
C++ 常用的数据结构（适配器容量：栈、队列、优先队列）
数据结构·c++
程序员编程指南1 小时前
Qt字符串处理与正则表达式应用
c语言·c++·qt·正则表达式
BS_Li1 小时前
C++模板进阶
c++·模板进阶
szx04271 小时前
缓存HDC内容用于后续Direct2D绘制.
c++·缓存·directx·d2d·direct2d·dx·gdi+dx
运维帮手大橙子1 小时前
字符串缓冲区和正则表达式
java·开发语言
橘颂TA1 小时前
【C++】C++11特性的介绍和使用（第三篇）
前端·c++·算法·c++11
嶔某1 小时前
网络：应用层
linux·服务器·网络·c++
慢慢沉2 小时前
Lua（数据库访问）
开发语言·数据库·lua
GISer_Jing2 小时前
50道JavaScript基础面试题：从基础到进阶
开发语言·javascript·ecmascript
热门推荐
01Qwen3-Coder 快速上手教程 | Qwen Code + Claude Code02vue数据变化但页面不变03全球最强模型Grok4，国内已可免费使用！（附教程）04KGG转MP3工具|非KGM文件|解密音频05【2025.7.18】更新vscode后所有.vue文件template标签后报红的临时解决办法，Vue - Official 插件3.0.2导致06干翻 Typora！MilkUp：完全免费的桌面端 Markdown 编辑器！07ChatGPT Agent 完全使用指南：2025年7月最新功能详解08这次领先Cursor！体验了Trae 2.0 SOLO 模式，超酷！09Cursor Claude 模型无法使用的解决方法10Claude Code用不了？来试下Qwen3-Coder加持的Qwen Code吧