AVL树的实现

谷雨不太卷2025-06-15 9:22

AVL树是一棵平衡二叉搜索树

二叉搜索树虽可以缩短查找的效率，但如果数据有序或接近有序二叉搜索树将退化为单支树，查

找元素相当于在顺序表中搜索元素，效率低下

一种解决上述问题的方法：当向二叉搜索树中插入新结点后，如果能保证每个结点的左右子树高度之差的绝对值不超过1(需要对树中的结点进行调整)，即可降低树的高度，从而减少平均搜索长度，平衡二叉搜索树就诞生了。

在这里，主要实现他的调节功能。

首先在每一个节点了都需要一个平衡因子bf，通过平衡因子判断是否平衡。

cpp 复制代码 
template<class T, class V >
struct AVLTreeNode
{
	AVLTreeNode<T,V>* _parent; // 指向其父节点
	AVLTreeNode<T,V>* _left;
	AVLTreeNode<T,V>* _right;
	T _key;
	V _value;
	int bf;   //  平衡因子
	AVLTreeNode(const T& key = T(), const V& value = V())
		:_parent(nullptr)
		,_left(nullptr)
		,_right(nullptr)
		,_key(key)
		,_value(value)
		,bf(0)
	{}
};

bf为右子树的高度减左子树的高度，也就是说，平衡搜索二叉树要保持每一个节点里的bf都小于2，大于-2。

在之前，已经实现了通过插入就可以保持一颗搜索树。

插入代码(未调节)

