【C++实现AVL树】

最新推荐文章于 2024-08-10 19:01:23 发布
最新推荐文章于 2024-08-10 19:01:23 发布
阅读量654 收藏 15
点赞数 17
分类专栏： 数据结构 文章标签： c++ 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_62618590/article/details/128901943
版权
文章详细介绍了AVL树的概念，强调了其作为平衡二叉搜索树的特性，以及如何在插入新节点后通过调整平衡因子和执行四种旋转操作（左单旋、右单旋、左右双旋、右左双旋）来保持树的平衡。同时，文章提到了AVL树的验证方法和性能特点，指出其在查询效率高但结构修改操作成本大的特点。
摘要由CSDN通过智能技术生成

文章目录

一、AVL树概念

AVL树出现在二叉搜索树之后，弥补了二叉搜索树的一些缺点。

二叉搜索树虽可以缩短查找的效率，但如果数据有序或接近有序二叉搜索树将退化为单支树，查找元素相当于在顺序表中搜索元素，效率低下。因此，两位俄罗斯的数学家G.M.Adelson-Velskii和E.M.Landis在1962年发明了一种解决上述问题的方法：当向二叉搜索树中插入新结点后，如果能保证每个结点的左右子树高度之差的绝对值不超过1(需要对树中的结点进行调整)，即可降低树的高度，从而减少平均搜索长度。

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

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

但是，AVL树不一定都有平衡因子，因为平衡因子只是用来检测平衡的方式，如果有其他检测的方法，也可以将平衡因子弃之不用。

例：
在这里插入图片描述

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

二、AVL树节点的定义

一个AVL树的节点和二叉搜索树类似，不同的是AVL树采用三叉链的结构更方便控制(即子节点也有一个指向父节点的指针)。但这个和平衡因子一样，不是必须要求的，也可采用其他方法，只要能完成相同的操作即可(本篇文章采用三叉链进行讲解)。
另外，对AVL树中存储的数据，这里采用pair<K,V>的方式，可以适用于更多的场景。

代码如下：

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;//平衡因子

	AVLTreeNode(const pair<K, V>& kv)
		:_left(nullptr)
		, _right(nullptr)
		, _parent(nullptr)
		, _bf(0)//初始时，该节点没有左右孩子，平衡因子为0
		, _kv(kv)
	{}
};

AVL树类模板初始如下：

template<class K, class V>
class AVLTree
{
	typedef AVLTreeNode<K, V> Node;
public:
	AVLTree()
		:_root(nullptr)
	{}
private:
	Node* _root;
};

三、AVL树的插入

AVL树的插入分为三步：

  1. 像二叉搜索树一样按照左孩子小于父节点，右孩子大于父节点的规则插入节点
  2. 检查每一个节点的平衡因子绝对值是否小于2
  3. 若平衡因子绝对值大于1，则进行旋转

插入节点：

若树为空树，直接将新增节点作为根节点。否则再依次向下比较节点key值的大小，以确定正确的插入位置。若已有相同key值的节点存在，则插入失败。不要忘记维护好三个节点指针的指向。

如下：
在这里插入图片描述
代码实现如下：

bool Insert(const pair<K, V>& kv)
	{
		if (_root == nullptr)
		{//根节点为空，直接将新增节点作为根节点
			_root = new Node(kv);
			return true;
		}
		Node* parent = nullptr;
		Node* cur = _root;
		while (cur)
		{//比较新增节点和当前节点的key值，确定将其放在左/右
			if (cur->_kv.first < kv.first)
			{
				parent = cur;
				cur = cur->_right;
			}
			else if (cur->_kv.first > kv.first)
			{
				parent = cur;
				cur = cur->_left;
			}
			else
			{
				return false;
			}
		}
		//走到这里时表明已经找到合适的节点作为新增节点的父节点
		cur = new Node(kv);
		if (parent->_kv.first < kv.first)
		{//将新增节点与当前节点链接时不要忘记处理新增节点的父节点指针
			parent->_right = cur;
			cur->_parent = parent;
		}
		else
		{
			parent->_left = cur;
			cur->_parent = parent;
		}
}

但是，就上图而言，很明显已经不是一棵AVL树了，因为它的节点中出现了平衡因子不小于2的情况。所以为了保证每插入一个节点之后，AVL树结构不被破坏，就需要检查节点的平衡因子。
本篇文章中的平衡因子为右子树高度-左子树高度

