数据结构与算法-14_AVL 树

已于 2024-06-10 15:48:00 修改
阅读量1.1k 收藏 29
点赞数 31
分类专栏： 数据结构与算法 文章标签： 数据结构 AVL树 java 开发语言
于 2024-06-06 08:23:17 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_62036548/article/details/139466934
版权

文章目录

1.概述

AVL 树是一种自平衡二叉搜索树。

在二叉搜索树中，如果插入的元素按照特定的顺序排列，可能会导致树变得非常不平衡，从而降低搜索、插入和删除的效率。为了解决这个问题，AVL 树通过在每个节点中维护一个平衡因子来确保树的平衡。平衡因子是左子树的高度减去右子树的高度。如果平衡因子的绝对值大于等于 2，则通过旋转操作来重新平衡树。

AVL 树是用于存储有序数据的一种重要数据结构，它是二叉搜索树的一种改进和扩展。它不仅能够提高搜索、插入和删除操作的效率，而且还能够确保树的深度始终保持在 O(log n) 的水平。

如果一棵二叉搜索树不平衡，那么查询的效率会受到影响

在这里插入图片描述

通过旋转可以让树重新变得平衡，并且不会改变二叉搜索树的性质（即左边仍然小，右边仍然大）
在这里插入图片描述

如何判断失衡？

如果一个节点的左右孩子，高度差超过 1，则此节点失衡，才需要旋转

处理高度

求高度是一个非常频繁的操作，因此将高度作为节点的一个属性，将来新增或删除时及时更新，默认为 1。

static class AVLNode {
    int height = 1;
    int key;
    Object value;
    AVLNode left;
    AVLNode right;
    // ...
}

求高度代码

加入height 函数方便求节点为 null 时的高度

private int height(AVLNode node) {
    return node == null ? 0 : node.height;
}

更新高度代码

新增、删除、旋转时，高度都可能发生变化，需要更新

private void updateHeight(AVLNode node) {
    node.height = Integer.max(height(node.left), height(node.right)) + 1;
}
何时触发失衡判断？

定义平衡因子（balance factor）如下
平衡因子 = 左子树高度 − 右子树高度 平衡因子 = 左子树高度 - 右子树高度 平衡因子=左子树高度−右子树高度
当平衡因子

  • bf = 0，1，-1 时，表示左右平衡
  • bf > 1 时，表示左边太高
  • bf < -1 时，表示右边太高

代码

private int bf(AVLNode node) {
    return height(node.left) - height(node.right);
}

当插入新节点，或删除节点时，引起高度变化时

在这里插入图片描述

目前此树平衡，当再插入一个 4 时，节点们的高度都产生了相应的变化，8 节点失衡

在这里插入图片描述

下面这棵树一开始也是平衡

在这里插入图片描述

当删除节点 8 时，节点们的高度都产生了相应的变化，6 节点失衡

在这里插入图片描述

失衡的四种情况

LL

在这里插入图片描述

  • 失衡节点（图中 8 红色）的 bf > 1，即左边更高
  • 失衡节点的左孩子（图中 6）的 bf >= 0 即左孩子这边也是左边更高或等高

LR
在这里插入图片描述

  • 失衡节点（图中 8）的 bf > 1，即左边更高
  • 失衡节点的左孩子（图中 6 红色）的 bf < 0 即左孩子这边是右边更高

RL
在这里插入图片描述

  • 失衡节点（图中 3）的 bf < -1，即右边更高
  • 失衡节点的右孩子（图中 6 红色）的 bf > 0，即右孩子这边左边更高

RR

在这里插入图片描述

  • 失衡节点（图中 3）的 bf <-1，即右边更高
  • 失衡节点的右孩子（图中 6 红色）的 bf <= 0，即右孩子这边右边更高或等高

2.实现

解决失衡

树的旋转：是在不干扰元素顺序的情况下更改结构，通常用来让树的高度变得平衡。

右旋

旋转前

在这里插入图片描述

  • 红色节点，旧根（失衡节点）
  • 黄色节点，旧根的左孩子，将来作为新根，旧根是它右孩子
  • 绿色节点，新根的右孩子，将来要换爹作为旧根的左孩子

旋转后

在这里插入图片描述

代码

private AVLNode rightRotate(AVLNode red) {
    AVLNode yellow = red.left;
    AVLNode green = yellow.right;
    yellow.right = red;
    red.left = green;
    return yellow;
}

左旋

旋转前

在这里插入图片描述

  • 红色节点，旧根（失衡节点）
  • 黄色节点，旧根的右孩子，将来作为新根，旧根是它左孩子
  • 绿色节点，新根的左孩子，将来要换爹作为旧根的右孩子

