C++ 搜索二叉树

已于 2024-10-08 10:27:52 修改
阅读量858 收藏 27
点赞数 27
分类专栏： C++进阶 文章标签： c++ 数据结构 java 开发语言
于 2024-10-08 10:25:08 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_73523775/article/details/142700532
版权

大家好呀，我是残念，希望在你看完之后，能对你有所帮助，有什么不足请指正！共同学习交流哦（不能私学，谁私学谁是在这里插入图片描述
）
本文由：残念ing原创CSDN首发，如需要转载请通知
个人主页：残念ing-CSDN博客，欢迎各位→点赞👍 + 收藏⭐️ + 留言📝
📣系列专栏：残念ing 的C++进阶系列专栏——CSDN博客
请添加图片描述

什么是搜索二叉树

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

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

在这里插入图片描述
时间复杂度：增删查改时间复杂度O(N)

二叉搜索树的查找

  1. 从根开始比较，查找比根大则往右边走查找，比根小则往左边走查找。
  2. 最多查找高度次，走到空，还没有找到，说明要找的值不在。

二叉搜索树的插入

  1. 树为空，则直接新增节点，赋值给root指针
  2. 树不为空，按二叉搜索树性质插入位置，插入新的节点

二叉搜索树的删除

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

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

解决办法：
a. 可以与2或3两个情况结合起来
b. 删除该结点且使被删除结点的双亲结点指向被删除结点的左孩子结点—直接删除
c. 删除该结点且使被删除结点的双亲结点指向被删除结点的右孩子结点—直接删除
d. 在它的右子树中寻找中序下的第一个结点（最小结点）,用它的值填补到被删除结点中，再来处理该结点的删除问题–替换法删除
在这里插入图片描述

二叉搜索树的实现

#pragma once

#include<iostream>
using namespace std;

template<class K>

struct BSTNodes
{
	K _key;
	BSTNodes<K>* _left;
	BSTNodes<K>* _right;

	BSTNodes(const K& key)
		:  _key(key)
		, _left(nullptr)
		, _right(nullptr)
	{}
};


template <class K>

class BSTree
{
	typedef BSTNodes<K> NOde;
public:
	
	//添加
	bool Inster(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;
	}

	void Inorder()
	{
		_Inorder(_root);
		cout << endl;
	}
	bool Delete(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
			{
				//delete一个或0个孩子
				if (cur->_left == nullptr)
				{
					if (parent == nullptr)
					{
						_root = cur->_right;
					}
					else
					{
						if (parent->_left == cur)
						{
							parent->_left = cur->_right;
						}
						else
						{
							parent->_right = cur->_right;
						}
					}
					delete cur;
					return true;
				}
				if (cur->_right == nullptr)
				{
					if (parent == nullptr)
					{
						_root = cur->_left;
					}
					else
					{
						if (parent->_right == cur)
						{
							parent->_right = cur->_left;
						}
						else
						{
							parent->_left = cur->_left;
						}
					}
					delete cur;
					return true;
				}

				//两个孩子
				//右子树最小节点作为代替节点
				NOde* rightMinp = cur;
				NOde* rightMin = cur->_right;
				while (rightMin->_left)
				{
					rightMinp = rightMin;
					rightMin = rightMin->_left;
				}
				cur->_key = rightMin->_key;

				if (rightMinp->_left == rightMin)
					rightMinp->_left = rightMin->_right;
				else
					rightMinp->_right = rightMin->_right;

				delete rightMin;
				return true;
			}
		}
		return false;
	}
private:
	void _Inorder(NOde* root)
	{
		if (root == nullptr)
		{
			return;
		}
		_Inorder(root->_left);
		cout << root->_key << " ";
		_Inorder(root->_right);
	}

private:
	NOde* _root=nullptr;
};

上面的实现是一种K模型，那什么是K模型呢？？？

两个模型

1. K模型

K模型：K模型即只有key作为关键码，结构中只需要储存key即可，关键码即为需要搜索到的值。
比如：给一个单词，判断该单词是否拼写正确
~以词库中所有单词集合中的每个单词作为key，构建一课二叉搜索树；
~在二叉搜索树中检查该单词是否存在，存在则拼写正确，不存在则拼写错误；

2. KV模型

