C++ AVL树

最新推荐文章于 2025-12-03 16:18:05 发布
原创 最新推荐文章于 2025-12-03 16:18:05 发布 · 644 阅读 · 23 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#数据结构

本文详细阐述了AVL树的概念，强调了其通过维持节点左右子树高度差不超过1来保持高效搜索。文章介绍了AVL树的插入过程，包括遵循二叉搜索树规则插入新节点并调整平衡因子，以及删除节点后的平衡因子更新和可能的旋转操作。

1.概念

二叉搜索树虽可以缩短查找的效率，但如果数据有序或接近有序二叉搜索树将退化为单支树，查找元素相当于在顺序表中搜索元素，效率低下。

因此，两位俄罗斯的数学家G.M.Adelson-Velskii 和E.M.Landis在1962年发明了一种解决上述问题的方法：

当向二叉搜索树中插入新结点后，如果能保证每个结点的左右子树高度之差的绝对值不超过1(需要对树中的结点进行调整)，即可降低树的高度，从而减少平均搜索长度。

左右子树高度之差(简称平衡因子)的绝对值不超过1(-1/0/1)，如下图：

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

2.AVL树的插入

AVL树就是在二叉搜索树的基础上引入了平衡因子，因此AVL树也可以看成是二叉搜索树。

平衡因子（_bf）就是该节点右子树高度减去左子树高度

那么 AVL树的插入过程可以分为两步：

1. 按照二叉搜索树的方式插入新节点

2. 调整节点的平衡因子

调整节点的平衡因子

一个合格的AVL树在插入之前，就应该满足AVL树的条件，插入节点的父亲节点的平衡因子只有三种可能（-1，0，1）

插入分以下几种情况：

第一种和第四种插入后子树的高度没有变化，所以上面的节点的平衡因子都不会变，平衡因子的更新可以结束了

第二种和第三种插入后子树的高度发生变化，所以上面的节点的平衡因子要变，要继续更新平衡因子

继续更新后如果有一个节点的平衡因子不再是（-1，0，1）也就是变成2或者-2，就要进行处理

平衡因子变成2或者-2的节点的子树，对于这个子树，一定是高的那个子树插入一个节点，导致在原先就高的那一边的子树，更加高了

我们可以分成以下几种情况继续分析

2 1树（左旋）

平衡因子不合格的本质是树的高度差太大，所以需要降高度。

对8左旋：

-2 -1树(右旋)

对8右旋：

-2 1树(左右旋)

先对8左旋再对10右旋：

这里加在b，也可以加在c，还有可能9就是新增节点，但是中间旋转的过程都是不变的，改变的只有平衡因子，但顶部的平衡因子一定为0。

2 -1 树(右左旋)

先对10右旋再对8左旋：

和上面一样，这里加在c，也可以加在b，还有可能9就是新增节点，但是中间旋转的过程都是不变的，改变的只有平衡因子，但顶部的平衡因子一定为0。

3.AVL树的删除

删除我熬了一个通宵搞明白的，不容易啊

3.1.删除节点

先考虑一下，删除有哪些情况：

1.删除的节点左右都为空，删除的就是叶子节点

2.删除的节点左右一边为空，只有以下两种情况，因为这是AVL树，所有节点的平衡因子只能是（-1，0，1）

现在已知一边为空，所以平衡因子=另一边子树的高度，所以只能有一个节点

3.删除的节点的左右都都不为空，这种情况，和搜索二叉树的找月嫂思想是一样的

这三种情况的解决方式有异曲同工之处

情况1：删除叶子节点，如果他是父亲的左孩子，（bf）平衡因子++，反之--

情况2：可以把被删除的节点存储的值和他的唯一的孩子交换，然后删除他的孩子，问题转换成情况1

情况3：找到左子树的最大值节点，与其交换一下存储的内容，问题转换成删除那个左子树最大的节点，这个节点，又符合左为空的情况，如果右也为空就是情况1，反之情况2

删除节点最后都会转为删除叶子节点

3.2.平衡因子更新

节点删除了，被删除节点的父亲节点的平衡因子也更新了，但是是否需要继续更新，当前位置是否平衡都需要考虑

平衡因子的正常范围是[-1,1]

被删除节点的父亲节点平衡因子可以分为以下三种情况：

