数据结构——AVL树(详解 + C++模拟实现)

最新推荐文章于 2024-11-07 11:26:19 发布
最新推荐文章于 2024-11-07 11:26:19 发布
阅读量313 收藏 1
点赞数
分类专栏： C++ 数据结构 文章标签： 数据结构 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_72883322/article/details/133418780
版权

文章目录

前言

本篇博客将为大家详细讲述AVL树是什么以及其相对于普通的二叉搜索树有什么优点，将详细讲述其拥有哪些性质，并且通过模拟实现的方式让大家对该数据结构有更深入的理解和认识，对于该数据结构的增删查改操作，其中的删除操作是在普通搜索二叉树的基础上进行一些改进，会简单提及，但不会细讲，重点将会讲述插入操作，查和改操作和二叉搜索树一模一样，也不做讲解。

由于AVL树是一棵特殊的二叉搜索树，因此想要学习AVL树需要先知道二叉搜索树是什么东西，如果有不知道二叉搜索树是什么的小伙半可以先看看博主的另一篇博客:
数据结构—— 二叉搜索树(附c++模拟实现)
该篇博客详细介绍了二叉搜索树。

AVL树的概念

我们知道，二叉搜索树虽然可以缩短查找的效率，但如果数据有序或接近有序，那么此时二叉搜索树将会退化成单支树，此时的查找效率和在链表中搜索等同，效率低下，因此，两位俄罗斯的数学家(G.M.Adelson-Velskii 和E.M.Landis)在1962年的时候发明了一种解决上述问题的方法：

当向二叉搜索树中插入新节点后，如果能够保证每个节点的左右子树高度差的绝对值不超过1(在不破坏二叉搜素树性质的情况下对树中节点进行调整)，即可降低树的高度，从而减少平均搜索长度。

因此，AVL树就这样诞生了！
一棵AVL树可以是空树，或者是具有如下性质的搜索二叉树：

  • 它的左右子树都是AVL树
  • 左右子树高度之差的绝对值超过1

在这里插入图片描述

因此，对于一棵AVL树，最重要的就是如何控制每棵树左右子树高度之差都不超过1，这种控制是通过翻转操作来实现的，博主在下文会重点讲解。

另外，AVL树的实现方式有两种，一种就是在插入的过程中动态的检查左右子树的高度差是否超过1，另外一种就是引入一个新的概念——平衡因子，对于每个节点都存储一个int值表示该根节点左右子树的高度差，负数代表左子树更高，正数代表右子树更高，然后在插入的过程中不断维护每个节点的平衡因子即可。

这里由于第二种方法实现起来相对逻辑更加清晰，所以我们采用第二种方法进行模拟实现，并且用key_value的模型进行实现

AVL树节点的定义

和普通二叉搜索树节点定义不同的是，AVL树的节点为了方便进行旋转操作，需要多加一个指针指向其双亲节点，并且还要有一个int值表示平衡因子，定义如下：

template<typename K, typename V>
struct TreeNode
{
	pair<K, V> _kv;
	TreeNode<K, V>* _parent = nullptr;
	TreeNode<K, V>* _left = nullptr;
	TreeNode<K, V>* _right = nullptr;
	int _bf = 0;          //balance factor
	TreeNode(const K& key, const V& value)
		:_kv({ key, value })
	{}
};

AVL树类框架

template<typename K, typename V>
class AVL_Tree
{
	typedef TreeNode<K, V> node;
private:
	node* _root = nullptr;
public:
	bool insert(const pair<K, V>& kv)	
	void inorder();
	void is_AVL();
};

AVL树的插入

AVL树就是在二叉搜索树的基础上引入平衡因子，因此插入过程其实可以分成两步：

  1. 按照二叉搜索树的方式插入新节点
  2. 调整节点的平衡因子

对于第一步按照二叉搜索树的规则插入新节点的步骤这里不进行详解，这里重点讲解如何调整插入节点后各个AVL树节点的平衡因子。

pCur表示新插入的节点，pParent表示新插入节点的父节点，（需要找到父节点是节点定义时需要定义指向双亲的指针的原因之一）。
pCur插入后， pParent的平衡因子一定需要调整，插入之前，pParent的平衡因子分为三种情况(-1/0/1)，而根据pCur插入位置的不同，可以分为以下两种情况：

  1. 如果pCur插入到pParent的左侧，只需要给pParent的平衡因子减一
  2. 如果pCur插入到pParent的右侧，只需要给pParent的平衡因子加一

