【C++进阶】第十七篇——二叉搜索树（概念+二叉搜索树实现+二叉搜索树的应用+二叉树性能分析）

最新推荐文章于 2024-08-16 16:54:02 发布
最新推荐文章于 2024-08-16 16:54:02 发布
阅读量1.4k 收藏 6
点赞数 15
分类专栏： C++篇 文章标签： c++ 数据结构 二叉树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_58450087/article/details/123058484
版权
本文介绍了二叉搜索树的基本概念、实现方式，包括插入、查找和删除节点的操作。在删除操作中详细分析了四种情况，并提供了相应的代码实现。此外，还展示了二叉搜索树在K-V模型中的应用，如字典查找和统计树。最后，讨论了二叉搜索树的性能分析，以及后续将要介绍的AVL树和红黑树。
摘要由CSDN通过智能技术生成

⭐️从这篇博客开始，我就要和大家介绍有关二叉搜索树的知识，它还衍生出了两棵树——AVL树和红黑树，在后面两篇博客我都会介绍。今天先从二叉搜索树开始引入。
⭐️博客代码已上传至gitee：https://gitee.com/byte-binxin/cpp-class-code

目录

🌏概念

二叉搜索树又称为二叉排序书，因为这棵树的中序遍历是有序的。二叉搜索树总结起来有以下几个性质：

  • 若它的左子树不为空，则左子树上所有节点的值都小于根节点的值
  • 若它的右子树不为空，则右子树上所有节点的值都大于于根节点的值
  • 它的左右子树都是二叉搜索树
  • 这棵树中没有重复的元素

在这里插入图片描述

🌏二叉搜索树的实现

🌲基本框架

由一个节点的成员构成，先构建节点的类型，和我们之前数据结构中的二叉树的节点定义是一样的。二叉搜索树的根节点先默认给空。

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

	BSTNode(const K& key, const V& value)
		:_left(nullptr)
		, _right(nullptr)
		, _key(key)
		,_value(value)
	{}
};
template <class K, class V>
class BSTree //Binary Search Tree
{
	typedef BSTNode<K, V> Node;
private:
	Node* _root = nullptr;
};

🌲二叉搜索树的插入

插入分为下面几个步骤：

  1. 先判断树是否为空，为空就让要插入的这个节点作为根节点，然后结束
  2. 部署就确定要插入节点的位置
  3. 用一个cur记录当前节点，parent记录父节点
  4. 要插入节点的值如果比当前节点的值小，cur就往左走，如果比当前节点的值大，就往右子树走，如果等于就返回false，表面这棵树中有这个数据，不需要插入。

下面是一个简单的动图演示
请添加图片描述
注意： 这里不用担心新插入节点会在树中间插入，它一定是在最下面插入的，它会走到最下面，然后在树的底部插入。

代码实现如下：

bool Insert(const K& key, const V& value)
{
	// 没有节点时第一个节点就是根节点
	if (_root == nullptr)
	{
		_root = new Node(key, value);
		return true;
	}

	// 用一个父亲节点记录cur的上一个节点
	Node* parent = nullptr;
	Node* cur = _root;
	while (cur)
	{
		parent = cur;
		// 小于往左边走
		if (key < cur->_key)
			cur = cur->_left;
		else if (key > cur->_key)
			cur = cur->_right;
		else
			return false;// 已有的节点不插入，此次插入失败
	}

	cur = new Node(key, value);
	// 判断应该插在父节点的左边还是右边
	if (cur->_key < parent->_key)
	{
		parent->_left = cur;
	}
	else
	{
		parent->_right = cur;
	}

	return true;
}

为了更好地观察这棵树插入后是否有效，我们可以实现一个中序遍历，将其打印出来。
中序遍历代码如下：

void InOrder()
{
	// 利用子函数遍历
	_InOrder(_root);
	cout << endl;
}
void _InOrder(Node* root)
{
	if (root == nullptr)
		return;

	_InOrder(root->_left);
	cout << root->_key << ":" << root->_value << endl;
	_InOrder(root->_right);
}