KV模型：每一个关键码key，都有与之对应的值value，即<key,value>的键值对。这种模型在生活中很常见：
~比如英汉词典就是英文与中文的对应关系，通过英文可以快速找到与其对应的中文，英文单词与其对应的中文<word, chinese>就构成一种键值对；
~再比如统计单词次数，统计成功后，给定单词就可快速找到其出现的次数，单词与其出现次数就是<word, count>就构成一种键值对；

#pragma once
#pragma once

#include<iostream>
using namespace std;

template<class K , class V>

struct BSTNodes
{
	K _key;
	V _value;
	BSTNodes<K,V>* _left;
	BSTNodes<K, V>* _right;

	BSTNodes(const K& key,const V& value)
		: _key(key)
		, _value(value)
		, _left(nullptr)
		, _right(nullptr)
	{}
};


template <class K,class V>

class KVBSTree
{
	typedef BSTNodes<K,V> NOde;
public:

	//添加
	bool Inster(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;
	}

	void Inorder()
	{
		_Inorder(_root);
		cout << endl;
	}
	bool Delete(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
			{
				//delete一个或0个孩子
				if (cur->_left == nullptr)
				{
					if (parent == nullptr)
					{
						_root = cur->_right;
					}
					else
					{
						if (parent->_left == cur)
						{
							parent->_left = cur->_right;
						}
						else
						{
							parent->_right = cur->_right;
						}
					}
					delete cur;
					return true;
				}
				if (cur->_right == nullptr)
				{
					if (parent == nullptr)
					{
						_root = cur->_left;
					}
					else
					{
						if (parent->_right == cur)
						{
							parent->_right = cur->_left;
						}
						else
						{
							parent->_left = cur->_left;
						}
					}
					delete cur;
					return true;
				}

				//两个孩子
				//右子树最小节点作为代替节点
				NOde* rightMinp = cur;
				NOde* rightMin = cur->_right;
				while (rightMin->_left)
				{
					rightMinp = rightMin;
					rightMin = rightMin->_left;
				}
				cur->_key = rightMin->_key;

				if (rightMinp->_left == rightMin)
					rightMinp->_left = rightMin->_right;
				else
					rightMinp->_right = rightMin->_right;

				delete rightMin;
				return true;
			}
		}
		return false;
	}
private:
	void _Inorder(NOde* root)
	{
		if (root == nullptr)
		{
			return;
		}
		_Inorder(root->_left);
		cout << root->_key <<" " << root->_value << " ";
		_Inorder(root->_right);
	}

private:
	NOde* _root = nullptr;
};

总结

插入和删除操作都必须查找，查找的效率代表了二叉搜索树中各个操作的性能。
对有n个结点的二叉搜索树，若每个元素查找的概率相等，则二叉搜索树平均查找长度是结点在二叉搜索树的深度的函数，即结点越深，则比较次数越多。
最优情况下，二叉搜索树为完全二叉树（或接近），其平均比较次数为：log_2 N
最差情况下，二叉搜索树退化为单支数（或者类似单支），其平均比较次数为：N/2

在这里插入图片描述

