AVL树：高效平衡的二叉搜索树

news2025/4/17 2:29:42

🌟 快来参与讨论💬，点赞👍、收藏⭐、分享📤，共创活力社区。🌟

在这里插入图片描述

引言🤔

在数据结构的奇妙世界里，二叉搜索树（BST）原本是查找数据的好帮手。想象一下，它就像一本有序的字典，能快速帮我们找到想要的信息。可要是数据排得太整齐，像排队一样有序，二叉搜索树就会“变形”成单支树，这时候查找数据就像在长长的队伍里一个个找，效率低得让人抓狂😫。别担心，1962年，两位聪明的俄罗斯数学家G.M.Adelson - Velskii和E.M.Landis发明了AVL树，给这个问题找到了完美的解决方案👏。

AVL树的概念🧐

1.1 平衡的定义

AVL树就像是一个超级严格的“平衡大师”😏，它不仅是二叉搜索树，还得满足每个节点的左右子树高度差（也就是平衡因子）的绝对值不能超过1。这就好比走钢丝的杂技演员，两边的平衡杆长度差得控制在一定范围内，才能稳稳地走在钢丝上。
在这里插入图片描述

1.2 高度与复杂度

因为AVL树这么会“平衡”，所以哪怕它有好多好多节点（(n)个节点），它的高度也能保持在(O(log_2 n))这个不错的水平。这就意味着，我们查找数据的时候，时间复杂度也是(O(log_2 n))，快得飞起🛫！

AVL树节点的定义📋

要实现AVL树，先得把它的“小砖头”——节点定义好。每个节点都像一个小盒子，装着数据，还有指向左右“小伙伴”（子节点）和“家长”（父节点）的指针，另外还有个记录平衡因子的小标签。下面是用C++ 写的节点定义模板哦👇：

template<class T>
struct AVLTreeNode
{
    AVLTreeNode(const T& data)
        : _pLeft(nullptr), _pRight(nullptr), _pParent(nullptr)
    , _data(data), _bf(0)
    {}
    AVLTreeNode<T>* _pLeft;   // 该节点的左孩子
    AVLTreeNode<T>* _pRight;  // 该节点的右孩子
    AVLTreeNode<T>* _pParent; // 该节点的双亲
    T _data;
    int _bf;         // 该节点的平衡因子
};

AVL树的插入🎯

AVL树插入新数据就像往一个有序的书架上放新书，分两步走：

3.1 二叉搜索树插入

先按照二叉搜索树的规矩，从根节点开始，把新书（新数据）和每个节点的数据比较。要是新书比当前节点的数据小，就往左走；要是大，就往右走，直到找到合适的空位，把新书放进去📚。

3.2 平衡因子调整

新书放进去后，可能会把书架弄“歪”，也就是破坏了AVL树的平衡。这时候就得从新书的“家长”开始，沿着书架往上检查，调整每个节点的平衡因子。在调整过程中，“家长”节点的平衡因子会根据新书插在左边还是右边做相应变化（左边就减1，右边就加1）。这时候“家长”的平衡因子可能出现三种情况：

  • 平衡因子为0：这说明放新书之前，“家长”的平衡因子是正负1，放进去后刚刚好变成0，书架又稳了，插入成功🎉。
  • 平衡因子为正负1：意味着放新书前“家长”的平衡因子是0，放进去后变成正负1，以“家长”为根的这部分书架变高了，还得继续往上检查调整🧐。
  • 平衡因子为正负2：糟糕，这说明“家长”的平衡因子违反规定啦，得赶紧用旋转操作来把书架扶正😰。

AVL树的旋转🔄

当AVL树因为插入新书变得不平衡时，根据新书插的位置不同，有四种旋转“魔法”来恢复平衡：

4.1 左左（LL）：右单旋