旋转后

在这里插入图片描述

代码

private AVLNode leftRotate(AVLNode red) {
    AVLNode yellow = red.right;
    AVLNode green = yellow.left;
    yellow.left = red;
    red.right = green;
    return yellow;
}

左右旋

指先左旋左子树，再右旋根节点（失衡），一次旋转并不能解决失衡

在这里插入图片描述

左子树旋转后

在这里插入图片描述

根右旋前

在这里插入图片描述

根右旋后

在这里插入图片描述

代码

private AVLNode leftRightRotate(AVLNode root) {
    root.left = leftRotate(root.left);
    return rightRotate(root);
}

右左旋

指先右旋右子树，再左旋根节点（失衡）

在这里插入图片描述

右子树右旋后
在这里插入图片描述

根左旋前

在这里插入图片描述

根左旋后
在这里插入图片描述

代码

private AVLNode rightLeftRotate(AVLNode root) {
    root.right = rightRotate(root.right);
    return leftRotate(root);
}

判断及调整平衡代码

private AVLNode balance(AVLNode node) {
    if (node == null) {
        return null;
    }
    int bf = bf(node);
    if (bf > 1 && bf(node.left) >= 0) {
        return rightRotate(node);
    } else if (bf > 1 && bf(node.left) < 0) {
        return rightLeftRotate(node);
    } else if (bf < -1 && bf(node.right) > 0) {
        return leftRightRotate(node);
    } else if (bf < -1 && bf(node.right) <= 0) {
        return rightRotate(node);
    }
    return node;
}

四种旋转代码，都需要更新高度，需要更新的节点是红色、黄色，而绿色节点高度不变

新增
public void put(int key, Object value) {
    root = doPut(root, key, value);
}

private AVLNode doPut(AVLNode node, int key, Object value) {
    if (node == null) {
        return new AVLNode(key, value);
    }
    if (key == node.key) {
        node.value = value;
        return node;
    }
    if (key < node.key) {
        node.left = doPut(node.left, key, value);
    } else {
        node.right = doPut(node.right, key, value);
    }
    updateHeight(node);
    return balance(node);
}
删除
public void remove(int key) {
    root = doRemove(root, key);
}

private AVLNode doRemove(AVLNode node, int key) {
    if (node == null) {
        return null;
    }
    if (key < node.key) {
        node.left = doRemove(node.left, key);
    } else if (node.key < key) {
        node.right = doRemove(node.right, key);
    } else {
        if (node.left == null) {
            node = node.right;
        } else if (node.right == null) {
            node = node.left;
        } else {
            AVLNode s = node.right;
            while (s.left != null) {
                s = s.left;
            }
            s.right = doRemove(node.right, s.key);
            s.left = node.left;
            node = s;
        }
    }
    if (node == null) {
        return null;
    }
    updateHeight(node);
    return balance(node);
}

完整代码备份

public class AVLTree {
    static class AVLNode {
        int height = 1;
        int key;
        Object value;
        AVLNode left;
        AVLNode right;

        public AVLNode(int key) {
            this.key = key;
        }

        public AVLNode(int key, Object value) {
            this.key = key;
            this.value = value;
        }

        public AVLNode(int key, Object value, AVLNode left, AVLNode right) {
            this.key = key;
            this.value = value;
            this.left = left;
            this.right = right;
        }
    }

    AVLNode root;

    private AVLNode leftRotate(AVLNode p) {
        AVLNode r = p.right;
        AVLNode b = r.left;
        r.left = p;
        p.right = b;
        updateHeight(p);
        updateHeight(r);
        return r;
    }

    private void updateHeight(AVLNode node) {
        node.height = Integer.max(height(node.left), height(node.right)) + 1;
    }

    private AVLNode rightRotate(AVLNode r) {
        AVLNode a = r.left;
        AVLNode b = a.right;
        a.right = r;
        r.left = b;
        updateHeight(r);
        updateHeight(a);
        return a;
    }

    private AVLNode leftRightRotate(AVLNode p) {
        AVLNode r = p.left;
        p.left = leftRotate(r);
        return rightRotate(p);
    }

    private AVLNode rightLeftRotate(AVLNode p) {
        AVLNode r = p.right;
        p.right = rightRotate(r);
        return leftRotate(p);
    }

    private int height(AVLNode node) {
        return node == null ? 0 : node.height;
    }



    public void remove(int key) {
        root = doRemove(root, key);
    }

