（数据结构）AVL树

404未精通的狗2026-02-15 8:21

AVL树

AVL树

概念

  • AVL树是最先发明的自平衡二叉查找树，AVL是一颗空树，或者具备下列性质的二叉搜索树：它的左右子树都是AVL树，且左右子树的高度差的绝对值不超过1。AVL树是一颗高度平衡搜索二叉树，通过控制高度差去控制平衡。
  • AVL树得名于它的发明者G. M. Adelson-Velsky和E. M. Landis是两个前苏联的科学家，他们在1962年的论文《An algorithm for the organization of information》中发表了它。
  • AVL树实现这里我们引入一个平衡因子(balance factor)的概念，每个结点都有一个平衡因子，任何结点的平衡因子等于右子树的高度减去左子树的高度，也就是说任何结点的平衡因子等于0/1/-1，AVL树并不是必须要平衡因子，但是有了平衡因子可以更方便我们去进行观察和控制树是否平衡，就像一个风向标一样。
  • 思考一下为什么AVL树是高度平衡搜索二叉树，要求高度差不超过1，而不是高度差是0呢？0不是更好的平衡吗？画画图分析我们发现，不是不想这样设计，而是有些情况是做不到高度差是0的。比如一棵树是2个结点，4个结点等情况下，高度差最好就是1，无法做到高度差是0
  • AVL树整体结点数量和分布和完全二叉树类似，高度可以控制在 logN，那么增删查改的效率也可
    以控制在O(logN) ，相比二叉搜索树有了本质的提升。

    上图所有节点的的平衡因子都是-1/0/1，说明该树是AVL树。

上图10的平衡因子不是-1/0/1，说明该树并不是AVL树。

AVL树实现

复用二叉搜索树中已实现的代码

结构

cpp 复制代码 
//key-value类型
template<class K,class V>
struct AVLTreeNode
{
	pair<K，V> _kv;
	AVLTreeNode<K,V>* _left;
	AVLTreeNode<K,V>* _right;
	AVLTreeNode<K, V>* _parent;
	int _bf;	//平衡因子
	//带参构造
	BSTreeNode(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;
};

插入

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

  • 更新原则：

    • 平衡因子 = 右子树高度-左子树高度

    • 只有子树高度变化才会影响当前结点平衡因子。

    • 插入结点，会增加高度，所以新增结点在parent的右子树，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就停止了。
  • 图示
  • AVL树插入和删除的时间复杂度都是O(logn)
代码实现（包含旋转）
cpp 复制代码 
//插入
bool Insert(const pair<K, V>& kv)
{
    if (_root == nullptr) //树为空
    {
        _root = new Node(kv);
        return true;
    }

    //正常插入，不支持冗余版本
    Node* cur = _root;
    Node* parent = nullptr;//记录cur的父节点
    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++;

        //1._bf==0 停止向上更新
        if (parent->_bf == 0)
        {
            break;
        }
        //2.继续往上更新（bf为1/-1）
        else if (parent->_bf == 1 || parent->_bf == -1)
        {
            cur = parent;
            parent = cur->_parent;
        }
        //3.破坏了平衡，进行旋转处理
        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);
            }
            break;
        }
        else
        {
       		//排除其他情况
            assert(false);
        }
    }
    return true;
}

旋转

  • 旋转的原则
  1. 保持搜索树的规则
  2. 让旋转的树从不平衡表变平衡，其次降低旋转树的高度
    旋转总共分为四种，左单旋、右单旋、左右双旋、右左双旋。
    单旋是纯粹的一边高（parent和cur平衡因子同号），而双旋是两边各有高（parent和cur平衡因子异号）
    四种旋转最简单的情况
右单旋

本图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整棵树的一个局部子树，旋转后不会再影响上一层，插入结束了。

图示

最重要：抽象规则

subL：parent的左孩子

subLR：parent的左孩子的右孩子

实例分析：情况极其多，所以了解抽象的规律就好）

  • 代码实现
cpp 复制代码 
void RotateR(Node* parent)
{
	//注意：父亲、孩子、平衡因子都要更新
	//1.调整孩子
	Node* subL = parent->_left;
	Node* subLR = parent->_left->_right;
	parent->_left = subLR;
	subL->_right = parent;
	//2.调整父亲
	//注意subLR有可能为空
	if(subLR)
		subLR->_parent = parent;
	Node* ppnode = parent->_parent;
	if (parent = _root) 
	{
		_root = subL;
		subL->_parent = nullptr;
	}
	else
	{
		if (ppnode->_left == parent)
		{
			ppnode->_left = subL;
		}
		else
		{
			ppnode->_right = subL;
		}
	}
	subL->_parent = ppnode;
	parent->_parent = subL;
	//3.更新平衡因子
	parent->_bf = subL->_bf = 0;
}
左单旋

