平衡二叉树（AVL）

最新推荐文章于 2024-10-05 10:07:31 发布
最新推荐文章于 2024-10-05 10:07:31 发布
阅读量595 收藏 28
点赞数 23
分类专栏： 算法程序设计 文章标签： 笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_46450354/article/details/140605118
版权

阅读之前请先了解 二叉搜索树 | 二叉查找树 | 二叉排序树 （Binary Search Tree，简称 BST）

1. 为什么使用「平衡二叉树」

二叉搜索树能提高查询的效率 O(logn)，但是当你插入 {1,2,3,4,5,6} 这种数据的时候，你的二叉树就像一个「链表」一样，搜索效率变为 O(n)
在这里插入图片描述

于是在 1962 年，一个姓 AV 的大佬（G. M. Adelson-Velsky） 和一个姓 L 的大佬（ Evgenii Landis）提出「平衡二叉树」（AVL） 。

插入 {1,2,3,4,5,6} 这种数据结果如下图所示：
在这里插入图片描述

2. 判断「平衡二叉树」

判断「平衡二叉树」的 2 个条件：

    1. 是「二叉排序树」
    1. 任何一个节点的左子树或者右子树都是「平衡二叉树」（左右高度差小于等于 1）

（1）下图不是「平衡二叉树」因为它不是「二叉排序树」违反第 1 条件
在这里插入图片描述

（2）下图不是「平衡二叉树」因为有节点子树高度差大于 1 违法第 2 条件

在这里插入图片描述

（3）下图是「平衡二叉树」因为符合 1、2 条件
在这里插入图片描述

3. 相关概念

3.1 平衡因子 BF（Balance Factor）

  • 定义： 左子树和右子树高度差
  • 计算： 左子树高度 - 右子树高度的值（可能是负值，表示右子树高于左子树）

一般来说 BF 的绝对值大于 1，,平衡树二叉树就失衡，需要「旋转」纠正

3.2 最小不平衡子树

最小不平衡子树： 在新插入的结点向上查找，以第一个平衡因子的绝对值超过 1 的结点**（平衡因子 BF 变成了 -2 或 2）**为根的子树称为最小不平衡子树。也就是说，一棵失衡的树，是有可能有多棵子树同时失衡的。而这个时候，我们只要调整最小的不平衡子树，就能够将不平衡的树调整为平衡的树。

「旋转」纠正只需要纠正「最小不平衡子树」即可
在这里插入图片描述

4. 二种旋转方式

2 种「旋转」方式：

  • 左旋
    • 旧根节点为新根节点的左子树
    • 新根节点的左子树（如果存在）为旧根节点的右子树
  • 右旋：
    • 旧根节点为新根节点的右子树
    • 新根节点的右子树（如果存在）为旧根节点的左子树

右旋

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

左旋

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

5. 4 种「旋转」纠正类型：

  • LL 型：插入左孩子的左子树导致不平衡，右旋
  • RR 型：插入右孩子的右子树导致不平衡，左旋
  • LR 型：插入左孩子的右子树导致不平衡，先左旋，再右旋
  • RL 型：插入右孩子的左子树导致不平衡，先右旋，再左旋

在这里插入图片描述
在这里插入图片描述

5.1 LL 型失衡「右旋」

由于在被破坏节点的的左孩子 (L) 的左子树 (L) 上插入新结点，使原来平衡二叉树变得不平衡，此时 A 的平衡因子由 1 增至 2。

如下： 第三个节点「1」插入的 时候，BF(3) = 2，BF(2) = 1，LL 型失衡，右旋，根节点顺时针旋转

在这里插入图片描述
在这里插入图片描述在这里插入图片描述

5.2 RR 型失衡「左旋」

由于在被破坏节点的右孩子（R）的右子树（R）上插入了新结点，平衡因子由 -1 减至 -2，导致以被破坏节点为根的子树失去平衡，需要一次向左的旋转操作。

如下： 第三个节点「3」插入的 时候，BF(1)=-2 BF(2)=-1，RR 型失衡，左旋，根节点逆时针旋转
在这里插入图片描述
在这里插入图片描述