    private AVLNode doRemove(AVLNode node, int key) {
        if (node == null) {
            return null;
        }
        if (key < node.key) {
            node.left = doRemove(node.left, key);
        } else if (node.key < key) {
            node.right = doRemove(node.right, key);
        } else {
            if (node.left == null) {
                node = node.right;
            } else if (node.right == null) {
                node = node.left;
            } else {
                AVLNode s = node.right;
                while (s.left != null) {
                    s = s.left;
                }
                s.right = doRemove(node.right, s.key);
                s.left = node.left;
                node = s;
            }
        }
        if (node == null) {
            return null;
        }
        updateHeight(node);
        return balance(node);
    }

    public void put(int key, Object value) {
        root = doPut(root, key, value);
    }

    private AVLNode doPut(AVLNode node, int key, Object value) {
        if (node == null) {
            return new AVLNode(key, value);
        }
        if (key == node.key) {
            node.value = value;
            return node;
        }
        if (key < node.key) {
            node.left = doPut(node.left, key, value);
        } else {
            node.right = doPut(node.right, key, value);
        }
        updateHeight(node);
        return balance(node);
    }

    private int bf(AVLNode node) {
        return height(node.left) - height(node.right);
    }

    private AVLNode balance(AVLNode node) {
        if (node == null) {
            return null;
        }
        int bf = bf(node);
        if (bf > 1 && bf(node.left) >= 0) {
            return rightRotate(node);
        } else if (bf > 1 && bf(node.left) < 0) {
            return rightLeftRotate(node);
        } else if (bf < -1 && bf(node.right) > 0) {
            return leftRightRotate(node);
        } else if (bf < -1 && bf(node.right) <= 0) {
            return rightRotate(node);
        }
        return node;
    }
}
小结

AVL树的优点：

  1. AVL树是一种自平衡树，保证了树的高度平衡，从而保证了树的查询和插入操作的时间复杂度均为O(logn)。
  2. 相比于一般二叉搜索树，AVL树对查询效率的提升更为显著，因为其左右子树高度的差值不会超过1，避免了二叉搜索树退化为链表的情况，使得整棵树的高度更低。
  3. AVL树的删除操作比较简单，只需要像插入一样旋转即可，在旋转过程中树的平衡性可以得到维护。

AVL树的缺点：

  1. AVL树每次插入或删除节点时需要进行旋转操作，这个操作比较耗时，因此在一些应用中不太适用。
  2. 在AVL树进行插入或删除操作时，为保持树的平衡需要不断进行旋转操作，在一些高并发环节和大数据量环境下，这可能会导致多余的写锁导致性能瓶颈。
  3. AVL树的旋转操作相对较多，因此在一些应用中可能会造成较大的空间浪费。
