C++——⼆叉搜索树

已于 2024-10-05 17:48:34 修改
阅读量831 收藏 28
点赞数 30
分类专栏： C++ 文章标签： c++ 开发语言 数据结构
于 2024-09-15 13:16:37 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_79998744/article/details/142281738
版权

文章目录

一、 ⼆叉搜索树的概念

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

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

在这里插入图片描述

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

最优情况下，⼆叉搜索树为完全⼆叉树(或者接近完全⼆叉树)，其⾼度为：O(log2 N)
最差情况下，⼆叉搜索树退化为单⽀树(或者类似单⽀)，其⾼度为：O( N / 2)

所以综合⽽⾔⼆叉搜索树增删查改时间复杂度为：O(N)

那么这样的效率显然是⽆法满⾜我们需求的，后面⼆叉搜索树的变形，平衡⼆叉搜索树AVL树和红⿊树，才能适⽤于我们在内存中存储和搜索数据。

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

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

这⾥也就体现出了平衡⼆叉搜索树的价值。
在这里插入图片描述

三、⼆叉搜索树的插⼊

插⼊的具体过程如下：

  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;
		}
	}
	cur = new Node(key);
	if (parent->_key > key)
	{
		parent->_left = cur;
	}
	else
	{
		parent->_right = cur;
	}
	return true;
}

四、⼆叉搜索树的查找

1.从根开始⽐较，查找x，x⽐根的值⼤则往右边⾛查找，x⽐根值⼩则往左边⾛查找。
2. 最多查找⾼度次，⾛到到空，还没找到，这个值不存在。
3. 如果不⽀持插⼊相等的值，找到x即可返回。
4. 如果⽀持插⼊相等的值，意味着有多个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;
}

五、⼆叉搜索树的删除

⾸先查找元素是否在⼆叉搜索树中，如果不存在，则返回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，可以直接删除。

在这里插入图片描述
在这里插入图片描述

在这里插入图片描述

bool Erase(const k& key)
{
	Node* cur = _root;
	Node* parent = nullptr;
	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* replaceparent = cur;
				Node* replace = cur->_right;
				//右子树的最小值
				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(const Node* root)
{
	if (root == nullptr)
	{
		return;
	}
	_InOrder(root->_left);
	cout << root->_key << " ";
	_InOrder(root->_right);
}

七、⼆叉搜索树的实现代码

//Binary Search Tree
//二叉搜索树
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
	{
	public:
		//下面这两个作用相等
		//typedef BSTNode<k> Node;
		using Node = BSTNode<k>;

		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->_left = cur;
			}
			else
			{
				parent->_right = 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* cur = _root;
			Node* parent = nullptr;
			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* replaceparent = cur;
						Node* replace = cur->_right;
						//右子树的最小值
						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);
			cout << endl;
		}

	private:
		//中序遍历
		void _InOrder(const Node* root)
		{
			if (root == nullptr)
			{
				return;
			}
			_InOrder(root->_left);
			cout << root->_key << " ";
			_InOrder(root->_right);
		}

	private:
		Node* _root = nullptr;
	};
}

八、二叉搜索树key与key_value的应用

key的应用

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

场景1：⼩区⽆⼈值守⻋库，⼩区⻋库买了⻋位的业主⻋才能进⼩区，那么物业会把买了⻋位的业主的⻋牌号录⼊后台系统，⻋辆进⼊时扫描⻋牌在不在系统中，在则抬杆，不在则提⽰⾮本⼩区⻋辆，⽆法进⼊。
场景2：检查⼀篇英⽂⽂章单词拼写是否正确，将词库中所有单词放⼊⼆叉搜索树，读取⽂章中的单词，查找是否在⼆叉搜索树中，不在则波浪线标红提⽰。

key_value的应用

每⼀个关键码key，都有与之对应的值value，value可以任意类型对象。 树的结构中(结点)除了需要存储key还要存储对应的value，增/删/查还是以key为关键字⾛⼆叉搜索树的规则进⾏⽐较，可以快速查找到key对应的value。
key/value的搜索场景实现的⼆叉树搜索树⽀持修改，但是不⽀持修改key，修改key破坏搜索树结构了，可以修改value。