pParent的平衡因子经过修改后，可能会出现五种情况，0，±1，±2

  1. 如果pParent的平衡因子为0，说明修改后以pParent为根节点的最高高度并没有发生变化，所以无需继续调整，插入成功
    如下图所示：在这里插入图片描述
  2. 如果插入后pParent的平衡因子为±1，说明插入前pParent的平衡因子一定是0，插入后被更新成±1，说明插入后以pParent为根的子树高度增加了1，也就是说我们需要继续向上更新祖先节点的平衡因子
    如下图所示:
    在这里插入图片描述
    这个过程将不断循环，直到一直更新到pParent的平衡因子为0或者pParent更新到根节点为止。
  1. 如果pParent的平衡因子为±2，那么此时以pParent为根的树已经不满足AVL树的性质了，此时，就需要进行旋转操作，对于旋转是什么，我们在下一个小节进行讲解，这里先给出插入代码整体框架：
	bool insert(const pair<K, V>& kv)
	{
		//如果头节点为空，直接将值赋给头节点即可
		if (!_root)
		{
			node* newNode = new node(kv.first, kv.second);
			_root = newNode;
			return true;
		}
		//如果不为空，寻找插入位置
		node* parent = nullptr, *cur = _root;
		while (cur)
		{
			auto& key = cur->_kv.first;
			parent = cur;
			if (kv.first > key)
				cur = cur->_right;
			else if (kv.first < key)
				cur = cur->_left;
			else 
				return false;
		}
		node* newNode = new node(kv.first, kv.second);
		//循环结束，找到插入位置
		if (parent->_kv.first < kv.first)
			parent->_right = newNode;
		else
			parent->_left = newNode;
		newNode->_parent = parent;

		cur = newNode;
		//更新平衡因子
		while (parent)
		{
			//先修改因子
			//判断新增节点的方位对parent的平衡因子进行处理
			if (parent->_right == cur)
				parent->_bf++;
			else
				parent->_bf--;
			if (parent->_bf == 0) break;
			//如果parent的平衡因子为±1，继续处理
			else if (abs(parent->_bf) == 1)
			{
				cur = parent;
				parent = parent->_parent;
			}
			else if (abs(parent->_bf) == 2)
			{
				//此时以pParent为根的子树已经违反了AVL树的特性，需要进行旋转处理
				//...
			}
			//由于平衡因子的情况只有以上五种，出现其他种类的平衡因子说明AVL树已经被破坏
			//通过抛异常来显示
			else throw "the bf out_of_range";

		}
		return true;
	}

AVL树的旋转

上一小节说到，在一棵本来是平衡的AVL树中插入一个新节点，可能导致不平衡，必须调整树的结构，使之平衡，这一步也叫做旋转，AVL树的旋转也分为四种：

旋转的本质其实是使高度较高的子树高度降低，然后将降低的高度给到其另一个较低的子树

新节点插入较高子树的左侧 —— 左左: 右单旋

在这里插入图片描述

上图是左单旋的普遍思路，但是我们还需要考虑一些特殊场景:

  1. 30的右孩子可能存在，也可能不存在
  2. 60可能是根节点，也可能是子树
    如果60是根节点，旋转完成之后需要更新根节点，如果60是子树，可能是左子树也可能是右子树，需要注意更改上面的链接关系

这里大家可以自行画图模拟一下各种特殊场景，至于为什么要考虑这些场景，是因为虽然整个思路很简单，但是由于我们整棵树是以三叉链的形式来存储的，所以修改过程中需要维护这一结构。
下面是右旋代码：

void reverseR(node* parent)
{
	node* cur = parent->_left, *ppnode = parent->_parent;
	node* curR = cur->_right;
	//连接parent和curR
	parent->_left = curR;
	if (curR)
		curR->_parent = parent;
	//连接cur和parent
	cur->_right = parent;
	parent->_parent = cur;
	//连接ppnode和cur
	cur->_parent = ppnode;
	if (ppnode)
	{
		if (ppnode->_right == parent)
			ppnode->_right = cur;
		else
			ppnode->_left = cur;
	}
	else
		_root = cur;
	//跟新bf
	parent->_bf = cur->_bf = 0;
}

