AVL树（插入）

最新推荐文章于 2023-11-09 19:33:19 发布
最新推荐文章于 2023-11-09 19:33:19 发布
阅读量816 收藏 4
点赞数
文章标签： AVL树 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Enthusiastic_boy/article/details/125125854
版权

目录

AVL树的概念

AVL树节点的定义

AVL树的插入

AVL树的旋转

左单旋

右单旋

右左双旋

左右双旋

完整代码

AVL树的概念

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

AVL树节点的定义

AVL树的节点需要包含平衡因子_bf，以平衡因子的值来确定当前树是否需要调整。还需要_parent指针域，以方便在调整的过程中找到其双亲节点。定义如下： 
template <class T>
class AVLNode{
public:
	AVLNode(const T& val=T())
		:_parent(nullptr)
		,_right(nullptr)
		, _left(nullptr)
		, _val(val)
		,_bf(0)//平衡因子默认为0，因为刚插入时，没有左右子树
	{

	}
	~AVLNode(){
		Destroy(_root);
	}
	AVLNode<T>* _parent;//指向双亲
	AVLNode<T>* _left;//左指针域
	AVLNode<T>* _right;//右指针域
	T _val;//值域
	int _bf;//平衡因子
};

AVL树的插入

AVL树就是在二叉搜索树的基础上引入了平衡因子，因此AVL树也可以看成是二叉搜索树。那么AVL树的插入过程可以分为两步：
1. 按照二叉搜索树的方式插入新节点
2. 调整节点的平衡因子
代码如下： 
template <class T>
class AVLTree{
typedef AVLNode<T> Node;//重命名节点名
public:
	AVLTree()
		:_root(nullptr)
	{

	}
	bool Insert(T val){
		//按照二叉搜索树的方式插入新节点
		if (_root==nullptr){
			_root = new Node(val);
			return true;
		}
		Node* parent = nullptr;
		Node* cur = _root;
		while (cur){
			parent = cur;
			if (val>cur->_val){
				cur = cur->_right;
			}
			else if(val<cur->_val){
				cur = cur->_left;
			}
			else{
				return false;
			}
		}
		cur = new Node(val);
		cur->_parent = parent;
		if (parent->_val>cur->_val){
			parent->_left = cur;
		}
		else{
			parent->_right = cur;
		}
		//更新平衡因子
		while (parent){parent不空，往上更新
			if (parent->_left==cur){//一进入循环先更新平衡因子
				parent->_bf--;
			}
			else{
				parent->_bf++;
			}
			if (parent->_bf==0){//平衡因子为0，此时树一定平衡，跳出循环
				break;
			}
			else if (parent->_bf==1||parent->_bf==-1){//说明有一条路径中增加了一个节点，可能会违反AVL树的性质，需要向上不断更新
				cur = cur->_parent;
				parent = parent->_parent;
			}
			else{//AVL树的性质遭到破坏，进行调整
				if (parent->_bf==2){
					if (cur->_bf==1){//左单旋
						_RotateL(parent);
					}
					else{
						_RotateRL(parent);//右左双旋
					}
				}
				else{
					if (cur->_bf==-1){
						_RotateR(parent);
					}
					else{
						_RotateLR(parent);//左右双旋
					}
				}
				break;//调整完成后不会违反AVL树的性质了，直接跳出循环
			}
		}
	}
private:
	void Destroy(Node*& root){//销毁AVL树
		if (root==nullptr){
			return;
		}
		Destroy(root->_left);
		Destroy(root->_right);
		delete root;
		root = nullptr;
	}
	Node* _root;//底层维护_root指针
};

以上代码中_root为AVL树底层维护的指针，指向AVL树的根节点，对于插入节点我们并不陌生，在平衡因子为1或者-1时，需要向上调整平衡因子也非常好理解。而当平衡因子为-2或者2时候，就需要特殊处理了，而这种旋转是比较困难的，接下来进行详细讲解。

AVL树的旋转

左单旋

新插入的节点在parent较高右子树的右侧，那么就需要左单旋，具体示意图如下：

