二叉搜索树完全解析：从理论到C++手把手实现

444A4E2025-04-15 10:38

一、二叉搜索树的概念

二叉搜索树又称二叉排序树，它可以是一颗空树，或者是具有以下性质的二叉树：

  • 若左子树不为空，则左子树上所有节点的值都小于等于根节点的值。
  • 若右子树不为空，则右子树上所有节点的值都大于等于根节点的值。
  • 左右子树也分别是二叉搜索树。
  • 分场景可以支持插入相等值或不支持插入相等值，map/set/multimap/multiset 系列容器底层就是二叉搜索树，其中map/set 不支持插入相等值，multimap/multiset支持插入相等值。这些后面文章再说。

二、二叉搜索树的性能分析

最优情况下二叉搜索树为完全二叉树或者接近完全二叉树，其高度为 <math xmlns="http://www.w3.org/1998/Math/MathML"> l o g 2 N log2N </math>log2N。最差情况下，二叉搜索树退化为单枝树，其高度为 <math xmlns="http://www.w3.org/1998/Math/MathML"> N N </math>N。所以综合而言二叉搜索树增删改查时间复杂度为 <math xmlns="http://www.w3.org/1998/Math/MathML"> O ( N ) O(N) </math>O(N)。

但是这样的效率无法满足需求，所以还有二叉树的变形结构：平衡二叉树、AVL树、红黑树，这些也放在后面的文章中。

三、二叉搜索树的插入

  1. 树为空直接新增节点给root
  2. 树不为空，插入节点值比当前节点大往右走，插入值比当前节点小往左走，到空位置插入。
  3. 如果支持插入相等值，可以向左也可以向右，但后续插入需保持一致性。

四、二叉搜索树的查找

假设查找的值为x：

  1. 从根开始比较，x 比根的值大向右找，x比根值小则向左找。
  2. 走到为空则x不存在。
  3. 如果不支持插入相同值则找到x即可返回。
  4. 如支持插入相同值，一般为查找中序遍历的第一个x。

五、二叉搜索树的删除

首先查找元素是否在树中，不存在返回false ，存在则分四种情况处理（假设要删除的节点为N）：

  1. N的左右子节点均为空。
  2. N的左子节点为空，右不为空。
  3. N的右子节点为空，左不为空。
  4. N的左右子节点均不为空。

解决办法：

  1. 直接删除N 节点，将N 的父节点指向N节点的指针置空（这种情况可以直接和2、3情况一起处理，效果相同）。
  2. 改变N 节点的父节点指针，指向N 的右子节点，删除N节点。
  3. 改变N 节点的父节点指针，指向N 的左子节点，删除N节点。
  4. 替换法删除：找N 节点左子树中的最大节点，也就是左子树中的最右节点（假设为R ），或者是N 节点右子树中的最小节点，也就是右子树中的最左节点（假设为R ），来替换N 节点（也就是交换N 节点和R 节点的值），然后删除R节点。

情况1和情况2：删除1和10

情况3：删除14

情况4：删除3和8