测试代码如下：

void TestBSTree()
{
	BSTree<int> bt;
	int arr[] = { 5,3,4,1,7,8,2,6,0,9 };
	//int arr[] = { 1,2,3,4 };
	//int arr[] = { 4,3,2,1};
	for (auto e : arr)
	{
		bt.Insert(e);
	}

	bt.InOrder();
}

代码运行结果如下：
在这里插入图片描述

🌲二叉搜索树的查找

查找的步骤如下：（和插入的步骤有些类似）

  1. 如果查找值key比当前节点的值小，就往左子树走
  2. 如果查找值key比当前节点的值大，就往右子树走
  3. 如果查找值key和当前节点的值相等，就返回当前节点的指针

代码实现如下：

Node* Find(const K& key)
{
	if (_root == nullptr)
		return nullptr;
	Node* cur = _root;
	while (cur)
	{
		// 小于往左边走
		if (key < cur->_key)
			cur = cur->_left;
		else if (key > cur->_key)
			cur = cur->_right;
		else
			return cur;
	}

	return nullptr;
}

🌲二叉搜索树的删除（重点）

二叉搜索树的删除相对来说会复杂一些，下面我要给大家分析一下。
有四种情况
先看下面这棵树，分别对以下四个节点进行删除会发生什么（如何处理）？
在这里插入图片描述

  1. 删除节点1时，它的左右都为空，可以直接删除
  2. 删除节点2时，它的左不为空右为空，删除方法如下：
    在这里插入图片描述

还要分析一种特殊的情况，就是此时2没有父亲节点，也就是自己为根时，看下面如何操作
在这里插入图片描述

  1. 删除节点7时，它的左为为右不为空，删除方法如下：
    在这里插入图片描述

和情况2一样，该节点如果为根节点，就让自己的右孩子变成根节点。

  1. 左右都不为空（替代法）
    这种情况我们采用替代法来解决，替代法就是找一个节点和现在这个节点交换，然后转移为上面的情况，具体如下：
    我们可以选择用左子树的最右节点（左子树最大的节点）或右子树的最左节点（右子树的最小节点）和当前节点互换，然后删除互换后的节点，这里我们统一采用用右子树的最右节点来进行替换。
    在这里插入图片描述

然后这里可以转化为情况3来对节点进行删除，因为所有的最左孩子一定是左为空，右是不确定的。

总结： 一共有四种情况，但是情况1可以归为情况3，因为它也是左为空，所以整体处理下来是三种情况。

代码实现如下：

bool Erase(const K& key)
{
		// 如果树为空，删除失败
		if (_root == nullptr)
			return false;

		Node* parent = nullptr;
		Node* cur = _root;
		while (cur)
		{
			// 小于往左边走
			if (key < cur->_key)
			{
				parent = cur;
				cur = cur->_left;
			}
			else if (key > cur->_key)
			{
				parent = cur;
				cur = cur->_right;
			}
			else
			{
				// 找到了，开始删除
				// 1.左右子树都为空 直接删除  可以归类为左为空
				// 2.左右子树只有一边为空  左为空，父亲指向我的右，右为空，父亲指向我的左  
				// 3.左右子树都不为空  取左子树最大的节点或右子树最小的节点和要删除的节点交换，然后再删除
				if (cur->_left == nullptr)
				{
					// 要删除节点为根节点时，直接把右子树的根节点赋值给——root
					// 根节点的话会导致parent为nullptr
					if (_root == cur)
					{
						_root = _root->_right;
					}
					else
					{
						// 左为空，父亲指向我的右
						// 判断cur在父亲的左还是右
						if (parent->_left == cur) // cur->_key < parent->_key
							parent->_left = cur->_right;
						else
							parent->_right = cur->_right;
					}

					delete cur;
					cur = nullptr;
				}
				else if (cur->_right == nullptr)
				{
					if (_root == cur)
					{
						_root = _root->_left;
					}
					else
					{
						// 右为空，父亲指向我的左
						// 判断cur在父亲的左还是右
						if (parent->_left == cur)
							parent->_left = cur->_left;
						else
							parent->_right = cur->_left;
					}

					delete cur;
					cur = nullptr;
				}
				else
				{
					// 找右子树中最小的节点
					Node* rightMinParent = cur;
					Node* rightMin = cur->_right;// 去右子树找
					while (rightMin->_left)
					{
						rightMinParent = rightMin;
						rightMin = rightMin->_left;
					}
					//swap(cur->_key, rightMin->_key);
					// 替代删除
					cur->_key = rightMin->_key;

					// 转换成了第一种情况  左为空
					if (rightMinParent->_left == rightMin)
						rightMinParent->_left = rightMin->_right;
					else
						rightMinParent->_right = rightMin->_right;


					delete rightMin;
					rightMin = nullptr;
				}
				return true;
			}
		}

		return false;
	}