1.bf == 0 

说明原先该节点的bf == -1 或者 1 变成 0 后  说明原先高的那一边被删除了，导致高的子树高度降低，变得和另一边一样高，整颗树树的高度发生了变化，需要继续更新

2.bf == 1 或者 -1

说明原先该节点的bf == 0 0 变成 1 后 说明原先平衡，删除了一边，导致一边子树的高度变低了，但整颗树的高度没有变化，不需要更新

3. bf == 2 或者 bf == -2

这颗子树不平衡了，需要处理

3.3.旋转

不平衡分成两种大情况：

1.由于删除节点，导致当前子树不平衡

2.由于删除节点后导致平衡因子更新，而导致树不平衡

在更新平衡因子过程中，cur的bf一定是变成0，才会进一步，导致parent变化

在这个过程中，parent的bf变成2或者-2，是判断是否需要旋转的条件

而具体该怎么旋转，就由叔叔决定，因为cur的bf一定是0。和上面插入的旋转道理是一样的，也是这四种旋转。

这里右六种情况：

因为parent的bf可以是-2或者2，uncle的bf可以是-1，0，1

parent->bfuncle->bf旋转方式
21左旋
20左旋
2-1右左双旋
-21右旋
-20右旋
-2-1左右双旋

在旋转之后还需要更新cur和parent，因为还有继续更新平衡因子的需要

4.源代码

#pragma once
#include<assert.h>

template<class K, class V>
struct AVLtreeNode
{
	AVLtreeNode* _left;
	AVLtreeNode* _right;
	AVLtreeNode* _parent;
	pair<K, V> _kv;
	int _bf;

	AVLtreeNode(const K& key, const V& val)
		:_left(nullptr),
		_right(nullptr),
		_parent(nullptr),
		_kv(key, val),
		_bf(0)
	{}
};

template<class K, class V>
class AVLtree
{
public:
	typedef AVLtreeNode<K, V> Node;
	typedef pair<K, V> value_type;
	AVLtree() :_root(nullptr){}

	bool insert(const value_type& val)
	{
		if (_root == nullptr)
		{
			_root = new Node(val.first, val.second);
			return true;
		}
		// 找插入位置
		Node* parent = nullptr;
		Node* cur = _root;
		while (cur)
		{
			parent = cur;
			if (cur->_kv.first > val.first)
				cur = cur->_left;
			else if (cur->_kv.first < val.first)
				cur = cur->_right;
			else
				return false;
		}
		// 插入
		if (parent->_kv.first > val.first)
		{
			parent->_left = new Node(val.first, val.second);
			cur = parent->_left;
			cur->_parent = parent;
		}
		else
		{
			parent->_right = new Node(val.first, val.second);
			cur = parent->_right;
			cur->_parent = parent;
		}
		// 更新_bf平衡因子
		while (parent)
		{
			if (cur == parent->_left)
				parent->_bf--;
			else
				parent->_bf++;

			if (parent->_bf == -1 || parent->_bf == 1)
			{
				//继续更新
				cur = parent;
				parent = parent->_parent;
			}
			else if (parent->_bf == 0)
			{
				//无需继续更新
				break;
			}
			else if (parent->_bf == -2 || parent->_bf == 2)
			{
				//不平衡，要旋转
				if (parent->_bf > 0 && cur->_bf > 0)
					RotateL(parent);
				else if (parent->_bf < 0 && cur->_bf < 0)
					RotateR(parent);
				else if (parent->_bf > 0 && cur->_bf < 0)
					RotateRL(parent);
				else
					RotateLR(parent);
				
				break;
			}
			else
			{
				assert(false);
			}
		}
		return true;
	}

