手写AVL树(详解插入时的4种旋转)

已于 2022-09-16 19:42:05 修改
阅读量370 收藏
点赞数
分类专栏： Cpp 文章标签： 数据结构 二叉树
于 2021-06-03 22:09:01 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45928272/article/details/117413895
版权

目录

1. 为什么要有AVL树

1.1 基本概念

二叉搜索树有其自身的缺陷，假如往树中插入的元素有序或者接
近有序，二叉搜索树就会退化成单支树，时间复杂度会退化成O(N)。

所以科学家对二叉搜索树采取平衡处理，实现出AVL树。

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

1.2 性质

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

如果一棵二叉搜索树的高度是平衡的，它就是AVL树。如果它有n个结点，其高度可保持在 ，搜索时间复杂度O(logN)。内存足够的话，将中国所有人的身份证号存入AVL树，只需要31次就可以查找到想要找的人。确实很厉害，但是后面要讲的哈希表，效率更加的高。

1.3 节点组成

这里定义出AVL树的节点，这里我选择用三叉链，即记录每个节点的父亲，以及记录每个节点的平衡因子，来判断是否平衡。
他们两个不是必须要有的。
在这里插入图片描述

2. 实现AVL树

2.1 插入

插入与二叉搜索树并无差别，但是他多了一项工作，调节平衡因子。且调节平衡因子有以下几种情况。
因为情况过于复杂，下面几种旋转均采用抽象图。

2.1.1 左单旋

在这里插入图片描述
在这里插入图片描述

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

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

		subR->_left = parent;

		Node* parentParent = parent->_parent;
		parent->_parent = subR;

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

	}

2.1.2 右单旋

在这里插入图片描述
在这里插入图片描述

void rotateR(Node* parent)
	{
		
		Node* subL = parent->_left;
		Node* subLR = subL->_right;

		
		parent->_left = subLR;
		if (subLR)//可能为空
		subLR->_parent = parent;

		//假如他是一颗子树，就需要这个节点，连接上一棵树
		Node* parentParent = parent->_parent;

		subL->_right = parent;
		parent->_parent = subL;
		
		//完整的树
		if (parent == _root)
		{
			_root = subL;
			_root->_parent = nullptr;
		}
		else//一颗子树
		{
			
			
			if (parentParent->_left == parent)
			{
				parentParent->_left = subL;
			}
			else
			{
				parentParent->_right = subL;
			}
			subL->_parent = parentParent;
		}
		//位置调好后处理平衡因子

		subL->_bf = parent->_bf = 0;

	}

2.1.3 左右双旋

在这里插入图片描述
复用之前的代码即可，需要注意
在这里插入图片描述

假如60存在左右孩子，在任意孩子插入均会引起左右双旋，且90，60，30的平衡因子变化都不一样。另一种情况是60为新插入节点，也就是说原来只有90，30的时候。平衡因子变化也会不同。所以对这三种情况需要分别进行讨论（即subLR的平衡因子为，-1，0，1三种情况）
在这里插入图片描述
将60的左给30，60的右给90，自己去做根

在这里插入图片描述
在这里插入图片描述

void rotateLR(Node* parent)
	{
		Node* subL = parent->_left;
		Node* subLR = subL->_right;
		int bf = subLR->_bf;//旋转会修改，保存一下
		rotateL(parent->_left);
		rotateR(parent);

		//此时由于插入位置不同，导致subLR的平衡因子情况不同，1,-1,0。从而导致旋转后平衡因子情况不同
		
		if (bf == -1)//新增节点在subLR的左
		{
			subLR->_bf = subL->_bf= 0;
			parent ->_bf= 1;
		}
		else if (bf == 1)//新增节点在subLR的右
		{
			parent->_bf = subLR->_bf = 0;
			 subL->_bf = -1;
			
		}
		else if(bf==0)//subLR本身为新增节点
		{
			subLR ->_bf= subL->_bf = parent->_bf=0;
		}
		else
		{
			assert(false);
		}
	}

2.1.4 右左双旋

