二叉搜索树

最新推荐文章于 2025-08-05 20:53:10 发布
原创 最新推荐文章于 2025-08-05 20:53:10 发布 · 805 阅读 · 16 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#数据结构 #c++ #开发语言

一、概念

二叉搜索树又称 二叉排序树（这种树的主要功能为搜索 ， 其次为排序）  ， 它或者是一棵空树，或者是具有一下性质的二叉树：

  • 若它是的左子树不为空 ， 则左子树上所有结点的值都小于等于根结点的值。
  • 若它是的右子树不为空 ， 则右子树上所有结点的值都大于等于根结点的值。
  • （左 < 根 < 右 ） ， ---> 二叉搜索树的中序遍历一定是从小到大（升序）的 。 
  • 它的 左右子树 也分别为二叉搜索树
  • 二叉搜素树可以支持插入相等的值，也可以不支持插入相等的值，具体看使用场景定义，后续我们学习map / set / multimap / multiset 系列 容器底层就是二叉树 ， 其中map/set  不支持 插入相等的值，multimap / multiset 支持 插入相等的值

二、性能分析

  1. 最优情况下，二叉搜索树为完全二叉树（或者接近完全二叉树），其高度为 logN
  2. 最差情况下，二叉搜索树为单支树（或者类似单支），其高度为 N

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

那么这样的效率显然是无法满足我们需求的 ， 后续介绍的二叉树的变形，平衡二叉树AVL树 和 红黑树 ， 才适用于我们在  内存中 存储 和 搜索 数据  。

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

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

这里也体现出了平衡二叉树的价值 。

正常情况下，二叉搜索树的增删查的时间复杂度为 O(logN) :

但是，如果数据刚好是有序的，构建的二叉搜索树是单支的 ， 时间复杂度增为O(N) ，后续会讲解解决方法：

三、插入

  1. 树为空 ， 则直接新增结点 ， 赋值给 root 指针
  2. 树不为空 ， 按二叉搜索树性质，插入值比当前结点大往右走 ， 插入值比当前结点小往左走 ， 找到空位置 ， 插入新结点 。
  3. 如果支持插入相等的值，插入值跟当前结点相等的值可以往右走，也可以往左走，找到空位置，插入新结点 。（要注意的是保持逻辑一致性 ， 插入相等的值不要一会往右走，一会往左走）

插入数据16： 

插入数据3： 

四、查找

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

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

  3. 如果不支持插入相等的值，找到x即可返回。
  4. 如果支持插入相等的值，意味着有多个x存在 ， 一般要求查找中序的第一个x 。 如下图，查找3 ， 要找到 1 的右孩子的那个3返回 。

五、删除

  1. 首先确认一下查找元素是否在二叉搜索树中，如果不存在，则返回false。
  2. 如果查找元素存在则分以下四种情况分别处理：（假设要删除的结点为N）
  • 要删除结点N左右孩子均为空
  • 要删除的结点N左孩子位空，右孩子结点不为空
  • 删除的结点N右孩子位空，左孩子结点不为空
  • 要删除的结点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，可以直接删除。

简单来说：

1）删除叶子结点 ： 直接删除即可

2）删除只有左子树或者只有右子树的结点：让只有的那一个子树代替即可

3）删除既有左子树又有右子树的结点：找到删除结点的左子树的最大结点，或者右子树的最小结点 。

六、实现代码

#pragma once

//结点
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 SearchBinaryTree
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
			{
				//删除
				if (cur->_left == nullptr)
				{
					//if (parent == nullptr)
					if (cur == _root)
					{
						_root = cur->_right;
					}
					else
					{
						// 父亲指向我的右
						if (cur == parent->_right)
						{
							parent->_right = cur->_right;
						}
						else
						{
							parent->_left = cur->_right;
						}
					}

					delete cur;
				}
				else if (cur->_right == nullptr)
				{
					if (cur == _root)
					{
						_root = cur->_left;
					}
					else
					{
						// 父亲指向我的左
						if (cur == parent->_right)
						{
							parent->_right = cur->_left;
						}
						else
						{
							parent->_left = cur->_left;
						}
					}

					delete cur;
				}
				else
				{
					// 找右子树最小节点(最左)替代我的位置
					Node* minRightParent = cur;
					Node* minRight = cur->_right;
					while (minRight->_left)
					{
						minRightParent = minRight;
						minRight = minRight->_left;
					}

					cur->_key = minRight->_key;

					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 << " ";
		_InOrder(root->_right);
	}

	Node* _root = nullptr;
};


#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
using namespace std;
#include"SearchBinaryTree.h"

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

	t.Erase(8);
	t.InOrder();

	t.Erase(14);
	t.InOrder();

	t.Erase(1);
	t.InOrder();

	for (auto e : a)
	{
		t.Erase(e);
		t.InOrder();
	}

	return 0;
}

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

7.1 key搜索场景

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

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

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

7.2 key/value搜索场景

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