新节点插入较高右子树的右侧——右右: 左单旋

在这里插入图片描述
由于右单旋和左单旋基本类似，这里不进行细致讲解，下面是实现代码:

void reverseL(node* parent)
{
	node* ppnode = parent->_parent, *cur = parent->_right;
	node* curL = cur->_left;
	// 连接parent和curLeft
	parent->_right = curL;
	if (curL) curL->_parent = parent;
	// 连接parent和cur
	cur->_left = parent;
	parent->_parent = cur;
	//跟新parent和cur的平衡因子
	parent->_bf = cur->_bf = 0;
	//更新根节点或者与ppnode的连接关系
	if (ppnode)
	{
		if (ppnode->_right == parent)
			ppnode->_right = cur;
		else
			ppnode->_left = cur;
		cur->_parent = ppnode;
	}
	else
	{
		_root = cur;
		cur->_parent = nullptr;
	}
}

新节点插入较高左子树的右侧 —— 左右： 先左单旋然后再有单旋

在这里插入图片描述
其次，对于右左单旋来说还有一个需要考虑的点就是平衡因子的更新，对于这个问题，我们可以先总结一下上图，（90作为pParent, 30作为pCur, 60作为curR）左右单旋的结果其实使把curR的左子树与pCur链接，curR的右子树与pParent链接，然后curR作为新树的根，那么平衡因子的修改就需要根据60的平衡因子为状况进行修改了,curR的平衡因子一共有三种情况(-1/0/1).我们逐步分析：

  1. curR是新插入的节点 —— curR的平衡因子是0，相当于上图中h等于0的情况

插入后pParent，pCur和curR的平衡因子都变成0

  1. 插入在curR的左子树 —— curR的平衡因子是-1

由于插入后curR的左子树交给了pCur，也就是上图中的情况，此时pCur和curR的平衡因子都变成0，pParent的平衡因子变成1

  1. 插入在curR的右子树——curR的平衡因子是1

对应的就是上图中c的高度是h, b的高度是h - 1, 此时pParent 和 curR的平衡因子都变成0， pCur的平衡因子变成-1

因此，旋转后平衡因子的改变是根据curR的平衡因子的状况就行分类修改的，并且由于上文中我们定义了左右旋转的函数，直接复用就可以得到左右单选的函数，代码如下:

	void reverseRL(node* parent)
	{
		node* cur = parent->_right, * curL = cur->_left;
		int bf = curL->_bf;
		reverseR(cur);
		reverseL(parent);
		if (bf == 0)
			cur->_bf = parent->_bf = curL->_bf = 0;
		else if (bf == -1)
		{
			cur->_bf = 1;
			parent->_bf = curL->_bf = 0;
		}
		else if (bf == 1)
		{
			parent->_bf = -1;
			cur->_bf = curL->_bf = 0;
		}
		else
			throw "balance factor out_of_range";
	}

新节点插入较高右子树的左侧：右左单旋

在这里插入图片描述
这里的思考方式和右左单选相同，留给大家自己思考。

旋转总结

假如以pParent为根的子树不平衡，即pParent的平衡因子为±2，分以下情况考虑：

  1. pParent的平衡因子为2，说明pParent的右子树高，设pParent的右子树的根为pCur
  • 当pCur的平衡因子为1是，执行左单旋
  • 如果是-1，执行右左单选
  1. pParent的平衡因子为-2，说明pParent的左子树高，设pParent的左子树的根为pCur
  • 当pCur的平衡因子为-1时，执行右单旋
  • 当pCur的平衡因子为1时，执行左右单旋
    另外，我们可以发现旋转完成之后，当前根的平衡因子都变成了0，因此不需要继续向上更新

AVL树插入完整代码

