AVL树节点的插入

数据结构(AVL树) 这棵“畸形”的二叉树虽然依旧是一棵标准的BST,但却已经明显左轻右重了,事实上这棵二叉树已经退化成了一条链表,在这棵BST中搜索某一节点的时间复杂度跟链表是一样的。这种“左轻右重”或者“左重右轻”的长短腿的情形,就是所谓的不平衡,一棵树如果不平衡,那么他的搜索性能将会受到影响,具体来讲:当树保持平衡时,其搜索时间复杂度是O(log2n)Olog2​n),当树退化成链表时,其搜索时间复杂度变成O(n)On),其他情况下树的平均搜索时间复杂度就介于这两者之间。 阅读详情

先声明一下这里为什么只写了AVL树节点的插入哈

  • 首先说一下AVL树的查找,因为查找并没有破坏节点位置。而我们的AVL树是在搜索树的基础上限定了树的左右树之间的高度不超过(-1 || 1),所以说查找是完全类比搜索二叉树的。
  • 在来说一下删除吧,因为删除是也是要考虑树的高度,还有顺序的,这个想一想就有一点麻烦,不过只要多画几张图,把分类的几种情况理清楚了,还是可以画出来的,但是要清楚一个概念就是空间换时间删除的搜索的时间是log2N,删除的时间想一想有多复杂,就有多复杂的。

好了,来主要说插入吧!
插入当中主要涉及到两个比较重要的点,一个是旋转还有一个就是平衡因子,而我们的旋转还有平衡因子为什么要改变,都是通过插入元素间接引起的。
AVL树还是主要要看图的不看图,几下子就晕了。
在这里插入图片描述
我们先简单的看一下这张图,主要先看一下插入节点对平衡因子的影响,黑色圈子是我插入的节点插入节点以后我们数根节点左边的高度,开始是-3,插入以后变成了-4,根节点右边一直是2,插入以后根节点平衡因子变成了-2。而追根问底从下往上寻找第一个-2产生位置在根节点左子树位置
其实我个人感觉记住低一个产生不满足条件的平衡因子是会让理解旋转很多变的方便很多的。
好了,看一下代码吧。

  • 先简单的构造一下AVL树吧
#include <iostream>
using namespace std;



template<class K, class V>
struct AVLTreeNode
{
	AVLTreeNode(const K& key = K(), const V& value = V())
		: _pLeft(nullptr)
		, _pRight(nullptr)
		, _pParent(nullptr)
		, _key(key)
		, _value(value)
		, _bf(0)
	{}

	AVLTreeNode<K, V>* _pLeft;
	AVLTreeNode<K, V>* _pRight;
	AVLTreeNode<K, V>* _pParent;
	K _key;
	V _value;
	int _bf;    // 平衡因子
};


我们主要通过在AVL树里面放了一个数值,即键值对。

  • 插入数值
bool Insert(const K& key, const V& value)
	{
		if (nullptr == _pRoot)
		{
			_pRoot = new Node(key, value);
			return true;
		}

		// 找待插入节点的位置
		PNode pCur = _pRoot;
		PNode pParent = nullptr;
		while (pCur)
		{
			pParent = pCur;
			if (key < pCur->_key)
				pCur = pCur->_pLeft;
			else if (key > pCur->_key)
				pCur = pCur->_pRight;
			else
				return false;
		}

		// 插入节点
		pCur = new Node(key, value);
		if (key < pParent->_key)
			pParent->_pLeft = pCur;
		else
			pParent->_pRight = pCur;

		pCur->_pParent = pParent;

		while (pParent)
		{
			// 更新双亲的平衡因子
			if (pParent->_pLeft == pCur)
				pParent->_bf--;
			else
				pParent->_bf++;

			if (0 == pParent->_bf)
				break;
			else if (-1 == pParent->_bf || 1 == pParent->_bf)
			{
				pCur = pParent;
				pParent = pCur->_pParent;
			}
			else
			{
				// parent的平衡因子已经不满足情况
				if (2 == pParent->_bf)
				{
					// 右子树比较高
					if (1 == pCur->_bf)
						RotateL(pParent);
					else
						RotateRL(pParent);
				}
				else
				{
					// 左子树比较高
					if (-1 == pCur->_bf)
						RotateR(pParent);
					else
						RotateLR(pParent);
				}

				break;
			}
		}

		return true;
	}