在这里插入图片描述

5.3 LR 型

LR平衡旋转（先左后右双旋转）。由于在被破坏节点的左孩子（L）的右子树（R）上插入新结点，被破坏节点的平衡因子由1增至2，导致以被破坏节点为根的子树失去平衡，需要进行两次旋转操作，先左旋转后右旋转。先将被破坏结点的左孩子1的右子树的根结点2向左上旋转提升到1结点的位置，然后再把该2结点向右上旋转提升到1结点的位置

如下： 第三个节点「2」插入的 时候，BF(3)=2 BF(1)=-1， LR 型失衡，先「左旋」变为 LL 型，再「右旋」
在这里插入图片描述

（1）最小不平衡子树左子树 {2,1} 先左旋
在这里插入图片描述

（2）最小不平衡子树 {3,2,1} 再右旋
在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

5.4 RL 型

第三个节点「1」插入的 时候，BF(1)=-2 BF(3)=1 RL 型失衡，先「右旋」再「左旋」

在这里插入图片描述

（1）最小不平衡子树根节点右子树{3,2}先右旋
在这里插入图片描述

（2）最小不平衡子树 {1,2,3} 再左旋（L）

在这里插入图片描述

在这里插入图片描述

5. 实例

实例一

接下来以 {3,2,1,4,5,6,7,10,9,8} 为实例练习刚刚的 4 种插入方式

（1）依次插入 3、2、1 插入第三个点 1 的时候 BF(3)=2 BF(2)=1，LL 型失衡。对最小不平衡树 {3,2,1}进行「右旋」
在这里插入图片描述

（2）依次插入 4 ，5 插入 5 点的时候 BF(3) = -2 BF(4)=-1，RR 型失衡。对最小不平衡树 {3,4,5} 进行「左旋」
在这里插入图片描述

（3）插入 4 ，5 插入 5 点的时候 BF(2)=-2 BF(4)=-1 ，RR 型失衡 对最小不平衡树进行「左旋」

在这里插入图片描述
在这里插入图片描述

（4）插入 7 节点的时候 BF(5)=-2, BF(6)=-1 ，RR 型失衡，对最小不平衡树 进行「左旋」
在这里插入图片描述

（5）依次插入 10 ，9 。插入 9 点的时候 BF(10) = 1，BF(7) = -2 ，RL 型失衡，先「右旋」再「左旋」
在这里插入图片描述
在这里插入图片描述

（6）最后插入节点 8 ，BF(6)=-2 BF(9)=1，RL 型失衡，先「右旋」再「左旋」
在这里插入图片描述
在这里插入图片描述

结束
在这里插入图片描述

实例二

选取一组数据分别为2，1，0，3，4，5，6，9，8，7的10个结点来构造平衡二叉树。

首先数据为2的结点作为根结点插入，接着插入1，仍是平衡的，再插入0是，2的平衡因子变为2，此时出现了不平衡，因此需要进行调整，最低不平衡结点为2，属于LL型，调整过程如图所示。
在这里插入图片描述

接着插入3，是平衡的，再插入4，此时出现了不平衡，结点 1 和 2 的平衡因子都为 -2，结点2为最低不平衡结点，属于RR型，调整过程如图所示
在这里插入图片描述

接着插入5，此时结点 1 的平衡因子为 -2，导致不平衡，结点1为最低不平衡结点，属于RR型，调整如图所示。
在这里插入图片描述

接着插入6，此时结点4的平衡因子为 -2，导致不平衡，结点4为最低不平衡结点，属于RR型，调整如图所示。
在这里插入图片描述

接着插入9，是平衡的，再插入8，此时结点 3、5、6 的平衡因子都为 -2，导致不平衡，结点6为最低不平衡结点，属于RL型，调整如图所示。
在这里插入图片描述

插入7，此时结点3、5的平衡因子为 -2，导致不平衡，最低不平衡结点为5，属于RL型，调整如图所示。
在这里插入图片描述

6.代码实现

6.1 定义节点