如上图，旋转之前此树是不平衡的，经过一次左旋之后，此二叉树就变得平衡了。在上图中，只体现了节点左右指针域的变化，并没有体现_parent指针域的变化，需要在代码中注意_parent指针域的变化，且parent还可能存在_parent节点，旋转后可能还需要改变其左或者右指针域的值。旋转后需要将parent节点的平衡因子以及subR节点的平衡因子修改为0，对应代码如下：

void _RotateL(Node* parent){//左单旋
		Node* pparent = parent->_parent;//记录上parent的双亲节点，可能存在，可能不存在
		Node* subR = parent->_right;//记录上parent的右孩子节点，一定存在
		Node* subRL = subR->_left;//记录上subRL的左孩子节点，可能存在，可能不存在
		parent->_right = subRL;//直接改变parent->_right指向，不用管subRL存不存在
		if (subRL){//如果subRL存在，则改变其_parent指针域的指向
			subRL->_parent = parent;
		}
		parent->_parent = subR;
		subR->_left = parent;
		subR->_parent = pparent;
		if (pparent==nullptr){//最后判断pparent是否为空，如果是，说明parent是根节点，就需要改变_root的指向了
			_root = subR;
		}
		else{//pparent存在，则令pprent的左或者右指向subR
			if (pparent->_left == parent){
				pparent->_left = subR;
			}
			else{
				pparent->_right = subR;
			}
		}
		parent->_bf = 0;//最后修改平衡因子
		subR->_bf = 0;
	}

右单旋

右单旋可以看作是左单旋的反情况，新插入的节点在parent较高左子树的左侧，那么就需要右单旋，具体示意图如下：

右单旋对比左单旋，只是旋转方向变反了，代码的实现形式类似，如下：

void _RotateR(Node* parent){//右单旋
		Node* pparent = parent->_parent;
		Node* subL = parent->_left;
		Node* subLR = subL->_right;
		parent->_left = subLR;
		if (subLR){
			subLR->_parent = parent;
		}
		parent->_parent = subL;
		subL->_right = parent;
		subL->_parent = pparent;
		if (pparent==nullptr){
			_root = subL;
		}
		else{
			if (pparent->_left==parent){
				pparent->_left = subL;
			}
			else{
				pparent->_right = subL;
			}
		}
		parent->_bf = 0;
		subL->_bf = 0;
	}

右左双旋

新插入的节点在parent较高右子树的左侧，那么就需要右左双旋了，而右左双旋后，修改平衡因子非常麻烦，需要分情况讨论：

1.parent的左子树为空，那么直接调用右单旋和左单旋即可，图示如下：

把3对应的节点作进行一次右单旋后，在把2对应的节点进行一次左单旋即可。

2. parent的左子树不空，新插入的节点在parent较高右子树的左侧的左侧，图示如下：

对 subR进行一次右单旋后，在对parent进行一次左单旋，旋转完成后，subR的平衡因子不对，需要单独修改为1。可以发现在旋转之前，subRL的平衡因子为-1，根据这一规律修改即可。

3.parent的左子树不空，新插入的节点在parent较高右子树的左侧的右侧，图示如下：

 对 subR进行一次右单旋后，在对parent进行一次左单旋，旋转完成后，parent的平衡因子不对，需要单独修改为-1。可以发现在旋转之前，subRL的平衡因子为1，根据这一规律修改即可。

代码如下：

void _RotateRL(Node* parent){//右左双旋
		Node* subR = parent->_right;//记录parent的_right
		Node* subRL = subR->_left;//记录subR的_left
		int bf = subRL->_bf;//记录subR的平衡因子，根据其值是-1还是1，进而在旋转完成后修改平衡因子
		_RotateR(subR);//对subR及以下部分进行右单旋
		_RotateL(parent);//对parent及以下部分进行左单旋
		if (bf==1){//根据bf的值，修改parent或者subR的平衡因子
			parent->_bf = -1;
		}
		else if (bf==-1){
			subR->_bf = 1;
		}
	}

左右双旋

左右双旋和右边双旋的实现方式类似，新插入的节点在parent较高左子树的右侧，需要进行右左双旋，分情况讨论如下：

1.parent的右子树为空，那么直接调用左单旋和右单旋即可，图示如下：

 把1对应的节点作进行一次左单旋后，在把3对应的节点进行一次右单旋即可。