public:
	bool insert(const pair<K, V>& kv)
	{
		//如果头节点为空，直接将值赋给头节点即可
		if (!_root)
		{
			node* newNode = new node(kv.first, kv.second);
			_root = newNode;
			return true;
		}
		//如果不为空，寻找插入位置
		node* parent = nullptr, *cur = _root;
		while (cur)
		{
			auto& key = cur->_kv.first;
			parent = cur;
			if (kv.first > key)
				cur = cur->_right;
			else if (kv.first < key)
				cur = cur->_left;
			else 
				return false;
		}
		node* newNode = new node(kv.first, kv.second);
		//循环结束，找到插入位置
		if (parent->_kv.first < kv.first)
			parent->_right = newNode;
		else
			parent->_left = newNode;
		newNode->_parent = parent;
	
		cur = newNode;
		//更新平衡因子
		while (parent)
		{
			//先修改因子
			//判断新增节点的方位对parent的平衡因子进行处理
			if (parent->_right == cur)
				parent->_bf++;
			else
				parent->_bf--;
			if (parent->_bf == 0) break;
			//如果parent的平衡因子为±1，继续处理
			else if (abs(parent->_bf) == 1)
			{
				cur = parent;
				parent = parent->_parent;
			}
			else if (abs(parent->_bf) == 2)
			{
				//进行翻转操作
				if (parent->_bf == 2 && cur->_bf == 1) reverseL(parent);
				else if (parent->_bf == -2 && cur->_bf == -1)reverseR(parent);
				else if (parent->_bf == 2 && cur->_bf == -1) reverseRL(parent);
				else if (parent->_bf == -2 && cur->_bf == 1) reverseLR(parent);
				break;
			}
			//由于平衡因子的情况只有以上五种，出现其他种类的平衡因子说明AVL树已经被破坏
			//通过抛异常来显示
			else throw "the bf out_of_range";

		}
		return true;
	}
private:
	void reverseL(node* parent)
	{
		node* ppnode = parent->_parent, *cur = parent->_right;
		node* curL = cur->_left;
		// 连接parent和curLeft
		parent->_right = curL;
		if (curL) curL->_parent = parent;
		// 连接parent和cur
		cur->_left = parent;
		parent->_parent = cur;
		//跟新parent和cur的平衡因子
		parent->_bf = cur->_bf = 0;
		//更新根节点或者与ppnode的连接关系
		if (ppnode)
		{
			if (ppnode->_right == parent)
				ppnode->_right = cur;
			else
				ppnode->_left = cur;
			cur->_parent = ppnode;
		}
		else
		{
			_root = cur;
			cur->_parent = nullptr;
		}
	}
	void reverseR(node* parent)
	{
		node* cur = parent->_left, *ppnode = parent->_parent;
		node* curR = cur->_right;
		//连接parent和curR
		parent->_left = curR;
		if (curR)
			curR->_parent = parent;
		//连接cur和parent
		cur->_right = parent;
		parent->_parent = cur;
		//连接ppnode和cur
		cur->_parent = ppnode;
		if (ppnode)
		{
			if (ppnode->_right == parent)
				ppnode->_right = cur;
			else
				ppnode->_left = cur;
		}
		else
			_root = cur;
		//跟新bf
		parent->_bf = cur->_bf = 0;
	}
	void reverseRL(node* parent)
	{
		node* cur = parent->_right, * curL = cur->_left;
		int bf = curL->_bf;
		reverseR(cur);
		reverseL(parent);
		if (bf == 0)
			cur->_bf = parent->_bf = curL->_bf = 0;
		else if (bf == -1)
		{
			cur->_bf = 1;
			parent->_bf = curL->_bf = 0;
		}
		else if (bf == 1)
		{
			parent->_bf = -1;
			cur->_bf = curL->_bf = 0;
		}
		else
			throw "balance factor out_of_range";
	}
	void reverseLR(node* parent)
	{
		node* cur = parent->_left;
		node* curR = cur->_right;
		int bf = curR->_bf;
		reverseL(cur);
		reverseR(parent);
		if (bf == 0)
			cur->_bf = parent->_bf = curR->_bf = 0;
		else if (bf == -1)
		{
			parent->_bf = -1;
			cur->_bf = curR->_bf = 0;
		}
		else if (bf == 1)
		{
			cur->_bf = 1;
			curR->_bf = parent->_bf = 0;
		}
		else 
			throw"balance factor out_of_range";
	}

AVL树的验证

可以通过监视窗口进行验证，但是这样过于麻烦，我们可以设计一个验证函数：

验证其为二叉搜索树