本图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 < a子树的值 < 15，将a变成10的右子树，10变成15的左子树，15变成这棵

树新的根，符合搜索树的规则，控制了平衡，同时这棵的高度恢复到了插入之前的h+2，符合旋转

原则。如果插入之前10整棵树的一个局部子树，旋转后不会再影响上一层，插入结束了。

  • 代码实现：
cpp 复制代码 
//左单旋与右单旋对称一致
void RotateL(Node* parent)
{
	//注意：父亲、孩子、平衡因子都要更新
	//1.调整孩子
	Node* subR = parent->_right;
	Node* subRL = parent->_right->_left;
	parent->_right = subRL;
	subR->_left = parent;
	//2.调整父亲
	//注意subLR有可能为空
	if (subRL)
		subRL->_parent = parent;
	Node* ppnode = parent->_parent;
	if (parent = _root)
	{
		_root = subR;
		subR->_parent = nullptr;
	}
	else
	{
		if (ppnode->_left == parent)
		{
			ppnode->_left = subR;
		}
		else
		{
			ppnode->_right = subR;
		}
	}
	subR->_parent = ppnode;
	parent->_parent = subR;
	//3.更新平衡因子
	parent->_bf = subR->_bf = 0;

}
左右双旋

三种情况旋转步骤一致，但由两次单旋组成平衡因子的变化不同，要单独去调节

cpp 复制代码 
void RotateLR(Node* parent)
{
    Node* subL = parent->_left;
    Node* subLR = subL->_right;
    int bf = subLR->_bf;

    RotateL(subL); // 修正：parent->_left 等价于 subL，写法更清晰
    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 = subL->_bf = subLR->_bf = 0;
    }
    else
    {
        assert(false);
    }
}
右左双旋

与左右完全是对称的

cpp 复制代码 
void RotateRL(Node* parent)
{
    Node* subR = parent->_right;
    Node* subRL = subR->_left;
    int bf = subRL->_bf;

    RotateR(subR); 
    RotateL(parent);

    //平衡因子调整
    if (bf == -1)
    {
        parent->_bf = 0;
        subR->_bf = 1;
        subRL->_bf = 0;
    }
    else if (bf == 1)
    {
        parent->_bf = -1;
        subR->_bf = 0;
        subRL->_bf = 0;
    }
    else if (bf == 0)
    {
        parent->_bf = subR->_bf = subRL->_bf = 0;
    }
    else
    {
        assert(false);
    }
}

查找

按照二叉搜索树逻辑实现即可，搜索效率为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 小时前
【数据结构】顺序表
数据结构
Дерек的学习记录10 小时前
C++：入门基础（下）
开发语言·数据结构·c++·学习·算法·visualstudio
程序员酥皮蛋13 小时前
hot 100 第二十四题 24.回文链表
数据结构·链表
仟濹16 小时前
【算法打卡day7（2026-02-12 周四）算法：BFS and BFS】 3_卡码网107_寻找存在的路线_并查集
数据结构·算法·图论·宽度优先
数智工坊16 小时前
【数据结构-排序】8.2 冒泡排序-快速排序
数据结构
芝士爱知识a17 小时前
[2026深度测评] AI期权交易平台推荐榜单：AlphaGBM领跑，量化交易的新范式
开发语言·数据结构·人工智能·python·alphagbm·ai期权工具
芝士爱知识a17 小时前
【FinTech前沿】AlphaGBM：重塑期权交易的智能分析引擎——从原理到实践
数据结构·数据库·人工智能·alphagbm·期权
EE工程师18 小时前
数据结构篇 - 循环队列
数据结构
俩娃妈教编程18 小时前
洛谷选题：P1420 最长连号
数据结构·算法
热门推荐
01PHP Error: 常见错误及其解决方法02GitHub 镜像站点03Claude Code + GLM4.7 避坑指南：解决 Unable to connect to Anthropic services04HTB 赛季10 - Pterodactyl - user05爬虫逆向之观安（观镜WEB应用安全防护系统）06UV安装并设置国内源07openClaw安装飞书插件｜核心踩坑：spawn EINVAL 错误终极解决指南08243 行 microGPT：把“训练 + 推理”拆到骨头里09Android Studio Panda 1 正式版来了：JDK 终于不用手动配了，内存泄漏也有原生方案了10关于 nvidia-smi: no devices were found 解决方案