C++数据结构实战：二叉搜索树的核心操作与应用场景

m0_65245374

2870人浏览 · 2025-11-09 14:32:30

m0_65245374 · 2025-11-09 14:32:30 发布

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

7.1 key搜索场景

7.2 key/value搜索场景

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

1 二叉搜索树的概念

二叉搜索树也叫做二叉排序树，具有以下性质：

若它的左子树不为空，则左子树上所有节点的值都小于等于根节点的值。
若它的右子树不为空，则右子树上所有节点的值都大于等于根节点的值
它的左右子树也分别为二叉搜索树

二叉搜索树中可以支持插入相等的值，也可以不支持插入相等的值。像map/set/multimap/multiset系列容器，底层就是二叉搜索树。其中map/set不支持插入相同的值，multimap/multiset支持插入相等的值。了解二叉树搜索树的结构和核心操作有利于更好的理解和掌握这些容器。这也是本文的目的。

2 二叉搜索树的性能分析

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

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

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

这样的效率显然是无法满足我们要求的，像更进阶的平衡二叉树AVL树和红黑树，才能适用于我们在内存中存储和搜索数据。

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

需要存储早支持下标访问的结构中，并且要有序。
插入和删除的效率很低，因为要挪动数据

所以就体现出了平衡二叉树的价值

3 二叉搜索树的插入

首先创建一个头文件BinarySearch.h,创建一个命名空间key，然后定义节点，创建类模板，接下来的插入删除查找操作写在类里面，框架如下：

#pragma once

#include <iostream>
namespace key
{
	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//Binary Search Tree
	{
		typedef BTNode<K> Node;
	public:

	private:
		Node* _root = nullptr;
	};
}

插入函数：在二叉搜索树中插入节点，（1）如果树是空的，直接新增节点赋值给root指针（2）树不为空，根据性质，插入值比节点大往右走，插入值比节点小往左走，找到空位值，插入新节点（3）如果支持插入相等的值，插入值跟当前节点相等的值可以向右走，也可以向左走，但要保持逻辑一致性（遇到相等的值要一直向右走或一直向左走），找到空位置，插入节点。代码如下：

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;
		}
	}

	Node* newnode = new Node(key);
	if (parent->_key < key)
	{
		parent->_right = newnode;
	}
	else if (parent->_key > key)
	{
		parent->_left = newnode;
	}
	return true;
}

如果想要测试以下插入函数是否有效，并打印屏幕上查看，我们可以写一个中序遍历函数，根据二叉搜索树的性质，中序遍历可以打印从小到大的值。函数代码如下：

void _InOrder(Node* root)
{
	if (root == nullptr)
	{
		return;
	}
	_InOrder(root->_left);
	std::cout << root->_key << " ";
	_InOrder(root->_right);
}

在main函数中使用这个函数时，根节点参数不好传参，我们可以把这个函数放进private中，然后创建一个InOrder函数，放在public中，来调用这个中序遍历函数：

void InOrder()
{
	_InOrder(_root);
	std::cout << std::endl;
}

这回可以创建测试文件test.cpp,验证插入函数，如果代码没问题，会打印出从小到大的值

#include "BinarySearch.h"
int main()
{
	key::BSTree<int> t;
	int a[] = { 8,3,1,10,1,6,4,7,14,13 };
	for (auto e : a)
	{
		t.Insert(e);
	}
	t.InOrder();
	return 0;
}

运行结果：

可以看到a数组中所有元素都插入到二叉搜索树中，并且通过中序遍历来打印出从小到大的值，验证了函数的有效性。

4 二叉搜索树的查找

从根开始比较，查找x，x比根的值大则往右走查找，x比根值小则往左边走查找。
最多查找高度次，走到空，还没找到，这个值不存在。
如果不支持插入相等的值，找到x即可返回。
如果支持插入相等的值，意味着有多个x存在，一般要求查找中序的第一个x，如图，查找3，要找到1的右孩子的那个3返回。

代码如下：

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;
}

5 二叉树搜索树的删除

二叉搜索树的删除较为复杂，首先查找要删除的元素是否在二叉搜索树中，不存在返回false。

查找到要删除的元素的位置分为四种情况，每种不同的情况要分别处理（假设要删除的节点为N）

（1）要删除的节点N左右孩子均为空

