avl树自实现（带图），探讨平衡因子与旋转

news2024/9/23 13:29:54

引子：

在此之前，我们学过了搜索二叉树，这种树，在如果数据有序或接近有序的情况下，二叉搜索树将退化为单支树，查找元素相当于在顺序表中搜索元素，效率低下，而且普通搜索二叉树无法有重复的元素，对此，我们提出了平衡二叉树，avl树就是比较基础的，一种基于搜索二叉树的改进树，引入了平衡因子与旋转的概念！avl树是由两位俄罗斯的数学家G.M.Adelson-Velskii 和E.M.Landis在1962年 发明了一种方法。

什么是avl树？

AVL树是一种自平衡的二叉搜索树，它的名字来源于它的发明者Adelson-Velsky和Landis。AVL树的特点是任何节点的两个子树的高度（或深度）最大差异为1。这种平衡特性确保了树的查找、插入和删除操作都能在对数时间内完成，即时间复杂度为O(log n)。当向二叉搜索树中插入新结点后，如果能保证每个结点的左右 子树高度之差的绝对值不超过1(需要对树中的结点进行调整)，即可降低树的高度，从而减少平均 搜索长度。

一棵AVL树或者是空树，或者是具有以下性质的二叉搜索树：

1，它的左右子树都是AVL树 左右子树高度之差(简称平衡因子)的绝对值不超过1(-1/0/1)

2，如果一棵二叉搜索树是高度平衡的，它就是AVL树。如果它有n个结点，其高度可保持在O(log_2n)，搜索时间复杂度O(log_2n)。

avl树的实现

如何实现avl树呢，我们要从图入手，并一步一步实现avl树代码的实现！

我们可以先换一侧树的全部情况，先写出“一半代码”，然后仿照着写就可以了。

一，先试着画出一半的图，思考如何写？以下是一个示范图

图一：

图二：

图三：

二，导入库

#include<iostream>
#include<assert.h>
using namespace std;

三，创建节点

//创建节点
template<class K,class V>
class avlTreeNode
{
public:
	avlTreeNode* _left;//左节点
	avlTreeNode* _right;//右节点
	avlTreeNode* _parent;//上级节点
	int _bf;//平衡因子
	pair<K, V>_kv;//kv的值；

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

四，整体框架；

template<class K,class V>
class avlTree
{
	typedef avlTreeNode<K,V> Node;
public:
	//构造函数
	avlTree() = default;
	//拷贝构造函数,树形节点要一个一个拷贝
	avlTree(const avlTree<K, V>& h)
	{
		_root = copy(h._root);
	}

	//find K值
	Node* Find( const K& key)
	{
		Node* cur = _root;
		while (cur)
		{
			if (cur->_left->_kv.first < key)
			{
				cur = cur->_right;
			}
			else if (cur->_left->_kv.first > key)
			{
				cur = cur->_left;
			}
			else
			{
				return cur;
			}
		}

		return nullptr;
	}

	//find V值
	Node* Find(const V& key)
	{
		Node* cur = _root;
		while (cur)
		{
			if (cur->_left->_kv.second < key)
			{
				cur = cur->_right;
			}
			else if (cur->_left->_kv.second > key)
			{
				cur = cur->_left;
			}
			else
			{
				return cur;
			}
		}

		return nullptr;
	}

	//中序有序，避免了_root是内部private的加密
	void _InOrder()
	{
		_InOrder(_root);

		cout << endl;
	}