如果中序遍历能够得到一个有序序列，那就说明是二叉搜索树

public:
	void inorder() 
	{
		_inorder(_root); 
		cout << endl;
		return;
	}
private:
	void _inorder(node* root)
	{
		if (!root) return;
		_inorder(root->_left);
		cout << root->_kv.first << ' ' << root->_kv.second << endl;
		_inorder(root->_right);
	}

验证其为平衡树

  • 每个节点子树的高度绝对值不超过1
  • 验证节点的平衡因子是否计算正确
    博主采用的是回溯的方法来验证，先验证左子树和右子树是否为AVL_Tree，同时返回该树的高度，用于验证上层的树是否为AVL_Tree。
    代码如下:
public:
	void is_AVL() 
	{
		auto ret = _is_AVL(_root); 
		if (ret.second) cout << "this tree is AVL_tree\n";
	}
private:
	pair<int, bool> _is_AVL(node* root)
	{
		pair<int, bool> ret{ 0, true };
		if (!root) return ret;
		auto ret_left = _is_AVL(root->_left);
		auto ret_right = _is_AVL(root->_right);
		ret.second = ret_left.second && ret_right.second;
		//判断平衡因子是否正确
		int ans_bf = ret_right.first - ret_left.first;
		if (ans_bf != root->_bf)
		{
			printf("平衡因子计算错误，正确平衡因子: %d, 当前平衡因子:%d", ans_bf, root->_bf);
			ret.second = false;
		}
		if (abs(ans_bf) >= 2)
		{
			cout << "平衡因子超过最大值\n";
			ret.second = false;
		}
		ret.first = max(ret_left.first, ret_right.first) + 1;
		return ret;
	}

AVL树的删除

因为AVL树也是搜索二叉树，所以可以按照搜索二叉树的方式将节点删除，然后只需要加入更新平衡因子的步骤就可以了，比较不同的是删除操作下平衡因子的更新是如果删除后节点的平衡因子为0还需要继续更新，而如果是±1不需要继续更新，±2进行旋转，但是旋转完成之后由于根的平衡因子变成了0，还有可能需要继续向上更新。

AVL树的性能

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

完整实现代码

template<typename K, typename V>
struct TreeNode
{
	pair<K, V> _kv;
	TreeNode<K, V>* _parent = nullptr;
	TreeNode<K, V>* _left = nullptr;
	TreeNode<K, V>* _right = nullptr;
	int _bf = 0;
	TreeNode(const K& key, const V& value)
		:_kv({ key, value })
	{}
};