（2）要删除的节点N左孩子为空，右孩子节点不为空

（3）要删除的节点N右孩子为空，左孩子的节点不为空

（4）要删除的节点N左右孩子均不为空

对于以上的四种情况的解决方案：

（1）把N节点的父亲对应的孩子指针指向空，直接删除N节点

情况（1）样例：删除1

（2）把N节点的父亲对应孩子指针指向N的右孩子，直接删除N节点

情况（2）样例：删除10

（3）把N节点的父亲对应的孩子指针指向N的左孩子，直接删除N节点

情况（3）样例：删除14

（4）不能直接删除N节点，因为N节点有两个孩子节点，可以用替换法删除。替换法就是找出N左子树的最大值(R)或者N右子树的最小值(R)替代N，就是将这个节点值和N节点值交换，转变成删除R节点。

情况（4）样例：删除3，删除8

代码实现：

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 (cur == _root)
				{
					_root = cur->_right;
				}
				else
				{
					if (parent->_left == cur)
					{
						parent->_left = cur->_right;
					}
					else
					{
						parent->_right = cur->_right;
					}
				}
				delete cur;
			}
			else if (cur->_right == nullptr)
			{
				//右为空
				if (cur == _root)
				{
					_root = cur->_left;
				}
				else
				{
					if (parent->_left == cur)
					{
						parent->_left = cur->_left;
					}
					else
					{
						parent->_right = cur->_left;
					}
				}
				delete cur;
			}
			else
			{
				//左右都不为空，找右子树最左节点或左子树最右节点
				Node* replace = cur->_right;
				Node* replaceParent = cur;
				while (replace->_left)
				{
					replaceParent = replace;
					replace = replace->_left;
				}
				cur->_key = replace->_key;

				if (replaceParent->_left == replace)
					replaceParent->_left = replace->_right;
				else
					replaceParent->_right = replace->_right;
				delete replace;
			}
			return true;
		}
	}
	return false;
}

在测试文件下测试删除函数是否有效，采用范围for方式，一个个删除元素，直到删除所有元素：

#include "BinarySearch.h"
int main()
{
	key::BSTree<int> t;
	int a[] = { 8,3,1,10,1,6,4,7,14,13 };
	for (auto e : a)
	{
		t.Insert(e);
	}

	t.InOrder();
	return 0;
}

运行结果：

可以看到数据最后全部删除，可以验证四种情况下，删除函数正确运行。

6 二叉搜索树实现代码

下面给出完整的头文件，实现了插入，查找，删除操作：

BinarySearchTree.h文件：

#include <iostream>
namespace key
{
	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//Binary Search Tree
	{
		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;
				}
			}

			Node* newnode = new Node(key);
			if (parent->_key < key)
			{
				parent->_right = newnode;
			}
			else if (parent->_key > key)
			{
				parent->_left = newnode;
			}
			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
				{
					//删除
					//左为空
					if (cur->_left == nullptr)
					{
						if (cur == _root)
						{
							_root = cur->_right;
						}
						else
						{
							if (parent->_left == cur)
							{
								parent->_left = cur->_right;
							}
							else
							{
								parent->_right = cur->_right;
							}
						}
						delete cur;
					}
					else if (cur->_right == nullptr)
					{
						//右为空
						if (cur == _root)
						{
							_root = cur->_left;
						}
						else
						{
							if (parent->_left == cur)
							{
								parent->_left = cur->_left;
							}
							else
							{
								parent->_right = cur->_left;
							}
						}
						delete cur;
					}
					else
					{
						//左右都不为空，找右子树最左节点或左子树最右节点
						Node* replace = cur->_right;
						Node* replaceParent = cur;
						while (replace->_left)
						{
							replaceParent = replace;
							replace = replace->_left;
						}
						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);
			std::cout << std::endl;
		}
	private:
		Node* _root = nullptr;

		void _InOrder(Node* root)
		{
			if (root == nullptr)
			{
				return;
			}
			_InOrder(root->_left);
			std::cout << root->_key << " ";
			_InOrder(root->_right);
		}
	};
}

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

二叉搜索树在使用层面有两个使用场景，下面介绍这两个场景。

7.1 key搜索场景