场景一：简单中英互译字典 ， 树的结构中（结点）存储  key(英文) 和 value(中文)，搜索时输入英文 ， 则同时查找到了英文对应的中文。

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

场景三：统计一篇文章中单词出现的次数 ， 读取一个单词 ， 查找单词是否存在，不存在这个说明第一次出现单词，（单词，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
	{
		typedef BSTNode<K, V> Node;
	public:
		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)
						if (cur == _root)
						{
							_root = cur->_right;
						}
						else
						{
							// 父亲指向我的右
							if (cur == parent->_right)
							{
								parent->_right = cur->_right;
							}
							else
							{
								parent->_left = cur->_right;
							}
						}

						delete cur;
					}
					else if (cur->_right == nullptr)
					{
						if (cur == _root)
						{
							_root = cur->_left;
						}
						else
						{
							// 父亲指向我的左
							if (cur == parent->_right)
							{
								parent->_right = cur->_left;
							}
							else
							{
								parent->_left = cur->_left;
							}
						}

						delete cur;
					}
					else
					{
						// 找右子树最小节点(最左)替代我的位置
						Node* minRightParent = cur;
						Node* minRight = cur->_right;
						while (minRight->_left)
						{
							minRightParent = minRight;
							minRight = minRight->_left;
						}

						cur->_key = minRight->_key;

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

}
int main()
{
	string arr[] = { "苹果","香蕉","香蕉","西瓜", "苹果", "西瓜", "苹果", "苹果", "西瓜",
"苹果", "香蕉", "苹果", "香蕉","香蕉","香蕉" };
	key_value::BSTree<string, int> countTree;
	for (auto& e : arr)
	{
		//key_value::BSTNode<string, int>* ret = countTree.Find(e);
		auto ret = countTree.Find(e);

		if (ret == nullptr)
		{
			countTree.Insert(e, 1);
		}
		else
		{
			ret->_value++;
		}
	}

	countTree.InOrder();

	return 0;
}