StartLFly
关注
专栏目录
数据结构 - AVL树
TPON的博客
11-10 778
AVL树 - 平衡二叉搜索树
瑞_数据结构与算法_AVL树
阿瑞——从事Java后端，喜欢研读源码、自研框架、分享经验
01-29 1159
本文章为瑞_系列专栏之《数据结构与算法》的AVL树篇，AVL 树是一种自平衡二叉搜索树，AVL树是用于存储有序数据的一种重要数据结构，它是二叉搜索树的一种改进和扩展。它不仅能够提高搜索、插入和删除操作的效率，而且还能够确保树的深度始终保持在 O(log n) 的水平
数据结构--AVL树介绍
2302_80190174的博客
07-21 954
上图在插入前，AVL树是平衡的，新节点插入到SubL的左子树(注意：此处不是左孩子)中，SubL左子树增加了一层，导致以parent为根的二叉树不平衡，要让其平衡，只能将parent左子树的高度减少一层，右子树增加一层，即将左子树往上提，这样parent转下来，因为parent的值比SubL大，只能将其放在SubL的右子树，而如果SubL有右子树，右子树根的值一定大于SubL的值，小于parent的值，只能将其放在parent的左子树，旋转完成后，更新节点的平衡因子即可。
数据结构-AVL树（平衡二叉树）
m0_61433144的博客
08-11 1036
规定在插入和删除二叉搜索树的结点时，要保证任意结点的左右子树高度差的绝对值不超过1，我们将这样特殊的二叉搜索树称为AVL树（平衡二叉树）。每一个结点中有记录其左右子树高度差的平衡因子，也即平衡因子的值只可能是-1,0,1。（1如果某结点的左子树高度比右子树高度高一则平衡因子为-1，如果某结点的左子树高度比右子树高度低一则平衡因子为1，如果某结点的左子树高度与右子树高度一样则平衡因子为0）。............
数据结构与算法--面试必问AVL树原理及实现
0102的博客
12-16 840
数据结构与算法–AVL树原理及实现 上一篇：数据结构与算法–二叉查找树实现原理
数据与结构--AVL树
weixin_66905164的博客
05-25 1078
AVL树的概念;AVL树的性质;AVL树结点的定义;AVL树的插入;AVL树的旋转;左单旋;右单旋;左右双旋;右左单旋;AVL树的验证;AVL树的查找;AVL树的修改;AVL树的删除
笔记-数据结构与算法-树
weixin_44938921的博客
06-17 1949
定义1其中一个节点被设定为根；每个节点n（除根节点），都恰连接一条来自节点p的边，p是n的父节点；每个节点从根开始的路径是唯一的如果每个节点最多有两个子节点，这样的数称为“二叉树”定义2（递归定义）树是空集或者由根节点及0或多个子树构成（其中子树叶也是树），每个子树的根到根节点具有边相连。
Python - 深夜数据结构与算法之 AVL 树 & 红黑树
BITDDD小栈
01-15 1688
AVL 树、红黑树简介。
【数据结构与算法】AVL树
程序员波特
09-28 1474
AVL 树是一种自平衡二叉搜索树，由托尔·哈斯特罗姆在 1960 年提出并在 1962 年发表。它的名字来源于发明者的名字：Adelson-Velsky 和 Landis，他们是苏联数学家，于 1962 年发表了一篇论文，详细介绍了 AVL 树的概念和性质。在二叉搜索树中，如果插入的元素按照特定的顺序排列，可能会导致树变得非常不平衡，从而降低搜索、插入和删除的效率。为了解决这个问题，AVL 树通过在每个节点中维护一个平衡因子来确保树的平衡。平衡因子是左子树的高度减去右子树的高度。
数据结构与算法分析--C语言描述_数据结构与算法_
10-01
常见的数据结构包括数组、链表、栈、队列、树（如二叉树、AVL树、红黑树）、图等。数组是最基础的数据结构，提供随机访问但插入和删除操作相对较慢；链表则通过指针链接元素，便于动态调整但访问速度较慢；栈和队列...
小甲鱼数据结构与算法课件+源码.zip_-baijiahao_expresschs_once4l3_小甲鱼 ppt_小甲鱼数据结
07-15
常见的数据结构包括数组、链表、栈、队列、哈希表、树（二叉树、平衡树如AVL和红黑树）、图等。这些数据结构各有特点，适用于不同的场景，理解它们的特性和操作方法是编程能力提升的关键。 例如，数组是最基础的...
数据结构和算法-思维导图.pdf
05-26
以上是根据文件的标题、描述、标签和部分预览内容总结出的数据结构与算法知识点。这些知识点是IT行业中软件开发人员必备的基础知识，广泛应用于软件设计、算法实现、系统优化等众多领域。掌握这些知识点能够帮助IT...
数据结构课设PPT_地图着色_推销商问题_遗传算法_AVL树_回溯法
08-22
在这个课设中，我们关注的是几种关键的数据结构和算法，包括地图着色问题、推销商问题、遗传算法以及AVL树。 地图着色问题是一个典型的图论问题，目标是用最少的颜色给地图上的各个区域着色，相邻的区域不能使用...
数据结构与算法课程设计-2019_数据结构课设资料_
10-03
- **树**：非线性数据结构，包括二叉树、平衡树（如AVL树、红黑树）等，广泛应用于搜索、排序等任务。 - **图**：表示对象间的关系，有邻接矩阵和邻接表等多种表示方式，用于路径查找、网络流问题等。 2. **算法...
数据结构编程实践20讲(Python版)—05二叉树
最新发布
AnFany
10-08 400
数据结构编程实践20讲(Python版)-05二叉树
数据结构-哈西表笔记
2302_80490510的博客
10-05 322
如果不用去重就可以用哈希表。
数据结构 ——— 单链表oj题：返回链表的中间节点
weixin_55341642的博客
10-02 411
slow 指针一次走一步，fast 指针一次走两步，那么 fast 指针就是 slow 指针的二倍
C++学习笔记----8、掌握类与对象（四）---- 不同类型的数据成员（1）
weixin_71738303的博客
10-05 920
c++对于数据成员给了你许多选项。除了在类中声明简单的数据成员，可以生成静态数据成员供所有类的对象共享，const成员，引用成员，reference-to-const成员，等等。本节我们解释一下这些不同类型的数据成员的细节。
数据结构C语言版-严蔚敏_吴伟民PDF版
7. **动态规划**：虽然不是数据结构本身，但常与数据结构结合解决复杂问题，如背包问题、最长公共子序列等。 8. **递归与回溯**：递归是解决问题的重要方法，而回溯则是求解多解或无解问题的有效策略，如八皇后问题...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值