	bool erase(const K& key)
	{
		if (_root == nullptr)
		{
			return false;
		}
		
		//找key
		Node* cur = _root;
		while(cur)
		{
			if (cur->_kv.first > key)
			{
				cur = cur->_left;
			}
			else if (cur->_kv.first < key)
			{
				cur = cur->_right;
			}
			else//找到了
			{
				if (cur->_left == nullptr && cur->_right == nullptr)//删除的节点是叶子节点
				{
					cur = DeleteNode(cur);
				}
				else if (cur->_left == nullptr)
				{
					Node* del = cur->_right;
					cur->_kv = del->_kv;
					cur = DeleteNode(del);
				}
				else if (cur->_right == nullptr)
				{
					Node* del = cur->_left;
					cur->_kv = del->_kv;
					cur = DeleteNode(del);
				}
				else
				{
					//找左子树的最大节点
					Node* leftmax = cur->_left;
					while (leftmax->_right)
						leftmax = leftmax->_right;

					cur->_kv = leftmax->_kv;

					//是否需要托孤
					if(leftmax->_left)
					{
						Node* del = leftmax->_left;
						leftmax->_kv = del->_kv;
						cur = DeleteNode(del);
					}
					else
					{
						Node* del = leftmax;
						cur = DeleteNode(del);
					}
				}
				if (cur == nullptr)//根节点被删除
					return true;
				if (cur->_bf == 2 || cur->_bf == -2)//删除那个节点导致不平衡
				{
					Node* parent = cur;
					cur = nullptr;
					Rotate_delete_check(parent, cur);
				}
				
				//更新平衡因子
				Node* parent = cur->_parent;
				while (parent && cur->_bf == 0)//cur的平衡因子是0才需要更新
				{
					if (parent->_left == cur)
						parent->_bf++;
					else
						parent->_bf--;

					if (parent->_bf == -1 || parent->_bf == 1)
					{
						//无需继续更新
						break;
					}
					else if (parent->_bf == 0)
					{
						//继续更新
						cur = parent;
						parent = parent->_parent;
					}
					else if (parent->_bf == -2 || parent->_bf == 2)
					{
						cout << "//////////////////////////////" << endl;
						Rotate_delete_check(parent, cur);
					}
				}
				return true;
			}
		}
		return false;
	}

	bool check_balance()
	{
		return _check_balance(_root);
	}

	void InOrder()
	{
		_InOrder(_root);
		cout << endl;
	}

private:

	Node* DeleteNode(Node* cur)//删除叶子节点，并且返回其父亲
	{
		Node* del = cur;
		Node* parent = cur->_parent;
		if (parent == nullptr)//cur是根节点
		{
			_root = nullptr;
			delete del;
			return nullptr;
		}
		if (parent->_left == del)
		{
			parent->_left = nullptr;
			parent->_bf++;
		}
		else
		{
			parent->_right = nullptr;
			parent->_bf--;
		}
		delete del;
		return parent;
	}

	void Rotate_delete_check(Node*& parent, Node*& cur)
	{
		Node* uncle;
		if (parent->_left == cur)
			uncle = parent->_right;
		else
			uncle = parent->_left;

		if (parent->_bf == 2 && uncle->_bf == 1)
		{
			RotateL(parent);
			cur = uncle;
		}
		else if (parent->_bf == -2 && uncle->_bf == -1)
		{
			RotateR(parent);
			cur = uncle;
		}
		else if (parent->_bf == 2 && uncle->_bf == -1)
		{
			cur = uncle->_left;
			RotateRL(parent);
		}
		else if (parent->_bf == -2 && uncle->_bf == 1)
		{
			cur = uncle->_right;
			RotateLR(parent);
		}
		else if (parent->_bf == 2 && uncle->_bf == 0)
		{
			RotateL(parent);
			parent->_bf = 1;
			uncle->_bf = -1;
			cur = uncle;
		}
		else if (parent->_bf == -2 && uncle->_bf == 0)
		{
			RotateR(parent);
			parent->_bf = -1;
			uncle->_bf = 1;
			cur = uncle;
		}
		else assert(false);
		parent = cur->_parent;
	}

	void balence_check(Node* parent, Node* cur)
	{
		if (parent == nullptr)
			return;
		if (parent->_bf == 0)
		{
			//无需继续更新
		}
		else if (parent->_bf == -2 || parent->_bf == 2)
		{
			//不平衡，要旋转
			if (parent->_bf > 0 && cur->_bf > 0)
				RotateL(parent);
			else if (parent->_bf < 0 && cur->_bf < 0)
				RotateR(parent);
			else if (parent->_bf > 0 && cur->_bf < 0)
				RotateRL(parent);
			else
				RotateLR(parent);
		}
	}

	void _InOrder(Node* root)
	{
		if (root == nullptr)
			return;
		_InOrder(root->_left);
		cout << root->_kv.first << " ";
		_InOrder(root->_right);
	}