又因为一个节点的平衡因子与左右子树有关，所以新增一个节点之后，只会影响新增节点的祖先节点的平衡因子,也就是说，只需要检测新增节点到根节点所在路径中的节点平衡因子。

更新平衡因子的详细步骤：

  • 首先更新新增节点的父节点平衡因子

如果新增节点为父节点的左孩子，则父节点平衡因子-1；若为右孩子，则父节点的平衡因子+1。

  • 然后向上更新父节点的祖先节点的平衡因子

这里有三种情况：
①插入新增节点后，父节点平衡因子为0。则说明插入之前父节点已经有一个孩子，插入后只是新增一个孩子，以父节点为根的子树高度不变，也就不会影响祖先的平衡因子，则更新结束。

②插入新增节点后，父节点平衡因子为1或-1。则说明更新前父节点平衡因子为0，更新后，父节点的左右子树其中之一的高度+1。这时必定会影响到父节点的祖先节点的平衡因子，所以需要继续向上更新。

③插入新增节点后，父节点平衡因子为2或-2，这时父节点为根的子树已经不平衡了，需要进行旋转(下文讲解)。

上面三种情况如图：
在这里插入图片描述
注意，这里最坏情况下，会一直更新到根节点。

代码实现如下：

while (parent)
{
	if (cur == parent->_left)
		parent->_bf--;
	else
		parent->_bf++;
	if (parent->_bf == 0)
	{
		break;
	}
	else if (parent->_bf == 1 || parent->_bf == -1)
	{
		// 继续往上更新
		cur = parent;
		parent = parent->_parent;
	}
	else if (parent->_bf == 2 || parent->_bf == -2)
	{
		// 旋转处理
	}
	else
	{
		// 说明插入更新平衡因子之前，树中平衡因子就有问题了
		assert(false);
	}
}

四、AVL树的旋转

当一棵树中某一棵子树的根节点的平衡因子绝对值大于1时，为了保证AVL树结构，就必须进行旋转操作。而旋转又分为四种----左单旋、右单旋、左右双旋和右左双旋。下面一 一介绍：
右单旋：

当某一个节点的平衡因子为-2且子节点平衡因子为-1时，表示左子树的高度比右子树大2，为了平衡，就必须进行右单旋，如下：
在这里插入图片描述
这样既保证了平衡因子满足要求，又保证了搜索树的特性，而且这棵树的高度完成了-1。
注意，需要调整的不一定是整棵树，也可能是某一棵子树，这种情况下，调整子树不会破坏整棵树的平衡。

代码如下：

if (parent->_bf == -2 && cur->_bf == -1)
{
	RotateR(parent);
}
void RotateR(Node* parent)
{
	Node* subL = parent->_left;
	Node* subLR = subL->_right;

	parent->_left = subLR;
	if (subLR)//不能将空节点的父节点赋值
		subLR->_parent = parent;
	//记录父节点的父节点，方便为后续subL的父节点赋值
	Node* parentParent = parent->_parent;

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

	if (parent == _root)
	{//父节点为根，则subL变为新的根
		_root = subL;
		_root->_parent = nullptr;
	}
	else
	{
		if (parentParent->_left == parent)
			parentParent->_left = subL;
		else
			parentParent->_right = subL;

		subL->_parent = parentParent;
	}
	//别忘了调整subL和parent的平衡因子
	subL->_bf = parent->_bf = 0;
}

左单旋：

类比右单旋，左单旋就是一个节点的平衡因子为2且子节点平衡因子为1的情况，如图：
在这里插入图片描述

这里就不粘贴代码了，在文章最后会给出完整代码。

双旋(左右/右左)：

当一棵树的子树的左子树的高度大于右子树，且这棵子树的子树的右子树高度大于左子树时(相反情况也适用)，就需要用到双旋，如图：
在这里插入图片描述
这种情况就需要用到左右双旋，直接复用左单旋和右单旋即可。

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

至于右左双旋类比即可。
但这样还不够，因为在某些场景下，有些节点的平衡因子会出错，这种情况下文再详谈。

五、AVL树的验证

上文中，我们已经实现了AVL树的插入，那么该怎么验证这个插入的过程没有错误呢？

答：需要对整棵树计算出左子树和右子树的高度，判断它们的差的绝对值是否小于2。
注意，这里计算的过程应该包含每一棵子树。不用平衡因子检测是因为平衡因子本身可能出错。

代码如下：

bool IsBalance()
{
	return _IsBalance(_root);
}

