c++二叉搜索树

于 2024-09-16 10:58:07 发布
阅读量974 收藏 23
点赞数 28
文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/suiyi_freely/article/details/142300102
版权

一、概念

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

• 若它的左子树不为空，则左子树上所有结点的值都小于等于根结点的值

• 若它的右子树不为空，则右子树上所有结点的值都大于等于根结点的值

• 它的左右子树也分别为⼆叉搜索树

• 二叉搜索树中可以支持插⼊相等的值，也可以不支持插入相等的值，具体看使用场景定义，

map/set/multimap/multiset系列容器底层就是⼆叉搜索树，其中map/set不支持插入相等

值，multimap/multiset支持插⼊相等值
在这里插入图片描述

二、性能分析

最优情况下，二叉搜索树为完全二叉树(或者接近完全二叉树)，其高度为： O(log2 N)

最差情况下，⼆叉搜索树退化为单⽀树(或者类似单支)，其高度为： O( N )

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

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

  1. 需要存储在支持下标随机访问的结构中，并且有序。

  2. 插入和删除数据效率很低，因为存储在下标随机访问的结构中，插入和删除数据⼀般需要挪动数

据。

这里也就体现出了平衡⼆叉搜索树的价值。

在这里插入图片描述

三、实现

1、插入

插入的具体过程如下：

  1. 树为空，则直接新增结点，赋值给root指针

  2. 树不空，按二叉搜索树性质，插⼊值比当前结点大往右走，插入值比当前结点小往左走，找到空位

置，插入新结点。

  1. 如果支持插入 相等的值，插入值跟当前结点相等的值可以往右走，也可以往左走，找到空位置，插

入新结点。（要注意的是要保持逻辑⼀致性，插入相等的值不要⼀会往右走，⼀会往左走）

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

在这里插入图片描述

	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->_left;
			}
			else if(cur->_key < key)
			{
				parent = cur;
				cur = cur->_right;
			}
			else
			{
				return false;//相等不插入
			}
		}
		cur = new Node(key);//出来以后判断在左边插还是右边插（插入那边一定为空，上面判断过了）
		if (parent->_key < key)
		{
			parent->_right = cur;
		}
		else
		{
			parent->_left = cur;
		}
		return true;
	}

2、查找

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

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

  3. 如果不支持插入相等的值，找到x即可返回

  4. 如果支持插入相等的值，意味着有多个x存在，⼀般要求查找中序的第⼀个x。如下图，查找3，要

找到1的右孩子的那个3返回

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

bool Find(const K& key)
{
	auto cur = root;
	while (cur)
	{
		if (cur->_key > key)
		{
			cur = cur->_left;
		}
		else if (cur->_key < key)
		{
			cur = cur->_right;
		}
		else
		{
			return true;
		}
	}
	return false;
}

3、删除

首先查找元素是否在二叉搜索树中，如果不存在，则返回false。

如果查找元素存在则分以下四种情况分别处理：（假设要删除的结点为N）

  1. 要删除结点N左右孩子均为空

  2. 要删除的结点N左孩子位空，右孩子结点不为空

  3. 要删除的结点N右孩子位空，左孩子结点不为空

  4. 要删除的结点N左右孩子结点均不为空

对应以上四种情况的解决方案：

  1. 把N结点的父亲对应孩子指针指向空，直接删除N结点（情况1可以当成2或者3处理，效果是⼀样

的）

  1. 把N结点的父亲对应孩子指针指向N的右孩子，直接删除N结点

  2. 把N结点的父亲对应孩子指针指向N的左孩子，直接删除N结点

  3. 无法直接删除N结点，因为N的两个孩子无处安放，只能用替换法删除。找N左子树的值最大结点

R(最右结点)或者N右子树的值最小结点R(最左结点)替代N，因为这两个结点中任意⼀个，放到N的

位置，都满足二叉搜索树的规则。替代N的意思就是N和R的两个结点的值交换，转而变成删除R结

点，R结点符合情况2或情况3，可以直接删除。

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