public class AVLNode {
    /** 数据 **/
    public int data;
    /** 相对高度 **/
    public int height;
    /** 父节点 **/
    public AVLNode parent;
    /** 左子树 **/
    public AVLNode left;
    /** 右子树 **/
    public AVLNode right;
    public AVLNode(int data) {
        this.data = data;
        this.height = 1;
    }
}

6.2 计算高度

节点高度等于左子树和右子树最大高度 + 1

/** 通过子树高度 计算高度 **/
private int calcHeight(AVLNode root) {
    if (root.left == null && root.right == null) {
        return 1;
    }
    else if (root.right == null) {
        return root.left.height + 1;
    } else if (root.left == null) {
        return root.right.height + 1;
    }else {
        return root.left.height > root.right.height ? root.left.height + 1 : root.right.height + 1;
    }
}

6.3 计算 BF

BF（平衡因子）的值为：左子树高度 - 右子树高度

private int calcBF(AVLNode root) {
    if (root == null){
        return 0;
    }
    else if (root.left == null && root.right == null) {
        return 0;
    }
    else if (root.right == null) {
        return root.left.height ;
    } else if (root.left == null) {
        return - root.right.height;
    }else {
        return root.left.height - root.right.height;
    }
}

6.4 旋转

2 种「旋转」方式：

  • 左旋
    • 旧根节点为新根节点的左子树
    • 新根节点的左子树（如果存在）为旧根节点的右子树
  • 右旋：
    • 旧根节点为新根节点的右子树
    • 新根节点的右子树（如果存在）为旧根节点的左子树

重点理解： 旋转之后通过需要刷新高度

高度变化只有： oldRoot 和 newRoot

但是它们子树的高度是不变的（这很关键）

我们可以通过它们 子树的高度计算他们的高度

使用不变的因数计算变化的因素是一个很好的思维

public AVLNode leftRotate(AVLNode root) {
    AVLNode oldRoot = root;
    AVLNode newRoot = root.right;
    AVLNode parent = root.parent;
    //1.newRoot 替换 oldRoot 位置
    if (null != parent ) {
        if (oldRoot.parent.data > oldRoot.data) {
            parent.left = newRoot;
        }else  {
            parent.right = newRoot;
        }
    }
    newRoot.parent = parent;
    //2.重新组装 oldRoot (将 newRoot 的左子树 给 oldRoot 的右子树)
    oldRoot.right = newRoot.left;
    if (newRoot.left != null) {
        newRoot.left.parent = oldRoot;
    }
    //3. oldRoot 为 newRoot 的左子树
    newRoot.left = oldRoot;
    oldRoot.parent = newRoot;
    //刷新高度
    oldRoot.height = calcHeight(oldRoot);
    newRoot.height = calcHeight(newRoot);
    return newRoot;
}


public AVLNode rightRotate(AVLNode root) {
    AVLNode oldRoot = root;
    AVLNode newRoot = root.left;
    AVLNode parent = root.parent;
    //1.newRoot 替换 oldRoot 位置
    if (null != parent ) {
        if (oldRoot.parent.data > oldRoot.data) {
            parent.left = newRoot;
        }else {
            parent.right = newRoot;
        }
    }
    newRoot.parent = parent;
    //2.重新组装 oldRoot (将 newRoot 的右子树 给 oldRoot 的左子树)
    oldRoot.left = newRoot.right;
    if (newRoot.right != null) {
        newRoot.right.parent = oldRoot;
    }
    //3. oldRoot 为 newRoot 的左子树
    newRoot.right = oldRoot;
    oldRoot.parent = newRoot;
    //刷新高度
    oldRoot.height = calcHeight(oldRoot);
    newRoot.height = calcHeight(newRoot);
    return newRoot;
}

6.5 插入（总代码）

插入操作

  • 递归插入新节点
  • 刷新高度
  • 旋转并再次刷新高度