要是新书插在较高左子树的左侧，就来个右单旋。想象一下，失衡的节点（叫它(pParent)）像个小塔，它的左子节点（(pSubL)）来帮忙把塔扶正。具体做法就是：

  • 把(pSubL)的右子节点（(pSubLR)）放到(pParent)的左边当左子节点。
  • 如果(pSubLR)存在，记得告诉它新“家长”是(pParent)。
  • 再把(pParent)放到(pSubL)的右边当右子节点。
  • 接着更新(pParent)和(pSubL)的“家长”指针，要是原来的塔尖（根节点）变了，也要更新根节点指针。
  • 最后，把(pParent)和(pSubL)的平衡因子都设为0，塔就稳稳当当啦🧱。
    在这里插入图片描述

4.2 右右（RR）：左单旋

和左左情况相反，新书插在较高右子树的右侧时，就来个左单旋，跟右单旋类似，只是方向反过来。
在这里插入图片描述

4.3 左右（LR）：先左单旋再右单旋

新书插在较高左子树的右侧时，先对失衡节点的左子节点来个左单旋，再对失衡节点来个右单旋。这个过程中，要小心保存和更新每个节点的平衡因子，保证书架重新平衡。
在这里插入图片描述

4.4 右左（RL）：先右单旋再左单旋

新书插在较高右子树的左侧时，先对失衡节点的右子节点来个右单旋，再对失衡节点来个左单旋。同样，别忘了平衡因子的更新。
在这里插入图片描述

AVL树的验证✅

要看看AVL树是不是真的“合格”，可以从两方面检查：

5.1 验证为二叉搜索树

像给书架上的书排序一样，对AVL树进行中序遍历。要是遍历出来的顺序是有序的，那就说明它是个合格的二叉搜索树📖。

5.2 验证为平衡树

一个个检查每个节点的平衡因子，看看它们左右子树高度差的绝对值是不是都没超过1。同时，还要检查平衡因子算得对不对🧮。
在这里插入图片描述

AVL树的删除🗑️

AVL树删除节点就像从书架上拿走一本书，和二叉搜索树的删除方法差不多。但拿走书后，书架可能又歪了，得重新调整平衡。有时候运气不好，可能得一直调整到最上面的根节点。具体怎么做，可以参考《算法导论》或者《数据结构 - 用面向对象方法与C++描述》殷人昆版📚。

AVL树的性能📈

AVL树在查找数据方面就像个超级跑车，时间复杂度是(O(log_2 n))，快得没话说。可要是经常对它进行插入和删除这些“大动作”，就像经常给跑车改装，为了保持平衡，得频繁调整，性能就会受影响，特别是删除的时候，可能要一直调整到根节点，很费时间。所以呢，要是数据基本不怎么变，查询又多，AVL树就是个好选择；要是数据经常变来变去，它可能就不太合适啦😕。

AVL树实现代码示例📄

#pragma once
#include <iostream>
#include <utility>
#include <cassert>

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

    AVLTreeNode<K, V>* _left;
    AVLTreeNode<K, V>* _right;
    AVLTreeNode<K, V>* _parent;
    int _bf; // 平衡因子
    std::pair<K, V> _kv;
};

template<class K, class V>
class AVLTree
{
public:
    typedef AVLTreeNode<K, V> Node;

    ~AVLTree()
    {
        destroy(_root);
    }

    void destroy(Node* node)
    {
        if (node)
        {
            destroy(node->_left);
            destroy(node->_right);
            delete node;
        }
    }