六、二叉搜索树的代码实现

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

	template<class K>
	class BinarySearchTree
	{
		typedef TreeNode<K> Node;
	public:
		// 插入
		bool insert(const K& key)
		{
			if (_root == nullptr)
			{
				_root = new Node(key);
				return true;
			}

			Node* cur = _root;
			Node* parent = nullptr;
			while (cur)
			{
				if (key > cur->_key)
				{
					parent = cur;
					cur = cur->_right;
				}
				else if (key < cur->_key)
				{
					parent = cur;
					cur = cur->_left;
				}
				else
				{
					return false;
				}
			}
			cur = new Node(key);
			if (cur->_key > parent->_key) { parent->_right = cur; }
			else { parent->_left = cur; }
			return true;
		}

		// 查找   
		bool find(const K& key)
		{
			Node* cur = _root;
			while (cur)
			{
				if (key > cur->_key) { cur = cur->_right; }
				else if (key < cur->_key) { cur = cur->_left; }
				else { return true; }
			}
			return false;
		}

		// 删除
		bool erase(const K& key)
		{
			Node* cur = _root;
			Node* parent = nullptr;
			while (cur)
			{
				if (key > cur->_key)
				{
					parent = cur;
					cur = cur->_right;
				}
				else if (key < cur->_key)
				{
					parent = cur;
					cur = cur->_left;
				}
				else
				{
					if (cur->_left == nullptr)
					{
						if (cur == _root) { _root = cur->_right; }
						else
						{
							// 左为空
							if (cur == parent->_left) { parent->_left = cur->_right; }
							else { parent->_right = cur->_right; }
							delete cur;
						}
					}
					else if (cur->_right == nullptr)
					{
						if (cur == _root) { _root = cur->_left; }
						else
						{
							// 右为空
							if (cur == parent->_left) { parent->_left = cur->_left; }
							else { parent->_right = cur->_left; }
							delete cur;
						}
					}
					else
					{
						// 找右子树的最小节点
						Node* replaceParent = cur;
						Node* replace = cur->_right;
						while (replace->_left)
						{
							replaceParent = replace;
							replace = replace->_left;
						}

						swap(replace->_key, cur->_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);
		}

	private:
		Node* _root = nullptr;
	};
}

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

7.1 key 搜索场景

只有key 作为关键码，结构中只需存储key 即可，关键码即为要搜索到的值，搜索时只需要判断key 在不在。这样的二叉搜索树支持增删查，但不支持修改，因为修改key会破坏搜索树的结构。

场景一：无人值守车库，小区买了车位的车主才能进小区，那么物业只需要把买了车位的车主车牌号录入系统，车辆进入时扫描车牌是否在系统中，在则放行，否则无法进入。

场景二：检查单词拼写是否正确，将词库所有单词放入搜索二叉树，读取单词是否在搜索树中，不在则波浪线标红提示。

7.2 key/value 搜索场景

每一个关键码key 都有与之对应的value ，value 可以是任意类型对象。树的节点除了存储key 还需要存储value ，增删查以key 为关键字进行比较，找到对应的value 。key/value 的场景不支持修改key ，因为会破坏结构，支持修改value。

场景一：商场无人值守车库，车辆进入时扫描车牌并记录入场时间，车辆离开时扫描车牌查找时间，用当前时间减入场时间，计算出停车费用。

场景二 ：英汉互译字典，节点存储key（英文） 和 value（中文），搜索输入英文查找对应的中文。

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

cpp 复制代码 
namespace Key_value
{
	template<class K, class V>
	struct TreeNode
	{
		K _key;
		V _value;
		TreeNode<K, V>* _left;
		TreeNode<K, V>* _right;
		TreeNode(const K& key, const V& value) :_key(key), _value(value), _left(nullptr), _right(nullptr) {}
	};

	template<class K, class V>
	class BinarySearchTree
	{
		typedef TreeNode<K, V> Node;
	public:
		BinarySearchTree() = default;
		BinarySearchTree(const BinarySearchTree<K, V>& BSTree) { _root = _copy(BSTree._root); }

		BinarySearchTree<K, V>& operator=(BinarySearchTree<K, V> BSTree)
		{
			swap(_root, BSTree._root);
			return *this;
		}

		~BinarySearchTree()
		{
			_Destory(_root);
			_root = 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 (key > cur->_key)
				{
					parent = cur;
					cur = cur->_right;
				}
				else if (key < cur->_key)
				{
					parent = cur;
					cur = cur->_left;
				}
				else
				{
					return false;
				}
			}
			cur = new Node(key, value);
			if (cur->_key > parent->_key) { parent->_right = cur; }
			else { parent->_left = cur; }
			return true;
		}
		// 查找   
		Node* find(const K& key)
		{
			Node* cur = _root;
			while (cur)
			{
				if (key > cur->_key) { cur = cur->_right; }
				else if (key < cur->_key) { cur = cur->_left; }
				else { return cur; }
			}
			return nullptr;
		}

		bool erase(const K& key)
		{
			Node* cur = _root;
			Node* parent = nullptr;
			while (cur)
			{
				if (key > cur->_key)
				{
					parent = cur;
					cur = cur->_right;
				}
				else if (key < cur->_key)
				{
					parent = cur;
					cur = cur->_left;
				}
				else
				{
					if (cur->_left == nullptr)
					{
						if (cur == _root) { _root = cur->_right; }
						else
						{
							// 左为空
							if (cur == parent->_left) parent->_left = cur->_right;
							else parent->_right = cur->_right;
							delete cur;
						}
					}
					else if (cur->_right == nullptr)
					{
						if (cur == _root) { _root = cur->_left; }
						else
						{
							// 右为空
							if (cur == parent->_left) { parent->_left = cur->_left; }
							else { parent->_right = cur->_left; }
							delete cur;
						}
					}
					else
					{
						// 找右子树的最小节点
						Node* replaceParent = cur;
						Node* replace = cur->_right;
						while (replace->_left)
						{
							replaceParent = replace;
							replace = replace->_left;
						}

						swap(replace->_key, cur->_key);
						swap(replace->_value, cur->_value);
						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;
		}

	private:
		Node* _root = nullptr;

		// 中序遍历
		void _InOrder(Node* root)
		{
			if (root == nullptr) { return; }
			_InOrder(root->_left);
			cout << root->_key << ":" << root->_value << " ";
			_InOrder(root->_right);
		}
		// 清理
		void _Destory(Node* root)
		{
			if (root == nullptr) { return; }
			_Destory(root->_left);
			_Destory(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;
		}
	};
}
相关推荐
CppPlayer-程序员阿杜几秒前
poll为什么使用poll_list链表结构而不是数组 - 深入内核源码分析
网络·c++·链表·list·poll
@hdd1 分钟前
C++| 深入剖析std::list底层实现：链表结构与内存管理机制
c++·链表·list
weixin_428498491 小时前
使用POCO库进行ZIP压缩和解压
c++
摆烂能手1 小时前
C++基础精讲-06
开发语言·c++
蜕变的土豆1 小时前
十四、C++速通秘籍—函数式编程
c++
Bl_a_ck1 小时前
【C++基础】GNU简介
开发语言·c++·gnu
虾球xz1 小时前
游戏引擎学习第228天
c++·学习·游戏引擎
8RTHT1 小时前
数据结构（三）---单向循环链表
数据结构·链表
编程侦探3 小时前
【设计模式】适配器模式：让不兼容的接口和谐共处
开发语言·c++·设计模式·适配器模式
张立龙6664 小时前
有序二叉树各种操作实现（数据结构C语言多文件编写）
c语言·开发语言·数据结构
热门推荐
01我决定放弃搞 Java 了02RAG 实践- Ollama+RagFlow 部署本地知识库03DeepSeek各版本说明与优缺点分析04Scipy||第三章 线性代数 (scipy.linalg)05DeepSeek RAGFlow构建本地知识库系统06如何在WPS和Word/Excel中直接使用DeepSeek功能07ZNS SSD垃圾回收优化方案解读-108汽车上的各种质量：整备质量、总质量、装载质量、簧上质量、簧下质量09本地化部署AI知识库：基于Ollama+DeepSeek+AnythingLLM保姆级教程10C#/.NET/.NET Core技术前沿周刊 | 第 34 期（2025年4.7-4.13）