public class ALVTree {
    AVLNode root;
    public void insert(int data) {
        if (null == this.root) {
            this.root = new AVLNode(data);
            return;
        }
        this.root = insert(this.root, data);
    }
    public AVLNode insert(AVLNode root, int data) {
        //插入左子树
        if (data < root.data) {
            if (null == root.left) {
                root.left = new AVLNode(data);
                root.left.parent = root;
            }else {
                insert(root.left,data);
            }
        }
        //插入右子树
        else if (data > root.data) {
            if (null == root.right) {
                root.right = new AVLNode(data);
                root.right.parent = root;
            } else {
                insert(root.right,data);
            }
        }
        //刷新高度
        root.height = calcHeight(root);
        //旋转
        //1. LL 型 右旋转
        if (calcBF(root) == 2){
            //2. LR 型 先左旋转
            if (calcBF(root.left) == -1) {
                root.left = leftRotate(root.left);
            }
            root = rightRotate(root);
        }
        //3. RR型 左旋转
        if (calcBF(root) == -2){
            //4. RL 型 先右旋转
            if (calcBF(root.right)== 1) {
                root.right = rightRotate(root.right);
            }
            root = leftRotate(root);
        }

        return root;
    }
    public AVLNode leftRotate(AVLNode root) {
        AVLNode oldRoot = root;
        AVLNode newRoot = root.right;
        AVLNode parent = root.parent;
        //1.newRoot 替换 oldRoot 位置
        if (null != parent ) {
            if (oldRoot.parent.data > oldRoot.data) {
                parent.left = newRoot;
            }else  {
                parent.right = newRoot;
            }
        }
        newRoot.parent = parent;
        //2.重新组装 oldRoot (将 newRoot 的左子树 给 oldRoot 的右子树)
        oldRoot.right = newRoot.left;
        if (newRoot.left != null) {
            newRoot.left.parent = oldRoot;
        }
        //3. oldRoot 为 newRoot 的左子树
        newRoot.left = oldRoot;
        oldRoot.parent = newRoot;
        //刷新高度
        oldRoot.height = calcHeight(oldRoot);
        newRoot.height = calcHeight(newRoot);
        return newRoot;
    }


    public AVLNode rightRotate(AVLNode root) {
        AVLNode oldRoot = root;
        AVLNode newRoot = root.left;
        AVLNode parent = root.parent;
        //1.newRoot 替换 oldRoot 位置
        if (null != parent ) {
            if (oldRoot.parent.data > oldRoot.data) {
                parent.left = newRoot;
            }else {
                parent.right = newRoot;
            }
        }
        newRoot.parent = parent;
        //2.重新组装 oldRoot (将 newRoot 的右子树 给 oldRoot 的左子树)
        oldRoot.left = newRoot.right;
        if (newRoot.right != null) {
            newRoot.right.parent = oldRoot;
        }
        //3. oldRoot 为 newRoot 的左子树
        newRoot.right = oldRoot;
        oldRoot.parent = newRoot;
        //刷新高度
        oldRoot.height = calcHeight(oldRoot);
        newRoot.height = calcHeight(newRoot);
        return newRoot;
    }
    /** 通过子树高度 计算高度 **/
    private int calcHeight(AVLNode root) {
        if (root.left == null && root.right == null) {
            return 1;
        }
        else if (root.right == null) {
            return root.left.height + 1;
        } else if (root.left == null) {
            return root.right.height + 1;
        }else {
            return root.left.height > root.right.height ? root.left.height + 1 : root.right.height + 1;
        }
    }
    private int calcBF(AVLNode root) {
        if (root == null){
            return 0;
        }
        else if (root.left == null && root.right == null) {
            return 0;
        }
        else if (root.right == null) {
            return root.left.height ;
        } else if (root.left == null) {
            return - root.right.height;
        }else {
            return root.left.height - root.right.height;
        }
    }
}

AVL树的问题

既然AVL树可以保证二叉树的平衡，这就意味着AVL搜索的时候，它最坏情况的时间复杂度O(logn) ，要低于普通二叉树BST和链表的最坏情况O(n)。

那么HashMap直接使用AVL树来替换链表就好了，为什么选择用红黑树呢？