template<typename K, typename V>
class AVL_Tree
{
	typedef TreeNode<K, V> node;
private:
	node* _root = nullptr;
public:
	bool insert(const pair<K, V>& kv)
	{
		//如果头节点为空，直接将值赋给头节点即可
		if (!_root)
		{
			node* newNode = new node(kv.first, kv.second);
			_root = newNode;
			return true;
		}
		//如果不为空，寻找插入位置
		node* parent = nullptr, *cur = _root;
		while (cur)
		{
			auto& key = cur->_kv.first;
			parent = cur;
			if (kv.first > key)
				cur = cur->_right;
			else if (kv.first < key)
				cur = cur->_left;
			else 
				return false;
		}
		node* newNode = new node(kv.first, kv.second);
		//循环结束，找到插入位置
		if (parent->_kv.first < kv.first)
			parent->_right = newNode;
		else
			parent->_left = newNode;
		newNode->_parent = parent;

		cur = newNode;
		//更新平衡因子
		while (parent)
		{
			//先修改因子
			//判断新增节点的方位对parent的平衡因子进行处理
			if (parent->_right == cur)
				parent->_bf++;
			else
				parent->_bf--;
			if (parent->_bf == 0) break;
			//如果parent的平衡因子为±1，继续处理
			else if (abs(parent->_bf) == 1)
			{
				cur = parent;
				parent = parent->_parent;
			}
			else if (abs(parent->_bf) == 2)
			{
				//进行翻转操作
				if (parent->_bf == 2 && cur->_bf == 1) reverseL(parent);
				else if (parent->_bf == -2 && cur->_bf == -1)reverseR(parent);
				else if (parent->_bf == 2 && cur->_bf == -1) reverseRL(parent);
				else if (parent->_bf == -2 && cur->_bf == 1) reverseLR(parent);
				break;
			}
			//由于平衡因子的情况只有以上五种，出现其他种类的平衡因子说明AVL树已经被破坏
			//通过抛异常来显示
			else throw "the bf out_of_range";

		}
		return true;
	}
	void inorder() 
	{
		_inorder(_root); 
		cout << endl;
		return;
	}
	void is_AVL() 
	{
		auto ret = _is_AVL(_root); 
		if (ret.second) cout << "this tree is AVL_tree\n";
	}
private:
	void reverseL(node* parent)
	{
		node* ppnode = parent->_parent, *cur = parent->_right;
		node* curL = cur->_left;
		// 连接parent和curLeft
		parent->_right = curL;
		if (curL) curL->_parent = parent;
		// 连接parent和cur
		cur->_left = parent;
		parent->_parent = cur;
		//跟新parent和cur的平衡因子
		parent->_bf = cur->_bf = 0;
		//更新根节点或者与ppnode的连接关系
		if (ppnode)
		{
			if (ppnode->_right == parent)
				ppnode->_right = cur;
			else
				ppnode->_left = cur;
			cur->_parent = ppnode;
		}
		else
		{
			_root = cur;
			cur->_parent = nullptr;
		}
	}
	void reverseR(node* parent)
	{
		node* cur = parent->_left, *ppnode = parent->_parent;
		node* curR = cur->_right;
		//连接parent和curR
		parent->_left = curR;
		if (curR)
			curR->_parent = parent;
		//连接cur和parent
		cur->_right = parent;
		parent->_parent = cur;
		//连接ppnode和cur
		cur->_parent = ppnode;
		if (ppnode)
		{
			if (ppnode->_right == parent)
				ppnode->_right = cur;
			else
				ppnode->_left = cur;
		}
		else
			_root = cur;
		//跟新bf
		parent->_bf = cur->_bf = 0;
	}
	void reverseRL(node* parent)
	{
		node* cur = parent->_right, * curL = cur->_left;
		int bf = curL->_bf;
		reverseR(cur);
		reverseL(parent);
		if (bf == 0)
			cur->_bf = parent->_bf = curL->_bf = 0;
		else if (bf == -1)
		{
			cur->_bf = 1;
			parent->_bf = curL->_bf = 0;
		}
		else if (bf == 1)
		{
			parent->_bf = -1;
			cur->_bf = curL->_bf = 0;
		}
		else
			throw "balance factor out_of_range";
	}
	void reverseLR(node* parent)
	{
		node* cur = parent->_left;
		node* curR = cur->_right;
		int bf = curR->_bf;
		reverseL(cur);
		reverseR(parent);
		if (bf == 0)
			cur->_bf = parent->_bf = curR->_bf = 0;
		else if (bf == -1)
		{
			parent->_bf = -1;
			cur->_bf = curR->_bf = 0;
		}
		else if (bf == 1)
		{
			cur->_bf = 1;
			curR->_bf = parent->_bf = 0;
		}
		else 
			throw"balance factor out_of_range";
	}
	//需要知道两个东西，层数高度以及高度差
	pair<int, bool> _is_AVL(node* root)
	{
		pair<int, bool> ret{ 0, true };
		if (!root) return ret;
		auto ret_left = _is_AVL(root->_left);
		auto ret_right = _is_AVL(root->_right);
		ret.second = ret_left.second && ret_right.second;
		//判断平衡因子是否正确
		int ans_bf = ret_right.first - ret_left.first;
		if (ans_bf != root->_bf)
		{
			printf("平衡因子计算错误，正确平衡因子: %d, 当前平衡因子:%d", ans_bf, root->_bf);
			ret.second = false;
		}
		if (abs(ans_bf) >= 2)
		{
			cout << "平衡因子超过最大值\n";
			ret.second = false;
		}
		ret.first = max(ret_left.first, ret_right.first) + 1;
		return ret;
	}
	void _inorder(node* root)
	{
		if (!root) return;
		_inorder(root->_left);
		cout << root->_kv.first << ' ' << root->_kv.second << endl;
		_inorder(root->_right);
	}

};

总结