bool earse(const K& key)
{
	Node* parent = nullptr;
	Node* cur = root;
	while (cur)
	{
		if (cur->_key > key)
		{
			parent = cur;
			cur = cur->_left;
		}
		else if (cur->_key < key)
		{
			parent = cur;
			cur = cur->_right;
		}
		else
		{
			//一个孩子或者没有孩子的情况
			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;
			}
			else if (cur->_right == nullptr)
			{
				if (parent == nullptr)
				{
					root = cur->_left;
				}
				else
				{
					if (parent->_left == cur)
					{
						parent->_left = cur->_left;
					}
					else
					{
						parent->_right = cur->_left;
					}
				}
				delete cur;
				return true;
			}
			//两个孩子的情况，用右树的最小替换
			else
			{
				Node* right_min_parent = cur;
				Node* right_min = cur->_right;
				while (right_min->_left)
				{
					right_min_parent = right_min;
					right_min = right_min->_left;
				}
				cur->_key = right_min->_key;//赋值过去最后删的是right_min结点
				if (right_min_parent->_left == right_min)
				{
					right_min_parent->_left = right_min->_right;//右边可能还有值
				}
				else
				{
					right_min_parent->_right = right_min->_right;
				}
				delete right_min;
				return true;
			}
		}
	}
	return false;//没找着
	
}

4、整体代码

#pragma once
#include<iostream>
using namespace std;
template<class K>
struct TreeNode
{
	K _key;
	TreeNode<K>* _left;
	TreeNode<K>* _right;
	TreeNode(const K& key)
		:_key(key)
		, _left(nullptr)
		, _right(nullptr)
	{}
};
template<class K>
class BST
{
	typedef TreeNode<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->_left;
			}
			else if(cur->_key < key)
			{
				parent = cur;
				cur = cur->_right;
			}
			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)
	{
		auto cur = root;
		while (cur)
		{
			if (cur->_key > key)
			{
				cur = cur->_left;
			}
			else if (cur->_key < key)
			{
				cur = cur->_right;
			}
			else
			{
				return true;
			}
		}
		return false;
	}
	bool earse(const K& key)
	{
		Node* parent = nullptr;
		Node* cur = root;
		while (cur)
		{
			if (cur->_key > key)
			{
				parent = cur;
				cur = cur->_left;
			}
			else if (cur->_key < key)
			{
				parent = cur;
				cur = cur->_right;
			}
			else
			{
				//一个孩子或者没有孩子的情况
				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;
				}
				else if (cur->_right == nullptr)
				{
					if (parent == nullptr)
					{
						root = cur->_left;
					}
					else
					{
						if (parent->_left == cur)
						{
							parent->_left = cur->_left;
						}
						else
						{
							parent->_right = cur->_left;
						}
					}
					delete cur;
					return true;
				}
				//两个孩子的情况，用右树的最小替换
				else
				{
					Node* right_min_parent = cur;
					Node* right_min = cur->_right;
					while (right_min->_left)
					{
						right_min_parent = right_min;
						right_min = right_min->_left;
					}
					cur->_key = right_min->_key;//赋值过去最后删的是right_min结点
					if (right_min_parent->_left == right_min)
					{
						right_min_parent->_left = right_min->_right;//右边可能还有值
					}
					else
					{
						right_min_parent->_right = right_min->_right;
					}
					delete right_min;
					return true;
				}
			}
		}
		return false;//没找着
		
	}
	void inorder()//private外部访问不到
	{
		_inorder(root);
	}
	

private:
	void _inorder(Node* root)//这可以访问
	{
		if (root == nullptr)
		{
			return;
		}
		_inorder(root->_left);
		cout << root->_key << " ";
		_inorder(root->_right);
	}
	Node* root = nullptr;
};
		}
					else
					{
						right_min_parent->_right = right_min->_right;
					}
					delete right_min;
					return true;
				}
			}
		}
		return false;//没找着
		
	}
	void inorder()//private外部访问不到
	{
		_inorder(root);
	}
	

