【C++】15.二叉搜索树

于 2024-07-16 17:05:35 发布
阅读量193 收藏 3
点赞数 3
分类专栏： C++ 文章标签： c++ 开发语言 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_80258336/article/details/140464767
版权

一、二叉搜索树的概念

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

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

二、二叉搜索树的分析与实现

我们接下来的操作以这张图为例：
在这里插入图片描述

2.1 查找

  • 从根开始比较，查找，比根大则往右边走查找，比根小则往左边走查找
  • 最多查找高度次，走到到空，还没找到，这个值不存在
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;
}

2.2 插入

  • 树为空，则直接新增节点，赋值给root指针
  • 树不空，按二叉搜索树性质查找插入位置，插入新节点
bool Insert(const K& key)
{
	if (root == nullptr)
	{
		root = new Node(key);
		return true;
	}
	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//等于就找到,不能重复就返回假
		{
			return false;
		}
	}
	//出了循环就找不到了，开始插入
	cur = new Node(key);
	if (cur->_key < parent->_key)
		parent->_left = cur;
	else
		parent->_right = cur;

	return true;
	
}

2.2 删除

首先查找元素是否在二叉搜索树中，如果不存在，则返回, 否则要删除的结点可能分下面四种情况：

  1. 要删除的结点无孩子结点
  2. 要删除的结点只有左孩子结点
  3. 要删除的结点只有右孩子结点
  4. 要删除的结点有左、右孩子结点

看起来有待删除节点有4中情况，实际情况a可以与情况b或者c合并起来，因此真正的删除过程如下：

  • 删除该结点且使被删除节点的双亲结点指向被删除节点的左孩子结点–直接删除
  • 删除该结点且使被删除节点的双亲结点指向被删除结点的右孩子结点–直接删除
  • 在它的右子树中寻找中序下的第一个结点(关键码最小)，用它的值填补到被删除节点中，再来处理该结点的删除问题–替换法删除
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//等于就找到
		{
			//0-1个孩子的情况
			//如果左子树为空
			if(cur->_left==nullptr)
			{
				//是否删除根节点
				if (parent == nullptr)
					root = root->_right;
				else
				{
					//说明cur是他的左子树
					if (parent->_left == cur)
						parent->_left = cur->_right;
					//说明cur是他的右子树
					else
						parent->_right = cur->_right;
				}		
				delete cur;
			}
			//如果他的右子树为空
			else if(cur->_right==nullptr)
			{
				if (parent = nullptr)
					root = root->_left;
				else
				{
					//说明cur是他的左子树
					if (parent->_left = cur)
						parent->_left = cur->_left;
					//说明cur是他的右子树
					else
						parent->_right = cur->_left;
				}
				delete cur;
			}
			//两个结点都不为空
			else
			{
				parent = cur;
				Node* rightmid = cur->_right;

				while (rightmid->_left)
				{
					parent = rightmid;
					rightmid = rightmid->_left;
				}
				cur->_key = rightmid->_key;
				if(parent->_right==rightmid)//右子树
					parent->_right = rightmid->_right;
				else//左子树
					parent->_left = rightmid->_right;
				delete rightmid;
			}
			return true;
		}
	}
	//出了循环就找不到了
	return false;
}

三、二叉搜素树的应用

3.1 key模型：主要用于确定key是否存在

比如：给一个单词word，判断该单词是否拼写正确。

代码如下：

//BSTree.h
#pragma once
#include<iostream>
using namespace std;

//树节点
template<class K>
struct TreeNode
{
	K _key;
	TreeNode<K>* _left;
	TreeNode<K>* _right;
	TreeNode(const K& key=K()):_key(key),_left(nullptr),_right(nullptr){}
};


template<class K>
class BSTree
{
	typedef TreeNode<K> Node;
public:
	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 Insert(const K& key)
	{
		if (root == nullptr)
		{
			root = new Node(key);
			return true;
		}
		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//等于就找到,不能重复就返回假
			{
				return false;
			}
		}
		//出了循环就找不到了，开始插入
		cur = new Node(key);
		if (cur->_key < parent->_key)
			parent->_left = cur;
		else
			parent->_right = cur;