在这里插入图片描述
这里就不啰嗦了，镜像处理且判断平衡因子的三种情况
在这里插入图片描述
在这里插入图片描述

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 = subRL->_bf = 0;
			subR->_bf = 1;
		}
		else if (bf == 1)
		{
			subR->_bf = subRL->_bf = 0;
			parent->_bf = -1;

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

2.1.5 插入整体代码

//插入
	//STL库中是iteator,这里用Node*代替 
	pair<Node*, bool> insert(const pair<K,V>& kv)
	{
		// 0. 假如根节点为空
		if (_root == nullptr)
		{
			_root = new Node(kv);
			return make_pair(_root, true);
		}
		Node* cur = _root;
		Node* parent = nullptr;
		//1. 从根节点开始，cur寻找合适的地方,准备插入
		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;
			}
			//等于的话,返回当前节点指针与false
			else
			{
				return make_pair(cur, false);
			}
		}


		//2. 找到位置，准备插入
		cur = new Node(kv);
		//parent为插入位置的父亲，判断插入到左还是右
		//插入对象比他大，插入到右边
		if (parent->_kv.first < kv.first)
		{
			parent->_right = cur;
			cur->_parent = parent;
		}
		else//小，插入到左边
		{
			parent->_left = cur;
			cur->_parent = parent;
		}

		Node* newNode = cur;//cur会变化，先把它保存下来
		//3. 调节平衡因子
		while(parent)
		{
			//插入在右边，平衡因子++
			if (cur == parent->_right)
			{
				parent->_bf++;
			}
			else//插入在左边,平衡因子--
			{
				parent->_bf--;
			}
			
			if (parent->_bf == 0)//平衡因子为0，说明插入的节点把父亲的一侧填补了，那么不会影响其他树
			{
				break;
			}
			else if (abs(parent->_bf )==1)//当平衡因子为1,或者-1，说明会影响其他树,迭代上去修改
			{
				//迭代上去，改变平衡因子
				cur = parent;
				parent = parent->_parent;
			}
			else if (abs(parent->_bf)==2)//当平衡因子为2或者-2，说明此时，已经不平衡，需要进行旋转
			{
				//因子为-2时
				if (parent->_bf == -2)
				{
					//假如长的一侧在左侧,且新增节点在最左的，右或者左，右单旋
					if (cur->_bf == -1)
					{
						rotateR(parent);
					}
					else//右侧，会引发左右双旋
					{
						rotateLR(parent);
					}
				}
				else//因子为2时
				{
					//假如长的一侧在右侧，且新增节点在最右的，右或者左，左单旋
					if (cur->_bf == 1)
					{
						rotateL(parent);
					}
					else//左侧，引发右左双旋
					{
						rotateRL(parent);
					}
				}
				break;//旋转完成break
			}
			else
			{
				assert(false);
			}

		}
		return make_pair(newNode, true);

	}

2.2 删除大概思路

从以往学习经验来看，任何数据结构的删除都是要比插入更加复杂的。
首先，删除肯定是先find到节点。然后

  1. 按照搜索二叉树的方式删除
  2. 更新平衡因子
  3. 如果不平衡旋转

假如在右边删除，平衡因子–，左边删除平衡因子++。插入的时候当平衡因子由-1或1变为0的时候，不需要更新，因为已经平衡，但是删除不一样，平衡因子由-1或1变为0，说明高度发生了变化，高度发生变化，就会影响到祖先。反而是平衡因子由0变为-1或1时，不需要处理，因为高度没有变，不会影响祖先。

3. 调试验证

在这里插入图片描述
在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

4. AVLTree代码

#include<iostream>
#include<cassert>
#include<algorithm>
using namespace std;

template<class K,class V>
class AVLTreeNode
{
public:
	AVLTreeNode(const pair<K, V>& kv)
		:_left(nullptr)
		, _right(nullptr)
		, _parent(nullptr)
		, _kv(kv)
		, _bf(0)
	{}
public:
	AVLTreeNode<K, V>* _left;//左孩子
	AVLTreeNode<K, V>* _right;//右孩子

	AVLTreeNode<K, V>* _parent;//父亲
	pair<K, V> _kv;

	int _bf;//平衡因子
};
#include<utility>
template<class K,class V>