C++搜索二叉树
RXY24601的博客
05-27 1409
C++搜索二叉树，包括搜索二叉树的增删查，key-value模型的介绍及实现，搜索二叉树效率分析
C++ 搜索二叉树的删除
bananawolf的博客
02-06 664
情况1和情况2：如果这个父亲只有一个孩子要照顾，或者一个也没有，那么他想要脱身，只需要把这个孩子托付给他的长辈，没有就是nullptr，我们可以把这个过程叫托孤。2.情况三，月嫂的托孤，月嫂不一定是父亲的右孩子（左子树最大值的前提下），月嫂可能就是要被删除节点的左孩子，所以也要妥善处理。其次，他要满足照顾这两个孩子的条件，这个节点的key值要比左子树的每个节点key都要大，比右子树的每个节点key都要小，1.就不需要再找父节点了，这样还少了判断，被删除节点是父亲节点的左孩子还是右孩子。
C++之搜索二叉树
一只小卷毛的博客
04-05 1285
本文介绍了二叉搜索树的相关概念，主要介绍了如何使用和实现搜索二叉树以及搜索二叉树具体的例题练习。
【C++】————搜索二叉树
bhbcdxb123的博客
07-22 2071
若它的左子树不为空，则左子树上所有节点的值都小于根节点的值若它的右子树不为空，则右子树上所有节点的值都大于根节点的值它的左右子树也分别为二叉搜索树1.一个冷知识：屏蔽力是一个人最顶级的能力，任何消耗你的人和事，多看一眼都是你的不对。2.你不用变得很外向，内向挺好的，但需要你发言的时候，一定要勇敢。正所谓：君子可内敛不可懦弱，面不公可起而论之。3.成年人的世界，只筛选，不教育。
c++的二叉树
热门推荐
客舟中
01-01 1万+
目录 二叉树的定义 二叉树的分类 1. 完全二叉树 2. 满二叉树 3. 斜树 4. 二叉搜索树 5. 平衡二叉树 二叉树的存储方式 1. 数组存储 2. 链表存储 二叉树的遍历方式 1. 前序遍历 2. 中序遍历 3. 后序遍历 4. 层序遍历 二叉树的代码实现 总结 技术参考 二叉树的定义 二叉树是每个节点最多只有两个子树的数结构，两个子树称为左子树和右子树。 二叉树的分类 1. 完全二叉树 假设其深度为 d（d>1）。除了第 d 层外....
【C++】搜索二叉树
喜欢编写一些小程序的科班菜鸟，但是由于准备考研，博客不能及时更新了，不好意思！
10-29 2031
二叉搜索树的功能介绍
C++搜索二叉树的查找、插入、删除
MilkLeong的博客
02-15 2427
以一年十二月的英文缩写为键值而产生二叉搜索树，查找其中的Feb值，及输出最小、最大值： 红框以内为输出，红框以外为输入。
C++【搜索二叉树】
芊樱烛渊的博客
10-23 1364
二叉搜索树又称二叉排序树，它或者是一棵空树，或者是具有以下性质的二叉树:若它的左子树不为空，则左子树上所有节点的值都小于根节点的值若它的右子树不为空，则右子树上所有节点的值都大于根节点的值它的左右子树也分别为二叉搜索树（每一棵子树都满足上面的特征）（这样我们的搜索二叉树就非常利于我们的搜索）比方说我们查找8,8比6大，找右子树，8比9小，找9的左子树，7比8小，找7的右子树，找到了。最多的查找次数是树的高度！这样就不是暴力查找了，而是利用了二叉树的特性。
C++ 二叉树
m0_58697609的博客
09-25 947
二叉搜索树又称二叉排序树，他或者是一棵空树，或者是具有以下性质的二叉树：①若它的左子树不为空，则左子树上所有节点的值都小于根节点的值②若它的右子树不为空，则右子树上所有节点的值都大于根节点的值③它的左右子树也分别为二叉搜索树。
C++实现二叉树搜索树
12-18
功能：插入、查找、删除、清除整个树、返回最大值、返回最小值、前序遍历、中序遍历、后序遍历。 注：此二叉树允许插入相同的值
二叉树_C++_二叉树遍历_Vc_
09-29
在这个项目中，我们将探讨如何在C++中使用二叉链表来实现二叉树，并进行前序、中序和后序遍历。 **二叉链表**是二叉树在内存中的存储形式之一，每个节点包含一个数据元素和两个指向子节点的指针。二叉链表的节点...
基于C++的二叉树的创建及使用示例.zip
04-26
在C++编程语言中，实现二叉树可以帮助我们高效地处理各种问题，如搜索、排序、文件系统等。这个压缩包“基于C++的二叉树的创建及使用示例.zip”显然提供了关于如何在C++中创建和操作二叉树的实例代码。 二叉树的...
编译器、IDE对C/C++新标准的支持
编程语言技巧经验分享
11-08 1111
很遗憾的是，微软VC++对C99的支持直到VS2015才基本完全支持，在VS2012之前，仅仅支持C89. 也正是2015年之前，这么多人骂微软并纷纷转移到其它C语言编译器的原因。VS2019开始才正式宣布支持C11/C17.对于C++标准，VS2013开始支持C++11，VS2017支持C++17, VS2019支持C++20, 显然，微软更偏爱C++.
GitLab 提交 C++ 技巧
nbspzs的专栏
11-08 352
在 GitLab 中提交 C++ 代码时，通常应只提交 源代码文件（例如 .cpp、.h）和 CMake 配置文件（例如 CMakeLists.txt），而不要提交通过 CMake 编译后的中间文件或构建产物。这样，当其他开发者克隆你的项目后，他们可以在自己的机器上使用 cmake 构建项目，而不需要下载编译产物。2. 跨平台兼容性：不同的开发者和平台可能会生成不同的编译产物，提交这些文件会造成不必要的冲突和问题。1. 在 .gitignore 文件中忽略编译生成的文件和目录。
C++——智能指针
Wangx_wang的博客
11-12 574
介绍了几种智能指针的不同和实现思路以及循环引用的问题
C++builder中的人工智能（15）：C++高斯误差线性单元（GELU）
caridle的专栏
11-08 706
激活函数（phi()），也称为转移函数或阈值函数，它根据净输入函数的给定值（sum）确定激活值（a = phi(sum)）。在这里，sum是它们权重中的信号之和，激活函数是这个和的新值，具有给定的函数或条件。换句话说，激活函数是将所有加权信号的和转换为该信号的新激活值的方法。有不同类型的激活函数，通常使用的是线性（恒等）、双极性和逻辑（sigmoid）函数。在C++（以及大多数编程语言）中，你可以创建自己的激活函数。注意，sum是净输入函数的结果，它计算所有加权信号的和。我们将使用这些作为输入函数的结果。
2024年华为OD机试真题-查找充电设备-C++-OD统一考试（E卷）
面试高手的博客
11-08 314
某个充电站，可提供n个充电设备只，每个充电设备均有对应的输出功率任意个充电设备组合的输出功率总和，均构成功率集合P的1个元素功率集合P的最优元素，表示最接近充电站最大输出功率pmax 的元素。每一题都含有详细的解题思路和代码注释，精编c++、JAVA、Python三种语言解法。当充电设备输出功率50、20、20组合时，其输出功率总和为90，最接近充电站最大充电输出功率，因此最优元素为90。所有充电设备的输出功率组合，均大于充电站最大充电输出功率30，此时最优元素值为0。第 2 行为每个充电设备的输出功率。
C++初阶——list
最新发布
qq_55890817的博客
11-12 509
list是一个可以在序列的任意位置进行插入和删除的容器，并且可以进行双向迭代。list的底层是一个双向链表，双向链表可以将它们包含的每个元素存储在不同且不相关的存储位置。通过将每个元素与前一个元素的链接和后一个元素的链接关联起来，内部保持了顺序。
C++搜索二叉树如何打印值
05-05
打印搜索二叉树的值可以使用中序遍历（In-order traversal）算法，该算法会以从小到大的顺序遍历每个节点并打印节点的值。具体实现可以参考以下 C 语言代码： ```c #include <stdio.h> #include <stdlib.h> // 定义搜索二叉树节点结构体 struct node { int value; struct node *left; struct node *right; }; // 中序遍历搜索二叉树并打印节点的值 void in_order_traversal(struct node *root) { if (root == NULL) { return; } in_order_traversal(root->left); printf("%d ", root->value); in_order_traversal(root->right); } int main() { // 构建一个搜索二叉树 struct node *root = (struct node*) malloc(sizeof(struct node)); root->value = 4; root->left = (struct node*) malloc(sizeof(struct node)); root->left->value = 2; root->left->left = (struct node*) malloc(sizeof(struct node)); root->left->left->value = 1; root->left->left->left = NULL; root->left->left->right = NULL; root->left->right = (struct node*) malloc(sizeof(struct node)); root->left->right->value = 3; root->left->right->left = NULL; root->left->right->right = NULL; root->right = (struct node*) malloc(sizeof(struct node)); root->right->value = 6; root->right->left = (struct node*) malloc(sizeof(struct node)); root->right->left->value = 5; root->right->left->left = NULL; root->right->left->right = NULL; root->right->right = (struct node*) malloc(sizeof(struct node)); root->right->right->value = 7; root->right->right->left = NULL; root->right->right->right = NULL; // 打印搜索二叉树的值 in_order_traversal(root); return 0; } ``` 上述代码中，我们先定义了一个搜索二叉树节点的结构体，包括节点的值、左子节点和右子节点。接着，我们实现了一个中序遍历算法 `in_order_traversal()`，该算法会递归遍历搜索二叉树的左子树、打印当前节点的值、再遍历右子树。最后，在 `main()` 函数中构建一个搜索二叉树，并调用 `in_order_traversal()` 打印搜索二叉树的值。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值