插入数值还是类比搜索二叉树,我们先检查这个节点是不是存在,如果存在就结束掉了,剩余就是更新平衡因子,然后通过平衡因子判断是否需要旋转。平衡因子的查看其实我们是要看三代的,**插入数(第一代) 插入树根节点(第二代) 插入树根节点的根节点(第三代)**里面内嵌的旋转函数下面会分情况讨论滴。

  • 函数的旋转
void RotateR(PNode pParent)
	{
		PNode pSubL = pParent->_pLeft;
		PNode pSubLR = pSubL->_pRight;

		pSubL->_pRight = pParent;
		pParent->_pLeft = pSubLR;

		if (pSubLR)
			pSubLR->_pParent = pParent;

		PNode pPParent = pParent->_pParent;
		pParent->_pParent = pSubL;
		pSubL->_pParent = pPParent;

		if (nullptr == pPParent)
			_pRoot = pSubL;
		else
		{
			if (pParent == pPParent->_pLeft)
				pPParent->_pLeft = pSubL;
			else
				pPParent->_pRight = pSubL;
		}

		pSubL->_bf = pParent->_bf = 0;
	}

	void RotateL(PNode pParent)
	{
		PNode pSubR = pParent->_pRight;
		PNode pSubRL = pSubR->_pLeft;

		pSubR->_pLeft = pParent;
		pParent->_pRight = pSubRL;

		if (pSubRL)
			pSubRL->_pParent = pParent;

		PNode pPParent = pParent->_pParent;
		pSubR->_pParent = pPParent;
		pParent->_pParent = pSubR;

		if (nullptr == pPParent)
			_pRoot = pSubR;
		else
		{
			if (pPParent->_pLeft == pParent)
				pPParent->_pLeft = pSubR;
			else
				pPParent->_pRight = pSubR;
		}

		pParent->_bf = pSubR->_bf = 0;
	}

	void RotateLR(PNode pParent)
	{
		PNode pSubL = pParent->_pLeft;
		PNode pSubLR = pSubL->_pRight;
		int bf = pSubLR->_bf;

		RotateL(pParent->_pLeft);
		RotateR(pParent);

		if (1 == bf)
			pSubL->_bf = -1;
		else if (-1 == bf)
			pParent->_bf = 1;
	}

	void RotateRL(PNode pParent)
	{
		PNode pSubR = pParent->_pRight;
		PNode pSubRL = pSubR->_pLeft;
		int bf = pSubRL->_bf;

		RotateR(pParent->_pRight);
		RotateL(pParent);

		if (1 == bf)
			pParent->_bf = -1;
		else if (-1 == bf)
			pSubR->_bf = 1;
	}

  • 节点插入左子树左侧 右旋
    在这里插入图片描述
    需要注意的是我们的子树的根节点是否是二叉树的根节点,其他的通过二叉树搜索树的性质就可以判断了。

  • 节点插入右子树右侧 左旋
    在这里插入图片描述

  • 节点在左子树右侧插入 先左旋在右旋
    在这里插入图片描述
    这个图我就直接在左旋图的基础上用箭头代表指向,其实我就是感觉这样画稍微简单一点了

  • 节点在右子树左侧插入 先右旋在左旋
    在这里插入图片描述

  • 完整代码


#include <iostream>
using namespace std;



template<class K, class V>
struct AVLTreeNode
{
	AVLTreeNode(const K& key = K(), const V& value = V())
	: _pLeft(nullptr)
	, _pRight(nullptr)
	, _pParent(nullptr)
	, _key(key)
	, _value(value)
	, _bf(0)
	{}

	AVLTreeNode<K, V>* _pLeft;
	AVLTreeNode<K, V>* _pRight;
	AVLTreeNode<K, V>* _pParent;
	K _key;
	V _value;
	int _bf;    // 平衡因子
};


template<class K, class V>
class AVLTree
{
	typedef AVLTreeNode<K, V> Node;
	typedef Node* PNode;

public:
	AVLTree()
		: _pRoot(nullptr)
	{}