场景1：简单中英互译字典，树的结构中(结点)存储key(英⽂)和vlaue(中⽂)，搜索时输⼊英⽂，则同时查找到了英⽂对应的中⽂。
场景2：商场⽆⼈值守⻋库，⼊⼝进场时扫描⻋牌，记录⻋牌和⼊场时间，出⼝离场时，扫描⻋牌，查找⼊场时间，⽤当前时间-⼊场时间计算出停⻋时⻓，计算出停⻋费⽤，缴费后抬杆，⻋辆离场。
场景3：统计⼀篇⽂章中单词出现的次数，读取⼀个单词，查找单词是否存在，不存在这个说明第⼀次出现，（单词，1），单词存在，则++单词对应的次数。

可以参考下面的两个代码：

void test03()
{
	key_value::BSTree<string, string> t;
	t.insert("insert", "插入");
	t.insert("erase", "删除");
	t.insert("find", "查找");
	t.insert("mihayou", "米哈游");
	string s;
	while (cin >> s)
	{
		auto cur = t.find(s);
		if (cur)
		{
			cout << cur->_value << endl;
		}
		else
		{
			cout << "no find" << endl;
		}
	}
}

在这里插入图片描述

void test04()
{
	string arr[] = {"aaa","bbb","ddd","ccc","aaa","bbb","ccc","ddd","qqq"};
	key_value::BSTree<string, int> t;
	for (auto& e : arr)
	{
		auto cur = t.find(e);
		if (cur)
		{
			cur->_value++;
		}
		else
		{
			t.insert(e, 1);
		}
	}
	t.InOrder();

	/*key_value::BSTree<string, int> tt = t;
	tt.InOrder();

	key_value::BSTree<string, int> ttt;
	ttt = t;

	ttt.InOrder();*/

}