	//insert
	bool Insert(const pair<K, V>& kv)
	{
		if (_root == nullptr)
		{
			_root = new Node(kv);
			return true;
		}
		//要先找到，插入位置
		Node* parent = nullptr;
		Node* current = _root;
		while (current)
		{
			if (current->_kv.first < kv.first)
			{
				parent = current;
				current = current->_right;
			}
			else if (current->_kv.first > kv.first)
			{
				parent = current;
				current = current->_left;
			}
			else
			{
				return false;
			}
		}
		//新增节点再链接上去
		current = new Node(kv);
		if (kv.first > (parent->_kv.first))
		{
			parent->_right = current;
		}
		else if (kv.first < (parent->_kv.first))
		{
			parent->_left = current;
		}
		return true;
		current->_parent = parent;

		//更新平衡因子,新节点插入后，AVL树的平衡性可能会遭到破坏，此时就需要更新平衡因子，并检测是否
		//破坏了AVL树
		while (current)
		{
			//左插--，右插++
			if (current == parent->_left)
			{
				parent->_bf--;
			}
			else if (current == parent->_right)
			{
				parent->_bf++;
			}
			
			if (parent->_bf == 0)
			{
				//高度不变，达到最理想状态
				break;
			}
			else if (parent->_bf == -1 || parent->_bf == 1)
			{
				//向上更新
				current = parent;
				parent = parent->_parent;
			}
			else if(parent->_bf == 2 || parent->_bf == -2)//不平衡情况
			{
				if (parent->_bf == 2 && current->_bf == 1)//左旋
					RotateL(parent);
				else if (parent->_bf == -2 && current->_bf == -1)//右旋
					RotateR(parent);
				else if (parent->_bf == 2 && current->_bf ==-1)//左右旋
					RotateRL(parent);
				else  //(parent->_bf == -2 && current->_bf == 1)
					RotateLR(parent);
			}
			else
				assert(false);
		}
		return true;
	}

	//因为AVL树也是二叉搜索树，可按照二叉搜索树的方式将节点删除，然后再更新平衡因子，只不
	//错与删除不同的时，删除节点后的平衡因子更新，最差情况下一直要调整到根节点的位置。




	//重载=
	avlTree<K, V>& operator=(const avlTree<K, V>& h)
	{
		swap(_root, h._root);
		return *this;
	}
	//析构函数,注意开辟了空间后，对于树形结构的节点要一个一个删除
	~avlTree()
	{
		Destory(_root);
		_root = nullptr;
	}
	int Height()
	{
		return _Height(_root);
	}

	int Size()
	{
		return _Size(_root);
	}

五，private部分

private:
	//计算有效的节点
	int _Size(Node* root)
	{
		return root == nullptr ? 0 : _Size(root->_left) + _Size(root->_right) + 1;
	}

	//计算树的高度，利用递归
	int _Height(Node* root)
	{
		if (root == nullptr)
			return 0;

		int leftHeight = _Height(root->_left);
		int rightHeight = _Height(root->_right);

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

	//对它进行检验

	bool _IsBalanceTree(Node* root)
	{
		// 空树也是AVL树
		if (nullptr == root) 
			return true;
		//严格检验

		int TreeHeight_L = _Height(root->_left);
		int TreeHeight_R = _Height(root->_right);
		//我们默认的是右到左
		int diff = TreeHeight_R - TreeHeight_L;

		//高度与平衡因子的数值不匹配
		if (diff != root->_bf || (diff > 1 || diff < -1))
			return false;

		return _IsBalanceTree(root->_left) && _IsBalanceTree(root->_right);
	}

	//中序遍历
	void _InOrder(Node* root)
	{
		if (root == nullptr)
		{
			return;
		}
		//左根右；
		_InOrder(root->_left);
		cout << root->_kv.first << " :" << root->_kv.second << " ";
		_InOrder(root->_right);
	}

	void RotateL( Node* parent)
	{
		Node* subR = parent->_right;
		Node* subRL = subR->_left;

		parent->_right = subRL;
		if (subRL)
			subRL->_parent = parent;

		subR->_left = parent;
		parent->_parent = subR;

		Node* parent_parent = parent->_parent;
		if (parent_parent == nullptr)
		{
			_root = subR;
			parent_parent = nullptr;
		}
		else
		{
			if (parent_parent->_left == parent)
			{
				parent_parent->_left = subR;
			}
			else if (parent_parent->_right == parent)
			{
				parent_parent->_right = subR;
			}
			subR->_parent = parent_parent;
		}
		subR->_bf = parent->_bf = 0;
	}

	void RotateR( Node* parent)
	{
		Node* subL = parent->_left;
		Node* subLR = subL->_right;
		parent->_left = subLR;
		if (subLR)
			subLR->_parent = parent;

		subL->_right = parent;
		parent->_parent = subL;

		Node* parent_parent = parent->_parent;
		if (parent_parent == nullptr)
		{
			_root = subL;
			parent_parent = nullptr;
		}
		else
		{
			if (parent_parent->_left == parent)
			{
				parent_parent->_left = subL;
			}
			else if (parent_parent->_right == parent)
			{
				parent_parent->_right = subL;
			}
			subL->_parent = parent_parent;
		}
		subL->_bf = parent->_bf = 0;
	}

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

		RotateR(parent->_right);
		RotateL(parent);
		
		if (bf == 0)
		{
			subR->_bf = 0;
			subRL->_bf = 0;
			parent->_bf = 0;
		}
		else if (bf == 1)
		{
			subR->_bf = 0;
			subRL->_bf = 0;
			parent->_bf = -1;
		}
		else if (bf == -1)
		{
			subR->_bf = 1;
			subRL->_bf = 0;
			parent->_bf = 0;
		}
		else
		{
			assert(false);
		}
	}

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

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

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

