A V L树

最新推荐文章于 2024-08-03 21:14:32 发布
最新推荐文章于 2024-08-03 21:14:32 发布
阅读量466 收藏
点赞数 1
分类专栏： C++ 文章标签： 算法 数据结构 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liar________/article/details/128679021
版权

概念

在之前介绍了搜索二叉树，但是当我们插入的数据若是有序或者接近于有序，那么此时查找的效率底下，于是俄罗斯的数学家G.M.Adelson-Velskii和E.M.Landis在1962年发明了一种解决上述问题的方法：当向二叉搜索树中插入新结点后，如果能保证每个结点的左右子树高度之差的绝对值不超过1(需要对树中的结点进行调整)，即可降低树的高度，是二叉树更加平衡，从而减少平均搜索长度。

AVL树的性质

  1. 它的左右子树都是AVL树
  2. 左右子树的高度之差的绝对值不超过1(-1/0/1)(高度之差简称为平衡因
    在这里插入图片描述

AVL树实现

在AVL树的实现这里我们只来实现一下它的插入，我们采用记录平衡因子的方式来定义完成AVL树的实现。
我们先来定义它的节点

template<class K,class V>
struct AVLTreeNode
{
	AVLTreeNode<K, V>* _left;
	AVLTreeNode<K, V>* _right;
	AVLTreeNode<K, V>* _parent;
	pair<K, V> _kv;
	int _bf;//平衡因子  balance factor

	AVLTreeNode(const pair<K, V>& kv)
		:_left(nullptr)
		,_right(nullptr)
		,_parent(nullptr)
		,_kv(kv)
		,_bf(0)
	{}
};

这里的_bf我们当作这个节点的平衡因子，我们默认这里的平衡因子为右子树的高度减去左子树的高度。
在我们插入之前，我们首先要遵循搜索树的规则，找到空的位置

bool Insert(const pair<K, V>& kv)
	{
		if (_root == nullptr)
		{
			_root = new Node(KV);
			return true;
		}

		Node* parent = nullptr;
		Node* cur = _root;

		while (cur)
		{
			if (cur->_kv.first > kv.first)
			{
				parent = cur;
				cur = cur->_left;
			}
			else if (cur->_kv.first < kv.first)
			{
				parent = cur;
				cur = cur->_right;
			}
			else
			{
				return false;
			}
		}
		cur = new Node(kv);
		if (parent->_kv.first < kv.first)
		{
			cur->_parent = parent;
			parent->_right = cur;
		}
		else
		{
			cur->_parent = parent;
			parent->_left = cur;
		}
	}

在找到位置之后我们需要去更新平衡因子，这里有五种情况

  1. 插入的cur的位置为parent的右边的时，此时右子树的高度加一，那么parent->_bt++;
  2. 插入的cur的位置为parent的左边的时，此时右子树的高度加一，那么parent->_bt–;
  3. 更新以后，parent的平衡因子要是是0，那么更新结束，因为插入一个节点之后这个节点的_bf变为了0，代表这个新增的节点一定是插入在高度小的那边的，因此parent的所在的子树高度不变。
  4. 更新以后，parent的平衡因子要是是1或者-1，那么继续向上更新，因为插入一个节点前parent->_bf就是0，那么parent的高度变化了，因此parent的父亲的平衡因子也肯定要变化。
  5. 更新之后，parent->_bt==-2/2,parent已经不平衡了，需要进行旋转处理

旋转

右单旋

新节点插入较高左子树的左侧—左左
在这里插入图片描述
代码实现

void RotateR(Node* parent)
	{
		Node* SubL = parent->_left;
		Node* SubLR = SubL->_right;

		parent->_left = SubLR;
		//此时SubLR可能为空
		if (SubLR)
		{
			SubLR->_parent = parent;
		}

		Node* parentparent = parent->_parent;

		SubL->_right = parent;
		parent->_parent = SubL;

		if (parent == _root)
		{
			_root = SubL;
			SubL->_parent = nullptr;
		}
		else
		{
			if (parent == parentparent->_left)
			{
				parentparent->_left = SubL;
				SubL->_parent = parentparent;
			}
			else
			{
				parentparent->_right = SubL;
				SubL->_parent = parentparent;
			}
		}
		parent->_bf = SubL->_bf = 0;
	}

左单旋

新节点插入较高右子树的右侧—右右
在这里插入图片描述
代码实现

void RotateL(Node* parent)
	{
		Node* SubR = parent->_right;
		Node* SubRL = SubR->_left;

		parent->_right = SubRL;
		if (SubRL)
		{
			SubRL->_parent = parent;
		}

		Node* parentparent = parent->_parent;

		SubR->_left = parent;
		parent->_parent = SubR;

		if (parent == _root)
		{
			_root = SubR;
			SubR->_parent = nullptr;
		}
		else
		{
			if (parent == parentparent->_left)
			{
				parentparent->_left = SubR;
			}
			else
			{
				parentparent->_right = SubR;
			}
			SubR->_parent = parentparent;
		}
		SubRL->_bf = SubR->_bf = 0;

	}

左右双旋

新节点插入较高左子树的右侧—左右
在这里插入图片描述
代码实现

void RotateLR(Node* parent)
	{
		RotateL(parent->_left);
		RotateR(parent);
	}

右左双旋

新节点插入较高右子树的左侧—右左
在这里插入图片描述
代码实现

void RotateRL(Node* parent)
	{
		RotateR(parent->_right);
		RotateL(parent);
	}

双旋平衡因子更正

上面的就是针对于插入导致树不平衡之后对其节点进行旋转的处理，那么针对于双旋，我们都是举例插在C的位置，那么当h要是等于0和h等于一的时候插入在b/c不同的位置，又需要对平衡因子进行更正

左右双旋

在这里插入图片描述
针对于以上三种情况，我们要对平衡因子进行处理

void RotateLR(Node* parent)
	{
		Node* Subl = parent->_left;
		Node* SubLR = Subl->_right;
		int bf = SubLR->_bf;

		RotateL(parent->_left);
		RotateR(parent);

		if (bf == -1)
		{
			parent->_bf = 1;
			Subl->_bf = 0;
			SubLR->_bf = 0;
		}
		else if (bf == 1)
		{
			parent->_bf = 0;
			Subl->_bf = -1;
			SubLR->_bf = 0
		}
		else if (bf == 0)
		{
			parent->_bf = Subl->_bf = SubLR->_bf = 0;
		}
		else
		{
			assert(false);
		}
	}

右左双旋

在这里插入图片描述
针对于以上三种情况，我们还是要对平衡因子进行处理

void RotateRL(Node* parent)
	{
		Node* SubR = parent->_right;
		Node* SubRL = SubR->_left;
		int bf = SubRL->_bf;

		RotateR(parent->_right);
		RotateL(parent);

		if (bf == 1)
		{
			parent->_bf = -1;
			SubR->_bf = 0;
			SubRL->_bf = 0;
		}
		else if (bf == -1)
		{
			parent->_bf = 0;
			SubR->_bf = 1;
			SubRL->_bf = 0;
		}
		else if (bf == 0)
		{
			parent->_bf = SubR->_bf = SubRL->_bf = 0;
		}
		else
		{
			assert(false);
		}
	}

完整代码

#pragma once
#include<assert.h>
template<class K,class V>
struct AVLTreeNode
{
	AVLTreeNode<K, V>* _left;
	AVLTreeNode<K, V>* _right;
	AVLTreeNode<K, V>* _parent;
	pair<K, V> _kv;
	int _bf;//平衡因子  balance factor

	AVLTreeNode(const pair<K, V>& kv)
		:_left(nullptr)
		,_right(nullptr)
		,_parent(nullptr)
		,_kv(kv)
		,_bf(0)
	{}
};

template<class K,class V>
class AVLTree
{
	typedef AVLTreeNode<K, V> Node;
public:

	AVLTree()
		:_root(nullptr)
	{}

	bool Insert(const pair<K, V>& kv)
	{
		if (_root == nullptr)
		{
			_root = new Node(KV);
			return true;
		}

		Node* parent = nullptr;
		Node* cur = _root;

		while (cur)
		{
			if (cur->_kv.first > kv.first)
			{
				parent = cur;
				cur = cur->_left;
			}
			else if (cur->_kv.first < kv.first)
			{
				parent = cur;
				cur = cur->_right;
			}
			else
			{
				return false;
			}
		}
		cur = new Node(kv);
		if (parent->_kv.first < kv.first)
		{
			cur->_parent = parent;
			parent->_right = cur;
		}
		else
		{
			cur->_parent = parent;
			parent->_left = cur;
		}


		//接下来需要控制平衡
		while (parent)
		{
			if (cur == parent->_left)
			{
				parent->_bf--;
			}
			else
			{
				parent->_bf++;
			}

			if (parent->_bf == 0)//平衡因子等于0的时候就说明这里插入的位置是正确的，直接跳出
			{
				break;
			}
			//平衡因子等于1或-1的时候，此时需要向上调整
			else if (parent->_bf == 1 || parent->_bf == -1)
			{
				cur = parent;
				parent = parent->_parent;
			}
			//平衡因子等于2或-2的时候，此时需要旋转处理
			else if (parent->_bf == 2 || parent->_bf == -2)
			{
				//右单旋
				if (parent->_bf == -2 && cur->_bf == -1)
				{
					RotateR(parent);
				}
				//左单旋
				if (parent->_bf == 2 && cur->_bf == 1)
				{
					RotateL(parent);
				}
				else if (parent->_bf == -2 && cur->_bf == 1)
				{
					RotateLR(parent);
				}
				else if (parent->_bf == 2 && cur->_bf == -1)
				{
					RotateRL(parent);
				}
				else
				{
					assert(false);
				}
			}
			else
			{
				//当走到这里的时候就说明原本的树就有问题,直接报错
				assert(false);
			}

		}

		return true;
	}

	//右单旋
	void RotateR(Node* parent)
	{
		Node* SubL = parent->_left;
		Node* SubLR = SubL->_right;

		parent->_left = SubLR;
		//此时SubLR可能为空
		if (SubLR)
		{
			SubLR->_parent = parent;
		}

		Node* parentparent = parent->_parent;

		SubL->_right = parent;
		parent->_parent = SubL;

		if (parent == _root)
		{
			_root = SubL;
			SubL->_parent = nullptr;
		}
		else
		{
			if (parent == parentparent->_left)
			{
				parentparent->_left = SubL;
				SubL->_parent = parentparent;
			}
			else
			{
				parentparent->_right = SubL;
				SubL->_parent = parentparent;
			}
		}
		parent->_bf = SubL->_bf = 0;
	}

	void RotateL(Node* parent)
	{
		Node* SubR = parent->_right;
		Node* SubRL = SubR->_left;

		parent->_right = SubRL;
		if (SubRL)
		{
			SubRL->_parent = parent;
		}

		Node* parentparent = parent->_parent;

		SubR->_left = parent;
		parent->_parent = SubR;

		if (parent == _root)
		{
			_root = SubR;
			SubR->_parent = nullptr;
		}
		else
		{
			if (parent == parentparent->_left)
			{
				parentparent->_left = SubR;
			}
			else
			{
				parentparent->_right = SubR;
			}
			SubR->_parent = parentparent;
		}
		SubRL->_bf = SubR->_bf = 0;

	}

	void RotateLR(Node* parent)
	{
		Node* Subl = parent->_left;
		Node* SubLR = Subl->_right;
		int bf = SubLR->_bf;

		RotateL(parent->_left);
		RotateR(parent);

		if (bf == -1)
		{
			parent->_bf = 1;
			Subl->_bf = 0;
			SubLR->_bf = 0;
		}
		else if (bf == 1)
		{
			parent->_bf = 0;
			Subl->_bf = -1;
			SubLR->_bf = 0
		}
		else if (bf == 0)
		{
			parent->_bf = Subl->_bf = SubLR->_bf = 0;
		}
		else
		{
			assert(false);
		}
	}

	void RotateRL(Node* parent)
	{
		Node* SubR = parent->_right;
		Node* SubRL = SubR->_left;
		int bf = SubRL->_bf;

		RotateR(parent->_right);
		RotateL(parent);

		if (bf == 1)
		{
			parent->_bf = -1;
			SubR->_bf = 0;
			SubRL->_bf = 0;
		}
		else if (bf == -1)
		{
			parent->_bf = 0;
			SubR->_bf = 1;
			SubRL->_bf = 0;
		}
		else if (bf == 0)
		{
			parent->_bf = SubR->_bf = SubRL->_bf = 0;
		}
		else
		{
			assert(false);
		}
	}

private:
	Node* _root;
};
qr2001
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
珂朵莉树详解
Suryxin's blogs
02-23 8245
珂朵莉树的起源？ 珂朵莉树原名老司机树(Old Driver Tree，ODT)，由2017年一场CF比赛中提出的数据结构，因为题目背景主角是《末日时在做什么？有没有空？可以来拯救吗？》的主角珂朵莉，因此该数据结构被称为珂朵莉树。 什么是珂朵莉树？ 珂朵莉树是一种以近乎暴力的形式存储区间信息的一个数据结构。方式是通过set存放若干个用结构体表示的区间，每个区间的元素都是相同的。 珂朵莉树的用途？ 只要是涉及到区间赋值操作的题，就可以用珂朵莉树处理几乎任何关于区间信息的询问 什么情况下可以用珂朵莉树而不被卡？
决策树的Python实现
西瓜的博客
07-23 8151
本文摘要：决策树的概述，决策树相关概念以及公式，构建决策树的三种算法：ID3、C4.5、CART，用Python实现ID3算法，用sklearn实现决策树
决策树 代码实现
编码时光
01-02 2836
文章目录决策树的简单实现SKLearn 中的决策树树模型参数:代码信息熵二分类问题使用信息熵寻找最优划分使用基尼系数划分CART 和 决策树的超参数max_depthmin_samples_splitmin_samples_leafmax_leaf_nodes决策树解决回归问题Decision Tree Regressorcalifornia_housing 做决策树可视化 graphviz & pydotplus调整树模型参数 决策树的简单实现 import numpy as np import
线段树详解
orz
05-20 9926
1. 什么是线段树 顾名思义 ， 线段树是一棵二叉树 ， 但不同的是这棵树的结点储存的值是一个数列中 [l,r][l,r][l,r] 的某个需要的值 （例如，求和，求最大值，求最小值） 这是一棵典型的线段树 ，其性质是 ： 若其中一子节点编号为 aaa ， 则该节点左儿子编号为 2a2a2a ， 其右儿子编号为 2a+12a+12a+1 2. 线段树的用处 线段树的用处就是，对编号连续的一些点进行修改或者统计操作，修改和统计的复杂度都是 O(log2n)O(log_2 n)O(log2​n). 3.
线段树从零开始
热门推荐
岩之痕
08-22 5万+
从零开始讲线段树，适合有一定C/C++编程基础，想学习线段树的读者。
大家的人工智能——决策树
LXYTSOS的专栏
06-30 5839
在Logistic回归中，我们接触到了分类任务，今天我们将要介绍的是决策树，它是一种用于分类与回归的算法，这里主要讨论用于分类的决策树。 决策树初探 从名字中就不难猜出决策树模型是呈树形结构，在分类问题中，基于特征对实例进行分类，我们可以想象有一系列的if-else规则集合，通过判断特征是否符合这些规则来对实例进行分类。 决策树结构 决策树是一种对实例进行分类的树形结构，它由结点和有向边组成。而结...
树的应用
sf9090的博客
01-06 1万+
最小生成树 生成树连通图包含全部顶点的一个极小连通子图 对于带权无向连通图G= (V，E)，G的所有生成树当中边的权值之和最小的生成树为G的最小生成树(MST). 性质 1）最小生成树不一定唯一，即最小生成树的树形不一定唯一。当带权无 向连通图G的各边权值不等时或G只有结点数减1条边时，MST唯一。 2）最小生成树的权值是唯一的，且是最小。 3）最小生成树的边数为顶点数减1 IGENRIC_MST《G)[ T=NULL; while T未形成一棵生戍树: do 找到一条最小代价边(u，v)并且
决策树的分类准则
qq_21176497的博客
09-12 2664
决策树的分裂准则 ID3决策树——以信息增益为准则来选择划分属性的决策树 Gain(D,a)=Ent(D)−∑v=1V∣Dv∣∣D∣Ent(Dv)=Ent(D)−H(D∣a)\begin{aligned}Gain(D,a)&=Ent(D)-\sum^V_{v=1}{|D^v|\over{|D|}}Ent(D^v)\\&=Ent(D)-H(D|a)\end{aligned}Gain(D,a)​=Ent(D)−v=1∑V​∣D∣∣Dv∣​Ent(Dv)=Ent(D)−H(D∣a)​ 选择信息
决策树的完整实现
gjy_hahaha的博客
10-23 3144
文章目录决策树决策树的构造信息增益划分数据集递归构建决策树 决策树 决策树(Decision Tree)是在已知各种情况发生概率的基础上，通过构成决策树来求取净现值的期望值大于等于零的概率，评价项目风险，判断其可行性的决策分析方法，是直观运用概率分析的一种图解法。决策树是一种树形结构，其中每个内部节点表示一个属性上的测试，每个分支代表一个测试输出，每个叶节点代表一种类别。 机器学习中，决策树是一个预测模型;他代表的是对象属性与对象值之间的一种映射关系。树中每个节点表示某个对象，而每个分叉路径则代表的某个可能
圆方树
Hellsegamosken
05-14 2449
神奇的建树方法。 对每个点双新建一个方点，把这个点双里原来的边去掉，并把每个点连向这个方点。这样原图就是一棵树，而且这棵树有一些优美的性质： 1.原图的割点就是圆方树中度数大于 111 的圆点。 2.树上任意一条路径上圆点方点间隔分布。 3.如果圆点的 sizesizesize 为 111 ，那么一个圆点子树的 sizesizesize 和就是它“下面”的所有点的数量（用心灵去感受）。 ...
线段树（模板+例题——郭神）
02-17
因此，线段树的深度为log₂(b - a + 1) + 1（向上取整）。 2. **节点数量**：叶子节点的数量与根节点表示区间的长度相同；线段树中的节点要么是叶子节点，要么有两个子节点。因此，如果叶子节点数目为N，则线段树...
s905L使用的dtb和安卓切换工具.zip
02-14
此工具的V1.0版本可能包含基本的功能，如刷入新的系统映像、备份当前系统、恢复系统等。用户应该谨慎操作，确保遵循正确的步骤，以免损坏设备。 压缩包中的“关于安卓切换工具.txt”很可能是提供工具使用指南的文档...
树链剖分模板题
05-19
void update(int k,int l,int r,int P,int V){ if(l==r){ Max[k]=Sum[k]=V; return; } int mid=(l+r)>>1; if(P)update(k*2,l,mid,P,V); else update(k*2+1,mid+1,r,P,V); Max[k]=max(Max[k*2],Max[k*2+1])...
AVL_tree.zip_avl_遍历avl树
09-19
AVL树是一种自平衡二叉查找树（Binary Search Tree, BST），由Georgy Adelson-Velsky和Emanuel Landis在1962年提出，因此得名AVL树，其中A、V、L分别代表三位发明者的首字母。AVL树的主要特点是任何节点的两个子树的...
树形动态规划详细讲解
01-19
大学内部有一套员工层级结构，即员工之间的上下级关系构成了一棵树，树的根节点是校长V.E.Tretyakov。为了让派对更有趣，校长决定不让任何员工与其直接上司同时参加。人事部门已经为每位员工评定了一个快乐指数...
[知识点]-[最短路]
m0_52398496的博客
07-31 457
【代码】[知识点]-[最短路]
C++初学者指南-5.标准库(第二部分)--更改元素算法
最新发布
silencestarsky的博客
08-03 474
本文介绍了C++标准库中的元素更改算法，包括如何使用fill、generate、transform等函数来填充、生成和替换元素。这些算法有助于简单且高效地处理容器中的数据，同时提供了示例代码以辅助学习。
「数组」Knuth洗牌算法|C++random库简单介绍 / LeetCode 384（C++）
dakingffo的博客
08-03 213
Knuth算法可以公平地对数组进行随机排序。
VRF 算法流程及代码实现
smilejiasmile的博客
08-03 69
Verifiable Random Functions (VRFs) 是一种密码学原语，能够为给定输入生成一个随机输出，并提供一个可以验证的证明，证明输出是由特定输入生成的。VRFs 具有许多应用，包括区块链、分布式系统和安全协议。使用secp256k1曲线可以产生确定性签名，适用于 VRF 实现。通过使用 HMAC-SHA256 生成确定性随机数k，可以确保签名过程对相同的输入始终产生相同的结果，从而满足 VRF 的要求。
线段树详解：动态维护区间最大值
1. Update(x, v)：将数组A中的第x个元素更新为v。 2. Query(L, R)：计算数组A中从下标L到R（包含L和R）这段区间的最大值。 线段树的结构设计如下： - 区间：定义为一对整数a和b，表示一个前闭后开的区间[a, b)。 -...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值