	bool Insert(const K& key, const V& value)
	{
		if (nullptr == _pRoot)
		{
			_pRoot = new Node(key, value);
			return true;
		}

		// 找待插入节点的位置
		PNode pCur = _pRoot;
		PNode pParent = nullptr;
		while (pCur)
		{
			pParent = pCur;
			if (key < pCur->_key)
				pCur = pCur->_pLeft;
			else if (key > pCur->_key)
				pCur = pCur->_pRight;
			else
				return false;
		}

		// 插入节点
		pCur = new Node(key, value);
		if (key < pParent->_key)
			pParent->_pLeft = pCur;
		else
			pParent->_pRight = pCur;

		pCur->_pParent = pParent;

		while (pParent)
		{
			// 更新双亲的平衡因子
			if (pParent->_pLeft == pCur)
				pParent->_bf--;
			else
				pParent->_bf++;

			if (0 == pParent->_bf)
				break;
			else if (-1 == pParent->_bf || 1 == pParent->_bf)
			{
				pCur = pParent;
				pParent = pCur->_pParent;
			}
			else
			{
				// parent的平衡因子已经不满足情况
				if (2 == pParent->_bf)
				{
					// 右子树比较高
					if (1 == pCur->_bf)
						RotateL(pParent);
					else
						RotateRL(pParent);
				}
				else
				{
					// 左子树比较高
					if (-1 == pCur->_bf)
						RotateR(pParent);
					else
						RotateLR(pParent);
				}

				break;
			}
		}

		return true;
	}

	void InOrder()
	{
		_InOrder(_pRoot);
	}

	bool IsBalanceTree()
	{
		return _IsBalanceTree(_pRoot);
	}

private:
	bool _IsBalanceTree(PNode pRoot)
	{
		if (nullptr == pRoot)
			return true;

		int leftHeight = _Height(pRoot->_pLeft);
		int rightHeight = _Height(pRoot->_pRight);
		int diff = rightHeight - leftHeight;
		if (abs(diff) > 1 || diff != pRoot->_bf)
			return false;

		return _IsBalanceTree(pRoot->_pLeft) && _IsBalanceTree(pRoot->_pRight);
	}

	int _Height(PNode pRoot)
	{
		if (nullptr == pRoot)
			return 0;

		int leftHeight = _Height(pRoot->_pLeft);
		int rightHeight = _Height(pRoot->_pRight);

		return leftHeight > rightHeight ? leftHeight + 1 : rightHeight + 1;
	}

	void _InOrder(PNode pRoot)
	{
		if (pRoot)
		{
			_InOrder(pRoot->_pLeft);
			cout << "<" << pRoot->_key << "," << pRoot->_value << ">" << endl;
			_InOrder(pRoot->_pRight);
		}
	}

	void RotateR(PNode pParent)
	{
		PNode pSubL = pParent->_pLeft;
		PNode pSubLR = pSubL->_pRight;

		pSubL->_pRight = pParent;
		pParent->_pLeft = pSubLR;

		if (pSubLR)
			pSubLR->_pParent = pParent;

		PNode pPParent = pParent->_pParent;
		pParent->_pParent = pSubL;
		pSubL->_pParent = pPParent;

		if (nullptr == pPParent)
			_pRoot = pSubL;
		else
		{
			if (pParent == pPParent->_pLeft)
				pPParent->_pLeft = pSubL;
			else
				pPParent->_pRight = pSubL;
		}

		pSubL->_bf = pParent->_bf = 0;
	}

	void RotateL(PNode pParent)
	{
		PNode pSubR = pParent->_pRight;
		PNode pSubRL = pSubR->_pLeft;

		pSubR->_pLeft = pParent;
		pParent->_pRight = pSubRL;

		if (pSubRL)
			pSubRL->_pParent = pParent;

		PNode pPParent = pParent->_pParent;
		pSubR->_pParent = pPParent;
		pParent->_pParent = pSubR;

		if (nullptr == pPParent)
			_pRoot = pSubR;
		else
		{
			if (pPParent->_pLeft == pParent)
				pPParent->_pLeft = pSubR;
			else
				pPParent->_pRight = pSubR;
		}

		pParent->_bf = pSubR->_bf = 0;
	}

	void RotateLR(PNode pParent)
	{
		PNode pSubL = pParent->_pLeft;
		PNode pSubLR = pSubL->_pRight;
		int bf = pSubLR->_bf;

		RotateL(pParent->_pLeft);
		RotateR(pParent);

		if (1 == bf)
			pSubL->_bf = -1;
		else if (-1 == bf)
			pParent->_bf = 1;
	}

	void RotateRL(PNode pParent)
	{
		PNode pSubR = pParent->_pRight;
		PNode pSubRL = pSubR->_pLeft;
		int bf = pSubRL->_bf;

		RotateR(pParent->_pRight);
		RotateL(pParent);

		if (1 == bf)
			pParent->_bf = -1;
		else if (-1 == bf)
			pSubR->_bf = 1;
	}

private:
	PNode _pRoot;
};