2.parent的右子树不空，新插入的节点在parent较高左子树的右侧的右侧，图示如下： 

对subL进行一次左单旋后，在对parent进行一次右单旋，旋转完成后，subL的平衡因子不对，需要单独修改为-1。可以发现在旋转之前，subLR的平衡因子为1，根据这一规律修改即可。

3.parent的右子树不空，新插入的节点在parent较高左子树的右侧的左侧，图示如下： 

对subL进行一次左单旋后，在对parent进行一次右单旋，旋转完成后，parent的平衡因子不对，需要单独修改为1。可以发现在旋转之前，subLR的平衡因子为-1，根据这一规律修改即可。

代码如下：

void _RotateLR(Node* parent){//左右双旋
		Node* subL = parent->_left;
		Node* subLR = subL->_right;
		int bf = subLR->_bf;
		_RotateL(parent->_left);
		_RotateR(parent);
		if (bf==1){
			subL->_bf = -1;
		}
		else if (bf==-1){
			parent->_bf = 1;
		}
	}

完整代码

#pragma once
#include <iostream>
using namespace std;
template <class T>
class AVLNode{
public:
	AVLNode(const T& val=T())
		:_parent(nullptr)
		,_right(nullptr)
		, _left(nullptr)
		, _val(val)
		,_bf(0)//平衡因子默认为0，因为刚插入时，没有左右子树
	{

	}
	~AVLNode(){
		Destroy(_root);
	}
	AVLNode<T>* _parent;//指向双亲
	AVLNode<T>* _left;//左指针域
	AVLNode<T>* _right;//右指针域
	T _val;//值域
	int _bf;//平衡因子
};
//默认没有重复元素
template <class T>
class AVLTree{
typedef AVLNode<T> Node;//重命名节点名
public:
	AVLTree()
		:_root(nullptr)
	{

	}
	bool Insert(T val){
		//按照二叉搜索树的方式插入新节点
		if (_root==nullptr){
			_root = new Node(val);
			return true;
		}
		Node* parent = nullptr;
		Node* cur = _root;
		while (cur){
			parent = cur;
			if (val>cur->_val){
				cur = cur->_right;
			}
			else if(val<cur->_val){
				cur = cur->_left;
			}
			else{
				return false;
			}
		}
		cur = new Node(val);
		cur->_parent = parent;
		if (parent->_val>cur->_val){
			parent->_left = cur;
		}
		else{
			parent->_right = cur;
		}
		//更新平衡因子
		while (parent){
			if (parent->_left==cur){//一进入循环先更新平衡因子
				parent->_bf--;
			}
			else{
				parent->_bf++;
			}
			if (parent->_bf==0){//平衡因子为0，此时树一定平衡，跳出循环
				break;
			}
			else if (parent->_bf==1||parent->_bf==-1){//说明有一条路径中增加了一个节点，可能会违反AVL树的性质，需要向上不断更新
				cur = cur->_parent;
				parent = parent->_parent;
			}
			else{//AVL树的性质遭到破坏，进行调整
				if (parent->_bf==2){
					if (cur->_bf==1){//左单旋
						_RotateL(parent);
					}
					else{
						_RotateRL(parent);//右左双旋
					}
				}
				else{
					if (cur->_bf==-1){
						_RotateR(parent);
					}
					else{
						_RotateLR(parent);//左右双旋
					}
				}
				break;
			}
		}
	}
	void InOrder(){
		cout << "中序遍历结果为：" << endl;
		_InOrder(_root);
		cout << endl;
	}
	bool InvalidAVL(){
		return _InvalidAVL(_root);
	}
private:
	int GetLength(Node* root){//计算以_root为根的二叉树深度
		if (root==nullptr){
			return 0;
		}
		int left = GetLength(root->_left) + 1;
		int right = GetLength(root->_right) + 1;
		return left > right ? left : right;
	}
	bool _InvalidAVL(Node* root){//检查构建的二叉搜索树是否正确
		if (root==nullptr){
			return true;
		}
		int left = GetLength(root->_left);
		int right = GetLength(root->_right);
		if (right-left!=root->_bf){
			cout << "Node:" << root->_val << endl;
			cout << right - left << " " << root->_bf << endl;
			return false;
		}
		return _InvalidAVL(root->_left)&&_InvalidAVL(root->_right);
	}
	void _InOrder(Node* root){//中序遍历
		if (root==nullptr){
			return;
		}
		_InOrder(root->_left);
		cout << root->_val << ' ';
		_InOrder(root->_right);
	}
	void _RotateL(Node* parent){//左单旋
		Node* pparent = parent->_parent;//记录上parent的双亲节点，可能存在，可能不存在
		Node* subR = parent->_right;//记录上parent的右孩子节点，一定存在
		Node* subRL = subR->_left;//记录上subRL的左孩子节点，可能存在，可能不存在
		parent->_right = subRL;//直接改变parent->_right指向，不用管subRL存不存在
		if (subRL){//如果subRL存在，则改变其_parent指针域的指向
			subRL->_parent = parent;
		}
		parent->_parent = subR;
		subR->_left = parent;
		subR->_parent = pparent;
		if (pparent==nullptr){//最后判断pparent是否为空，如果是，说明parent是根节点，就需要改变_root的指向了
			_root = subR;
		}
		else{//pparent存在，则令pprent的左或者右指向subR
			if (pparent->_left == parent){
				pparent->_left = subR;
			}
			else{
				pparent->_right = subR;
			}
		}
		parent->_bf = 0;//最后修改平衡因子
		subR->_bf = 0;
	}
	void _RotateR(Node* parent){//右单旋
		Node* pparent = parent->_parent;
		Node* subL = parent->_left;
		Node* subLR = subL->_right;
		parent->_left = subLR;
		if (subLR){
			subLR->_parent = parent;
		}
		parent->_parent = subL;
		subL->_right = parent;
		subL->_parent = pparent;
		if (pparent==nullptr){
			_root = subL;
		}
		else{
			if (pparent->_left==parent){
				pparent->_left = subL;
			}
			else{
				pparent->_right = subL;
			}
		}
		parent->_bf = 0;
		subL->_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){
			subL->_bf = -1;
		}
		else if (bf==-1){
			parent->_bf = 1;
		}
	}
	void _RotateRL(Node* parent){//右左双旋
		Node* subR = parent->_right;//记录parent的_right
		Node* subRL = subR->_left;//记录subR的_left
		int bf = subRL->_bf;//记录subR的平衡因子，根据其值是-1还是1，进而在旋转完成后修改平衡因子
		_RotateR(subR);//对subR及以下部分进行右单旋
		_RotateL(parent);//对parent及以下部分进行左单旋
		if (bf==1){//根据bf的值，修改parent或者subR的平衡因子
			parent->_bf = -1;
		}
		else if (bf==-1){
			subR->_bf = 1;
		}
	}
	void Destroy(Node*& root){//销毁AVL树
		if (root==nullptr){
			return;
		}
		Destroy(root->_left);
		Destroy(root->_right);
		delete root;
		root = nullptr;
	}
	Node* _root;//底层维护_root指针
};