只有key作为关键码，关键码即为需要搜索到的值，搜索场景只需要判断key在不在。key搜索场景实现二叉树搜索树支持增删查，不支持修改，修改key会破坏搜索树结构。

场景1：：小区⽆人值守⻋库，小区车库买了⻋位的业主车才能进⼩区，那么物业会把买了⻋位的业主的⻋牌号录⼊后台系统，车辆进入时扫描⻋牌在不在系统中，在则抬杆，不在则提示非本小区车辆，无法进入。

场景2：检查⼀篇英文文章单词拼写是否正确，将词库中所有单词放⼊⼆叉搜索树，读取文章中的单词，查找是否在⼆叉搜索树中，不在则波浪线标红提示。

7.2 key/value搜索场景

每一个关键码key，都有与之对应的值value，value可以是任意类型对象。树的结构中除了需要存储key还要存储对应的value，增删查操作还是以key为关键字走二叉搜索树的规则进行比较，可以快速查找到key对应的value。key/value的搜索场景实现的二叉搜索树支持修改，支持修改value，但是不支持修改key。

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

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

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

namespace key_value
{
	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//Binary Search Tree
	{
		typedef BSTNode<K,V> Node;
	public:
		//强制生成构造
		BSTree() = default;
		BSTree(const BSTree& t)
		{
			_root = Copy(t._root);
		}

		BSTree& operator=(BSTree tmp)
		{
			swap(_root, tmp._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;
				}
			}

			Node* newnode = new Node(key,value);
			if (parent->_key < key)
			{
				parent->_right = newnode;
			}
			else if (parent->_key > key)
			{
				parent->_left = newnode;
			}
			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 (cur == _root)
						{
							_root = cur->_right;
						}
						else
						{
							if (parent->_left == cur)
							{
								parent->_left = cur->_right;
							}
							else
							{
								parent->_right = cur->_right;
							}
						}
						delete cur;
					}
					else if (cur->_right == nullptr)
					{
						//右为空
						if (cur == _root)
						{
							_root = cur->_left;
						}
						else
						{
							if (parent->_left == cur)
							{
								parent->_left = cur->_left;
							}
							else
							{
								parent->_right = cur->_left;
							}
						}
						delete cur;
					}
					else
					{
						//左右都不为空，找右子树最左节点或左子树最右节点
						Node* replace = cur->_right;
						Node* replaceParent = cur;
						while (replace->_left)
						{
							replaceParent = replace;
							replace = replace->_left;
						}
						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);
			std::cout << std::endl;
		}
	private:
		Node* _root = nullptr;

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

测试代码，设定一个字符数组，统计相同字符出现的个数：

int main()
{
	std::string arr[] = { "苹果","西瓜","苹果","西瓜","苹果","苹果","西瓜","苹果","香蕉","苹果","香蕉" };
	key_value::BSTree<std::string, int> countTree;
	for (const auto& str : arr)
	{
		//查找水果在在不在搜索树中
		//如果不在，说明水果第一次出现，插入<水果，1>
		//在，则查找到的节点中水果对应的次数+1

		//BSTreeNode<string,int>* ret=countTree.Find(str);
		auto ret = countTree.Find(str);
		if (ret == nullptr)
		{
			countTree.Insert(str, 1);
		}
		else
		{
			ret->_value++;
		}
	}
	countTree.InOrder();
	return 0;
}

这是一个字典统计应用场景，展示了key/value二叉搜索树的实用性。

以上就是二叉搜索树的介绍和使用了，希望对您有所帮助，如果这篇文章对你有用，可以点点赞哦，你的支持就是我写下去的动力，后续会不断地分享知识。

AI Agent技术社区

Agent 垂直技术社区，欢迎活跃、内容共建。

更多推荐

2026企业微信AI Agent实测：7款技术方案对比

会话审计、敏感词管理、聊天质检、敏感行为识别、舆情、属性、词频及竞品分析覆盖服务风险；线索公海、客户、产品、商机、订单、回款、发票和业绩目标则连接销售全过程。快创助手负责快速建运营任务，策略生成把目标拆成方案，智能客服回答系统使用咨询，数据报表处理自然语言查数，AI洞察联合标签、订单和会话分析客户。我们设计了客户筛选、订单关联、销售交接、会话质检和异常恢复任务，配合技术访谈与行业公开资料复核。准备