class AVLTree
{
	typedef AVLTreeNode<K, V> Node;
private:
	void rotateR(Node* parent)
	{
		
		Node* subL = parent->_left;
		Node* subLR = subL->_right;

		
		parent->_left = subLR;
		if (subLR)//可能为空
		subLR->_parent = parent;

		//假如他是一颗子树，就需要这个节点，连接上一棵树
		Node* parentParent = parent->_parent;

		subL->_right = parent;
		parent->_parent = subL;
		
		//完整的树
		if (parent == _root)
		{
			_root = subL;
			_root->_parent = nullptr;
		}
		else//一颗子树
		{
			
			
			if (parentParent->_left == parent)
			{
				parentParent->_left = subL;
			}
			else
			{
				parentParent->_right = subL;
			}
			subL->_parent = parentParent;
		}
		//位置调好后处理平衡因子

		subL->_bf = parent->_bf = 0;

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

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

		subR->_left = parent;

		Node* parentParent = parent->_parent;
		parent->_parent = subR;

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

	}
	void rotateLR(Node* parent)
	{
		Node* subL = parent->_left;
		Node* subLR = subL->_right;
		int bf = subLR->_bf;//旋转会修改，保存一下
		rotateL(parent->_left);
		rotateR(parent);

		//此时由于插入位置不同，导致subLR的平衡因子情况不同，1,-1,0。从而导致旋转后平衡因子情况不同
		
		if (bf == -1)//新增节点在subLR的左
		{
			subLR->_bf = subL->_bf= 0;
			parent ->_bf= 1;
		}
		else if (bf == 1)//新增节点在subLR的右
		{
			parent->_bf = subLR->_bf = 0;
			 subL->_bf = -1;
			
		}
		else if(bf==0)//subLR本身为新增节点
		{
			subLR ->_bf= subL->_bf = parent->_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 = subRL->_bf = 0;
			subR->_bf = 1;
		}
		else if (bf == 1)
		{
			subR->_bf = subRL->_bf = 0;
			parent->_bf = -1;

		}
		else if (bf==0)
		{
			subR->_bf = subRL->_bf = parent->_bf = 0;
		}
		else
		{
			assert(false);
		}
	}
	
public:
	//插入
	//STL库中是iteator,这里用Node*代替 
	pair<Node*, bool> insert(const pair<K,V>& kv)
	{
		// 0. 假如根节点为空
		if (_root == nullptr)
		{
			_root = new Node(kv);
			return make_pair(_root, true);
		}
		Node* cur = _root;
		Node* parent = nullptr;
		//1. 从根节点开始，cur寻找合适的地方,准备插入
		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;
			}
			//等于的话,返回当前节点指针与false
			else
			{
				return make_pair(cur, false);
			}
		}


		//2. 找到位置，准备插入
		cur = new Node(kv);
		//parent为插入位置的父亲，判断插入到左还是右
		//插入对象比他大，插入到右边
		if (parent->_kv.first < kv.first)
		{
			parent->_right = cur;
			cur->_parent = parent;
		}
		else//小，插入到左边
		{
			parent->_left = cur;
			cur->_parent = parent;
		}

		Node* newNode = cur;//cur会变化，先把它保存下来
		//3. 调节平衡因子
		while(parent)
		{
			//插入在右边，平衡因子++
			if (cur == parent->_right)
			{
				parent->_bf++;
			}
			else//插入在左边,平衡因子--
			{
				parent->_bf--;
			}
			
			if (parent->_bf == 0)//平衡因子为0，说明插入的节点把父亲的一侧填补了，那么不会影响其他树
			{
				break;
			}
			else if (abs(parent->_bf )==1)//当平衡因子为1,或者-1，说明会影响其他树,迭代上去修改
			{
				//迭代上去，改变平衡因子
				cur = parent;
				parent = parent->_parent;
			}
			else if (abs(parent->_bf)==2)//当平衡因子为2或者-2，说明此时，已经不平衡，需要进行旋转
			{
				//因子为-2时
				if (parent->_bf == -2)
				{
					//假如长的一侧在左侧,且新增节点在最左的，右或者左，右单旋
					if (cur->_bf == -1)
					{
						rotateR(parent);
					}
					else//右侧，会引发左右双旋
					{
						rotateLR(parent);
					}
				}
				else//因子为2时
				{
					//假如长的一侧在右侧，且新增节点在最右的，右或者左，左单旋
					if (cur->_bf == 1)
					{
						rotateL(parent);
					}
					else//左侧，引发右左双旋
					{
						rotateRL(parent);
					}
				}
				break;//旋转完成break
			}
			else
			{
				assert(false);
			}

		}
		return make_pair(newNode, true);

	}
	//Find
	Node* Find(const K& k)
	{
		Node* cur = _root;
		while (cur)
		{
			if (cur->_kv.first < k)
			{
				cur = cur->_right;
			}
			else if (cur->_kv.first>k)
			{
				cur = cur->_left;
			}
			else
			{
				return cur;
			}
		}
		
		return nullptr;
	}
	V& operator[](const K& k)
	{
		return (((insert(make_pair(k, V()))).first)->_kv).second;
	}