【数据结构】二叉搜索树
2401_82610555的博客
01-09 1967
本文主要介绍二叉搜索树，其概念为左子树节点值小于根节点，右子树节点值大于根节点，插入时依此规则确定位置。性能方面，最优时类似完全二叉树，时间复杂度低；最差时退化为单支树，时间复杂度高，平衡二叉搜索树等为此而生。实现上，插入操作在树空或遍历找到合适位置后插入新节点；查找是依据节点值大小比较来确定查找方向；删除需分多种情况处理，以维持二叉搜索树特性。使用场景包括 key 搜索场景如小区车库车牌识别、文章单词拼写检查，以及 key/value 搜索场景如中英互译字典、商场车库计费、文章单词计数等，还给出了相应代码
Java创建二叉搜索树,实现搜索,插入,删除的操作实例
08-28
Java 创建二叉搜索树、实现搜索、插入、删除的操作实例 Java 创建二叉搜索树是指通过 Java 语言实现一个二叉搜索树数据结构，该树具有查找、插入、删除等操作的功能。二叉搜索树是一种特殊的二叉树，每个节点的值...
二叉搜索树详解
2302_79215415的博客
06-25 2242
但对于有n个节点的二叉搜索树，若每个元素的概率相等，则二叉搜索树的平均查找长度是节点在二叉搜索树的深度的函数，节点越深，比较次数就越多。所有在“大佬“的改进下，我们有引入的平衡二叉树和红黑树的概念，使得二叉树的性能有了较大的提升，下一篇内容将会给大家介绍平衡二叉数。2、统计单词的次数，给定一个单词的拼写，就可以快速找到其出现的次数单词由其出现次数就是的一种键值对。情况d、在它的右子树中寻找中序下的第一个节点，用它 的值填补到被删除节点中，再去处理该节点的删除问题----替换删除。
二叉排序树（二叉查找树、二叉搜索树）（图解+完整代码）
热门推荐
weixin_54186646的博客
04-25 10万+
图解二叉排序树（二叉查找树、二叉搜索树）的插入操作、查找操作、删除操作以及完整的代码实现
C++：二叉搜索树
HZzzzzLu的博客
09-21 1701
一文带你理解二叉搜索树
【二叉搜索树】二叉搜索树的用法以及实现
有趣的中国人的博客
04-28 1449
二叉搜索树的用法以及实现
【Java 数据结构】实现一个二叉搜索树
程序猿教你打篮球的博客
01-09 7320
本期主要讲解： 1、认识二叉搜索树 2、实现一个二叉搜索树 2.1 成员变量 2.2 insert 方法 2.3 search 方法 2.4 remove 方法(重点) 3、二叉搜索树总结
什么是二叉搜索树？如何构建和维护二叉搜索树？
破损的天堂鸟博客
12-10 1213
AVL树：适用于对查找性能要求较高的场景，如数据库索引等，因为其严格的平衡机制可以保证较低的查找时间复杂度。红黑树：适用于对插入和删除操作要求较高的场景，如实时系统或需要频繁更新的数据结构，因为其较少的旋转操作提高了这些操作的效率。选择哪种树结构应根据具体的应用需求来决定：如果需要高效的查找操作，则AVL树是更好的选择；
可视化图解算法31： 判断是不是二叉搜索树（验证二叉搜索树）
weixin_42117918的博客
04-29 927
对于二叉树的相关算法，我们总结了一套【可视化+图解】方法，依据此方法来解决相关问题，算法变得易于理解，写出来的代码可读性高也不容易出错。
二叉搜索树（BinarySearchTree）
潜心钻研技术
03-05 1854
二叉搜索树（BinarySearchTree） 文章目录二叉搜索树（BinarySearchTree）二叉搜索树的概念如何定义 二叉搜索树的节点 && 二叉搜索树查找插入删除二叉搜索树的缺点二叉搜索树的应用 二叉搜索树的概念 搜索二叉树满足一下条件： 是一棵二叉树 这可树上的任意一个节点满足：若他的右子树不为空，则右子树上的所有节点的值大于该节点的值 这可树上的任意一个节点满足：若他的左子树不为空，则左子树上的所有节点的值小于该节点的值 它的的左子树和右子树也是二叉搜索树 例如下图就是一
c代码-二叉搜索树的删除操作
07-14
在IT领域，二叉搜索树（Binary Search Tree，简称BST）是一种常见的数据结构，它具有很多优秀的特性，比如快速的查找、插入和删除操作。在实际应用中，我们经常需要对BST进行各种操作，其中删除操作是相对复杂的一个...
树-98. 验证二叉搜索树-PYTHON
01-20
在二叉搜索树（Binary Search Tree，BST）中，每个节点的值必须满足以下规则：对于任意节点，其左子树中的所有节点的值都小于该节点的值，而其右子树中的所有节点的值都大于该节点的值。在给定的题目“树-98. 验证...
Python实现二叉搜索树BST的方法示例
09-18
二叉搜索树（BST，Binary Search Tree），又称为二叉查找树或二叉排序树，是一种特殊的二叉树数据结构，其每个节点的值满足以下条件： 1. 节点的左子树中所有节点的值都小于该节点的值。 2. 节点的右子树中所有节点...
数据结构2.（双向链表，循环链表及内核链表）
2401_89312016的博客
08-05 457
本文详细介绍了三种链表的实现方法：双向链表、循环链表和内核链表。双向链表部分包含节点定义、创建、头插/尾插法、遍历、查找、修改、删除等操作实现；循环链表在双向链表基础上增加了循环特性，调整了遍历条件；内核链表部分分析了Linux内核中的链表实现，包括节点定义、初始化、插入/删除操作以及各类遍历宏定义。全文通过代码示例展示了链表的核心操作，重点比较了不同链表类型在实现上的差异，特别是循环链表和内核链表在结构设计和操作实现上的优化技巧。
数据结构04 栈和队列
LI1109hd的博客
08-05 171
/队列: 先进先出。
数据结构：在链表中插入节点（Inserting in a Linked List）
2402_88047672的博客
08-03 854
本文讲解了在链表中插入节点的原理和实现方法。链表插入通过修改指针连接完成，相比数组更高效。插入分为三种情况：表头插入需更新头指针；中间插入需找到前驱节点并调整两个指针；尾部插入需遍历到末尾节点。文章详细分析了指针操作逻辑，并给出了C语言实现代码，包括处理边界条件（如越界检查）和内存管理。通过示例演示了如何在不同位置插入节点，最终构建出完整的链表结构。实现关键在于正确操作节点指针的指向关系。
【数据结构初阶】--顺序表（二）
yhrxh_ymq的博客
08-05 486
本文详细讲解了顺序表的实现方法，重点介绍了尾插、头插、尾删和头删四个核心操作。内容包含：1）尾插操作的动态扩容机制，采用2倍扩容策略；2）头插操作需要整体后移元素；3）尾删只需修改size值；4）头删需要前移元素。文中提供了完整的C语言实现代码，并通过测试用例验证了各功能的正确性。最后分析了时间复杂度：尾插/删为O(1)，头插/删为O(n)，说明顺序表更适合频繁操作尾部数据的场景。作者预告后续将继续完善顺序表的其他操作接口。
嵌入式 - 数据结构：循环链表和内核链表
最新发布
m0_74911141的博客
08-05 322
/ 数据域// 前驱指针// 后继指针} linknode;// 首尾自环Linux 内核中通过// 后继指针// 前驱指针初始化初始化头节点，使其首尾自环；插入（头插）、（尾插）；删除从链表中移除节点；遍历遍历数据元素，其中member为数据结构中成员的名称；数据定位通过节点指针ptr找到数据结构的首地址（核心宏，通过指针运算实现）。使用内核链表时，需在自定义数据结构中嵌入// 示例：定义一个包含内核链表节点的进程结构int pid;// 进程ID// 进程名。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值