private:
	void _inorder(Node* root)//这可以访问
	{
		if (root == nullptr)
		{
			return;
		}
		_inorder(root->_left);
		cout << root->_key << " ";
		_inorder(root->_right);
	}
	Node* root = nullptr;
};
suiyi_freely
关注
【C++】AVL树：平衡二叉搜索树；插入，左旋，右旋，双旋
weixin_43962381的博客
05-15 648
文章目录概述平衡因子 概述 平衡二叉搜索树又被称为AVL树，且具有以下性质： 在AVL树中任何节点的两个子树的高度最大差别不超过1，所以它也被称为高度平衡树，并且它的左右两个子树都是一棵平衡二叉树。AVL树的增加和删除可能需要通过一次或多次树旋转来重新平衡这个树。 使用AVL树的可以防止二叉搜索树退化为单边树。 平衡因子 一个结点的右子树高度减去左子树高度所得的值，就是该节点的平衡因子，范围：[-1,1] ...
C++二叉搜索树
weixin_63246738的博客
07-30 374
C++二叉搜索树
C++：平衡搜索二叉树（AVL）
最新发布
2301_80153885的博客
07-27 1068
int _bf;:_kv(kv),_bf(0){}由于要保证左右子树高度之差的绝对值不超过1(-1/0/1)，所以引用了平衡因子_bf来维护，平衡因子的计算为右子树高度减去左子树高度因为AVL树会对节点进行旋转，所以引入了父节点指针_parent来维护。
C++平衡搜索二叉树（AVL）
RXY24601的博客
07-22 110
平衡搜索二叉树（AVL树）：包括三叉链实现AVL树，平衡因子，四种旋转情况图示与代码实现
学习-＞C++篇十四：平衡二叉搜索树
u014801954的博客
10-04 367
目录 1.平衡二叉搜索树（AVL树）的定义 2.AVL树是如何平衡的？ 左旋操作 右旋操作 左右双旋操作 右左双旋操作
c++ AVLTree平衡二叉搜索树
Hedenghui777的博客
10-22 309
AVL树 前言 二叉搜索树虽可以缩短查找的效率，但如果数据有序或接近有序二叉搜索树将退化为单支树，查找元素相当于在顺序表中搜索元素，效率低下。 一、AVL是什么？ 当向二叉搜索树中插入新结点后，如果能保证每个结点的左右子树高度之差的绝对值不超过1(需要对树中的结点进行调整)，即可降低树的高度，从而减少平均搜索长度。 二、满足条件 1.它的左右子树都是AVL树 2.左右子树高度之差(简称平衡因子)的绝对值不超过1(-1/0/1) 三、实现AVL树 #pragma once template<clas
C++ 二叉搜索树(BST)的实现方法
08-30
C++ 二叉搜索树(BST)的实现方法 C++ 二叉搜索树(BST)是一种特殊的二叉树，它具有以下特征： 1. 二叉搜索树的每个节点都包含一个键值（key）和一个值（value）。 2. 对于任意一个节点，左子树中的键值都小于该节点...
二叉搜索树查找算法【实现】.rar_C++_C++ 二叉搜索树_organizationzme
09-23
C++实现二叉搜索树查找算法主要涉及以下几个核心概念： 1. **节点定义**：首先，我们需要定义一个二叉搜索树的节点结构。这个结构通常包括键值、指向左右子节点的指针以及可能的额外信息，如指向父节点的指针等。 ...
C++二叉搜索树的插入和删除例子
05-29
二叉搜索树（Binary Search Tree，BST）是一种特殊类型的二叉树，它的每个节点都包含一个键（key）、一个关联的值、一个指向左子树的指针和一个指向右子树的指针。在二叉搜索树中，对于任何一个节点，其左子树中的...
【C++】AVL树（平衡搜索二叉树）
慕雪华年的博客
09-02 815
二叉搜索树虽然缩短了查找的效率，但是数据有序的时候，就会出现一边非常长的情况，导致原本的O(logN)时间复杂度被迫变成了O(N)平衡树也是搜索二叉树，其引入了一个平衡因子的概念，用于控制搜索二叉树的平衡。它会保证左右子树的高度之差（绝对值）不超过1。当新插入节点导致高度之差超过1时，便会触发旋转，使得树的高度降低。简单说来：AVL树能保证两边高度的相对平衡，这样就稳定了二叉搜索树的效率那么本篇关于AVL树的博客到这里就结束拉！有什么问题欢迎在评论区提出哦！
平衡二叉树（C/C++）
Ivan_47的博客
12-28 424
描述： 平衡二叉树是二叉搜索树的改进，本文基于你已了解二叉搜索树为前提，不了解的朋友请看这里： https://blog.csdn.net/Ivan_47/article/details/111831396 当我们使用二叉搜索树时，若我们按递增或递减的顺序插入结点，那么每一次的新结点都会插入在左子树或右子树，这样一来二叉树便退化为了链表，那么搜索的效率就会降低。 为提升二叉排序树的平均效率，可将其升级为平衡二叉树，其特点是：所有根结点的左子树和右子树深度差不超过1。其中左右子树的深度差也称为平衡因子。每插入
[C++系列] 77. 详解AVL平衡二叉搜索树
Y-puyu 的博客
02-10 785
文章目录1. AVL 树的概念2. AVL 树节点的定义3. AVL树的插入与失衡4. AVL树的旋转4.1 新节点插入较高左子树的左侧---左左：右单旋4.2 新节点插入较高右子树的右侧---右右：左单旋4.3. 新节点插入较高左子树的右侧---左右：先左单旋再右单旋4.4. 新节点插入较高右子树的左侧---右左：先右单旋再左单旋5. AVL树旋转总结：6. AVL树的实现7. AVL树的验证7...
c++写AVL二叉平衡搜索树算法
BlackCarDriver的博客
03-20 337
下面是我写的avl数算法模板，虽然已过三个月，现在再次想重写，仍然难以找到可以在优化的地方。 这个算法里面用到的递归操作和其他细节都很多，一旦某处写错，可能造成难以发现的bug。。。 下面是代码，注释照旧，发现不足之处或有所疑问欢迎留言。 #include<iostream> #include<stdio.h> #include<vector> #include...
C/C++Linux平衡二叉搜索树简介
资料qun832218493
09-11 176
avltree， 平衡二叉查找树，是一种特殊情况下的二叉查找树，它的特殊之处在于，对于每一个节点，其左子树深度和右子树深度之差的绝对值不大于1. 自从上次写完BSTree后，心里想写AVL树了，查了点资料，感觉自己之前的结构是真的low，哎，知耻而后勇，先说一下这次的avl与上次bstree的两点不同： 1）节点数据结构中新增了一个高度变量，代码如下： struct Node{ struct Node *left; struct Node *right; int val; i
C++笔记——平衡二叉树
永不秃头的三三的博客
02-08 833
通过C++手撕一个平衡二叉树，实现插入、删除、查找、打印功能，以巩固自己的基础以及方便日后复习。
【c++】二叉搜索树、平衡二叉树（AVL树）的模拟实现及注意事项
qq_40408365的博客
07-10 439
二叉搜索树的概念 二叉搜索树又称二叉排序树，它或者是一棵空树，或者是具有以下性质的二叉树： 1.若它的左子树不为空，则左子树上所有节点的值都小于根节点的值 2.若它的右子树不为空，则右子树上所有节点的值都大于根节点的值 3.它的左右子树也分别为二叉搜索树 二叉搜索树的插入 核心思想一共3步： 1.根据性质来定位元素要插入的位置 2.判断是否有重复元素（插入） 3.修改插入操作...
数据结构与算法：C++实现 平衡二叉树
暮色年华的博客
06-02 508
保持平衡：调整树的形态，使BST性质不变又保证树的高度在任何情况下都是O(log2n)，确保树上的查找操作在最坏情况下是O(log2n)。RL：A结点的右孩子的左子树插入结点，使得A结点的平衡因子由-1变为-2引起的不平衡。RR：A结点的右孩子的右子树插入结点，使得A结点的平衡因子由-1变为-2引起的。LR：A结点的左孩子的右子树插入结点，使得A结点的平衡因子由1变为2引起的。LL：A结点的左孩子的左子树插入节点，使得A结点的平衡因子由1变为2引起的。(1)查找：在平衡二叉树中查找关键字为k的结点p。
算法导论-AVL树的C++实现
爱冒险的技术宅
10-23 3493
代码主要来自网上流传的一份南京大学陈氏三姐妹的大作业。 花了一些时间测试和修改，代码基本OK了，结构也比较清晰。 我两把刷子，裸写的话没一个礼拜真下不来。 #include #include #include #define EQ(a,b) ((a)==(b)) #define LT(a,b) ((a)<(b)) #define LQ(a,b) ((a)>(b)) #define LH
c++二叉搜索树的创建
11-13
以下是C++中创建二叉搜索树的示例代码： ```c++ #include using namespace std; // 定义二叉搜索树节点结构体 struct TreeNode { int val; TreeNode* left; TreeNode* right; TreeNode(int x) : val(x), left...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

suiyi_freely

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

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

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

打赏作者

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

抵扣说明：

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

余额充值