    //销毁
	void Destory(Node* root)
	{
		if (root==nullptr)
		{
			return;
		}
		Destory(root->_left);
		Destory(root->_right);
		Destory(root->_parent);
		delete root;
	}

	//拷贝
	Node* copy(const Node*& root)
	{
		if (root == nullptr)
		{
			return nullptr;
		}
		Node* temp = new Node(root->_kv);
		temp->_left=copy(root->_left);
		temp->_right=copy(root->_right);
		temp->_parent=copy(root->_parent);
		return temp;
	}

	Node* _root = nullptr;
};

六：说明，对于erase部分先不做处理啦！

七，AVL树的性能 AVL树是一棵绝对平衡的二叉搜索树，其要求每个节点的左右子树高度差的绝对值都不超过1，这 样可以保证查询时高效的时间复杂度，即log_2 (N)。但是如果要对AVL树做一些结构修改的操 作，性能非常低下，比如：插入时要维护其绝对平衡，旋转的次数比较多，更差的是在删除时， 有可能一直要让旋转持续到根的位置。因此：如果需要一种查询高效且有序的数据结构，而且数 据的个数为静态的(即不会改变)，可以考虑AVL树，但一个结构经常修改，就不太适合。


ok，感谢大家的观看，有
问题可以发评论区（微笑！）

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1982155.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

计算机“八股文”在实际工作中是助力、阻力还是空谈？

计算机“八股文”在实际工作中是助力、阻力还是空谈？

“八股文”在实际工作中是助力、阻力还是空谈&#xff1f; 作为现在各类大中小企业面试程序员时的必问内容&#xff0c;“八股文”似乎是很重要的存在。但“八股文”是否能在实际工作中发挥它“敲门砖”应有的作用呢&#xff1f;有IT人士不禁发出疑问&#xff1a;程序员面试考…
阅读更多...
ReentrantLock的阻塞性、可中断性

ReentrantLock的阻塞性、可中断性

结论&#xff1a; lock() 如果没有获取到锁&#xff0c;会一直阻塞并尝试获取锁&#xff0c;直到获取到锁。lock() 获取到锁之前&#xff0c;其他线程不可以中断该线程。因为线程Thread如线程t2的interrupt方法&#xff0c;想要中断线程&#xff0c;但不会真的中断&#xff0c…
阅读更多...
如何把uniapp 项目发布成Andriod App的流程

如何把uniapp 项目发布成Andriod App的流程

1&#xff1a;点击HBuilderX 状态栏左侧的未登录按钮&#xff0c;弹出登录的对话框。 2: 在弹出的登录的对话框中, 填写账号和密码之后, 点击登录即可。 3&#xff1a; 打开项目根目录中的 mainfest.json 配置文件&#xff0c; 在基础配置的面板中&#xff0c; 获取uniapp 的应…
阅读更多...
Redis2-Redis常见命令

Redis2-Redis常见命令

目录 Redis数据结构介绍 Redis通用命令 KEYS DEL EXISTS EXPIRE String类型 Key的层级格式 Hash类型 List类型 Set类型 SortedSet类型 Redis数据结构介绍 Redis是一个key-value的数据库&#xff0c;key一般是String数据库&#xff0c;value的类型多种多样 可以通过…
阅读更多...
SQL回顾

SQL回顾

一、知识点回顾 1、数据库的分类。 ①关系型数据库。&#xff08;磁盘、持久化&#xff09; 例&#xff1a;MySQL&#xff08;搭配php、java&#xff09;。 ②非关系型数据库。&#xff08;暂存、存在内存中&#xff09; 例&#xff1a;sql server&#xff08;搭配.net&…
阅读更多...
四、图片生成视频

四、图片生成视频

具体步骤 1、安装插件(VideoHelperSuite) 2、创建工作流 2.1 双击搜索svd 2.2 添加节点 2.3 选择clip视觉长按拖住生成checkpoint加载器 2.4 选择vae对应连接 2.4 选择图像添加加载图像节点 2.4 选择正面条件 选择k采样器节点新增 2.5 进行节点间的连接&#xff08;模型 …
阅读更多...
基于开源FFmpeg和SDL2.0的音视频解码播放和存储系统的实现

基于开源FFmpeg和SDL2.0的音视频解码播放和存储系统的实现

目录 1、FFMPEG简介 2、SDL简介 3、视频播放器原理 4、FFMPEG多媒体编解码库 4.1、FFMPEG库 4.2、数据类型 4.3、解码 4.3.1、接口函数 4.3.2、解码流程 4.4、存储&#xff08;推送&#xff09; 4.4.1、接口函数 4.4.2、存储流程 5、SDL库介绍 5.1、数据结构 5.…
阅读更多...
西部菱斑响尾蛇教你基础IO

西部菱斑响尾蛇教你基础IO

快学&#xff0c;再不学普洱就要超过你们了 在C阶段进行的文件操作有哪些呢&#xff1f; #include<stdio.h> #include<string.h>int main() {FILE* fp fopen("myfile", "w");if (!fp){printf("fopen error!\n");}const char* msg …
阅读更多...
大模型系列：大模型tokenizer分词编码算法BPE理论简述和实践

大模型系列：大模型tokenizer分词编码算法BPE理论简述和实践

关键词&#xff1a;大语言模型&#xff0c;分词&#xff0c;BPE&#xff0c;BBPE 前言 token是大模型处理和生成语言文本的基本单位&#xff0c;在之前介绍的Bert和GPT-2中&#xff0c;都是简单地将中文文本切分为单个汉字字符作为token&#xff0c;而目前LLaMA&#xff0c;Cha…
阅读更多...
云原生高级必备基础

云原生高级必备基础

一.文件管理 相对路径和绝对路径 touch 创建文件 mkdir 创建目录 -p多级创建 rm 删除 -i 删除前逐一询问确认。 -f 即使原档案属性设为唯读&#xff0c;亦直接删除&#xff0c;无需逐一确认。 -r 将目录及以下之档案亦逐一删除。 cp 复制 -p -r mv 移动 cp和mv的区别 …
阅读更多...
8月4号分析：CSGO市场行情如何，给几个操作建议

8月4号分析：CSGO市场行情如何，给几个操作建议

很多粉丝让我聊聊对近期CSGO饰品市场的看法&#xff0c;那今天就简单聊聊&#xff01; 最近的CSGO市场&#xff0c;从在线人数就可以看出来&#xff0c;这段时间是实打实的流失了很多玩家&#xff0c;就目前这个情况&#xff0c;120万的在线人数里面&#xff0c;至少还有10多万…
阅读更多...
sql注入之无列名注入

sql注入之无列名注入

目录 一、基础知识 二、平替information_schema库 三、无列名注入 3.1 正常无列名查询&#xff1a; 3.2 子查询&#xff1a; 3.3 实战 一、基础知识 我们在注入的过程中很多时候利用的就是information_schema这个库获取 table_schema table_name, column_name这些数据库内…
阅读更多...
一键转换语言，五款强大文件翻译软件推荐！

一键转换语言，五款强大文件翻译软件推荐！

在当今的职场环境中&#xff0c;跨语言沟通已成为常态。无论是与国际客户洽谈业务&#xff0c;还是处理海外项目报告&#xff0c;精准高效的文件翻译能力都是每位职场人士的必备技能。今天&#xff0c;我们就来盘点几款职场人士必备的文件翻译工具。 福昕在线翻译&#xff1a;…
阅读更多...
PXE批量安装——————rhel7

PXE批量安装——————rhel7

实验前准备 什么是PXE&#xff1f; PXE是一种基于网络的启动技术&#xff0c;它集成了在计算机的BIOS或UEFI中&#xff0c;允许计算机从网络服务器下载并启动操作系统或其他软件。 应用场景 无盘工作站&#xff1a;在教育和科研机构中&#xff0c;无盘工作站通过PXE启动操作…
阅读更多...
字符串切割split

字符串切割split

let obj {} let str "aa占比:17.48%,aa计费占比:0.00%" let arr str.split(,) // [aa占比:17.48%,aa计费占比:0.00%] arr.forEach(item > { let [key,value] item.split(:) obj[key] value }) console.log(obj) //{aa占比: 17.48%, aa计费占比: 0.00%} con…
阅读更多...
Markdown文本编辑器:Typora for Mac/win 中文版

Markdown文本编辑器:Typora for Mac/win 中文版

Markdown 是一种轻量级的标记语言&#xff0c;它允许用户使用易读易写的纯文本格式编写文档。Typora 支持且仅支持 Markdown 语法的文本编辑&#xff0c;生成的文档后缀名为 .md。 这款软件的特点包括&#xff1a; 实时预览&#xff1a;Typora 的一个显著特点是实时预览&#x…
阅读更多...
lombok安装成功但是找不到方法

lombok安装成功但是找不到方法

2024.1.1版本的IDE的插件安装了默认的lombok&#xff08;如图1&#xff09;&#xff0c;pom文件中也引入了lombok的依赖&#xff0c;在实体类写了Data的注解&#xff0c;当调用实体类的get和set方法运行时&#xff0c;报错找不到相应的方法&#xff0c;但是在调用get、set方法的…
阅读更多...
Java实现全局异常统一处理

Java实现全局异常统一处理

Java实现全局异常统一处理 【一】介绍【二】为什么要使用全局异常处理【三】案例实现【1】GlobalException【2】GlobalExceptionHandler【3】使用 【一】介绍 全局异常处理器是一种在应用程序中几种处理异常的机制&#xff0c;它允许在应用程序的任何地方抛出异常时&#xff0…
阅读更多...
2024年6月scratch图形化编程等级考试一级真题

2024年6月scratch图形化编程等级考试一级真题

202406 scratch编程等级考试一级真题 选择题&#xff08;共25题&#xff0c;每题2分&#xff0c;共50分&#xff09; 1、音乐Video Game1的时长将近8秒&#xff0c;点击一次角色&#xff0c;下列哪个程序不能完整地播放音乐两次 A、 B、 C、 D、 答案&#xff1a;D 考点分…
阅读更多...
CasaOS系统小主机Docker部署memos结合内网穿透打造私有云笔记

CasaOS系统小主机Docker部署memos结合内网穿透打造私有云笔记

文章目录 前言1. 使用Docker部署memos2. 注册账号与简单操作演示3. 安装cpolar内网穿透4. 创建公网地址5. 创建固定公网地址 前言 本文主要介绍如何在CasaOS轻NAS系统设备中使用Docker本地部署开源云笔记服务memos&#xff0c;并结合cpolar内网穿透工具配置公网地址&#xff0…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023