测试代码如下：（要测试每种情况，还有测试删空的情况）

void TestBSTree()
{
	BSTree<int> bt;
	int arr[] = { 5,3,4,1,7,8,2,6,0,9 };
	for (auto e : arr)
	{
		cout << "插入 " << e << " 后：";
		bt.Insert(e);
		bt.InOrder();
	}
	
	cout << "------------------------------" << endl;
	for (auto e : arr)
	{
		cout << "删除 " << e << " 后：";
		bt.Erase(e);
		bt.InOrder();
	}

}

代码运行结果如下：
在这里插入图片描述

🌏二叉搜索树的应用

二叉搜索树有两种模型：

  1. K模型： K模型只有key值，节点只存储key值。这里主要应用就是查找判断某个元素在不在。
  2. KV模型： KV模型每个key值都对应着一个value，主要应用就是通过key找value。（我们平时查找单词就是通过中文找英文，或者通过英文找中文）

下面我把上面的K模型的代码简单改造一下，实现KV模型：（这里没有使用传键值对的方法，之后的博客我会给大家介绍，这里使用传两个值的方式）

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

BSTNode(const K& key, const V& value)
	:_left(nullptr)
	, _right(nullptr)
	, _key(key)
	,_value(value)
{}
};
template <class K, class V>
class BSTree //Binary Search Tree
{
typedef BSTNode<K, V> Node;
public:
~BSTree()
{
	Node* cur = _root;
	while (cur)
	{
		Erase(cur->_key);
		cur = _root;
	}
}
Node* Find(const K& key)
{
	if (_root == nullptr)
		return nullptr;
	Node* cur = _root;
	while (cur)
	{
		// 小于往左边走
		if (key < cur->_key)
			cur = cur->_left;
		else if (key > cur->_key)
			cur = cur->_right;
		else
			return cur;
	}

	return nullptr;
}
bool Insert(const K& key, const V& value)
{
	// 没有节点时第一个节点就是根节点
	if (_root == nullptr)
	{
		_root = new Node(key, value);
		return true;
	}

	// 用一个父亲节点记录cur的上一个节点
	Node* parent = nullptr;
	Node* cur = _root;
	while (cur)
	{
		parent = cur;
		// 小于往左边走
		if (key < cur->_key)
			cur = cur->_left;
		else if (key > cur->_key)
			cur = cur->_right;
		else
			return false;// 已有的节点不插入，此次插入失败
	}

	cur = new Node(key, value);
	// 判断应该插在父节点的左边还是右边
	if (cur->_key < parent->_key)
	{
		parent->_left = cur;
	}
	else
	{
		parent->_right = cur;
	}

	return true;
}
bool Erase(const K& key)
{
	// 如果树为空，删除失败
	if (_root == nullptr)
		return false;

	Node* parent = nullptr;
	Node* cur = _root;
	while (cur)
	{
		// 小于往左边走
		if (key < cur->_key)
		{
			parent = cur;
			cur = cur->_left;
		}
		else if (key > cur->_key)
		{
			parent = cur;
			cur = cur->_right;
		}
		else
		{
			// 找到了，开始删除
			// 1.左右子树都为空 直接删除  可以归类为左为空
			// 2.左右子树只有一边为空  左为空，父亲指向我的右，右为空，父亲指向我的左  
			// 3.左右子树都不为空  取左子树最大的节点或右子树最小的节点和要删除的节点交换，然后再删除
			if (cur->_left == nullptr)
			{
				// 要删除节点为根节点时，直接把右子树的根节点赋值给——root
				// 根节点的话会导致parent为nullptr
				if (_root == cur)
				{
					_root = _root->_right;
				}
				else
				{
					// 左为空，父亲指向我的右
					// 判断cur在父亲的左还是右
					if (parent->_left == cur) // cur->_key < parent->_key
						parent->_left = cur->_right;
					else
						parent->_right = cur->_right;
				}

				delete cur;
				cur = nullptr;
			}
			else if (cur->_right == nullptr)
			{
				if (_root == cur)
				{
					_root = _root->_left;
				}
				else
				{
					// 右为空，父亲指向我的左
					// 判断cur在父亲的左还是右
					if (parent->_left == cur)
						parent->_left = cur->_left;
					else
						parent->_right = cur->_left;
				}

				delete cur;
				cur = nullptr;
			}
			else
			{
				// 找右子树中最小的节点
				Node* rightMinParent = cur;
				Node* rightMin = cur->_right;// 去右子树找
				while (rightMin->_left)
				{
					rightMinParent = rightMin;
					rightMin = rightMin->_left;
				}
				//swap(cur->_key, rightMin->_key);
				// 替代删除
				cur->_key = rightMin->_key;

				// 转换成了第一种情况  左为空
				if (rightMinParent->_left == rightMin)
					rightMinParent->_left = rightMin->_right;
				else
					rightMinParent->_right = rightMin->_right;


				delete rightMin;
				rightMin = nullptr;
			}
			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);
}
private:
Node* _root = nullptr;
};

void TestBSTree_KV1()
{
// 创建一个简易的字典
BSTree<string, string> dict;

dict.Insert("苹果", "apple");
dict.Insert("排序", "sort");
dict.Insert("培养", "cultivate");
dict.Insert("通过", "pass");
dict.Insert("apple", "苹果");
dict.Insert("sort", "排序");
dict.Insert("cultivate", "培养");
dict.Insert("pass", "通过");

string str;
while (cin >> str)
{
	BSTNode<string, string>* ret = dict.Find(str);
	if (ret)
	{
		cout << ret->_value << endl;
	}
	else
	{
		cout << "本字典无此词" << endl;
	}
}

下面测试几个应用：
实例1 英汉字典

void TestBSTree_KV1()
	{
		// 创建一个简易的字典
		BSTree<string, string> dict;

		dict.Insert("苹果", "apple");
		dict.Insert("排序", "sort");
		dict.Insert("培养", "cultivate");
		dict.Insert("通过", "pass");
		dict.Insert("apple", "苹果");
		dict.Insert("sort", "排序");
		dict.Insert("cultivate", "培养");
		dict.Insert("pass", "通过");

		string str;
		while (cin >> str)
		{
			BSTNode<string, string>* ret = dict.Find(str);
			if (ret)
			{
				cout << ret->_value << endl;
			}
			else
			{
				cout << "本字典无此词" << endl;
			}
		}
	}

代码运行结果演示：
在这里插入图片描述
实例2： 统计树

void TestBSTree_KV2()
{
	// 统计水果个数
	BSTree<string, int> countTree;

	string strArr[] = { "香蕉","水蜜桃","西瓜","苹果","香蕉" ,"西瓜","香蕉" ,"苹果","西瓜","苹果","苹果","香蕉" ,"水蜜桃" };

	for (auto e : strArr)
	{
		BSTNode<string, int>* ret = countTree.Find(e);
		if (ret == nullptr)
		{
			// 第一次插入
			countTree.Insert(e, 1);
		}
		else
		{
			ret->_value++;
		}
	}

	countTree.InOrder();
}

代码运行结果如下：
在这里插入图片描述

🌏二叉树性能分析

一般情况下，二叉搜索树的插入和删除的效率都是O(logN)，极端情况会导致效率变成O(N)。

理想状态： 完全二叉树：O(logN)
在这里插入图片描述
极端情况： 一条链：O(1)
在这里插入图片描述
后面我要和大家分析的AVL树会利用旋转，就可解决掉这种极端情况。

🌐总结

上面这些是二叉搜索树的大致内容，其中删除大家可以好好理解一下，它后面还有两棵树我还没有介绍，就是AVL树和红黑树，在后面两篇博客我都会介绍。今天就先到这了，喜欢的话，欢迎点赞支持~
在这里插入图片描述

呆呆兽学编程
关注
专栏目录
【c++】二叉搜索树
HenryBlog
04-20 446
目录一、概念二、操作2.1 查找2.2 插入2.3 删除 一、概念 二叉搜索树又称二叉排序树，它或者是一颗空树 特性： 若它的左子树不为空，则左子树上所有节点的值都小于根节点的值 若他的右子树不为空，则右子树上所有节点的值都大于根节点的值 它的左右子树也分别为二叉搜索树 二、操作 2.1 查找 2.2 插入 我们需要判断树为空，则直接插入，return true 树不为空，按二叉搜索树性质查找插入位置，插入新节点 这里当我们new出一个新的节点需要注意，把他进行链接，不然出了此函数就栈销毁了，导
【二叉树进阶】二叉搜索树的结构、实现及应用
codewinter的博客
06-15 1520
普通的二叉树单纯用来存储数据意义不大，还不如用数组和链表。普通数组和链表，面对一些需要频繁查找、插入、删除的场景，也很麻烦。所以这里引入了二叉搜索树。二叉搜索树又称二叉排序树，它或者是一棵空树，或者是具有以下性质的二叉树：二叉搜索树的结构特点带来的好处：定义二叉搜索树节点类模板： 定义二叉搜索树类模板： 2.2 默认成员函数的实现 2.2.1 构造函数 2.2.2 拷贝构造函数（要弄懂） 2.2.3 赋值运算符重载（要弄懂） 2.2.4 析构函数 三、二叉搜索树的相关接口实现 3.1 二叉搜索树
【C++】二叉树进阶（二叉搜索树,KV模型）
Anton的博客
05-17 936
二叉树进阶（二叉搜索树）一级目录二级目录三级目录 一级目录 二级目录 三级目录
C++ | 二叉搜索树
Nice_W的博客
07-20 451
关于数据结构中的树，想必大家都不会很陌生，今天，主要给大家一起学习搜索二叉树（BST）；前面，我们掌握学习过二叉树的三种遍历方式（前序，中序，后序的递归版本），以及我们实现过顺序结构的树（堆），前面的树在储存数据方面，并没有多大的意义，而今天所说的二叉搜索树在数据存储方面就有了很大的意义；
C++--二叉搜索树
qq_46659987的博客
05-16 387
二叉搜索树1. 二叉搜索树2. 二叉搜索树的操作2.1 二叉搜索树的查找2.2 二叉搜索树的插入2.3 二叉搜索树的删除3. 二叉搜索树的性能分析 1. 二叉搜索树 二叉搜索树又称二叉排序树， 性质： 若它的左子树不为空，则左子树上所有节点的值都小于根节点的值； 若它的右子树不为空，则右子树上所有节点的值都大于根节点的值； 它的左右子树也分别是二叉搜索树； 可以是一棵空树。 2. 二叉搜索树的操作 二叉树的结构 template<class T> struct BNode { T
C++_二叉搜索树
weixin_43867777的博客
12-10 789
1、二叉搜索数的概念 二叉搜索树又称二叉排序树，它或者是一棵空树，或者是具有以下性质的二叉树： 若它的左子树不为空，则左子树上所有节点的值都小于根节点的值 若它的右子树不为空，则右子树上所有节点的值都大于根节点的值 它的左右子树也分别为二叉搜索树 2、二叉搜索树操作 1、二叉搜索树的查找 2、二叉搜索树的插入 a、树为空，则直接插入 如果是空树，直接插入，然后返回true b、树不空，按二叉...
二叉树-基于C++实现的二叉搜索树.zip
04-26
在实际应用中，二叉搜索树可能会遇到平衡问题，即树的左右子树高度差异过大，导致性能下降。为了解决这个问题，可以使用自平衡二叉搜索树，如AVL树或红黑树。这些树在插入和删除节点时会自动进行旋转操作，以保持...
C++ 二叉搜索树(BST)的实现方法
08-30
C++ 二叉搜索树(BST)的实现方法 C++ 二叉搜索树(BST)是一种特殊的二叉树，它具有以下特征： 1. 二叉搜索树的每个节点都包含一个键值（key）和一个值（value）。 2. 对于任意一个节点，左子树中的键值都小于该节点...
二叉搜索树查找算法【实现】.rar_C++_C++ 二叉搜索树_organizationzme
09-23
C++实现二叉搜索树查找算法主要涉及以下几个核心概念： 1. **节点定义**：首先，我们需要定义一个二叉搜索树的节点结构。这个结构通常包括键值、指向左右子节点的指针以及可能的额外信息，如指向父节点的指针等。 ...
[C++进阶]第二十九节 二叉搜索树的应用
最新发布
2301_80017277的博客
08-16 412
前面我们讲过key模型和Key-Value模型就是常见的两种的模型。
c++——二叉搜索树
陌上人如玉，公子世无双。
08-17 412
关联式容器也是用来存储数据的，与序列式容器不同的是，其里面存储的是<key, value>结构的键值对，在数据检索时比序列式容器效率更高。 键值对： 用来表示具有一一对应关系的一种结构，该结构中一般只包含两个成员变量key和value，key代表键值， value表示与key对应的信息。 二叉搜索树： 二叉搜索树又称二叉排序树，它或者是一棵空树，或者是具有以下性质的二叉树： ...
【C++】二叉搜索树
knous
07-27 387
二叉搜索树及模拟实现，后续更新练习题
二叉树的二叉搜索表示.rar_二叉搜索树_二叉树的二叉搜索
09-22
在"二叉树的二叉搜索表示"的压缩包文件中，很可能包含了实现这些操作的C语言代码示例，供学习者理解和实践二叉搜索树的原理和应用。通过阅读和运行这些代码，可以深入理解二叉搜索树的工作机制，并进一步提升数据...
【C++】二叉搜索树（概念、实现、应用）
ZZZCCC的博客
04-24 494
在分块讲解前，我们要明白，递归要传根节点，但是用户平常使用这些借口并不会传根节点，而是直接调用，所以我们嵌套一层，这样就可以满足双方的需求了。可以在递归的参数中多一个父亲结点，每次递归都更新一下Parent，然后再带到下一层递归。由于没有二叉搜索树的官方库，我们增删查改的实现需要我们自己来完成，见下面的模拟实现。递归这种思想我么你还需要多加理解，下一章将详细讲解OJ题目，加深我们对于递归的理解！采用递归方式的缺点就是如果数的结点个数足够多的时候，就会有爆栈的风险！当出现单边树的情况时，就是〇（N）的情况。
评论 10
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

呆呆兽学编程

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值