AVL树的出现较为有效的解决了二叉搜索树在极端情况下效率低下的问题，但还处理的不够完善，因此，后面又出现了红黑树，对于AVL树在一些地方会更有优势，红黑树博主在之后也会讲解！关于AVL树的知识就到此结束了，如果大家有什么疑惑或者发现博主写的有哪些问题，欢迎在评论区指出！

数据结构——红黑树（详解性质+C++模拟）
weixin_72883322的博客
10-05 366
本篇博客将为大家重点讲述红黑树这一数据结构，讲解其实现的方式即其具有的性质，并且最后用C++进行模拟实现这一数据结构，和AVL树相同，这篇文章也着重讲解关于其的插入操作。
数据结构——红黑树详解
rab1211764820的博客
04-02 1312
红黑树的模拟实现 红黑树的验证 红黑树与AVL树的比较
AVL树的介绍与模拟实现（insert+旋转调平精美图示超详解哦）
weixin_73450183的博客
02-02 1179
AVL树在满足二叉搜索树条件的基础上，给每个结点中增加了一个平衡因子（这个平衡因子的值是该结点左右子树的高度差）。AVL树要求平衡因子的绝对值小于等于1，即任意一个结点左右子树的高度差不超过1。通过降低树的高度，从而达到减少平均搜索时间的效果（在这里做例子的平衡二叉树是按照大小次序依次插入的结果）
【高阶数据结构】红黑树详解
m0_70980326的博客
08-17 3110
红黑树详解
【C++】详解红黑树并模拟实现
ZZZCCC的博客
09-08 436
我们还是沿用AVL树节点的三叉链定义方法，颜色我们用枚举来实现：ps：这里一开始结点定义为红色的原因，我们在后文插入的时候会详细讲解。
高度平衡二叉搜索树（AVL树）
bang___bang_的博客
07-20 585
本文详解AVL树的插入操作，分为2种情况：不旋转和旋转；旋转又细分4个情况:左单璇、右单旋、左右双旋、右左双旋。文章图文并茂，详细讲解实现操作和代码实现。不要从轮子重新造起，要站在巨人的肩膀上！深究原理和实现细节是绝对有帮助的！
模拟实现哈希表超详解（C++）
m0_67430750的博客
05-15 7341
模拟实现哈希表两万字详解，包括哈希表的闭散列实现和开散列实现，以及迭代器的实现。
[数据结构] RBTree && 模拟实现RBTree
水墨不写bug
08-19 910
红黑树（RBTree）详解，模拟实现红黑树
二叉平衡树——插入操作（C++)
ll2633ll的博客
06-13 291
本文手写了AVL树的插入操作代码（C++），供大家分享~
数据结构 算法与应用（c++ 描述） 自练答案
qq_57065913的博客
09-12 4651
有不正确请提出 第一章 1.1 应该把形参 换成引用 int x--> int &x 1.2 #include<iostream> using namespace std; template <class T,class T1> //模板形参的类型 int count (T array,int end,T1 value){ int i =0,count=0; while(i<...
北京大学pku——acm一些题的详解
11-30
2. **数据结构**：ACM题目常涉及到链表、树（二叉树、平衡树如AVL、红黑树）、图、栈、队列、堆、哈希表等数据结构。熟悉它们的特性和操作方式，有助于高效地解决问题。 3. **字符串处理**：字符串在ACM中占据重要...
C++语言描述(PDF合集)
07-13
第二部分 数据结构 第3章 数据描述 75 3.1 引言 75 3.2 线性表 76 3.3 公式化描述 77 3.3.1 基本概念 77 3.3.2 异常类NoMem 79 3.3.3 操作 79 3.3.4 评价 83 3.4 链表描述 86 3.4.1 类ChainNode 和Chain 86 3.4.2 ...
福建省算法夏令营2018——课件
10-22
2. **数据结构详解**：数据结构是算法的基础，课件可能涉及数组、链表、栈、队列、树（二叉树、平衡树如AVL和红黑树）、图、哈希表等。理解它们的性质和操作，对于优化算法至关重要。 3. **算法实例与应用**：通过...
3013-Algorithms-Gordon
03-15
C++中的链表、栈、队列、树（如二叉搜索树、AVL树和红黑树）以及图都是常见的数据结构，它们在不同类型的算法中发挥着关键作用。 4. **图论**：在解决网络问题、最短路径、最小生成树等问题时，图论算法如Dijkstra...
Algorithm：【算法进阶之路】之算法面试刷题集合—数据结构的简介、最强学习路线(逻辑结构【数组-链表-栈和队列/树-图-哈希】、物理结构【元素/关系】、数据运算【十大排序/四大查找-图三大搜索-
近期请国内外头部出版社可尽快私信博主！——心比天高，仗剑走天涯，保持热爱，奔赴向梦想！低调，谦虚，自律，反思，成长，还算是比较正能量的博主，公益免费传播……内心特别想在AI界做出一些可以推进历史进程影响力的东西(兴趣使然，有点小情怀，也有点使命感呀)…
08-05 6032
​ Algorithm：【算法进阶之路】之算法面试刷题集合—数据结构的简介、最强学习路线(逻辑结构【数组-链表-栈和队列/树-图-哈希】、物理结构【元素/关系】、数据运算【十大排序/四大查找-图三大搜索-树三大遍历】、高级算法【枚举/回溯/递归/分治/动规/贪心】)、问题为导向的十大类刷题算法总结之详细攻略 目录 相关文章 数据结构思维导图 基本术语 一、数据结构的概述 二、数据的逻辑结构 三、数据的物理结构 四、数据的运算
C++求职基础汇总
Not everything that counts can be counted
07-26 1113
整理一些C++知识， 主要参考这里，文中引用已给出连接。 C/C++ 封装、继承、多态、重载、覆盖、隐藏 面向对象的三个特征： 封装：就是把客观事物封装为抽象的类，且类可以把自己的数据和方法只让可信的对象或者类进行操作，对不可信的类进行隐藏； 继承：可以使用现有类的所有功能，并在无需重新编写的情况写对这些功能进行拓展。通过继承产生了基类和派生类。继承是一种从一般到复杂的过程。 基类的数据成员和成员函数在派生类中都有一份拷贝，派生类能够直接访问从基类继承而来的public和protected成员，且
《算法和数据结构》从语言到算法的过渡篇_当语言学到什么程度可以开始学算法了
2401_84586779的博客
04-26 2581
看到太多爆肝熬夜整合的内容，又是几万字，又是爆肝，我也来试试看能不能扛得住。试完后发现，果然还是扛不住啊。但是既然整理完了，那就把我的算法学习路线发出来吧，我把整个算法学习的阶段总结成了五个步骤，分别为：「 基础语法 」「 语法练习 」「 数据结构 」「 算法入门 」「 算法进阶 」。本文梳理了这五个大项的思维导图，在下文会有详细介绍。希望各位能够找到自己的定位，通过自己的努力在算法这条路上越走越远。刚开始切勿心浮气躁，说一定要把这么多东西都学会。就算你的精力旺盛，日夜操劳，时间也是有限的。
精心整理2万字c++知识点
WangXinyu_090926的博客
11-30 4802
制作不易，求一键三连~ 文章目录1、基本数据结构数组链表队列、单调队列、双端队列栈2、中极数据结构堆并查集与带权并查集hash表自然溢出双hash3、高级数据结构树状数组线段树及其合并Zkw线段树Fhq线树超哥线段树平衡树Treap随机平衡二叉树Splay伸展树Scapegoat Tree替罪羊树后缀平衡树块状数组、块状链表树套树线段树套线段树线段树套平衡树平衡树套线段树可并堆左偏树配对堆KDTree、四分树舞蹈链（DLX）、二进制分组划分树4、可持久化数据结构可持久化线段树（主席树）可持久化平衡树可持久化
【数据结构与算法】-空间复杂度
最新发布
前鼻音的博客
11-07 1035
空间复杂度是衡量算法在运行过程中临时占用存储空间大小的一个重要指标。它描述了算法所需的额外存储空间与输入数据规模之间的关系。空间复杂度通常也用大O表示法（Big O notation）来表示。递归调用栈：考虑递归调用栈的深度。动态规划：考虑中间结果的存储空间。多维数组：考虑多维数组的大小。缓存和哈希表：考虑缓存和哈希表的大小。图的遍历：考虑访问状态记录和递归调用栈的大小。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

暮雨清秋.L

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

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

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

打赏作者

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

抵扣说明：

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

余额充值