    bool insert(const std::pair<K, V>& key)
    {
        try
        {
            if (_root == nullptr)
            {
                _root = new Node(key);
                return true;
            }
            Node* cur = _root;
            Node* parent = nullptr;
            while (cur)
            {
                parent = cur;
                if ((cur->_kv).first < key.first)
                {
                    cur = cur->_right;
                }
                else if ((cur->_kv).first > key.first)
                {
                    cur = cur->_left;
                }
                else
                {
                    return false;
                }
            }
            cur = new Node(key);
            cur->_parent = parent;
            if ((parent->_kv).first < (cur->_kv).first)
            {
                parent->_right = cur;
            }
            else
            {
                parent->_left = cur;
            }

            // 考虑平衡因子
            while (cur)
            {
                if (parent == nullptr)
                {
                    break; // 如果 parent 为 nullptr，说明已经到根节点，跳出循环
                }
                if (cur == parent->_right)
                {
                    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)
                        RotateL(parent);
                    else if (parent->_bf == -2 && cur->_bf == -1)
                        RotateR(parent);
                    else if (parent->_bf == 2 && cur->_bf == -1)
                    {
                        RotateRL(parent);
                    }
                    else if (parent->_bf == -2 && cur->_bf == 1)
                    {
                        RotateLR(parent);
                    }
                    break;
                }
                else
                {
                    assert(false);
                }
            }
            return true;
        }
        catch (const std::bad_alloc&)
        {
            return false;
        }
    }

    void RotateL(Node* parent) // 左单旋
    {
        Node* subR = parent->_right;
        Node* subRL = subR->_left;

        parent->_right = subRL;
        if (subRL)
        {
            subRL->_parent = parent;
        }

        subR->_left = parent;
        Node* parentParent = parent->_parent;
        parent->_parent = subR;

        if (parentParent == nullptr)
        {
            _root = subR;
            subR->_parent = nullptr;
        }
        else
        {
            if (parentParent->_left == parent)
            {
                parentParent->_left = subR;
            }
            else
            {
                parentParent->_right = subR;
            }
            subR->_parent = parentParent;
        }

        // 修改_bf
        parent->_bf = subR->_bf = 0;
    }

    void RotateR(Node* parent) // 右单旋
    {
        Node* subL = parent->_left;
        Node* subLR = subL->_right;

        parent->_left = subL->_right;
        if (subLR)
        {
            subLR->_parent = parent;
        }

        subL->_right = parent;
        Node* parentParent = parent->_parent;
        parent->_parent = subL;

        if (parentParent == nullptr)
        {
            _root = subL;
            subL->_parent = nullptr;
        }
        else
        {
            if (parentParent->_left == parent)
            {
                parentParent->_left = subL;
            }
            else
            {
                parentParent->_right = subL;
            }
            subL->_parent = parentParent;
        }

        // 修改_bf
        parent->_bf = subL->_bf = 0;
    }

    void RotateRL(Node* parent)
    {
        Node* subR = parent->_right;
        Node* subRL = subR->_left;
        int bf = subRL->_bf;

        RotateR(parent->_right);
        RotateL(parent);

        if (bf == 0)
        {
            // 新增的就是subRL
            parent->_bf = subR->_bf = subRL->_bf = 0;
        }
        else if (bf == 1)
        {
            // subRL的右结点就是新增的
            parent->_bf = -1;
            subR->_bf = 0;
            subRL->_bf = 0;
        }
        else if (bf == -1)
        {
            parent->_bf = 0;
            subR->_bf = 1;
            subRL->_bf = 0;
        }
        else
        {
            assert(false);
        }
    }

    void RotateLR(Node* parent)
    {
        Node* subL = parent->_left;
        Node* subLR = subL->_right;
        int bf = subLR->_bf;

        RotateL(parent->_left);
        RotateR(parent);

        if (bf == 1)
        {
            subL->_bf = -1;
            parent->_bf = 0;
            subLR->_bf = 0;
        }
        else if (bf == -1)
        {
            subL->_bf = 0;
            parent->_bf = 1;
            subLR->_bf = 0;
        }
        else
        {
            subL->_bf = 0;
            parent->_bf = 0;
            subLR->_bf = 0;
        }
    }

    // 中序打印方法
    void inorderPrint() const
    {
        inorderPrintHelper(_root);
        std::cout << std::endl;
    }

    // 判断是否为平衡二叉树
    bool isBalanced() const
    {
        int height = 0;
        return isBalancedHelper(_root, height);
    }

