【C++】AVL树

孙同学_2025-09-14 17:32

📌 个人主页： 孙同学_

🔧 文章专栏： C++

💡 关注我，分享经验，助你少走弯路

文章目录

    • [1. AVL树的概念](#1. AVL树的概念)
    • 2.AVL树的实现
      • [2.1 AVL树的结构](#2.1 AVL树的结构)
      • [2.2 AVL树的插入](#2.2 AVL树的插入)
      • [2.3 旋转](#2.3 旋转)
        • [2.3.1 旋转的原则](#2.3.1 旋转的原则)
        • [2.3.2 右单旋](#2.3.2 右单旋)
        • [2.3.3 右单旋的代码实现](#2.3.3 右单旋的代码实现)
        • [2.3.4 左单旋](#2.3.4 左单旋)
        • [2.3.5 左旋转的代码实现](#2.3.5 左旋转的代码实现)
        • [2.3.6 左右旋转](#2.3.6 左右旋转)
        • 2.3.7左右双旋代码实现
        • [2.3.8 右左双旋](#2.3.8 右左双旋)
        • [2.3.9 右左双旋代码实现](#2.3.9 右左双旋代码实现)
      • [2.4 AVL树查找](#2.4 AVL树查找)
      • [2.5 AVL树的平衡检测](#2.5 AVL树的平衡检测)

1. AVL树的概念

  • AVL树是最先发明的自平衡二叉查找树，AVL树是一棵空树，或者是库备下面性质的二叉搜索树：它的左右子树都是AVL树,且左右子树的高度差的绝对值不超过1，AVL树是一棵高度平衡二叉搜索树，通过控制高度差去控制平衡。
  • AVL树的实现这里我们要引入一个叫做平衡因子（balance factor）的概念,每个节点都有一个平衡因子，任何节点的平衡因子等于右子树的高度减去左子树的高度，也就是说任何节点的平衡因子等于0/1/-1,AVL树并不是必须需要平衡因子，但是有了平衡因子可以更方便我们去进行观察和控制树是否平衡。
  • 为什么AVL树是高度平衡的二叉搜索树，要求高度差不超过1，而不是高度差超过0呢？0不是更好的平衡吗？画图分析我们可以知道并不是不想这样设计，而是有些情况是做不到高度差是0的。比如一个树是2个结点fiance，4个结点的情况下，高度差最好就是1，无法做到高度差是0.
  • AVL树整体结点数量和分布和完全搜索二叉树类似，高度可以控制在logN，那么增删查改的效率也可以控制在O（logN）,相比二叉搜索树有了本质的提升。

2.AVL树的实现

2.1 AVL树的结构

cpp 复制代码 
template<class K,class V>
struct AVLTreeNode
{
	//需要parent指针，后续更新平衡因子可以看到
	pair<K, V> _kv;
	AVLTreeNode<K, V>* _left;
	AVLTreeNode<K, V>* _right;
	AVLTreeNode<K, V>* _parent;
	int _bf; //balance factor 平衡因子

	AVLTreeNode(const pair<K, V>& kv)
		:_kv(kv)
		,_left(nullptr)
		,_right(nullptr)
		,_parent(nullptr)
		,_bf(0)
	{}
};

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

2.2 AVL树的插入

2.2.1AVL树插入一个值的大概过程
  1. 插入一个值按照二叉搜索树的规则进行插入。
  2. 新增结点以后，只会影响祖先结点的高度，也就是可能会影响部分祖先结点的平衡因子，所以更新从新增结点->根结点上面平衡因子，实际中最坏情况下要更新到根，有些情况更新到中间就可以停止了。
  3. 更新平衡因子过程中没有出现任何问题则插入结束。
  4. 更新平衡因子的过程中出现了不平衡，对不平衡子树进行旋转，旋转后本质调平衡的同时，本质降低了子树的高度，不会再影响上一层，所以插入结束。
2.2.2 平衡因子的更新

更新原则：

  • 平衡因子 = 右子树的高度 - 左子树的高度
  • 只有子树的高度发生变化才会影响当前结点的平衡因子。
  • 插入结点，会增加高度，所以新增结点在parent的右子树，parent的平衡因子++，新增结点在parent的左子树，平衡因子- -。
  • parent所在的子树的高度是否变化决定了是否会继续往上更新。

更新停止的条件：

  • 更新后parent的平衡因子等于0，更新中parent的平衡因子变化为-1 -> 0 或者 1 -> 0,说明更新前parent的子树一边高一边低，新增结点插入在低的那一边，插入后parent所在的子树高度不变，不会影响parent的父亲结点的平衡因子，更新结束。
  • 更新后parent的平衡因子等于1或者-1，更新前更新中parent的平衡因子变化为0->-1或者0->1,说明更新前parent子树两边一样高，新增的插入结点后，parent所在的子树一边高一边低，parent所在子树符合平衡要求，但是高度增加了1，会影响parent的父节点的平衡因子，所以要继续向上更新。
  • 更新后parent的平衡因子等于2或者-2，更新前更新中parent的平衡因子变化为1->2或者-1->-2,说明更新前parent子树一边高一边低，新增的插入结点的高的那边，parent所在的子树高的那边更高了，破坏了平衡，parent所在子树不符合平衡要求，需要旋转处理，旋转的目标有两个：1.把parent子树旋转平衡。2.降低parent子树高度，恢复到插入结点之前的高度。所以旋转后也不需要继续往上更新，插入结束。
  • 不断更新，更新到根，根的平衡因子是1或者-1也停止了。

更新到10结点，平衡因子为2，10所在的子树已经不平衡，需要旋转处理

更新到中间结点，3为根的子树高度不变，不会影响上一层，更新结束

最坏更新到根停止

2.3.3插入结点及更新平衡因子的代码实现
cpp 复制代码 
bool Insert(const pair<K, V>& kv)
{
	if (_root == nullptr)
	{
		_root = new Node(kv);
		return true;
	}
	Node* parent = nullptr;
	Node* cur = _root;
	while (cur)
	{
		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;
	}
	else
	{
		parent->left = cur;
	}

	cur->_parent = parent;
	//更新平衡因子
	while (parent)
	{
		//更新平衡因子
		if (cur == parent->_left)
			parent->_bf--;
		else
			parent->_bf++;
		if (parent->_bf == 0)//如果parent的平衡因子等于0
		{
			//更新结束
			break;
		}
		else if (parent->_bf == 1 || parent->_bf == -1)
		{
			//继续向上更新
			cur = parent;
			parent = parent->_parent;
		}
		else if (parent->_bf == 2 || parent->_bf == -2)
		{
			//不平衡了，需旋转处理
			break;
		}
		else
		{
			//说明之前就出问题了
			assert(false);
		}
	}
	return true;
}

2.3 旋转

2.3.1 旋转的原则
  1. 保持搜索树的规则
  2. 让旋转的树从不满足变平衡，其次降低旋转树的高度

旋转总共分为四种：左单旋/右单旋/左右双旋/右左双旋

说明：下图中有些结点给的是具体的值，如10和5等节点，这里是为了我们能够快速的理解，实际值具体什么值都可以，只要大小关系符合搜索树的性质即可。

2.3.2 右单旋
  • 图1展示的是10为根的树，a/b/c是抽象为三棵高度为h的子树（h>=0），a/b/c均符合AVL树的要求。10可能是整棵树的根，也可能是一整棵树中局部的子树的根。a/b/c是高度为h的子树，是一种概括抽象表示，它代表了所有右单旋的场景，实际右单旋形态有很多种，具体图2/图3/图4/图5进行了详细描述。
  • 在a子树中插入一个新结点，导致a子树的高度从h变为h+1，不断向上更新平衡因子，导致10的平衡因子从-1变成了-2，10为根的树左右高度差超过了1，违反了平衡规则。10为根的树左边太高了，需要往右边旋转，控制两棵树的平衡。
  • 旋转的核心步骤，因为5<b子树的值<10,将b变成10的左子树，10变成5的右子树，5变成这棵树新的根，符合搜索树的规则，控制了平衡，同时这棵树的高度恢复到了插入之前的h+2，符合旋转原则。如果插入之前10整棵树的一个局部子树，旋转后不会再影响上一层了，插入结束了。


图2

图3

图4

图5

2.3.3 右单旋的代码实现
cpp 复制代码 
void RotateR(Node* parent)//rotate旋转 R代表右单旋
{
	//5
	Node* subL = parent->_left;
	//b
	Node* subLR = subL->_right;

	parent->_left = subLR;
	if (subLR)//如果subLR不为空
		subLR->_parent = parnet;

	Node* ppNode = parent->_parent;

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


	//此处有个小问题，就是subLR有可能为空，h等于0时，它就为空

	//有一种情况还得更新_root
	//还有一种情况就是旋转点不是根，只是一个子树，把这个结点叫做ppNode
	//if (ppNode == nullptr)//如果ppNode为空，这是一种判断条件
	if (parent == _root)//这也是一种判断条件
	{
		_root = subL;
		subL->_parent = nullptr;
	}
	else//不是根，就一定有ppNode
	{
		if (ppNode->_left = parent)
		{
			ppNode->_left = subL;
		}
		else
		{
			ppNode->_right = subL;
		}
		subL->_paernt = ppNode;
	}

	parent->_bf = 0;
	subL->_bf = 0;
}
2.3.4 左单旋
  • 图6展示的是10为根的树，有a/b/c抽象为三棵高度为h的子树（h>=0）,a/b/c均符合AVL树的要求。10可能是整棵树的根，也可能是一整棵树中局部的子树的根。这里a/b/c是高度为h的一种概括抽象表示，他代表了左单旋的场景，实际左单旋形态有很多种，具体跟上面右旋类似。
  • 在a子树中插入一个新结点，导致a子树的高度从h变成了h+1,不断地向上更新平衡因子，导致10的平衡因子从1变成了2，10为根的树左右高度差超过了1，违反了平衡规则。10为根的树右边太高，需要往左边旋转，控制两棵树的平衡。
  • 旋转核心步骤，因为10 < b子树的值 < 15,将变成10的右子树，10变成15的左子树，15变成这棵树新的根，符合搜索树的规则，控制了平衡，同时这棵树的高度恢复到插入之前的高度h+2,符合旋转原则。如果插入之前10整棵树的一个局部子树，旋转之后不会影响上一层，插入结束。
2.3.5 左旋转的代码实现
cpp 复制代码 
void RotateL(Node* parent)//rotate旋转 L代表左单旋
{
	//15
	Node* subR = parent->_right;
	//b
	Node* subRL = subR->_left;

	parent->_right = subRL;
	if (subRL) //如果subRL不为空
		subRL->_parent = parent;

	Node* ppNode = parnet->_parent;

	subR->_left = parent;
	parent->_parent = subR;

	if (parent == _root)
	{
		_root = subR;
		subR->_parent = nullptr;
	}
	else//不是根，就一定存在ppNode
	{
		if (ppNode->_right == parent)
		{
			ppNode->_right = subR；
		}
		else
		{
			ppNode->_right = subR;
		}
		subR->_parent = ppNode;
	}
	parent->_bf = 0;
	subR->_bf = 0;
}
2.3.6 左右旋转

通过下图可以看到，左边高时，如果插入位置不是在a子树，而是插入在b子树，b子树高度从h变成了h+1，引发旋转，右单旋无法解决问题，右单旋后，我们的树依旧是不平衡的。右单旋解决的是纯粹的左边高，但是插入在b子树中，10为根的子树不再是单纯的左边高，对于10是左边高，但是对于5说是右边高，需要用两次旋转才能解决，以5为旋转点进行一个左单旋，以10为旋转点进行一个右单旋，这棵树就平衡了。

上图是分别为左右双旋中h == 0和h == 1的具体场景分析，下面我们 将a/b/c子树抽象为高度为h的AVL子树进行分析，另外我们需要把b子树的细节进一步展开为8和左子树高度为h-1的e和f子树，因为我们要对b的父亲5为旋转点进行做单旋，左单旋需要动b树中的左子树。b子树中新增结点的位置不同，平衡因子更新的细节也不同，通过观察8的平衡因子不同，我们要分3个场景讨论。

  • 场景1：h>=1时，新增结点插⼊在e子树，e子树⾼度从h-1并为h并不断更新8->5->10平衡因子,引发旋转，其中8的平衡因子为-1，旋转后8和5平衡因为0，10平衡因子为1。
  • 场景2：h>=1时，新增结点插⼊在f子树，f子树⾼度从h-1变为h并不断更新8->5->10平衡因子，引发旋转，其中8的平衡因子为1，旋转后8和10平衡因⼦为0，5平衡因子为-1。
  • 场景3：h == 0时，a/b/c都是空树，b自己就是一个新增结点，不断更新5->10平衡因子，引发旋转，其中8的平衡因子为0，旋转后8和10和5平衡因子均为0。
2.3.7左右双旋代码实现
cpp 复制代码 
void RotateLR(Node* parent)
{
	Node* subL = parent->_left;
	Node* subLR = subL->_rifht;
	int bf = subLR->_bf;
	RotateL(parnet->_left);//parnet的left进行左单旋
	RotateR(parent);
	if (bf == -1)//就在e上插入
	{
		subL->_bf = 0;
		parent->_bf = 1;
		subLR->_bf = 0;
	}
	else if (bf == 1)//就在f上面插入
	{
		subL->_bf = -1;
		parent->_bf = 0;
		subLR->_bf = 0;
	}
	else if (bf == 0)
	{
		subL->_bf = 0;
		parent->_bf = 0;
		subLR->_bf = 0;
	}
	else
	{
		assert(false);
	}
}
2.3.8 右左双旋

跟左右双旋类似，下面我们将a/b/c子树抽象为高度为h的AVL子树进行分析，另外我们需要把b子树的细节进一步展开为12和左子树高度为h-1的e和f子树，因为我们要对b的父亲15为旋转点进行右单旋，右单旋需要动b树中的右子树。b树中的新增结点的位置不同，平衡因子更新细节也不同，通过观察12的平衡因子不同，这里我们分三个场景讨论。

  • 场景1：h >= 1时，新增结点插入在e子树，e子树高度从h-1变为h并不断更新12->15->10平衡因子，引发旋转，其中12的平衡因子为-1，旋转后10和12平衡因子为0，15平衡因子为1。
  • 场景2：h >= 1时，新增结点插入在子树，f子树高度从h-1变为h并不断更新12->15->10平衡因子，引发旋转，其中12的平衡因子为1，旋转后15和12平衡因子为0，10平衡因子为-1。
  • 场景3：h == 0时，a/b/c都是空树，b自己就是⼀个新增结点，不断更新15->10平衡因子，引发旋转，其中12的平衡因子为0，旋转后10和12和15平衡因子均为0。
    +
2.3.9 右左双旋代码实现
cpp 复制代码 
void RotateRL(Node* parent)
{
	Node* subR = parent->_right;
	Node* subRL = subR->_left;
	int bf = subRL->_bf;
	RotateR(parent->_right);
	RotateL(parent);
	if (bf == -1)//在e上面插入
	{
		subR->_bf = 1;
		parent->_bf = 0;
		subRL->_bf = 0;
	}
	else if (bf == 1)//在f上面插入
	{
		subR->_bf = 0;
		parent->_bf = -1;
		subRL->_bf = 0;
	}
	else if (bf == 0)
	{
		subR->_bf = 0;
		parent->_bf = 0;
		subRL->_bf = 0;
	}
	else
	{
		assert(false);
	}
}

2.4 AVL树查找

AVL树的查找拿二叉树逻辑实现即可。搜索的效率O（logN）

cpp 复制代码 
Node* Find(const K& key)
{
	Node* cur = _root;
	while (cur)
	{
		if (cur->_kv.first < key)
		{
			cur = cur->_right;
		}
		else if (cur->_kv.first > key)
		{
			cur = cur->_left;
		}
		else
		{
			return cur;
		}
	}
	return nullptr;
}

2.5 AVL树的平衡检测

我们实现的AVL树是否合格，我们通过检查左右子树的高度差的程序进行反向验证，同时检查下一个结点的平衡因子更新是否出现了问题。

cpp 复制代码 
bool _IsBalanceTree(Node* root)
{
	//空树也是AVL树
	if (nullptr == root)
		return true;

	//计算pRoot结点的平衡因子，即pRoot左右子树的高度差
	int leftHeight = _Height(root->_left);
	int rightHeight = _Height(root->right);
	int diff = rightHeight - leftHeight;

	//如果计算出的平衡因子与pRoot的平衡因子不相等，或者pRoot平衡因子的绝对值超过1，则一定不是AVVL树
	if (abs(diff) >= 2)
	{
		cout << root->_kv.first << "高度异常差" << endl;
		return false;
	}

	if (root->_bf != diff)
	{
		cout << root->_kv.first << "平衡因子异常" << endl;
		return false;
	}

	//pRoot的左和右如果都是AVL树，则该树一定是AVL树
	return _IsBalanceTree(root->_left) && _IsBalance(root->_right);
}

👍 如果对你有帮助，欢迎：

  • 点赞 ⭐️
  • 收藏 📌
  • 关注 🔔
相关推荐
island13142 小时前
【Redis#9】其他数据结构
数据结构·数据库·redis
winfield8212 小时前
Redis 线上问题排查完整手册
redis
君宝2 小时前
Linux ALSA架构：PCM_OPEN流程 (二)
java·linux·c++
island13143 小时前
【C++框架#5】Elasticsearch 安装和使用
开发语言·c++·elasticsearch
七夜zippoe3 小时前
多级缓存架构实战手册：Caffeine+Redis 从设计到落地的全链路解决方案
redis·缓存·架构
心月狐的流火号3 小时前
Redis 的高性能引擎 Reactor 详解与基于 Go 手写 Redis
redis·后端
岁忧3 小时前
(LeetCode 每日一题) 3541. 找到频率最高的元音和辅音 (哈希表)
java·c++·算法·leetcode·go·散列表
小六子成长记4 小时前
【C++】:list容器全面解析（超详细）
c++·windows·list
IT灰猫4 小时前
C++轻量级配置管理器升级版
开发语言·c++·设计模式·配置管理·ini解析
热门推荐
01KGG转MP3工具|非KGM文件|解密音频02GitHub 镜像站点03conda中设置镜像地址（附所有可换的地址）04UV安装并设置国内源05A股预测还能更准？开源大模型Kronos带你跑通预测+回测全流程0646个Nano-banana 精选提示词，持续更新中07UV 工具安装与国内镜像源配置指南08突破百度网盘的下载限速，两种方法教会你【超详细】09Spec-Kit 使用指南10教你如何认证 Gemini 教育优惠的二次验证，薅个 1年的 Gemini Pro 会员