		return true;
		
	}
	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//等于就找到
			{
				//0-1个孩子的情况
				//如果左子树为空
				if(cur->_left==nullptr)
				{
					//是否删除根节点
					if (parent == nullptr)
						root = root->_right;
					else
					{
						//说明cur是他的左子树
						if (parent->_left == cur)
							parent->_left = cur->_right;
						//说明cur是他的右子树
						else
							parent->_right = cur->_right;
					}		
					delete cur;
				}
				//如果他的右子树为空
				else if(cur->_right==nullptr)
				{
					if (parent = nullptr)
						root = root->_left;
					else
					{
						//说明cur是他的左子树
						if (parent->_left = cur)
							parent->_left = cur->_left;
						//说明cur是他的右子树
						else
							parent->_right = cur->_left;
					}
					delete cur;
				}
				//两个结点都不为空
				else
				{
					parent = cur;
					Node* rightmid = cur->_right;

					while (rightmid->_left)
					{
						parent = rightmid;
						rightmid = rightmid->_left;
					}
					cur->_key = rightmid->_key;
					if(parent->_right==rightmid)//右子树
						parent->_right = rightmid->_right;
					else//左子树
						parent->_left = rightmid->_right;
					delete rightmid;
				}
				return true;
			}
		}
		//出了循环就找不到了
		return false;
	}
	BSTree():root(nullptr){}
	void InOrder()
	{
		_InOrder(root);
		cout << endl;
	}
private:
	Node* root;
	void _InOrder(Node* root)
	{
		if (root == nullptr)
		{
			return;
		}
		_InOrder(root->_left);
		cout << root->_key << " ";
		_InOrder(root->_right);
	}
};

3.2 key/value模型：主要用于通过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 = K(),const V& value=V()) :_key(key),_value(value) ,_left(nullptr), _right(nullptr) {}
};


template<class K,class V>
class BSTree
{
	typedef TreeNode<K,V> Node;
public:
	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 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 (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 (cur->_key < parent->_key)
			parent->_left = cur;
		else
			parent->_right = cur;

		return true;

	}
	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//等于就找到
			{
				//0-1个孩子的情况
				//如果左子树为空
				if (cur->_left == nullptr)
				{
					//是否删除根节点
					if (parent == nullptr)
						root = root->_right;
					else
					{
						//说明cur是他的左子树
						if (parent->_left == cur)
							parent->_left = cur->_right;
						//说明cur是他的右子树
						else
							parent->_right = cur->_right;
					}
					delete cur;
				}
				//如果他的右子树为空
				else if (cur->_right == nullptr)
				{
					if (parent = nullptr)
						root = root->_left;
					else
					{
						//说明cur是他的左子树
						if (parent->_left = cur)
							parent->_left = cur->_left;
						//说明cur是他的右子树
						else
							parent->_right = cur->_left;
					}
					delete cur;
				}
				//两个结点都不为空
				else
				{
					parent = cur;
					Node* rightmid = cur->_right;

					while (rightmid->_left)
					{
						parent = rightmid;
						rightmid = rightmid->_left;
					}
					cur->_key = rightmid->_key;
					if (parent->_right == rightmid)//右子树
						parent->_right = rightmid->_right;
					else//左子树
						parent->_left = rightmid->_right;
					delete rightmid;
				}
				return true;
			}
		}
		//出了循环就找不到了
		return false;
	}
	BSTree() :root(nullptr) {}
	void InOrder()
	{
		_InOrder(root);
		cout << endl;
	}
private:
	Node* root;
	void _InOrder(Node* root)
	{
		if (root == nullptr)
		{
			return;
		}
		_InOrder(root->_left);
		cout << root->_key << " " << root->_value << endl;
		_InOrder(root->_right);
	}