	bool _check_balance(Node* root)
	{
		if (root == nullptr)
			return true;

		int lefthight = TreeHight(root->_left);
		int righthight = TreeHight(root->_right);
		if (abs(lefthight - righthight) >= 2 || righthight - lefthight != root->_bf)
		{
			cout << root->_kv.first << ":" << root->_bf << endl;
			return false;
		}
		return _check_balance(root->_left) && _check_balance(root->_right);
	}

	int TreeHight(Node* root)
	{
		if (root == nullptr)
			return 0;

		int lefthight = TreeHight(root->_left);
		int righthight = TreeHight(root->_right);
		return lefthight > righthight ? lefthight + 1: righthight + 1;
	}


	void RotateL(Node* parent)//左单旋
	{
		Node* Rightson = parent->_right;

		//旋转节点之间的链接
		parent->_right = Rightson->_left;
		if (parent->_right)
			parent->_right->_parent = parent;
		Rightson->_left = parent;
		Node* pparent = parent->_parent;
		parent->_parent = Rightson;
		
		//更新祖先的链接
		if (pparent == nullptr)
		{
			Rightson->_parent = nullptr;
			_root = Rightson;
		}
		else
		{
			if (pparent->_kv.first > Rightson->_kv.first)
				pparent->_left = Rightson;
			else
				pparent->_right = Rightson;
			Rightson->_parent = pparent;
		}
		parent->_bf = Rightson->_bf = 0;
	}

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

		//旋转节点之间的链接
		parent->_left = Leftson->_right;
		if (parent->_left)
			parent->_left->_parent = parent;
		Leftson->_right = parent;
		Node* pparent = parent->_parent;
		parent->_parent = Leftson;

		//更新祖先的链接
		if (pparent == nullptr)
		{
			Leftson->_parent = nullptr;
			_root = Leftson;
		}
		else
		{
			if (pparent->_kv.first > Leftson->_kv.first)
				pparent->_left = Leftson;
			else
				pparent->_right = Leftson;
			Leftson->_parent = pparent;
		}
		parent->_bf = Leftson->_bf = 0;
	}

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

		RotateL(Leftson);
		RotateR(parent);

		//平衡因子更新
		if (bf == 1)
		{
			Leftson->_bf = -1;
		}
		else if (bf == -1)
		{
			parent->_bf = 1;
		}
		else if (bf == 0) {}
		else
		{
			assert(false);
		}
	}

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

		RotateR(Rightson);
		RotateL(parent);

		//平衡因子更新
		if (bf == 1)
		{
			parent->_bf = -1;
		}
		else if (bf == -1)
		{
			Rightson->_bf = 1;
		}
		else if(bf == 0){}
		else
		{
			assert(false);
		}
	}

private:
	Node* _root;
};

写完了。