private:
    Node* _root = nullptr;

    // 中序遍历辅助函数
    void inorderPrintHelper(Node* node) const
    {
        if (node)
        {
            inorderPrintHelper(node->_left);
            std::cout << "Key: " << node->_kv.first << ", Value: " << node->_kv.second << std::endl;
            inorderPrintHelper(node->_right);
        }
    }

    // 判断是否为平衡二叉树的辅助函数
    bool isBalancedHelper(Node* node, int& height) const
    {
        if (node == nullptr)
        {
            height = 0;
            return true;
        }

        int leftHeight = 0;
        int rightHeight = 0;

        // 递归判断左子树是否平衡
        if (!isBalancedHelper(node->_left, leftHeight))
        {
            return false;
        }

        // 递归判断右子树是否平衡
        if (!isBalancedHelper(node->_right, rightHeight))
        {
            return false;
        }

        // 计算当前节点的高度
        height = std::max(leftHeight, rightHeight) + 1;

        // 检查当前节点的左右子树高度差是否不超过 1
        if (std::abs(leftHeight - rightHeight) > 1)
        {
            return false;
        }

        return true;
    }
};

总结🎉

AVL树就像一个聪明又有点小脾气的数据结构小伙伴😜。它用巧妙的平衡方法，解决了二叉搜索树可能失衡的问题，让查找数据又快又稳。它的插入、旋转和验证等操作一环扣一环，保证了自己时刻保持高效。虽然在结构经常变化的时候有点“小傲娇”，性能不太好，但在适合的场景下，绝对是个得力助手💪。通过深入了解AVL树，希望大家在编程时能更明智地选择数据结构，让程序跑得又快又好🚀。
在这里插入图片描述

投票环节🎊

你觉得AVL树在以下哪种场景最有用呢🧐？

  1. 数据基本不变，查询频繁：就像图书馆的藏书目录，很少新增或删除书籍，但经常有人查询。📚
  2. 数据频繁插入和删除：比如一个实时更新的新闻网站，不断有新新闻发布，旧新闻过期删除。📰
  3. 其他场景（请留言说明）：说不定你有独特的想法哦，快来分享！💡

快来投出你宝贵的一票吧👇，让我们看看大家对AVL树的看法！🎯

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/2298043.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

RHCA练习5：配置mysql8.0使用PXC实现高可用

RHCA练习5：配置mysql8.0使用PXC实现高可用

准备4台CentOS7的虚拟机&#xff08;CentOS7-1、CentOS7-2、CentOS7-3、CentOS7-4&#xff09; 备份原yum源的配置&#xff1a; mv /etc/yum.repos.d/CentOS-Base.repo /etc/yum.repos.d/CentOS-Base.repo.backup 更换阿里云镜像YUM源&#xff1a; curl -o /etc/yum.repos.…
阅读更多...
Java 大视界 -- 边缘计算与 Java 大数据协同发展的前景与挑战（85）

Java 大视界 -- 边缘计算与 Java 大数据协同发展的前景与挑战（85）

&#x1f496;亲爱的朋友们&#xff0c;热烈欢迎来到 青云交的博客&#xff01;能与诸位在此相逢&#xff0c;我倍感荣幸。在这飞速更迭的时代&#xff0c;我们都渴望一方心灵净土&#xff0c;而 我的博客 正是这样温暖的所在。这里为你呈上趣味与实用兼具的知识&#xff0c;也…
阅读更多...
机器学习 - 理论和定理

机器学习 - 理论和定理

在机器学习中&#xff0c;有一些非常有名的理论或定理&#xff0c;对理解机器学习的内在特性非常有帮助。本文列出机器学习中常用的理论和定理&#xff0c;并举出对应的举例子加以深化理解&#xff0c;有些理论比较抽象&#xff0c;我们可以先记录下来&#xff0c;慢慢啃&#…
阅读更多...
2025.2.11——一、[极客大挑战 2019]PHP wakeup绕过|备份文件|代码审计

2025.2.11——一、[极客大挑战 2019]PHP wakeup绕过|备份文件|代码审计