卡戎-caryon
关注
  • 3
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
BST_fanli.zip.二叉搜索树源码
04-10
在C++中实现二叉搜索树，通常会定义一个结构体或类来表示树节点，包括节点的键、左右子节点的指针，以及可能的附加信息，如节点的父节点指针。以下是一个基本的二叉搜索树节点的C++实现： ```cpp struct Node { ...
二叉树-基于C++实现的二叉搜索树.zip
04-26
在C++中实现二叉搜索树，我们需要定义一个节点结构，包含节点的值、左子节点和右子节点的指针。例如： ```cpp struct TreeNode { int val; TreeNode* left; TreeNode* right; TreeNode(int x) : val(x), left...
二叉搜索树查找算法【实现】.rar_C++_C++ 二叉搜索树_organizationzme
09-23
C++实现二叉搜索树查找算法主要涉及以下几个核心概念： 1. **节点定义**：首先，我们需要定义一个二叉搜索树的节点结构。这个结构通常包括键值、指向左右子节点的指针以及可能的额外信息，如指向父节点的指针等。 ...
C++ 二叉搜索树(BST)的实现方法
08-30
C++ 二叉搜索树(BST)的实现方法 C++ 二叉搜索树(BST)是一种特殊的二叉树，它具有以下特征： 1. 二叉搜索树的每个节点都包含一个键值（key）和一个值（value）。 2. 对于任意一个节点，左子树中的键值都小于该节点...
二叉搜索树的c++实现
07-05
使用二叉链表和c++来实现二叉搜索树，提供插入、删除、遍历、求最小节点、最大最节点等操作。
函数模板与类模板
程序员_小兵
07-12 1549
/交换int数据a = b;b = temp;//交换char数据a = b;b = temp;//问题：如果我要交换double类型数据，那么还需要些一个double类型数据交换的函数//繁琐，写的函数越多，当交换逻辑发生变化的时候，所有的函数都需要修改，无形当中增加了代码的维护难度//如果能把类型作为参数传递进来就好了，传递int就是Int类型交换，传递char就是char类型交换//我们有一种技术，可以实现类型的参数化---函数模板。
Linux C | 管道open打开方式
I_feige的博客
07-12 316
1.
C++ 多态
wxk2227814847的博客
07-10 789
多态是C++语言的三大特性之一，另两个特性是封装和继承。多态性使得对象可以根据运行时的实际类型来表现出不同的行为，从而实现灵活和可扩展的设计。在软件开发过程中，多态能够提高代码的复用性和可维护性，减少重复代码，并提供更加抽象和通用的接口。本文将详细探讨C++中的多态，包括其定义、构成、虚函数、抽象类以及实现原理，帮助读者全面理解这一重要概念。
Reversing Numbers C++
FGGFFoj的博客
07-11 377
在默认情况下，C++的输入输出流（比如 cin, cout）与C标准库的输入输出流是同步的，这意味着在使用C++的输入输出流时，可能会因为需要与C标准库的同步而导致性能略有损失。在 C++ 中，默认情况下，cin 和 cout 是绑定在一起的，意味着在输入时，输出可能需要等待输入完成才会进行，这样可能会造成一些性能上的损失，特别是在需要频繁输入输出的场景下。需要注意的是，在取消同步后，应确保不要混合使用C++的输入输出和C标准库的输入输出，因为这可能会导致未定义的行为。
c++ 生成随机字符串
最新发布
m0_56306892的博客
07-15 92
以下是一个示例代码，它使用std::random_device和std::mt19937生成随机字符，并将结果存储在一个字符串中。std::uniform_int_distribution<> distribution(0, max_index - 1) 创建一个均匀分布，以确保生成的随机数在字符集的索引范围内。输出随机字符串: 在主函数中调用generateRandomString生成一个长度为1024的随机字符串，并输出结果。std::random_device rd 用于生成一个随机种子。
C语言操作符详解
z317920的博客
07-11 631
目录一、操作符分类二、算术操作符三、赋值操作符四、关系操作符 五、条件操作符六、⼆进制和进制转换1.二进制 2.进制转换(1)2进制转10进制(2)10进制转2进制(3)2进制转8进制(4)2进制转16进制七、原码、反码、补码 八、移位操作符1.左移操作符2.右移操作符 九、位操作符1.按位与 &2.按位或 |3.按位异或 ^ 4.按位取反 ~ 十、单目操作符1.逻辑非操作符 ！ 2.自增++、自减-- 3.取地址符&、解引用符*、sizeof 3.1.取地址符& 3.2.解引
C++：哈希表
m0_61088872的博客
07-12 701
如果我们想要搜索这个数据，直接计算出这个数据的下标，然后就可以直接访问数组对应的位置，所以可以用O(1)的复杂度直接找到数据。当这个哈希表越满，我们查找数据的效率就越低，甚至说：如果查找一个不存在的数据，我们可能要用O(N)的复杂度遍历整个哈希表.因此我们因该把哈希表的负载率控制在一定值，当超过一定值，我们就要进行扩容操作。闭散列，也叫做开放定址法，当发生哈希冲突时，如果哈希表没有被装满，说明哈希表中还有空位置，那么我们可以把发生冲突的数据放到下一个空位置去。转化的函数，被写为了一个模板，而这个。
鸿蒙开发：Universal Keystore Kit（密钥管理服务）【密钥删除(C/C++)】
m0_70748845的博客
07-12 351
为保证数据安全性，当不需要使用该密钥时，应该删除密钥。
LeetCode：经典题之102、103题解及延伸｜双端队列Deque｜树的简介｜二叉树中BFS与层序遍历的关系
Chiefavefan
07-11 950
LeetCode经典题之102、103题解及延伸｜双端队列Deque｜树的简介｜二叉树中BFS与层序遍历的关系
[C/C++入门][变量和运算]7、交换变量（空杯思想）
qq_14840819的专栏
07-14 417
如图，一杯牛奶，一杯咖啡，如何进行交换呢？相信懂的都懂，不懂的看完这个图也就懂了。生活中非常简单的例子，放到我们计算机中也同样适用。
C++中的多态：虚函数与纯虚函数详解
TheJustice_的博客
07-14 299
在C++中，虚函数是在基类中使用virtual关键字声明的函数。当基类指针或引用指向派生类对象时，调用虚函数将执行派生类中的版本。public:public:void display() override { // 使用 override 确保函数被正确重写纯虚函数在基类中使用virtual关键字和= 0来声明。public:// 纯虚函数。
C语言——函数、形参与实参、局部变量
weixin_45720999的博客
07-11 699
printf("欢迎来到我的代码\n");int fuctWithData(int x) //形式参数，需要包含变量类型、变量名int y;y = x-1;return y;int y;printf("请输入一个数：");return 0;
数据结构-C语言-排序（2）
h_number_1的博客
07-14 1257
上述内容，即是我个人对数据结构排序中选择排序、堆排序、冒泡排序的个人见解以及自我实现。若有大佬发现哪里有问题可以私信或评论指教一下我这个小萌新。
PointCloudLib LocalMaximum_DeleteMaxPoint C++版本
linux_huangyu的博客
07-13 40
在点云库（Point Cloud Library，PCL）中，处理点云数据时，经常需要去除局部最大点（Local Maximum），这通常用于去除噪声、提取特定形状的特征或者简化点云数据。局部最大点指的是在局部区域内，其高度（或某个特定维度上的值）高于其邻近点的点。
C++STL 二叉搜索树
09-06
C++ STL中没有直接提供二叉搜索树的实现，但STL中有一些关于树的容器，比如set和map，它们底层的实现就是基于红黑树（一种平衡二叉搜索树）的。你可以使用这些容器来实现二叉搜索树的功能。关于二叉搜索树的一些知识，比如二叉树的遍历、迭代、线索二叉树、堆、Huffman编码、AVL树等都可以在STL中找到相应的实现。 二叉搜索树的查找可以通过比较根节点的值和目标值的大小来判断是往左子树还是往右子树查找，并重复这个过程直到找到目标值或者遍历到叶子节点为止。常规实现使用循环来实现查找，递归实现使用递归函数来查找。 二叉搜索树的插入操作也可以通过递归或循环来实现，根据目标值和当前节点的值的大小关系来决定是往左子树还是往右子树插入新节点。 STL中的二叉搜索树容器如set和map提供了插入、删除和查找等功能，并且保持了二叉搜索树的性质。你可以使用这些容器来处理二叉搜索树相关的操作。<span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *1* [C++ STL 数据结构 树](https://download.csdn.net/download/xinxipan/3008948)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_1"}}] [.reference_item style="max-width: 50%"] - *2* *3* [【C++ STL】-- 二叉搜索树](https://blog.csdn.net/weixin_64609308/article/details/128018280)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_1"}}] [.reference_item style="max-width: 50%"] [ .reference_list ]

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值