void TestAVLTree()
{
	//int array[] = { 16, 3, 7, 11, 9, 26, 18, 14, 15};
	int array[] = { 4, 2, 6, 1, 3, 5, 15, 7, 16, 14 };
	AVLTree<int, int> t;
	for (auto e : array)
	{
		t.Insert(e, e);
	}

	t.InOrder();

	if (t.IsBalanceTree())
	{
		cout << "t is AVL tree!!!" << endl;
	}
	else
	{
		cout << "t is not AVL tree!!!" << endl;
	}
}
int main()
{

	TestAVLTree();

	return 0;

}

验证一下结果
在这里插入图片描述

【复现论文】Looking here or there? Gaze Following in 360-Degree Images 论文:Looking here or there? 阅读详情

相关推荐

U24时钟信号上升下降沿出现非单调性--简单分析

交换机U24时钟信号上升下降沿出现非单调性--简单分析

qq_45185504的博客 1132

AVL树插入详解

AVL树、平衡二叉树、搜索二叉树、插入函数

Shall#的博客 733

安卓开发者必看:Win11最新Fastboot驱动安装避坑指南(含Android Bootloader Interface选择技巧)

本文为安卓开发者提供了Windows 11系统下Fastboot驱动安装的详细指南,特别针对Android Bootloader Interface选择技巧和多设备并发连接时的驱动冲突问题。通过解析Windows 11的特殊驱动验证机制,推荐使用Google官方USB驱动,并提供安装流程、版本选择建议及疑难问题排查方法,帮助开发者高效完成开发环境配置。

sea99的博客 1338

AVL树的插入

为什么需要AVL树? 我们知道搜索二叉树通过对每一个结点限制规定:左子树都比比根节点小,右子树比根节点大,来达到O(logN)的搜索效率的:​​ 但是一般的搜索二叉树还有一个很严重的问题:当左右子树高度差很大时,会导致搜索效率极度退化,甚至在顺序插入时退化至O(N): 很明显,普通的搜索二叉树在一些情况下并不能达到预期的O(logN)搜索效率,而其原因就是高度的极度不平衡。 而AVL树就通过旋转的方式来维持搜索二叉树的平衡,AVL树得名于它的发明者G. M. Adelson-Vels

LiangXiay的博客 2831

CKEditor5富文本编辑器 - 视频引入、预览及自定义toolbar

文章目录定义遇到的问题视频部分引入媒体url失败原因解决方法:自定义视频provider视频预览及页面不显示视频问题解决方案:H5 \标签如何移除toolbar中的部分插件 一个小后端很少接触前端框架,只能在知识的海洋中漂泊。。。 定义 <script src="https://cdn.ckeditor.com/ckeditor5/16.0.0/classic/ckeditor.js"&gt...

huhui806的博客 8198

科研智能体平台搭建与实战:大模型如何驱动科研自动化

大模型技术的快速发展,正推动AI智能体从单纯对话工具向主动执行任务的科研伙伴演进。智能体的核心原理在于整合模型调用、工具使用、知识库检索与工作流编排,使其能够自主拆解目标、执行操作并迭代优化。在科研场景中,这一技术价值尤为突出:文献初筛、实验数据清洗、代码调试、结果汇总等高频重复劳动均可实现自动化,大幅释放研究者精力。从基础组件配置到多智能体协同,从平台选型到提示词调优,实际落地需要关注模型匹配、工具稳定性、记忆管理与人机校验机制。本文基于真实工程经验,系统梳理科研智能体平台的搭建路径、应用案例与高频问题排

weixin_32597009的博客 292

【C++】AVL树插入删除

这是一篇深度剖析AVL的插入,删除,以及判断是否是AVL树为主体的内容,其中涉及到LL,RR,LR,RL旋转的详细讲解。并且这是用的三叉实现的AVL树。

fight_p的博客 2560

从泛光成像到可寻址扫描:Flash激光雷达的车规级优势与技术演进

Flash激光雷达凭借固态架构优势成为自动驾驶感知技术的重要发展方向。该方案无机械部件,具备抗振动、长寿命等特点,同时CMOS工艺带来显著成本优势。但传统泛光式存在能量弥散问题,难以兼顾大视场和远距离探测。可寻址扫描技术通过分区点亮VCSEL阵列,有效提升局部能量密度,在保持固态可靠性的同时突破性能瓶颈。这种"电子扫描+分区点亮"的混合架构,使Flash激光雷达有望实现大视场、远距离、高可靠和低成本的多重突破,推动自动驾驶技术发展。