private:
	//后序遍历验证是否平衡
	int _IsBanlance(Node* root)
	{
		if (root == nullptr)
		{
			return 0;
		}

		int leftHeight = _IsBanlance(root->_left);
		int rightHeight = _IsBanlance(root->_right);
		cout << root->_bf<<endl ;
		if (leftHeight == -1 || rightHeight == -1 || abs(leftHeight - rightHeight) > 1)
		{
			return -1;
		}
		else
		{
			return  max(leftHeight, rightHeight) + 1;
		}
	}
	//中序遍历是否为二叉搜索树
	void _Inorder(Node* root)
	{
		if (root == nullptr)
			return;
		_Inorder(root->_left);
		cout <<root->_kv.first << " : " << root->_kv.second << endl;;
		_Inorder(root->_right);
	}
	public:
	//后序遍历是否平衡
	bool IsBalance()
	{
		return _IsBanlance(_root)>=0;
	}
	void Inorder()
	{
		_Inorder(_root);
	}
private:
	Node* _root=nullptr;
};
楠c
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 3
    评论
专栏目录
手写代码 AVL 二叉平衡树（插入 删除）
weewqrer的博客
07-06 1556
avl是一种平衡二叉树，其难点在于插入和删除，这两个操作可能会导致avl树不再满足平衡条件（左右子树的高度相差小于2），所以需要旋转来重新回到平衡状态。本文实现的插入与《数据结构与算法分析–C语言描述 第二版》的方法类似，但稍有不同，本文没有用到单旋转和双旋转的概念，而是是用《算法导论》中“左旋”、“右旋”的概念。实际上左旋和右旋就是单旋转，而双旋转就是左旋和右旋的结合。下面用插图说明下在什么情况下
数据结构之AVL树详解
12-26
AVL树种查找、插入和删除在平均和最坏情况下都是O（log n），增加和删除可能需要通过一次或多次树旋转来重新平衡这个树。本文介绍了AVL树的设计思想和基本操作。 2. 基本术语 有四种种情况可能导致二叉查找树不平衡...
Java手写AVL树（非常详细）
fengxiandada的博客
04-08 2513
文章目录1. 二叉搜索树复杂度2. BST的平衡3. 改进二叉搜索树4. 平衡二叉搜索树（Balanced Binary Search Tree）5. AVL树5.1 AVL树的相关概念及特点5.2 普通BST和AVL树添加对比6. AVL树设计6.1 继承结构6.2 普通BST添加导致失衡例子6.3 解决添加失衡——LL-右旋转(单旋)6.4 解决添加失衡——RR-左旋转(单旋)6.5 解决添加失衡——LR-RR左旋转，LL右旋转(双旋)6.6 解决添加失衡——RL-LL右旋转，RR左旋转(双旋)6.7
AVL树的旋转操作详解
张小凡
09-18 2092
图解AVL平衡二叉树的旋转
AVL树的旋转
Colorful_X的博客
06-07 3728
文章目录定义AVL树的旋转左单旋转右单旋转双旋转 定义         一棵AVL树可以是空树，也可以是具有下列性质的二叉搜索树：它的左子树和右子树都是AVL树，且左子树和右子树的高度之差的绝对值不超过1(也就是小于等于1)。(右子树高度 - 左子树高度)         节点的平衡因子：给每个节点附加一个数字，给出该节点右子树的高度减去左子树的高度
AVL树的四种旋转方式(详细图解)
qq_65786321的博客
11-09 803
新节点插入到左子树的右侧时对parent使用左右双旋。新节点插入到右子树的左侧时对parent使用右左双旋。新节点插入到右子树的右侧时对parent使用左单旋。新节点插入到左子树的左侧时对parent使用右单旋。
avl.rar_AVL树_avl 旋转_树 旋转
09-24
实现了AVL树的查找，删除，四种旋转。可以直接运行
潜析AVL树–AVL树的双旋转
01-06
潜析AVL树–AVL树的双旋转 接上篇博文：简析AVL树–AVL树的概念及单旋转 AVL树如何恢复平衡之双旋转 首先假设我们有一颗已经处于平衡的AVL树： 上篇博文已经解决了LL和RR两种情况的平衡恢复解决方案—-单旋转。这篇...
avl.zip_1到n的avl图_avl树插入数字
09-21
用户输入N，得到依次插入1到N的数字所形成的AVL树的两种遍历结果。
手把手教，手写AVL树
weixin_30446613的博客
06-11 99
平衡二叉树相信大家都不陌生了，它是一颗平衡的二叉排序树，它的查询、插入删除的时间复杂度均为O(logn)，是非常好且重要的动态查找结构，因此被广泛的应用。而平衡二叉树的实现因为引入了旋转操作而经常让人难以理解，楼主写这篇文章的目的，其实是希望能够通过造轮子的方式，帮助到大家完全理解从普通二叉排序树逐步优化到平衡二叉树(AVL树)的过程。 一、平衡二叉树之AVL树简介 ...
面试常考手写代码之--二叉树非递归遍历
lingfengtengfei的专栏
10-06 2814
struct BTNode_s{     int value;     BTNode_s* pLeft;     BTNode_s* pRight; }BTNode;     //非递归 前序 void preOrder(BTNode * pRoot) {     if(pRoot !=NULL)     {         return;     }     
手写AVL树
汉堡怪兽
12-20 262
public class AVLBinaryTree&lt;E extends Comparable&lt;E&gt;&gt; { Node&lt;E&gt; root; int size = 0; private static final int LH = 1; private static final int RH = -1; private sta...
【C++AVL树】4种旋转详讲
m0_72964546的博客
11-02 1100
如果还没有元素是一课空树，直接插入即可；如果有元素，按pair的first(key)和比较的节点比较结果为大说明为空的哪个位置在右边，和比较的节点比较的结果小说明为空的哪个位置在左边，如果相等说明已经有这个元素了，二叉搜索树不支持冗余，插入失败返回false； 不知道这个已经找到的位置在父节点的左边还是右边，需要判断一下，然后插入元素； 插入元素的后那么平衡因子将发生变化，为0说明这个父亲节点左右平衡不会影响其他节点，为1或者-1需要向上调整，为2或者-2说明已经不平衡需要旋转；
【高阶数据结构（壹）】——一步一步教你手撕AVL树（增删查改）画图详解，内含代码实现包含注释）
sjp11的博客
01-17 878
???? 1.AVL树的概念 AVL树一颗二叉搜索树 左右子树高度之差(简称平衡因子)的绝对值不超过1。 如果一颗AVL树有n个节点，其高度可以保持在O(logn),搜索的时间复杂度是O(logn). ???? 2.AVL树节点的定义 template<class K,class V> struct AVLTreeNode { AVLTreeNode* _left;//左孩子节点 AVLTreeNode* _right;//右孩子节点 AVLTreeNode* parent;//
深入浅出C++ ——手撕AVL树
weixin_55051736的博客
02-22 801
在前面的文章中介绍了map / multimap / set / multiset 容器，这几个容器的底层都是按照二叉搜索树来实现的。但是二叉搜索树有其自身的缺陷，假如往树中插入的元素有序或者接近有序，二叉搜索树就会退化成单支树，时间复杂度会退化成O(N)。因此 map、set 等关联式容器的底层结构是对二叉树进行了平衡处理，即采用平衡树来实现。二叉搜索树虽可以缩短查找的效率，但如果数据有序或接近有序二叉搜索树将退化为单支树，查找元素相当于在顺序表中搜索元素，效率低下。
手撕AVL_二叉平衡树(图文并茂)
最新发布
weixin_73869209的博客
11-25 336
大家好,今天带大加手撕AVL树的插入一 .为了AVL树实现简单，AVL树节点在定义时维护一个平衡因子，具体节点定义如下：int val;int bf;// 平衡因子 -> 当前节点的平衡因子=右子树高度-左子树的高度// 节点的左孩子// 节点的右孩子// 节点的双亲注意： 当前节点的平衡因子=右子树高度-左子树的高度。但是，不是每棵树，都必须有平衡因子，这只是其中的一种实现 方式。大家多多理解,我们下一篇博客见。
今天终于懂了AVL树怎样旋转(带图理解)
山鬼谣弋痕夕的博客
02-23 4769
AVL树，也称平衡二叉搜索树，AVL是其发明者姓名简写。 AVL树属于树的一种，而且它也是一棵二叉搜索树，不同的是他通过一定机制能保证二叉搜索树的平衡，平衡的二叉搜索树的查询效率更高。 AVL树特点 AVL树是一棵二叉搜索树。 AVL树的左右子节点也是AVL树。 AVL树拥有二叉搜索树的所有基本特点。 每个节点的左右子节点的高度之差的绝对值最多为1，即平衡因...
手撕AVL树 (C++ 实现）
林慢慢的博客
06-29 936
AVL 树的定义、代码实现、性能分析
手撕AVL树
GG_Bruse的博客
11-19 784
两位俄罗斯的数学家G.M.Adelson-Velskii和E.M.Landis在1962年发明AVL树
avl树插入和删除好难呀
02-06
AVL树是一种自平衡二叉搜索树。它的插入和删除过程都有一定的复杂度。 在 AVL树中插入新节点时，需要先找到新节点应该插入的位置，然后将新节点插入到该位置。如果在插入新节点后AVL树的平衡性被破坏，则需要对AVL...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

楠c

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值