c++ AVL树 插入 删除
CoderZhuuu
04-14 1325
AVL树的插入很简单，根据BST树的特性插入之后在回溯的过程中调整即可 AVL树的删除也不是很难，一共有三种情况 第一种是左子树为空（右子树为不为空无所谓） 第二种是右子树为空（此时左子树不为空） 这两种直接用另一半子树覆盖当前节点然后删除再回溯调整树即可 第三种是左右子数都不为空 这个情况首先找到要删除的节点，然后找到比该节点大的节点中最小的一个节点（右子树中最左边的节点），或者比该...
C++AVL树
qq_74319491的博客
10-09 1302
介绍了AVL树的概念和详细的具体实现
C++ AVL树(四种旋转,插入)
Wzs040810的博客
12-20 3437
C++ AVL树(四种旋转,插入)
C++ AVL树(详解 完整代码)
SikJ_2020_10_24的博客
03-07 845
{}// 该节点的左孩子// 该节点的右孩子// 该节点的双亲T _data;int _bf;// 该节点的平衡因子。
精选资源
基于C++ AVL树的航空客运订票系统【100012693】
06-12
《基于C++ AVL树的航空客运订票系统详解》 航空客运订票系统是现代航空公司运营中的关键组成部分，它能够高效地处理航班信息、预订和退票等业务。本项目以C++编程语言为基础，利用AVL树这一自平衡二叉搜索树的数据...
c++AVL树四种旋转的详细图解
10-28
在计算机科学中，AVL树是一种自平衡二叉搜索树，它在插入、删除和查找操作中维持树的平衡，以确保最坏情况下这些操作的时间复杂度始终为O(log n)，其中n是树中元素的数量。AVL树的平衡通过一系列旋转操作来实现，...
C++ AVL树的实现
07-10
在C++中实现AVL树，通常会涉及以下几个关键部分： 1. **基础结构**：首先，我们需要定义一个表示AVL树节点的结构体或类，它至少包含三个成员：键（key）、高度（height）以及指向左子树和右子树的指针。例如： ```...
数据结构：栈
最新发布
2401_86982201的博客
12-03 952
本文介绍了栈的基本概念、结构及实现方法。栈是一种后进先出（LIFO）的线性数据结构，支持入栈、出栈等基本操作。文章详细讲解了使用数组实现栈的具体代码，包括初始化、销毁、扩容、入栈、出栈、获取栈顶元素等核心功能。通过顺序表结构实现栈操作，保证了O(1)的时间复杂度。文中还提供了测试代码示例，并展示了力扣"有效的括号"问题的栈解法，验证了栈在实际算法问题中的应用价值。最后提到后续将讲解队列相关知识。
算法基础篇：（二十一）数据结构之单调栈：从原理到实战，玩转高效解题
2301_79248256的博客
11-29 1573
本文深入解析了单调栈这一高效数据结构。首先介绍了单调栈的基本概念，即在普通栈的基础上增加元素单调性约束，可分为递增栈和递减栈。接着详细讲解了四种核心应用场景：寻找左右侧最近更大/更小元素，并提供了对应的C++代码实现。通过洛谷P5788等模板题和发射站、柱状图最大矩形等实战案例，展示了单调栈如何将O(n²)问题优化为O(n)解法。最后总结了单调性选择、遍历方向等核心技巧，并给出避免数据溢出、优化IO等实用建议。掌握单调栈能有效解决"找最近最值"类问题，是算法竞赛和面试中的重要工具。
Redis底层数据结构 -- ziplist, quicklist, skiplist
人工智能专业学生
11-29 3016
Redis底层数据结构学习笔记总结了ziplist、quicklist和skiplist三种核心结构。ziplist是紧凑型线性存储，用于小型List/Hash/ZSet，内存占用小但修改效率低；quicklist结合链表和ziplist，优化List结构的插入删除性能；skiplist作为ZSet底层，实现O(logN)的查找和范围查询。三种结构各有特点：ziplist空间最优但修改慢，quicklist折中平衡，skiplist查询高效但内存略大。这些设计体现了Redis在内存优化和查询性能间的权衡。
数据结构-模拟实现顺序表和链表
2301_81261819的博客
12-03 271
本文介绍了Java中顺序表(ArrayList)和链表(LinkedList)的实现与应用。首先展示了基于ArrayList实现的洗牌和发牌操作，包括创建牌组、洗牌算法及发牌过程。其次详细讲解了数组模拟ArrayList的实现，包含扩容、插入、删除等核心操作。然后阐述了链表结构的特点，分别模拟实现了单向链表和双向链表，实现了头插尾插、按位置/值删除等功能。最后对比了ArrayList和LinkedList在存储结构、访问效率、插入性能等方面的差异：ArrayList物理连续存储，支持O(1)随机访问但插入效
数据结构 带头节点的双向循环链表
似流水般平静而坚定。
12-01 281
本文实现了一个带头节点的双向循环链表，包含初始化、插入、删除等基本操作。链表节点包含数据域和前后指针，链表结构体维护头节点和当前大小。主要功能包括：1）初始化链表；2）在指定节点前插入元素；3）打印链表；4）删除指定节点；5）头删/尾删；6）头插/尾插。每个操作都处理了指针调整和内存管理，并维护链表大小。代码使用断言检查参数有效性，确保操作安全。这种实现方式适用于需要频繁在头部/尾部操作的场景，循环特性简化了边界条件处理。
数据结构核心内容
2501_90980137的博客
12-03 510
◦ 线性结构：元素间呈一对一关系，包括数组（固定大小、随机访问快）、链表（动态大小、插入删除快）、栈（先进后出，栈顶操作）、队列（先进先出，首尾操作）、哈希表（键值映射，平均O(1)查询）。◦ 排序核心：冒泡排序（O(n²)，稳定）、快速排序（O(nlogn)，不稳定，分治思想）、归并排序（O(nlogn)，稳定，分治+合并）、堆排序（O(nlogn)，不稳定，利用堆特性）。◦ 基础操作：增（插入）、删（删除）、改（更新）、查（查找）、排序（调整元素顺序）。
嵌入式第二十三篇——数据结构基本概念
2303_78799336的博客
11-30 944
数据结构是计算机存储和组织数据的方式，包括线性结构（数组、链表、栈、队列）和非线性结构（树、图）。基本操作有插入、删除、查找、遍历和排序。时间复杂度描述算法执行效率，常见类型有O(1)、O(logn)、O(n)、O(nlogn)、O(n²)等，计算时忽略低阶项和常数系数。时间复杂度与空间复杂度不同，前者关注时间增长趋势，后者关注内存需求。常见时间复杂度按效率排序为O(1)最快，O(n!)和O(nⁿ)最慢。
【数据结构】AVL树详解：从原理到C++实现
2301_79389054的博客
11-29 1386
本文介绍了AVL树（平衡二叉搜索树）的基本概念和实现方法。AVL树通过平衡因子控制树高，保持左右子树高度差不超过1，确保查找效率为O(logN)。文章详细讲解了AVL树的节点定义、插入操作、四种旋转调整方法（左旋、右旋、左右双旋、右左双旋）以及验证方法。最后分析了AVL树的性能特点，指出其适合静态数据查询，但对频繁修改的数据结构效率较低。AVL树为后续红黑树等数据结构奠定了基础。
数据结构 不带头结点的链表
似流水般平静而坚定。
11-30 233
该代码实现了一个不带头结点的单链表数据结构，包含16个基本操作函数。主要功能包括：链表初始化、判空、按位置查找、尾插/头插/指定位置插入、尾删/头删/指定位置删除、按值查找和删除、链表清空销毁以及链表反转等。每个函数都包含参数合法性检查，通过指针操作实现节点增删改查，使用malloc/free进行内存管理。链表维护当前节点数(cursize)便于操作，反转链表采用迭代法实现。代码结构清晰，将声明与实现分离，适合作为基础链表操作的参考实现。
进阶数据结构应用-维护序列
Ayanami_Rei的博客
12-03 394
但是延迟标记是有更新顺序的, 可以做如下套路, 假设当前考虑的区间是。(2)再讨论, 父节点的乘法延迟标记下传, 假设是。(1)此时, 父节点加法延迟标记下传, 假设是。先做加法再做加法, 假设区间中某个数字是。此时, 父节点加法延迟标记下传, 假设是。因此对于延迟标记的更新, 我们认为的规定。具体的来说假设当前节点的加法延迟标记是。, 父节点向下传递的加法标记是。, 很难在原数字基础上加。, 得到下面的式子(除非。那么新的加法延迟标记是。, 新的乘法延迟标记是。线段树需要记录的属性。
数据结构 12 图
im_AMBER的博客
11-29 900
编程基础→数据结构u→v。
c++ avl树构建
09-09
AVL树是一种自平衡的二叉搜索树，用于高效地插入、删除和查询数据。构建AVL树的基本步骤如下： 1. 首先，创建一个空的AVL树。 2. 从根节点开始，插入第一个元素作为根节点。 3. 对每个新插入的节点，更新它的平衡因子（左子树高度减去右子树高度）。 4. 如果插入节点后导致不平衡，进行相应的旋转操作来重新平衡树。 - 左左情况：插入到左子树的左子树上，需要进行右旋转。 - 右右情况：插入到右子树的右子树上，需要进行左旋转。 - 左右情况：插入到左子树的右子树上，先进行左旋转，再进行右旋转。 - 右左情况：插入到右子树的左子树上，先进行右旋转，再进行左旋转。 5. 更新树中的每个节点的平衡因子。 6. 重复步骤3至5，直到所有元素都被插入并且树保持平衡。 注意：在插入和删除操作后，必要时需要对AVL树进行旋转以保持平衡。旋转操作可以通过调整节点之间的连接关系来完成，从而保持树的平衡性质。
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值