致力于lidar应用开发 235

AVL树的插入操作

二叉搜索树虽可以缩短查找的效率,但如果数据有序或接近有序二叉搜索树将退化为单支树,查找元素相当于在顺序表中搜索元素,效率低下。因此,两位俄罗斯的数学家G.M.Adelson-Velskii和E.M.Landis在1962年发明了一种解决上述问题的方法:当向二叉搜索树中插入新结点后,如果能保证每个结点的左右子树高度之差的绝对值不超过1(需要对树中的结点进行调整),即可降低树的高度,从而减少平均搜索长度。一棵AVL树或者是空树,或者是具有以下性质的二叉搜索树:它的左右子树都是AVL树。......

Rinki123456的博客 2952

uniapp [安卓苹果App端] - 实现微信支付功能+拉起微信付款支付后返回本app页面,详解uniApp如何唤起本机微信app并跳转到支付页面全流程及示例源码(uniapp实现微信支付,可打包)

uni-app项目在APP端使用微信支付功能,uniapp前端实现微信支付,uniapp开发安卓App对接微信支付,uniapp苹果ios唤起微信支付,uniapp调用微信支付uniapp开发app-调用微信支付,uniapp开发安卓苹果app如何接入微信支付,前后端应该怎么做,UniApp中实现微信支付功能,支付报错,调起失败没响应,uniapp苹果微信支付唤起实现,app唤起微信支付,拉起微信支付,uniapp中唤醒微信进行支付并返回app,uniApp调起微信支付失败报错,全网最详细的uniapp微信

🏆 前端领域优质创作者 1万+

由ip地址和子网掩码求网络号、主机号、广播地址(超详细)

1、用二进制数表示IP地址   在进行计算之前,我们首先要学会十进制的IP地址怎么转换为二进制的IP地址。   给出一个例子: 十进制:172.16.25.3 二进制:10101100.00010000.00011001.00000011 1、如果两台主机的网络号相同,我们就说它们是同一网段 2、主机号的意义 - 1)主机号部分全变成1,即为该网段的广播地址 - 2)主机号部分全变成0,即为该网段的网路地址(网络号) 3、如果主机号部分为x位,则该网络能容纳最大主机数为: 2的x次方-2。减2

爱吃雪糕的小布丁的博客 9万+

AVL树的插入操作(四种情况)

主要内容为AVL树的插入操作(不包含重复值),主要分为四种情况

PYH的博客 4895

11.1华为OD机试真题 新系统 - 整理学生编号 (Java/Py/C/C++/Js/Go)

11.1华为OD机试真题 新系统 - 整理学生编号 (Java/Py/C/C++/Js/Go)

算法大师! 517

AVL树节点插入方式解析(单旋转和双旋转)

此时的抽象图就是对实际情况的归类,但是实际情况是存在无数种的,因为h可以等于0,1,2,3,4,5,6.当h等于2的时候,AVL树都存在三种,以下的三种都是可以放到abc,那三个位置的。但是这样打印出来一个升序的结果,只能证明这是一个搜索树,不能证明这一个AVL树,所以我们还需要些一个验证平衡的代码,即求出每一个节点的左右高度差(右子树高度减去左子树高度),如果不等于平衡因子,则证明我们的AVL树出现了错误。我们分开是因为虽然旋转的过程是一样的,到那时需要按照不同的情况,去处理不同的平衡因子。

D223546的博客 495

NTscan扫描工具

ntscan是一个扫描器,可以扫描没有密码和弱密码的共享,先到配置文件中填写猜测的用户名和密码,扫描过程中右侧出现的是扫描日志。

VC中sqlite的使用

在VC中对sqlite的使用,实现数据库大批数据的快速插入,读取数据库中的数据在ListCtrl中显示

数据结构学习笔记-----AVL树节点插入中平衡因子的调节及旋转问题

目录 一、AVL树 (一)概念 (二)定义 二、AVL树的插入 (一)先按照二叉搜索树的规则将节点插入到AVL树中 (二)平衡因子调节 1.调节过程 2.代码实现 (三)旋转 1.概念 2.新节点插入较高左子树的左侧---左左:右单旋 3.新节点插入较高右子树的右侧---右右:左单旋 4. 新节点插入较高左子树的右侧---左右:先左单旋再右单旋 5.新节点插入较高右子树的左侧---右左:先右单旋再左单旋 一、AVL 树 (一)概念 对于一个AVL树,它是一个高度平衡的搜.