题目来源&#xff1a;BUUCTF [极客大挑战 2019]PHP 目录 一、打开靶机&#xff0c;整理信息 二、解题思路 step 1&#xff1a;目录扫描、爆破 step 2&#xff1a;代码审计 1.index.php 2.class.php 3.flag.php step 3&#xff1a;绕过__wakeup重置 ​编辑 三、小结…
阅读更多...
Vivado生成edif网表及其使用

Vivado生成edif网表及其使用

介绍如何在Vivado中将模块设为顶层&#xff0c;并生成相应的网表文件&#xff08;Verilog文件和edif文件&#xff09;&#xff0c;该过程适用于需要将一个模块作为顶层设计进行综合&#xff0c;并生成用于其他工程中的网表文件的情况。 例如要将fpga_top模块制作成网表给其它工…
阅读更多...
JAVA生产环境(IDEA)排查死锁

JAVA生产环境(IDEA)排查死锁

使用 IntelliJ IDEA 排查死锁 IntelliJ IDEA 提供了强大的工具来帮助开发者排查死锁问题。以下是具体的排查步骤&#xff1a; 1. 编写并运行代码 首先&#xff0c;我们编写一个可能导致死锁的示例代码&#xff1a; public class DeadlockExample {private static final Obj…
阅读更多...
AI学习记录 - 最简单的专家模型 MOE

AI学习记录 - 最简单的专家模型 MOE

代码 import torch import torch.nn as nn import torch.nn.functional as F from typing import Tupleclass BasicExpert(nn.Module):# 一个 Expert 可以是一个最简单的&#xff0c; linear 层即可# 也可以是 MLP 层# 也可以是 更复杂的 MLP 层&#xff08;active function 设…
阅读更多...
【2025深度学习系列专栏大纲：深入探索与实践深度学习】

【2025深度学习系列专栏大纲：深入探索与实践深度学习】

第一部分：深度学习基础篇 第1章：深度学习概览 1.1 深度学习的历史背景与发展轨迹 1.2 深度学习与机器学习、传统人工智能的区别与联系 1.3 深度学习的核心组件与概念解析 神经网络基础 激活函数的作用与类型 损失函数与优化算法的选择 1.4 深度学习框架简介与选择建议 第2…
阅读更多...
数据治理双证通关经验分享 | CDGA/CDGP备考全指南

数据治理双证通关经验分享 | CDGA/CDGP备考全指南

历经1个月多的系统准备&#xff0c;本人于2024年顺利通过DAMA China的CDGA&#xff08;数据治理工程师&#xff09;和CDGP&#xff08;数据治理专家&#xff09;双认证。现将备考经验与资源体系化整理&#xff0c;助力从业者高效通关。 &#x1f31f; 认证价值与政策背景 根据…
阅读更多...
亚信安全正式接入DeepSeek

亚信安全正式接入DeepSeek

亚信安全致力于“数据驱动、AI原生”战略&#xff0c;早在2024年5月&#xff0c;推出了“信立方”安全大模型、安全MaaS平台和一系列安全智能体&#xff0c;为网络安全运营、网络安全检测提供AI技术能力。自2024年12月DeepSeek-V3发布以来&#xff0c;亚信安全人工智能实验室利…
阅读更多...
unet学习（初学者 自用）

unet学习（初学者 自用）

代码解读 | 极简代码遥感语义分割&#xff0c;结合GDAL从零实现&#xff0c;以U-Net和建筑物提取为例 以上面链接中的代码为例&#xff0c;逐行解释。 训练 unet的train.py如下&#xff1a; import torch.nn as nn import torch import gdal import numpy as np from torch…
阅读更多...
CCFCSP第34次认证第一题——矩阵重塑（其一）

CCFCSP第34次认证第一题——矩阵重塑（其一）

第34次认证第一题——矩阵重塑&#xff08;其一&#xff09; 官网链接 时间限制&#xff1a; 1.0 秒 空间限制&#xff1a; 512 MiB 相关文件&#xff1a; 题目目录&#xff08;样例文件&#xff09; 题目背景 矩阵&#xff08;二维&#xff09;的重塑&#xff08;reshap…
阅读更多...
探索B-树系列

探索B-树系列