在这里插入图片描述

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
	{
	public:
		//下面这两个作用相等
		//typedef BSTNode<k> Node;
		using Node = BSTNode<k,v>;

		BSTree() = default;

		BSTree(const BSTree& t)
		{
			_root = Copy(t._root);
		}

		BSTree& operator=(BSTree 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->_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->_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* replaceparent = cur;
						Node* replace = cur->_right;
						//右子树的最小值
						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);
			cout << endl;
		}

	private:
		//中序遍历
		void _InOrder(const Node* root)
		{
			if (root == nullptr)
			{
				return;
			}
			_InOrder(root->_left);
			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* newnode = new Node(root->_key, root->_value);
			newnode->_left = Copy(root->_left);
			newnode->_right = Copy(root->_right);
			return newnode;
		}    

	private:
		Node* _root = nullptr;
	};

}
郭二哈
关注
专栏目录
二叉搜索树的c++实现
07-05
使用二叉链表和c++来实现二叉搜索树，提供插入、删除、遍历、求最小节点、最大最节点等操作。
coder-L#LeetCodeRecord#538——把二叉搜索树转换为累加树1
07-25
示例：输入: 原始二叉搜索树:输出: 转换为累加树:思路：反中序遍历，先遍历右子树，然后根节点，然后左子树，保存求和的结果，依次赋值即可代码：Definitio
c++搜索树和BFS
qtmatt的博客
07-22 285
//搜索树 struct bintree { int data=0; bintree* pleft=nullptr; bintree* pright=nullptr; }; bintree* insert(bintree* proot, int num) { if (proot == nullptr) { bintree* pnew = new bintree; pnew-...
[C++]搜索树 查找/插入/删除
mzman的博客
11-29 448
搜索树：一种二叉树，满足任何节点的关键字大于都其左子树所有节点的关键字，小于其右子树所有节点的关键字（默认所有节点关键字不重复）。 查找：输入需要查找的关键字，从根节点开始，通过比较关键字的大小来搜索，若查找关键字小于根节点，则考察左子树；若查找关键字大于根节点，则考察右子树。最终若指针指向空节点，说明查找元素不存在。 插入：方法类似于查找，最终当指针指向的空节点即为插入元素的位置。 删除：先找到需要删除的节点的位置，若不存在则返回。若删除节点有两个子树，则需要先将需要删除的节点的左子树最大值（或右子树的最
【C++】二叉搜索树
QiHai的博客
11-05 2616
介绍一种利用非线性结构对每次插入的数据进行整理，从而能够达到查找最优效率为log_2 N，并且也为之后的容器map、set做好基础（AVL树和红黑树的实现前提）的二叉搜索树
C++二叉搜索树
weixin_41368411的博客
09-08 321
二叉搜索树又称二叉排序树，它或者是一棵空树，或者是具有以下性质的二叉树:（1）若它的左子树不为空，则左子树上所有节点的值都小于根节点的值（2）若它的右子树不为空，则右子树上所有节点的值都大于根节点的值（3）它的左右子树也分别为二叉搜索树。
c++四叉树地理文本搜索
11-17
基于C++的四叉树空间搜索，在一个MAIN函数里面写完的，
c++——扫雷简单版9*9
03-22
c++实现扫雷
一个好玩的c++游戏——生死枪战！
07-27
生死枪战游戏目前以3个模式运行（持续更新），玩家可以通过自己的喜好来选择，如：新手训练营，无限...如果想要更多c++游戏，请进入zzz工作室，网址http://zzz07.ysepan.com/ 我的聊天室网址：https://hack.chat/?zzz
C++课程设计——哈夫曼树.txt
04-09
设计内容： 欲发一封内容为AABBCAB ……(共长 100 字符,其中:A 、B 、C 、D 、E 、F分别有7 、9 、12 、22 、23、27个)的电报报文,实现哈夫曼编码。
C++实现二叉树搜索树
12-18
功能：插入、查找、删除、清除整个树、返回最大值、返回最小值、前序遍历、中序遍历、后序遍历。 注：此二叉树允许插入相同的值
C++笔记：二叉搜索树（Binary Search Tree）
ljh1257的博客
02-23 846
了解和实现二叉搜索树的接口，部分接口实现了迭代版和递归版，后面还记录了一下二叉搜索树的应用，还有其性能分析，及缺陷
C++实现搜索二叉树
qingdou_aixuexi的博客
09-21 2578
二叉搜索树的性质： 每个节点都有一个作为搜索依据的关键码（key），所有节点的关键码互不相同。左子树上所有节点的关键码（key）都小于根节点的关键码（key）。右子树上所有节点的关键码（key）都大于根节点的关键码（key）。左右子树都是二叉搜索树。 #define _CRT_SECURE_NO_WARNINGS 1 #include #include usin
C/C++ 二叉树
Sonui的博客
11-19 187
查找二叉树有一个特性 对于所有的节点，都满足左子树上的所有节点都比自己的小，而右子树上的所有节点都比自己大 ————《挑战程序设计竞赛第二版》P78 #include <iostream> #include <stdlib.h> using namespace std; typedef struct TreeNode { int data; struct TreeNode *LT, *RT; }TreeNode, *TreeList; //创建一个叶子节点
C++中关于树的一些定义
肩上风骋的博客
06-22 1651
本文以一个简单的树为例，来记录树的一些概念。
【数据结构】C++语言实现二叉树的介绍及堆的实现(详细解读)
最新发布
bhbcdxb123的博客
05-15 2059
int size;}HP;
C++数据结构第51课、树的定义与操作
xiebs的博客
08-22 918
1、树的定义与操作：树是一种非线性的数据结构，树是由 n( n >= 0 ) 个结点组成的有限集合。 — 如果 n= 0，称为空树； — 如果 n > 0，则：1、有一个特定的称之为根（root）的结点；2、根结点只有直接后继，但没有直接前驱；3、除根以外的其它结点划分为 m( m >= 0 ) 个互不相交的有限集合T0, T1, … Tm-1，每个集合又是一棵树，并且称之为根的子树（sub tree）。 2、树中度的概念 — 树的结点包含一个数据及若干指向子树的分支 — 结点拥有子树的
数据结构—普通树的定义与C++实现
zhengliuguo的专栏
05-03 1559
github地址：https://github.com/lining91/NormalTree实现了树的兄弟孩子表示法，插入新数据，查询某个数据，前序遍历，中序遍历，后序遍历。相关概念： 每一棵树都有一个根节点。 每个节点可以有多个儿子节点，没有儿子的结点叫做叶子节点。 具有相同父亲的节点叫做兄弟节点。 对于任意一个节点ni，ni的深度为从根到ni的唯一路径的长。因此，根的深度是0。 ni的高是从...
C++高效二叉搜索树查找算法实现探讨
资源摘要信息:"二叉搜索树查找算法【实现】.rar_C++_C++ 二叉搜索树_organizationzme" 本资源是一个关于二叉搜索树查找算法的实现的压缩包文件，文件名称为“二叉搜索树查找算法【实现】”，其内容主要涉及使用C++...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值