Enthusiastic_boy
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
AVL树的插入操作
Rinki123456的博客
08-08 2724
二叉搜索树虽可以缩短查找的效率，但如果数据有序或接近有序二叉搜索树将退化为单支树，查找元素相当于在顺序表中搜索元素，效率低下。因此，两位俄罗斯的数学家G.M.Adelson-Velskii和E.M.Landis在1962年发明了一种解决上述问题的方法：当向二叉搜索树中插入新结点后，如果能保证每个结点的左右子树高度之差的绝对值不超过1(需要对树中的结点进行调整)，即可降低树的高度，从而减少平均搜索长度。一棵AVL树或者是空树，或者是具有以下性质的二叉搜索树：它的左右子树都是AVL树。......
AVL树
L_listen的博客
03-21 256
二叉搜索树可以能够提高查找的效率，但如果数据有序或接近有序二叉搜索树将退化为单支 树，查找元素的效率将大大降低，由此 有了AVL树来解决这个问题。 AVL树概念 一棵AVL树或者是空树，或者是具有以下性质的二叉搜索树： 1、它的左右子树都是AVL树 2、左子树和右子树高度之差(简称平衡因子)的绝对值不超过1(-1、0、1) 右树高度减左树高度 如果一棵二叉搜索树是高度...
AVL树的插入操作（四种情况）
PYH的博客
08-25 4333
主要内容为AVL树的插入操作（不包含重复值），主要分为四种情况
AVL树的插入
LiangXiay的博客
05-29 2453
为什么需要AVL树？ 我们知道搜索二叉树通过对每一个结点限制规定：左子树都比比根节点小，右子树比根节点大，来达到O（logN）的搜索效率的:​​ 但是一般的搜索二叉树还有一个很严重的问题：当左右子树高度差很大时，会导致搜索效率极度退化，甚至在顺序插入时退化至O（N）： 很明显，普通的搜索二叉树在一些情况下并不能达到预期的O（logN）搜索效率，而其原因就是高度的极度不平衡。 而AVL树就通过旋转的方式来维持搜索二叉树的平衡，AVL树得名于它的发明者G. M. Adelson-Vels
【C++】AVL树（插入）
weixin_56916549的博客
01-26 901
AVL树的概念 平衡化旋转 右单旋转 左单旋转 先左后右双旋转 先右后左双旋转 AVL树的插入 根据BST树规则进行节点插入 平衡化处理 重新连接节点 完整的插入函数代码 AVL树的验证 AVL树的性能
Avl树插入、删除c++实现
03-11
- 插入：在AVL树中插入一个新节点时，首先按照二叉查找树的规则进行插入，然后检查插入操作是否破坏了树的平衡。如果破坏了平衡，就需要进行相应的单旋或双旋操作来重新平衡树。常见的旋转包括左旋、右旋、左右旋和...
avl.zip_1到n的avl图_avl树插入数字
09-21
在这个"avl.zip_1到n的avl图_avl树插入数字"的压缩包中，用户可以输入一个整数N，程序会生成一棵包含了从1到N所有数字的AVL树，并输出该树的前序遍历和后序遍历的结果。这两种遍历方式是理解AVL树结构的重要工具。 ...
C++树形查找（搜索树，AVL树插入删除，红黑树插入流程），参考书籍（王道考研书记结构2023版）
02-27
本文将深入探讨C++中与树形查找相关的知识点，包括搜索树、AVL树以及红黑树的插入操作，这些都是考研必备的知识点。 首先，我们要理解**搜索树**（Binary Search Tree，BST）。搜索树是一种特殊的二叉树，其中每个...
AVL平衡树及插入操作的C语言实现
06-21
- **插入操作**：插入新节点时，先进行常规的二叉搜索树插入，然后检查新插入节点的祖先节点的平衡因子，若超限则执行旋转。 - **旋转操作**： - **左旋**：当一个节点的右子树过高时，可能需要对其左旋。右子...
AVL.rar_AVL树
09-21
1. 插入节点：当向AVL树中插入一个新节点时，可能需要进行一次或多次旋转来保持树的平衡。插入过程分为普通二叉查找树的插入操作和平衡调整两步。 2. 删除节点：删除操作相对复杂，可能涉及单旋转、双旋转以及替换...
AVL树的插入详解
最新发布
C_Rio的博客
11-09 294
_kv(kv)//pair内部有实现自己的拷贝构造函数,_bf(0){}int _bf;//每个节点的平衡因子（right-left）class AVLpublic:AVL(){}private:首先我们要知道AVL树的数据类型一般都是K-V型，具体说也就是pair类型，而且AVL树和一般的树据关联是不同的，属于三叉连，也就是不仅仅要有左右指针还要有父指针，而父指针的目的就是在插入数据的时候可以更方便的处理祖宗节点的平衡因子。平衡因子的计算：右子树的高度—左子树的高度。
C++：AVL树的插入详解
AngelDg的博客
04-29 631
AVLAVL树的概念 AVL树的概念 二叉搜索树虽可以缩短查找的效率，但如果数据有序或接近有序二叉搜索树将退化为单支树，查找元素相当于在顺序表中搜索元素，效率低下。因此，两位俄罗斯的数学家G.M.Adelson-Velskii和E.M.Landis在1962年发明了一种解决上述问题的方法:当向二叉搜索树中插入新结点后，如果能保证每个结点的左右子树高度之差的绝对值不超过1(需要对树中的结点进行调整...
数据结构与算法——2022每日一练（1月）
yangwei2048的博客
01-02 1351
文章目录每日一练1.11.21.3 每日一练 1.1 以下Dubbo服务负载均衡策略中，哪一个策略的功能是相同参数的请求总是发到同一个提供者（） A. Random LoadBalance B. RoundRobin LoadBalance C. LeastActive LoadBalance D. ConsistentHash LoadBalance 【答案】D 1.2 分别以下列序列构造二叉排序树，层次遍历序列与用其它三个结果不同的是（） A. （100，80，90，140，50，120，160
高度平衡二叉搜索树(AVLTree)（插入与旋转）
m0_73904148的博客
06-06 394
AVL树是基于我们上一期讲过的二叉搜索树改变而来，如果没有看过我上一期博文的可以先看看这一期的代码也是基于上一章的基础上而来的二叉搜索树AVL树就是在二叉搜索树的基础上进行控制左右子树高度差的绝对值不超过1而我们接下来所讲的实现方式加入了平衡因子(bf)其实AVL树的查找与二叉搜索树的查找是一样的，他们之间的差别在于插入与删除而本节内容就针对AVL树的插入来展开话不多说我们正式进入正题int _bf;//新增的平衡因子T _data;
模拟实现AVL树插入操作
JayceSun的博客
05-21 437
目录avl树结构插入旋转左旋转左单旋代码右旋转右旋转代码右左双旋右左双旋代码左右双旋左右双旋代码insert代码 avl树 本文展示的是通过平衡因子控制高度的avl树。 平衡因子(balance factor简称bf)等于右子树高度-左子树高度，我们要控制树中的所有平衡因子都小于等于1。 结构 树中节点的成员如下 template<class K, class V>// k为键值 struct AVLTreeNode { // 本树使用三叉链可方便操作 AVLTreeNode<K, V&
平衡二叉树(AVL)的插入和删除详解(上)
热门推荐
arui的专栏
08-22 2万+
AVL树维基百科：http://zh.wikipedia.org/wiki/AVL树 在计算机科学中，AVL树是最先发明的自平衡二叉查找树。在AVL树中任何节点的两个子树的高度最大差别为1，所以它也被称为高度平衡树。查找、插入和删除在平均和最坏情况下都是O（log n）。增加和删除可能需要通过一次或多次树旋转来重新平衡这个树。AVL树得名于它的发明者G.M. Adelson-Velsky和E.M
平衡二叉树(AVL)的4种插入调整过程
今天好像忘写了
07-10 4394
平衡二叉树(AVL)的4种插入调整过程 平衡二叉树定义: 在插入中为了保证二叉排序树的性能，规定在插入和删除二叉树结点时，要保证任意结点的左、右子树的高度差的绝对数值不超过1，这样的二叉树被称为平衡二叉树(Balanced Binary Tree)，简称平衡树(AVL)。 平衡二叉树的插入： 我们知道，进行插入和删除操作时势必会对树的整体的造成的一定的影响，树的结构发生一定的变化，如果这...
【C++】AVL树的插入实现
QiHai的博客
11-09 788
介绍提高查找二叉树的效率的方法-平衡搜索二叉树中的实现方法之一AVL树
avl树插入和删除好难呀
02-06
AVL树是一种自平衡二叉搜索树。它的插入和删除过程都有一定的复杂度。 在 AVL树中插入新节点时，需要先找到新节点应该插入的位置，然后将新节点插入到该位置。如果在插入新节点后AVL树的平衡性被破坏，则需要对AVL树进行调整，以使其重新平衡。这个过程需要使用旋转操作来调整AVL树的结构。 在AVL树中删除节点时，需要先找到要删除的节点，然后在AVL树中删除该节点。如果在删除节点后AVL树的平衡性被破坏，则需要对AVL树进行调整，以使其重新平衡。这个过程也需要使用旋转操作来调整AVL树的结构。 总的来说，AVL树的插入和删除都比较复杂，但是它们可以保证AVL树在进行插入和删除操作后仍然是一棵平衡树。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值