&#x1f308;前言&#x1f308; 本文将讲解B树系列&#xff0c;包含 B-树&#xff0c;B树&#xff0c;B*树&#xff0c;其中主要讲解B树底层原理&#xff0c;为什么用B树作为外查询的数据结构&#xff0c;以及B-树插入操作并用代码实现&#xff1b;介绍B树、B*树。 &#x1f4…
阅读更多...
GRN前沿：DeepMCL：通过深度多视图对比学习从单细胞基因表达数据推断基因调控网络

GRN前沿：DeepMCL：通过深度多视图对比学习从单细胞基因表达数据推断基因调控网络

1.论文原名&#xff1a;Inferring gene regulatory networks from single-cell gene expression data via deep multi-view contrastive learning 2.发表日期&#xff1a;2023 摘要&#xff1a; 基因调控网络&#xff08;GRNs&#xff09;的构建对于理解细胞内复杂的调控机制…
阅读更多...
Linux 内核架构入门：从基础概念到面试指南*

Linux 内核架构入门：从基础概念到面试指南*

1. 引言 Linux 内核是现代操作系统的核心&#xff0c;负责管理硬件资源、提供系统调用、处理进程调度等功能。对于初学者来说&#xff0c;理解 Linux 内核的架构是深入操作系统开发的第一步。本篇博文将详细介绍 Linux 内核的架构体系&#xff0c;结合硬件、子系统及软件支持的…
阅读更多...
【竞技宝】PGL瓦拉几亚S4预选:Tidebound2-0轻取spiky

【竞技宝】PGL瓦拉几亚S4预选:Tidebound2-0轻取spiky

北京时间2月13日,DOTA2的PGL瓦拉几亚S4预选赛继续进行,昨日进行的中国区预选赛胜者组首轮Tidebound对阵的spiky比赛中,以下是本场比赛的详细战报。 第一局: 首局比赛,spiky在天辉方,Tidebound在夜魇方。阵容方面,spiky点出了幻刺、火枪、猛犸、小强、巫妖,Tidebound则是拿到飞…
阅读更多...
EasyRTC智能硬件：小体积，大能量，开启音视频互动新体验

EasyRTC智能硬件：小体积，大能量，开启音视频互动新体验

在万物互联的时代&#xff0c;智能硬件正以前所未有的速度融入我们的生活。然而&#xff0c;受限于硬件性能和网络环境&#xff0c;许多智能硬件在音视频互动体验上仍存在延迟高、卡顿、回声等问题&#xff0c;严重影响了用户的使用体验。 EasyRTC智能硬件&#xff0c;凭借其强…
阅读更多...
【ESP32指向鼠标】——icm20948与esp32通信

【ESP32指向鼠标】——icm20948与esp32通信

【ESP32指向鼠标】——icm20948与esp32通信 ICM-20948介绍 ICM-20948 是一款由 InvenSense&#xff08;现为 TDK 的一部分&#xff09;生产的 9 轴传感器集成电路。它结合了 陀螺仪、加速度计和磁力计。 内置了 DMP&#xff08;Digital Motion Processor&#xff09;即负责执…
阅读更多...
算法——结合实例了解深度优先搜索（DFS）

算法——结合实例了解深度优先搜索（DFS）

一&#xff0c;深度优先搜索&#xff08;DFS&#xff09;详解 DFS是什么&#xff1f; 深度优先搜索&#xff08;Depth-First Search&#xff0c;DFS&#xff09;是一种用于遍历或搜索树、图的算法。其核心思想是尽可能深地探索分支&#xff0c;直到无法继续时回溯到上一个节点…
阅读更多...
SpringMVC学习使用

SpringMVC学习使用

一、SpringMVC简单理解 1.1 Spring与Web环境集成 1.1.1 ApplicationContext应用上下文获取方式 应用上下文对象是通过new ClasspathXmlApplicationContext(spring配置文件) 方式获取的&#xff0c;但是每次从容器中获得Bean时都要编写new ClasspathXmlApplicationContext(sp…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023