int Height(Node* root)
{
	if (root == NULL)
		return 0;
	int leftHeight = Height(root->_left);
	int rightHeight = Height(root->_right);
	return leftHeight > rightHeight ? leftHeight + 1 : rightHeight + 1;
}

bool _IsBalance(Node* root)
{
	if (root == NULL)
		return true;

	// 对当前树进行检查
	int leftHeight = Height(root->_left);
	int rightHeight = Height(root->_right);
	if (rightHeight - leftHeight != root->_bf)
	{//检查平衡因子是否有误
		cout << root->_kv.first << "现在是:" << root->_bf << endl;
		cout << root->_kv.first << "应该是:" << rightHeight - leftHeight << endl;
		return false;
	}
	return abs(rightHeight - leftHeight) < 2
		&& _IsBalance(root->_left)
		&& _IsBalance(root->_right);
}

事实是上面的实现AVL树的代码确实会导致一些情况下，某些平衡因子出错的情况。
而且错误是出现在双旋的过程中的，该过程中需要控制平衡因子。在双旋中，把一些节点的平衡因子置0，但经过两次旋转后，它们的平衡因子可能并不为0。
例：
在这里插入图片描述
可以看到，这里双旋之后，3的平衡因子为-1，但原代码处理后，3的平衡因子为0，因为3在第一次左旋的时候，已经将其平衡因子置零了。

上面这种情况是左右双旋，而当右左双旋时，结果就会是右边的节点的平衡因子变为1。
当h=0，6为新增节点时，双旋后平衡因子都为0(具体过程可以通过画图观察一下)。

那么怎么区分这三种情况，并做出改正呢？

可以看到，这三种情况跟旋转前的6的平衡因子有关(6的平衡因子为1、-1和0的情况)。所以，在旋转之前记录6的平衡因子，再对旋转后的6的左/右节点的平衡因子进行改正即可。

这里只给出左右双旋的图示，右左双旋可以类比，总结如下：

  • 旋转前 sunLR：-1；旋转后 parent：1，subL：0，subLR：0

在这里插入图片描述

  • 旋转前 subLR：1；旋转后 parent：0，subL：-1，subLR：0

在这里插入图片描述

  • 旋转前 subLR：0；旋转后 parent：0，subL：0，subLR：0

在这里插入图片描述

下面给出完整的代码：

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;//平衡因子

	AVLTreeNode(const pair<K, V>& kv)
		:_left(nullptr)
		, _right(nullptr)
		, _parent(nullptr)
		, _bf(0)//初始时，该节点没有左右孩子，平衡因子为0
		, _kv(kv)
	{}
};

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)
		{//比较新增节点和当前节点的key值，确定将其放在左/右
			if (cur->_kv.first < kv.first)
			{
				parent = cur;
				cur = cur->_right;
			}
			else if (cur->_kv.first > kv.first)
			{
				parent = cur;
				cur = cur->_left;
			}
			else
			{
				return false;
			}
		}
		//走到这里时表明已经找到合适的节点作为新增节点的父节点
		cur = new Node(kv);
		if (parent->_kv.first < kv.first)
		{//将新增节点与当前节点链接时不要忘记处理新增节点的父节点指针
			parent->_right = cur;
			cur->_parent = parent;
		}
		else
		{
			parent->_left = cur;
			cur->_parent = parent;
		}

		// 控制平衡
		// 1、更新平衡因子 -- 新增节点到根节点的祖先路径
		// 2、出现异常平衡因子，那么需要旋转平衡处理
		while (parent)
		{
			if (cur == parent->_left)
				parent->_bf--;
			else
				parent->_bf++;

			if (parent->_bf == 0)
			{
				break;
			}
			else if (parent->_bf == 1 || parent->_bf == -1)
			{
				// 继续往上更新
				cur = parent;
				parent = parent->_parent;
			}
			else if (parent->_bf == 2 || parent->_bf == -2)
			{
				// 旋转处理
				// 右单旋
				if (parent->_bf == -2 && cur->_bf == -1)
				{
					RotateR(parent);
				}
				else 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);
				}

				break;
			}
			else
			{
				// 说明插入更新平衡因子之前，树中平衡因子就有问题了
				assert(false);
			}
		}

		return true;
	}

	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 (_root == parent)
		{
			_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 RotateR(Node* parent)
	{
		Node* subL = parent->_left;
		Node* subLR = subL->_right;

		parent->_left = subLR;
		if (subLR)//不能将空节点的父节点赋值
			subLR->_parent = parent;
		//记录父节点的父节点，方便为后续subL的父节点赋值
		Node* parentParent = parent->_parent;

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

		if (parent == _root)
		{//父节点为根，则subL变为新的根
			_root = subL;
			_root->_parent = nullptr;
		}
		else
		{
			if (parentParent->_left == parent)
				parentParent->_left = subL;
			else
				parentParent->_right = subL;

			subL->_parent = parentParent;
		}
		//别忘了调整subL和parent的平衡因子
		subL->_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);
		if (bf == 1)
		{
			parent->_bf = 0;
			subL->_bf = -1;
			subLR->_bf = 0;
		}
		else if (bf == -1)
		{
			parent->_bf = 1;
			subL->_bf = 0;
			subLR->_bf = 0;
		}
		else if (bf == 0)
		{
			parent->_bf = 0;
			subL->_bf = 0;
			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 = 0;
			subR->_bf = 0;
			subRL->_bf = 0;
		}
		else
		{
			assert(false);
		}
	}

	bool IsBalance()
	{
		return _IsBalance(_root);
	}

	int Height(Node* root)
	{
		if (root == NULL)
			return 0;
		int leftHeight = Height(root->_left);
		int rightHeight = Height(root->_right);
		return leftHeight > rightHeight ? leftHeight + 1 : rightHeight + 1;
	}

	bool _IsBalance(Node* root)
	{
		if (root == NULL)
			return true;

		// 对当前树进行检查
		int leftHeight = Height(root->_left);
		int rightHeight = Height(root->_right);

		if (rightHeight - leftHeight != root->_bf)
		{
			cout << root->_kv.first << "现在是:" << root->_bf << endl;
			cout << root->_kv.first << "应该是:" << rightHeight - leftHeight << endl;
			return false;
		}

		return abs(rightHeight - leftHeight) < 2
			&& _IsBalance(root->_left)
			&& _IsBalance(root->_right);
	}