cpp 复制代码 
template<class T, class V >
class AVLTree
{
	typedef AVLTreeNode<T, V> AVLTreeNode;
public:
	AVLTree()
		:_node(nullptr)
	{ }
	bool Insert(const T& key = T(), const V& value = V())
	{
		if (_node == nullptr)
		{
			_node = new AVLTreeNode(key,value);
			return true;
		}

		AVLTreeNode* cur = _node;
	    AVLTreeNode* parent = nullptr;  
		while (cur != nullptr)
		{
			if (cur->_key == key)
			{
				return false; 
			}
			if (cur->_key > key)
			{
				parent = cur;
				cur = cur->_left;
			}
			else
			{
				parent = cur;
				cur = cur->_right;
			}
		}

		if (key < parent->_key)
		{
			parent->_left = new AVLTreeNode(key, value);
			parent->_left->_parent = parent;
		}
		else
		{
			parent->_right = new AVLTreeNode(key, value);
			parent->_right->_parent = parent;
		}

接下来就是对平衡因子的判断的对树的调节，因为当我们插入一个节点，其祖先节点可能都会发生改变。

可以看出，当插入一个节点时，其祖先节点可能受影响，其他节点不受影响。

只需要向上调节并排查祖先的平衡因子。当某个祖先的平衡因子bf==0的时候结束。

如何调节祖先的平衡因子与为什么bf==0就结束呢？

蓝色方框表示将要插入的节点

这里的bf指2的bf。

图一，bf==1，左插入后，bf==0。

图二，bf==-1，右插入后，bf=0。

图三，bf==0，右插入后，bf=1。

图四，bf==0，左插入后，bf=-1。

可以发现，左插入，bf--，右插入，bf++

当插入后bf==0，其所有祖先的高度并没有被影响。

当插入后bf==1/-1，就要去向上判断祖先是否被影响，图三，图四(2的父节点)的bf均改变，变为了1，图五2的父节点的bf变为2，需要调节了。

写一下向上的代码

cpp 复制代码 
		while (parent)
		{
			if (parent->_key > key) // 通过key判断改变的是parent的左边还是右边
			{
				parent->bf--;
			}
			else
			{
				parent->bf++;
			}


			if (parent->bf == 0)      //  原来是1或-1，说明并没有改变高度
			{
				break;
			}
			else if (parent->bf == 1 || parent->bf == -1)     //  原来是为0 ，其所有的祖先都可能被影响了
			{                                //   往上走，判断其祖先
				cur = parent;
				parent = parent->_parent;
			}


			//   开始旋转
			else if((parent->bf == 2 || parent->bf == -2))
         }

看看是如何旋转的

将bf==2/-2的节点定义为parent，上调之前的parent定义为cur(cur->_parent==parent)

左旋转:将cur->left给parent->right(原来cur是parent->right)，parent变为cur->left。

右旋转：将cur->right给parent->left(原来cur是parent->left)，parent变为cur->right。

注意，这里也很复杂，需要考虑他们的_parent节点的连接和parent是否是头节点。

接下来具体讲一讲他们的分类

bf==1/-1继续往上走，看父节点的bf变化。

旋转一经过左旋转后就可以break了

旋转二就要复杂一点，看看旋转二的分析

可以看到在parent->bf==2，cur->bf==-1，需要双旋的，需要将左右旋结合。

左单旋

cpp 复制代码 
    //左单旋
	void RotateL(AVLTreeNode* parent)
	{
		if (parent == nullptr || parent->_right == nullptr)
			return;


		AVLTreeNode* subr = parent->_right;
		AVLTreeNode* subrL = subr->_left;    //记录，保证对cur->bf的正确修改
		parent->_right = subr->_left;



		if (subr->_left)
		{
			subr->_left->_parent = parent;
		}


		subr->_left = parent;
		AVLTreeNode* ppnode = parent->_parent;
		parent->_parent = subr;


		//对subr进行处理
		if (ppnode == nullptr)    //  parent是头节点
		{
			subr->_parent = nullptr;
			_node = subr;
		}
		else
		{
			subr->_parent = ppnode;
			if (ppnode->_left == parent)
			{
				ppnode->_left = subr;
			}
			else
			{
				ppnode->_right = subr;
			}
		}
        

        //  进行bf的修改
		if (parent->bf == 2)
		{
			if (subr->bf == 1)
			{
				parent->bf = subr->bf = 0;
			}
			if (subr->bf == -1)
			{
				if (subrL->bf == 0)
				{
					parent->bf = subrL->bf = subr->bf = 0;
				}
				if (subr->bf == -1)
				{
					parent->bf = subrL->bf = 0;
					subr->bf = 1;
				}
			}

		}
	}

右单旋

cpp 复制代码 
	void RotateR(AVLTreeNode* parent)
	{
		if (parent == nullptr)
		{
			return;
		}


		AVLTreeNode* subl = parent->_left;
		AVLTreeNode* sublR = subl->_right;
		parent->_left = subl->_right;


		if (subl->_right)  //  为空就不用去管他的_parent
		{
			subl->_right->_parent = parent;
		}



		subl->_right = parent;
		AVLTreeNode* ppnode = parent->_parent;
		parent->_parent = subl;



		if (ppnode == nullptr)
		{
			subl->_parent = nullptr;
		}
		else
		{
			subl->_parent = ppnode;
			if (ppnode->_left == parent)
			{
				ppnode->_left = subl;
			}
			else
			{
				ppnode->_right = subl;
			}
		}

		if (parent->bf == -2)
		{
			if (subl->bf == -1)
			{
				subl->bf = parent->bf = 0;
			}
			if (subl->bf == 1)
			{
				if (sublR->bf == 0)
				{
					parent->bf = sublR->bf = subl->bf = 0;
				}
				if (sublR->bf == 1)
				{
					parent->bf = sublR->bf = 0;
					subl->bf = -1;
				}
			}
		}
  	}

旋转代码

cpp 复制代码 
			//   开始旋转
			else if((parent->bf == 2 || parent->bf == -2))
			{
				if (parent->bf == 2)
				{
					if (cur->bf == 1)
					{
						RotateL(parent);
					}
					if (cur->bf == -1)
					{
						RotateR(cur);    //  不会给平衡因子，因为cur->parent!=-2
						RotateL(parent);
					}
				}
				if (parent->bf == -2)
				{
					if (cur->bf == -1)
					{
						RotateR(parent);
					}
					if (cur->bf == 1)
					{
						RotateL(cur);      //  不会给平衡因子，因为cur->parent!=-2
						RotateR(parent);
					}
				}
				break;    //   旋转了就保证了当前的树是平衡树，其祖先不需要判断了
			}

对代码进行测试

cpp 复制代码 
	void _InOrder(AVLTreeNode* root)
	{
		if (root == nullptr)
		{
			return;
		}

		_InOrder(root->_left);
		cout << root->_key << " " << root->_value << endl;
		_InOrder(root->_right);
	}

	void InOrder()
	{
		_InOrder(_node);
	}
	bool _IsbalanceTree(AVLTreeNode* root, int& high)
	{
		if (root == nullptr)
		{
			high = 0;
			return true;
		}
			int left_high = 0;
			if (_IsbalanceTree(root->_left, left_high) == false)
			{
				return false;
			}
			int right_high = 0;
			if (_IsbalanceTree(root->_right, right_high) == false)
			{
				return false;
			}
			if (left_high - right_high > 1 || left_high - right_high < -1)
			{
				return false;
			}
		high = 1 + (left_high > right_high ? left_high : right_high);
		return true;       //   满足左子树为平衡二叉树   右子树为平衡二叉树  该树为平衡二叉树
	}
	//判断平衡
	bool IsbalanceTree()
	{
		int k = 0;
		return _IsbalanceTree(_node, k);
	}
cpp 复制代码 
void test4()
{
	AVLTree<string, int> avl;
	avl.Insert("a", 1);
	avl.Insert("b", 2);
	avl.Insert("c", 3);
	avl.Insert("d", 4);
	avl.Insert("e", 5);
	avl.Insert("f", 6);
	avl.Insert("g", 7);
	avl.Insert("h", 8);
	avl.Insert("i", 9);
	avl.Insert("j", 10);
	//判断是否是平衡二叉搜索树
	// 搜索树
	avl.InOrder();

	// 平衡树
	if (avl.IsbalanceTree())
	{
		cout << "是平衡树" << endl;
	}
}


结果：
a 1
b 2
c 3
d 4
e 5
f 6
g 7
h 8
i 9
j 10
是平衡树

其实在耦合这块的话并不是很好，将左右旋和右左旋单独实现并修改平衡因子能够实现高内聚，低耦合。

希望能够彻底帮助你理解AVL树的旋转，而不是仅依靠一张结论图搬公式！！！

相关推荐
叶子爱分享10 分钟前
从事算法工作对算法刷题量的需求
算法
勇闯IT13 分钟前
有多少小于当前数字的数字
java·数据结构·算法
liuqun031940 分钟前
开心灿烂go开发面试题
算法·leetcode·golang
liulilittle1 小时前
通过高级处理器硬件指令集AES-NI实现AES-256-CFB算法并通过OPENSSL加密验证算法正确性。
linux·服务器·c++·算法·安全·加密·openssl
小皮侠1 小时前
【算法篇】逐步理解动态规划模型6（回文串问题）
java·开发语言·算法·动态规划
IT猿手1 小时前
动态多目标进化算法：基于迁移学习的动态多目标粒子群优化算法（TrMOPSO）求解IEEE CEC 2015，提供完整MATLAB代码
算法·matlab·迁移学习·动态多目标进化优化·动态多目标算法
এ᭄画画的北北1 小时前
力扣-279.完全平方数
数据结构·算法·leetcode
实习生小黄1 小时前
双三次贝塞尔曲面-canvas 实现4x4网格图片变化功能
前端·算法
jz_ddk1 小时前
[学习] FIR多项滤波器的数学原理详解：从多相分解到高效实现（完整仿真代码）
学习·算法·matlab
十秒耿直拆包选手1 小时前
Qt：Qt桌面程序正常退出注意事项
c++·qt
热门推荐
01Coze扣子平台完整体验和实践（附国内和国际版对比）02【图像处理与机器视觉】XJTU期末考点03KGG转MP3工具|非KGM文件|解密音频04扣子（coze）实战|我用扣子搭建了一个自动分析小红薯笔记内容的AI应用|详细步骤拆解05海康Visionmaster-常见问题排查方法-启动阶段06YOLOv8入门 | 重要性能衡量指标、训练结果评价及分析及影响mAP的因素【发论文关注的指标】07DeepSeek各版本说明与优缺点分析08从零安装 LLaMA-Factory 微调 Qwen 大模型成功及所有的坑09【SpeedAI科研小助手】2分钟极速解决知网维普重复率、AIGC率过高，一键全文降！文件格式不变，公式都保留的！10零代码入门 | Coze——让大模型接入自己的数据库