qq_41219243的博客 2552

ssm框架搭建

这个是一个在idea上成功跑起来的ssm框架项目,保存在这里方便以后使用直接下载

AVL树的插入、删除C语言实现

前言 在进行学习的过程中查阅了很多资料,这些资料中主要有以下几个问题: 树的节点高度获取方式不同: (1) 在树节点内定义一个变量储存节点高度,在进行旋转等操作的时候修改节点高度,优点:使用方便,缺点:在进行插入、删除操作时需子节点的高度无法修改,只能修改当前及其父节点的高度,且自我感觉这种方式定义节点高度存在计算错误。 (2) 在用到节点时,调用函数计算树的高度。 相比于(1)的方法,(2)方法更加直观,容易理解。 AVL树的实现 树节点定义与获取 节点定义 typedef struct Node{

ZYC_July的博客 721

数据结构与算法-AVL树

这棵“畸形”的二叉树虽然依旧是一棵标准的BST,但却已经明显左轻右重了,事实上这棵二叉树已经退化成了一条链表,在这棵BST中搜索某一节点的时间复杂度跟链表是一样的。这种“左轻右重”或者“左重右轻”的长短腿的情形,就是所谓的不平衡,一棵树如果不平衡,那么他的搜索性能将会受到影响,具体来讲:当树保持平衡时,其搜索时间复杂度是𝑂(𝑙𝑜𝑔2𝑛)Olog2​n),当树退化成链表时,其搜索时间复杂度变成𝑂(𝑛)On),其他情况下树的平均搜索时间复杂度就介于这两者之间。

m0_74147998的博客 987

AVL树插入新节点操作的实现

目录二叉搜索树的概念AVL树的概念AVL树节点的实现二叉搜索树插入操作平衡因子的更新旋转操作左单旋​编辑右单旋左右双旋右左双旋插入操作中补充旋转一颗AVL树或是空树,或者是具有以下性质的二叉搜索树:它的左右子树都是AVL树 左右子树高度之差(简称平衡因子)的绝对值不超过1注意:平衡因子是右子树的高度减左子树的高度 二叉搜索树插入操作 在实现AVL树节点插入之前我们先实现一个简单的二叉搜索树的插入操作:为了找到要插入的位置,定义两个节点指针,parent和cur,开始遍历cur,要插入的值比cur小cu

qq_55008871的博客 1144

【C++】AVL树|插入|单旋|双旋

AVL树节点的定义增加了一个指向父节点的指针,变成了三叉链结构,在原二叉树的基础上,加上平衡因子(调整平衡的作用)。struct AVLTreeNode //AVL树节点定义//构造函数, _kv(kv), _bf(0){}int _bf;

m0_67367079的博客 1144

【C++】图解AVL树

_kv(kv), _bf(0){}// 该节点的左孩子// 该节点的右孩子// 该节点的双亲int _bf;

luoshashou_123的博客 1156

AVL树的实现(万字图文详解)

本文利用图文结合的方式详细讲解了AVL树的实现以及相关知识,希望能对大家有所帮助!

originalHSL的博客 1149

树(四):平衡二叉树(AVL) C++实现

线索二叉树 C实现 以此二叉树为例进行创建: 前序法创建节点,输入’#'表示为NULL 用前序创建的话需要输入 :ABD##E##C#G## 前序遍历:ABD##E##C#G## 中序遍历:#D#B#E#A#C#G# 后序遍历: ##D##EB###GCA 层序遍历: ABCDEG ThreadBiTree.h: #pragma once #include <stdio.h> #in...

Worthy_Wang的博客 694

C++实现AVL树

AVL树的模拟实现啊

Yui_的博客 1274

【C++ 学习 ㉒】- 超详解 AVL 树的插入、平衡调整以及删除(含源代码)

超详解 AVL 树: 一、AVL 树的概念 二、AVL 树节点的定义 三、AVL 树的插入 四、AVL 树的平衡调整 五、AVL 树的删除 六、AVL 树的实现

melonyzzZ的博客 2513

AVL平衡二叉树 - 插入算法

/* LL型 A B / \ / \ B C -> Dx A / \ / \ Dx E E C */ static int rotate_LL(struct bitree_t *tree, struct bitree_node_t *A) { ...

zhgure的博客 514
上一篇: 搜索二叉树的增,查,删操作
下一篇: 红黑二叉树节点的插入
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值