private:
	Node* _root;
};

六、AVL树的性能

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

七、总结

本篇文章主要是介绍了AVL树的插入，对其中的四种旋转方法做了详解。
重中之重要注意区分什么时候该用哪一种合适的旋转方法(根据节点的平衡因子判断)，以及双旋之后该对哪些节点的平衡因子做出调整(不需要死记硬背，记住其中一种双旋结果，另外的就可以类比了)。

此外，本篇文章中并没有少搜索、修改以及删除的方法。因为搜索和修改比较简单，类比搜索树即可。而删除操作还是需要进行平衡因子的检查以及相应的旋转操作，可以类比插入。

另外，本篇文章中AVL树中的数据是pair<int,int>型的，可以适用于更多场景。读者可以根据自身需要，将数据类型改为int等。

本篇完，青山不改，绿水长流！

Undefined__yu
关注
专栏目录
C++实现AVL树
番茄都是西红柿
04-12 1983
AVL树的名字来源于它的发明作者G.M. Adelson-Velsky 和 E.M. Landis。AVL树是最先发明的自平衡二叉查找树（Self-Balancing Binary Search Tree,简称平衡二叉树）。 一棵AVL树有如下必要条件： 1.它必须是二叉查找树。 2.每个节点的左子树和右子树的高度差至多为1。 左边二叉树的节点45左子树高度2，右子树高度0，...
C++实现 AVL树
sy1227081317的博客
06-04 478
文章目录AVL树简介AVL树的旋转整体代码实现 AVL树简介 AVL树是 “ 搜索 平衡 二叉 树” ，我们知道 AVL树 来自 搜索 树， 我们知道 搜素树可以有效的提高数据的查找效率， 但是如果我们创建搜索树时，数据接近有序，搜索树就会退化成单支，此时我们查找的时间复杂度依然会是O(n)。 因此， 俄罗斯的两位数学家发明了AVL树解决了这个问题，AVL树的命名也是由两位数学家的名字缩写得来。 AVL树的特点是， 树中，任意一个节点的左右子树的高度之差不大于1。 这样就避免了搜索树退化成单支的问题。当A
AVL树 C++ 实现
09-20
平衡二叉树(AVL)的C++实现。 用泛型写的。 IDE为VS2008 好像没别的了~ 就怎么个东西
C++之AVL树
cls的博客
05-23 1091
前面对map/multimap/set/multiset进行了简单的介绍，在其文档介绍中发现，这几个容器有个共同点是： 其底层都是按照二叉搜索树来实现的，但是二叉搜索树有其自身的缺陷，假如往树中插入的元素有序或者接近有序，二叉搜索树就会退化成单支树，时间复杂度会退化成O(N)，因此map、set等关联式容器的底层结构是对二叉树进行了平衡处理，即采用平衡树来实现。 AVL 树 AVL树的概念 二叉搜索树虽可以缩短查找的效率，但如果数据有序或接近有序二叉搜索树将退化为单支树，查找元素相当于在顺序表
【C++】---AVL树详解
最新发布
weixin_75128035的博客
08-10 977
由于要实现AVL树的增删改查，所以定义AVL树的节点，就需要定义parent，否则插入节点时，不知道要链接到树里面哪个节点下面。// 结点int _bf;// 平衡因子// 构造函数,_kv(kv),_bf(0)public://构造函数AVLTree(){}return;
AVL树的C++实现
kenby的专栏
06-08 4785
包括3个文件:AvlNode.h    AvlTree.h和main.cpp1.节点类的定义AvlNode.h#ifndef AVLNODE_H#define AVLNODE_H#include using namespace std;template  class AvlTree; //声明AvlTree类template class AvlNode{public:       frien
C++实现AVL树：学生管理系统的数据操作
"此资源是一个基于C++实现的AVL树，用于学生管理系统的代码实现，包含插入、查找、删除和调整等操作。" 在计算机科学中，AVL树是一种自...通过C++实现AVL树，可以深入理解数据结构的工作原理，并能应用于实际项目中。
C++实现AVL树示例代码分析
在C++实现AVL树时，通常需要定义节点类（包含数据域、左孩子指针、右孩子指针和平衡因子）和树类（包含根节点指针及其它操作函数）。每个操作函数都需要维护树的平衡性，包括插入、删除、查找等基本操作，以及平衡...
【数据结构】AVL树——C++实现
Sauron7i的博客
10-01 1089
AVL树特点：**在BST树的基础上，引入了节点“平衡”的概念，任意一个节点的左右子树高度差不超过1。** **为什么要引入平衡这个概念？** 在BST树中，由于插入后就是排序好的，那就会存在这样一种情况：如果插入的元素依次增大，就会导致理想中的二叉树，形成了一个链表，如下图，这种情况会导致增删查的时间复杂度并不是O(logn)，而是O(n)。为了解决这样情况，引入了平衡的概念。
c++实现的avl树
03-09
包括插入，删除等操作的AVL树，C++实现
AVL树的实现基于C++语言
12-03
这两个源文件主要实现了基于C++语言编写的AVL树，将AVL树的所有操作都实现了。测试平台为Linux，现将AVL树的源码奉上。
AVL树（C++）
11-05
基于 C++实现avl树的学生管理系统基于 可直接运行，代码全自己实现
c++——AVL树
Britney_dark的博客
11-08 1755
如果结果不如你所愿，就在尘埃落定前奋力一搏！
AVL树(C++实现)
清欢Allen的技术博客
04-14 1280
我们实现的是KV模型的AVL树,为了方便后续的操作,这里AVL树结点定义为三叉链结构,并且引入平衡因子,方便判断每棵树的平衡情况,并且还需要一个初始化列表将结点成员全部初始化.//三叉链 AVLTreeNode < K , V > * _left;//存储键值对 int _bf;
AVL树的实现（C++)
King_DJF的博客
10-22 812
Implement of AVL_Tree using CppImplement of AVL_Tree using Cpp
C++进阶——AVL树的构建
weixin_43635473的博客
05-15 651
AVLTreeNode(const pair < k , v > & kv) //节点构造函数 : _left(nullptr) , _right(nullptr) , _parent(nullptr) , _kv(kv) , _be(0) {int _be;
AVL树—— C++实现
Mind_V的博客
05-22 674
AVL树的介绍 AVL树的C实现 AVL树节点 AVL树接口 旋转操作核心 1 LL的旋转 2 RR的旋转 3 LR的旋转 4 RL的旋转 完整的实现代码AVL树的介绍二叉查找树的深度越小，那么查找所需要的运算时间越小。一个深度为log(n)的二叉查找树，查找算法的时间复杂度也是log(n)。然而，我们在二叉查找树中已经实现的插入和删除操作并不能让保持log(n)的深度。如果我们按照8，7，6，5，
评论 11
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Undefined__yu

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

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

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

打赏作者

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

抵扣说明：

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

余额充值