原因是：

由于AVL树必须保证左右子树平衡，Max(最大树高-最小树高) <= 1，

所以在插入的时候很容易出现不平衡的情况，一旦这样，就需要进行旋转以求达到平衡。

正是由于这种严格的平衡条件，导致AVL需要花大量时间在调整上，故AVL树一般使用场景在于查询场景， 而不是 增加删除 频繁的场景。

红黑树(rbt)做了什么优化呢？

红黑树(rbt)继承了AVL可自平衡的优点，

同时, 红黑树(rbt)在查询速率和平衡调整中寻找平衡，放宽了树的平衡条件，从而可以用于 增加删除 频繁的场景。

在实际应用中，红黑树的使用要多得多。

References

平衡二叉树详解 通俗易懂

平衡二叉树

平衡二叉树AVL树定义、插入以及调整最小不平衡子树（C语言）

青年有志
关注
专栏目录
平衡二叉树AVL
Emperor10的博客
08-21 826
文章目录一、 相关概念1.1 AVL定义1.2 平衡因子1.3 AVL的作用二、 失衡调整2.1 LL型2.2 RR型2.3 LR型2.4 RL型 一、 相关概念 1.1 AVL定义 平衡二叉树又称为AVL树，它或者是颗空树，或者是具有下列性质的二叉排序树： 左右两个子树的高度差值不超过1； 它的左右子树也是一颗平衡二叉树； 1.2 平衡因子 某节点的左子树与右子树的高度差即为该节点的平衡因子BF。 按照定义我们可以得到，AVL上所有结点的平衡因子只可能是 -1，0 或 1。 下面这张图中标出了每一
平衡二叉树 AVL树 实现 C语言
su_1998的博客
12-16 1580
平衡树
平衡二叉树 AVL
喜欢吃冰棍de谷利文君的博客
03-07 863
平衡二叉树 AVL 先弄清楚几个概念： 1）满二叉树：除了叶子节点，都是满的； 2）完全二叉树：整体而言，空缺的节点一定是位于树的右下方；整棵树的叶子节点最大深度值和最小深度值，相差不会超过1； 3）平衡二叉树：对于任意一个节点，左子树和右子树的高度差不能超过1。 1 平衡因子 通过平衡因子可以判断出是否为平衡二叉树，这决定了是否需要进行左旋转或右旋转操作。 第一步，标注节点的高度；节点的高度=...
【数据结构】详解平衡二叉树AVL旋转操作(附相关C++代码)
weixin_50941083的博客
05-16 1805
本文介绍了什么是平衡二叉树，并详解了它的旋转操作。
平衡二叉树 avl
Calmye的博客
11-14 268
C语言-实现顺序二叉树和平衡二叉树AVL
mike_jun的博客
04-10 1118
在实现二叉树之前先看下结构体的一些使用方法数组是保存一系列相同的数据。在实际问题中，一组数据往往有很多种不同的数据类型。例如，登记学生的信息，可能需要用到 char型的姓名，int型或 char型的学号，int型的年龄访问其中的各个元素，用结构成员运算符点（.）。即访问成员的一般形式是：结构变量名 . 成员名如 a.name 表示学生 a 的姓名。1）结构体的成员逐个赋值2）整体赋值也可以在初始化的时候赋值3）整体拷贝如上每次使用结构体均需要写struct，可以使用typedef 简化书写。
详解AVL树（平衡二叉树）
热门推荐
水澹澹兮生烟
09-20 2万+
插入节点后对树进行旋转调整，分为四种情况。 1.右单旋 当一个平衡二叉树满足具有较高左子树时（如下图A），且要插入的节点插入到了较高左子树的左侧，此时进行右单旋。
动画讲解平衡二叉树AVL
jinking01的专栏
02-27 1873
前言 Wiki:在计算机科学中，AVL树是最早被发明的自平衡二叉查找树。在AVL树中，任一节点对应的两棵子树的最大高度差为1，因此它也被称为高度平衡树。查找、插入和删除在平均和最坏情况下的时间复杂度都是 O(logn）。增加和删除元素的操作则可能需要借由一次或多次树旋转，以实现树的重新平衡。AVL 树得名于它的发明者 G. M. Adelson-Velsky 和 Evgenii Landis，...
平衡二叉树AVL树
weixin_45863060的博客
04-06 1582
平衡二叉树（AVL树） 定义： AVL树是一颗特殊的二叉查找树，它具有保持平衡要求的特性，AVL树的每一个节点的左子树和右子树的高度差要求最大为1，如果超过1将破坏平衡特性，将不再是一颗平衡二叉树。 平衡条件的维持： 为什么需要维持平衡： AVL树需要时刻保持其平衡的特性，但这样的特性可能会在插入和删除的同时被打破，插入和删除新的节点造成的高度变化可能会使某些节点的左右子树的高度差超过1，所以我们需要在插入和删除的同时维护AVL树的平衡特性。 讨论如何维持AVL树的平衡： 明确平衡被破坏的位置 在讨论AV
平衡二叉树AVL操作模板
09-04
平衡二叉树 AVL 操作模板 平衡二叉树 AVL 操作模板是平衡二叉树的一种实现方式，通过 AVL 操作模板，可以对树进行插入、删除、查找等操作，并且保持树的平衡状态。 概念 1. 平衡二叉树：是一种自平衡二叉树，具有...
二叉树的应用：二叉排序树BST和平衡二叉树AVL的构造 课设作业 完整代码
02-10
平衡二叉树（Balanced Binary Tree）又被称为AVL树。具有以下性质：它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。构造与调整方法。 实验目的： 二叉排序树的实现...
java-平衡二叉树AVL的实现
04-23
在Java编程领域，平衡二叉树（特别是AVL树）是一种高效的数据结构，它通过保持树的高度平衡来确保查找、插入和删除操作的最优化。AVL树是最早被提出的自平衡二叉搜索树，由G. M. Adelson-Velsky和E. M. Landis于1962...
C++学习笔记----8、掌握类与对象（四）---- 不同类型的数据成员（1）
weixin_71738303的博客
10-05 731
c++对于数据成员给了你许多选项。除了在类中声明简单的数据成员，可以生成静态数据成员供所有类的对象共享，const成员，引用成员，reference-to-const成员，等等。本节我们解释一下这些不同类型的数据成员的细节。
（笔记）第三期书生·浦语大模型实战营（十一卷王场）--书生入门岛通关第2关Python 基础知识
haidizym的博客
10-02 477
学员闯关手册：https://aicarrier.feishu.cn/wiki/ZcgkwqteZi9s4ZkYr0Gcayg1n1g?课程视频：https://www.bilibili.com/video/BV1mS421X7h4/课程文档：https://github.com/InternLM/Tutorial/tree/camp3/docs/L0/Python。
江科大笔记—LED闪烁& LED流水灯& 蜂鸣器
m0_62005595的博客
09-28 491
LED闪烁& LED流水灯& 蜂鸣器
OpenGL笔记十九之相机系统
小勇博客
10-02 500
— 2024-10-02 晚上。
【韩顺平Java笔记】第6章：数组、排序和查找
随手写写
10-02 727
排序是将多个数据，依指定的顺序进行排列的过程。
【数学分析笔记】第4章第4节 复合函数求导法则及其应用（2）
最新发布
随手写写
10-05 582
【例4.4.3】ye1cosx​，求y′【解】y′e1cosx​⋅21cosx​1​⋅−sinx−21cosx​sinx​e1cosx​yfxuxvx两边取对数得lnylnfxvxlnux等式两边同时对x求导得y1​y′uxvx1​y′v′xlnuxuxvx​u′xy′xuxvxv′xln。
平衡二叉树AVL：概念与查找操作解析
这里的重点是AVL树，它是平衡二叉树的一种具体实现，由Adelson-Velsky和Landis于1962年提出，因此得名AVL树。 平衡二叉树的概念基于两个关键特性： 1. 平衡性：AVL树要求任意节点的左右子树高度差不超过1。这意味着...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值