AVL 平衡二叉搜索树

已于 2022-06-30 18:27:11 修改
阅读量209 收藏
点赞数
分类专栏： 数据结构 Java 文章标签： java 数据结构
于 2022-06-30 00:33:37 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Yan__Ran/article/details/125513921
版权

二叉搜索树（BST）虽能缩短查找效率，但如果数据有序或接近有序，BST将退化为单支树，此时查找元素就相当于在顺序表中搜索元素，效率低下。

那么此时如果能保证每个结点的左右子树高度差的绝对值不超过1，就可以降低树的高度，从而减少平均搜索长度。所以AVL带着这个使命诞生了。

一、AVL 

在二叉树中，如果每个结点的子树的高度差距为0、1或-1，则称这棵树是平衡二叉树，即AVL。

二、平衡二叉树

执行插入或删除操作后如果导致了AVL的不平衡，那么我们需要执行旋转操作来重新平衡这棵树。旋转操作主要有LL、RR、LR、RL四种类型。

1、LL

向左子树中的左孩子插入新结点后导致不平衡，此时需要右旋操作：

旋转后平衡二叉树将B看作新root， 将E结点与A.left相连，再将A与B.right相连，最后得到新的AVL。

    private void balanceLL(AVLTreeNode<E> A, TreeNode<E> parentOfA){
        TreeNode<E> B = A.left;
        if(A == root){
            root = B;
        }else{
            if(parentOfA.left == A){
                parentOfA.left = B;
            }else{
                parentOfA.right = B;
            }
        }

        A.left = B.right;
        B.right = A;
        updateHeight((AVLTreeNode<E>) A);

2、RR

和LL相反，向右子树中的右孩子插入新结点后导致的不平衡，此时需要左旋操作： 

    private void balanceRR(TreeNode<E> A, TreeNode<E> parentOfA){
        TreeNode<E> B =A.right;

        if(A == root){
            root  = B;
        }else{
            if(parentOfA.left == A){
                parentOfA.left = B;
            }else{
                parentOfA.right = B;
            }
        }

        A.right = B.left;
        B.left = A;
        updateHeight((AVLTreeNode<E>)A);
        updateHeight((AVLTreeNode<E>)B);
    }

3、LR 

左儿子左旋，根结点右旋：

    private void balanceLR(TreeNode<E> A, TreeNode<E> parentOfA){
        TreeNode<E> B = A.left;
        TreeNode C = B.right;

        if(A == root){
            root = C;
        }else{
            if(parentOfA.left == A){
                parentOfA.left = C;
            }else {
                parentOfA.right = C;
            }
        }

        A.left = C.right;
        B.right = C.left;
        C.left = B;
        C.right = A;

        updateHeight((AVLTreeNode<E>)A);
        updateHeight((AVLTreeNode<E>)B);
        updateHeight((AVLTreeNode<E>)C);
    }

4、RL

右儿子右旋，根结点左旋：

    private void balanceRL(TreeNode<E> A, TreeNode<E> parentOfA){
        TreeNode<E> B = A.right;
        TreeNode<E> C = B.left;

        if(A == root){
            root = C;
        }else{
            if(parentOfA.left == A){
                parentOfA.left = C;
            }else{
                parentOfA.right = C;
            }
        }
        A.right = C.left;
        B.left = C.right;
        C.left = A;
        C.right = B;

        updateHeight((AVLTreeNode<E>)A);
        updateHeight((AVLTreeNode<E>)B);
        updateHeight((AVLTreeNode<E>)C);
    }

 三、Java实现AVLTree类

AVLTree类继承BST类。

public class AVLTree<E extends Comparable<E>> extends BST<E>{
    public AVLTree() {
    }

    public AVLTree(E[] objects) {
        super(objects);
    }

    // 插入方法和BST中的方法一样，只不过每次添加后需要检查平衡
    @Override
    public boolean insert(E e){
        boolean success = super.insert(e);
        if(!success){
            return false;
        }else{
            balancePath(e);  // 检查是否需要平衡操作
        }
        return true;
    }

    private void updateHeight(AVLTreeNode<E> node){
        if(node.left == null && node.right == null){
            node.height = 0;
        }else if(node.left == null){
            node.height = 1 + ((AVLTreeNode<E>)(node.right)).height;
        }else if(node.right == null){
            node.height = 1 + ((AVLTreeNode<E>)(node.left)).height;
        }else
            node.height = 1 + Math.max(((AVLTreeNode<E>)(node.right)).height,((AVLTreeNode<E>)(node.left)).height);
    }

    // 平衡一条路径上的结点
    private void balancePath(E e){
        java.util.ArrayList<TreeNode<E>> path = path(e);  // 获取包含e的结点到根结点的路径
        for(int i = path.size() - 1; i >= 0; i--){
            AVLTreeNode<E> A = (AVLTreeNode<E>)(path.get(i));
            updateHeight(A);  // 更新高度
            AVLTreeNode<E> parentOfA = (A == root) ? null : (AVLTreeNode<E>)(path.get(i - 1));

            switch(balanceFactor(A)){  // 检查平衡因子，检查是否需要旋转
                case -2 :
                    if(balanceFactor((AVLTreeNode<E>)A.left) <= 0){
                        balanceLL(A,parentOfA);
                    }else{
                        balanceLR(A,parentOfA);
                    }
                    break;
                case +2 :
                    if(balanceFactor((AVLTreeNode<E>)A.right) >= 0){
                        balanceRR(A, parentOfA);
                    }else{
                        balanceRL(A, parentOfA);
                    }
            }
        }
    }

    private int balanceFactor(AVLTreeNode<E> node){
        if(node.left == null){
            return -node.height;
        }else if(node.left == null){
            return +node.height;
        }else
            return ((AVLTreeNode<E>)node.right).height - ((AVLTreeNode<E>)node.left).height;
    }

    private void balanceLL(AVLTreeNode<E> A, TreeNode<E> parentOfA){
        TreeNode<E> B = A.left;
        if(A == root){
            root = B;
        }else{
            if(parentOfA.left == A){
                parentOfA.left = B;
            }else{
                parentOfA.right = B;
            }
        }

        A.left = B.right;
        B.right = A;
        updateHeight((AVLTreeNode<E>) A);
        updateHeight((AVLTreeNode<E>) B);
    }

    private void balanceLR(TreeNode<E> A, TreeNode<E> parentOfA){
        TreeNode<E> B = A.left;
        TreeNode C = B.right;

        if(A == root){
            root = C;
        }else{
            if(parentOfA.left == A){
                parentOfA.left = C;
            }else {
                parentOfA.right = C;
            }
        }

        A.left = C.right;
        B.right = C.left;
        C.left = B;
        C.right = A;

        updateHeight((AVLTreeNode<E>)A);
        updateHeight((AVLTreeNode<E>)B);
        updateHeight((AVLTreeNode<E>)C);
    }

    private void balanceRR(TreeNode<E> A, TreeNode<E> parentOfA){
        TreeNode<E> B =A.right;

        if(A == root){
            root  = B;
        }else{
            if(parentOfA.left == A){
                parentOfA.left = B;
            }else{
                parentOfA.right = B;
            }
        }

        A.right = B.left;
        B.left = A;
        updateHeight((AVLTreeNode<E>)A);
        updateHeight((AVLTreeNode<E>)B);
    }

    private void balanceRL(TreeNode<E> A, TreeNode<E> parentOfA){
        TreeNode<E> B = A.right;
        TreeNode<E> C = B.left;

        if(A == root){
            root = C;
        }else{
            if(parentOfA.left == A){
                parentOfA.left = C;
            }else{
                parentOfA.right = C;
            }
        }
        A.right = C.left;
        B.left = C.right;
        C.left = A;
        C.right = B;

        updateHeight((AVLTreeNode<E>)A);
        updateHeight((AVLTreeNode<E>)B);
        updateHeight((AVLTreeNode<E>)C);
    }

    // 和BST中的删除方法一样，只不过需要判断下是否平衡
    @Override
    public boolean delete(E element){
        if (root == null) {
            return false;
        }
        TreeNode<E> parent = null;
        TreeNode<E> current = root;
        while(current != null){
            if(element.compareTo(current.element) < 0){
                parent = current;
                current = current.left;
            }else if(element.compareTo(current.element) > 0){
                parent = current;
                current = current.right;
            }else break;
        }
        if(current == null){
            return false;
        }

        if(current.left == null){
            if(parent == null){
                root = current.right;
            }else {
                if(element.compareTo(parent.element) < 0){
                    parent.left = current.right;
                }else{
                    parent.right = current.right;
                }
                balancePath(parent.element);
            }
        }else{
            TreeNode<E> parentOfRightMost = current;
            TreeNode<E> rightMost = current.left;

            while(rightMost.right != null){
                parentOfRightMost = rightMost;
                rightMost = rightMost.right;
            }
            current.element = rightMost.element;

            if(parentOfRightMost.right == rightMost){
                parentOfRightMost.right = rightMost.left;
            }else{
                parentOfRightMost.left = rightMost.left;
            }
            balancePath(parentOfRightMost.element);
        }
        size--;
        return true;
    }

    protected static class AVLTreeNode<E> extends BST.TreeNode<E>{
        protected int height = 0;

        public AVLTreeNode(E e){
            super(e);
        }
    }
}

四、测试AVLTree类

public class TestAVLTree {
    public static void main(String[] args){
        AVLTree<Integer> tree = new AVLTree<Integer>(new Integer[]{25, 20 ,5});
        System.out.print("After inserting 25,20,,5: ");
        printTree(tree);

        tree.insert(34);
        tree.insert(50);
        System.out.print("\nAfter inserting 34, 50 : ");
        printTree(tree);

        tree.insert(30);
        System.out.print("\nAfter inserting 30 : ");
        printTree(tree);

        tree.insert(10);
        System.out.print("\nAfter inserting 10 : ");
        printTree(tree);

        tree.delete(34);
        tree.delete(30);
        tree.delete(50);
        System.out.print("\nAfter removing 34, 30, 50: ");
        printTree(tree);

        tree.delete(5);
        System.out.print("\nAfter removing 5 : ");
        printTree(tree);

        System.out.print("\nTraverse the element in the tree: ");
        for(Object e : tree){
            System.out.print(e + " ");
        }
    }

    public static void printTree(BST tree){
        System.out.print("\nInorder (sorted) : ");
        tree.inorder();
        System.out.print("\nPostorder : ");
        tree.postorder();
        System.out.print("\nPreorder");
        tree.preorder();
        System.out.print("\nThe number of nodes is " + tree.getSize());
        System.out.println();
    }
}

程序插入图示： 

 程序删除图示：

颜 然
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
二叉查找树（BST)、平衡二叉树(AVL树) 右单旋： 左单旋： 左右双旋： 右左双旋： AVL树查找成功失败计算
ZJQ的博客
10-27 1320
二叉查找树（BST)、平衡二叉树(AVL树) AVL树就是平衡二叉树，左子树和右子树的高度之差绝对值不超过1。 而且规定，平衡二叉树的每个节点的平衡因子只能是-1 ，1 ，0； 按照公式 平衡因子 = 右子树的高度 - 左子树的高度 -1 ： 表示左子树比右子树高 1 : 表示右子树比左子树高 0 ： 表示左子树和右子树等高 例子有的元素是英文单词，其实就是按照26字母顺...
AVL平衡二叉查找树
slience_646898的博客
07-25 291
AVL树是带AVL树是根据它的发明者G.M. Adelson-Velsky和E.M. Landis命名的。 有平衡条件的二叉查找树，这个平衡条件要容易保持，保证树的深度是O（logN）。定义AVL树是每个节点左子树和右子数高度最多差1的平衡二叉树。AVL树是对BST树的一种优化，我们知道BST树插入的最坏情况是退化为线性数组，这样就大大降低了二分查找的效率，而AVL树在插入的时候会做旋转优化尽量...
二叉排序树（查找树）平均查找长度(成功和不成功)
热门推荐
weixin_33825683的博客
03-31 3万+
如图所示的二叉排序树 查找成功的平均查找长度为：∑（本层高度*本层元素个数）/节点总数=（1*1+2*2+3*3+3*4）/9 查找不成功的平均查找长度：∑（本层高度*本层补上的叶子个数）/补上的叶子总数=（2*1+3*3+4*6）/10 转载于:https://www.cnblogs.com/kangpp/p/4381358.html...
设平衡二叉排序树(AVL树) 的节点个数为n，则其平均检索长度为log2n
zhangvalue的博客
08-03 1万+
平衡二叉树又称AVL树，它或者是一棵空树，或者是具有下列性质的二叉树：它的左子树和右子树都是平衡二叉树， 且左子树和右子树的深度之差的绝对值不超过1，若将二叉树上节点的平衡因子BF定义为该节点的左子树的深度减去它的右子树的深度， 则平衡二叉树上所有节点的平衡因子只可能是-1、0和1。 只要二叉树上有一个节点的平衡因子的绝对值大于1，则该二叉树不平衡。AVL树上任何节点的左右子树的深度之差都不...
有序表，二叉排序树，二叉平衡树平均查找长度比较例题 && 二叉平衡树的高度
liuxiang15的博客
09-17 1万+
【说明】：博客内容选自课程课件 已知长度为12的表：         (Jan,Feb,Mar,Apr,May,Jun,Jul,Aug,Sep,Oct,Nov,Dec)    要求完成以下操作： 1.若对表中元素先进行排序（字典序），构成有序表，并求其在等概率的情况下，对此有序表查找成功时的平均查找长度； 2.按表中元素的顺序依次插入生成一颗二叉排序树(初始为空)，并求其在等概率的情况下...
AVL平衡搜索树
Comedly的博客
08-04 363
AVL树又称高度平衡的二叉搜索树。 性质：      1. 左子树和右子树的高度之差的绝对值不超过1      2. 树中的每个左子树和右子树都是AVL树      3. 每个节点都有一个平衡因子(balance factor--bf),任一节点的平衡因子是-1,0,1。(每个节点的平衡因子等于右子树的高度减去左子树的高度 )      当插入一个节点时，如果这个
二叉搜索树，红黑树，AVL平衡树，B树
05-08
完整实现二叉搜索树，红黑树，AVL平衡树，B树的搜索插入删除基本功能和其它功能。红黑树和B树参考自算法导论。
二叉树的应用：二叉排序树BST和平衡二叉树AVL的构造 课设作业 完整代码
02-10
二叉排序树(Binary Sort Tree)又称二叉查找(搜索)树(Binary Search Tree)。其定义为：二叉排序树或者是空树，或者是满足如下性质的二叉树：1.若它的左子树非空，则左子树上所有结点的值均小于根结点的值；2.若它的右...
Java 实现二叉搜索树的查找、插入、删除、遍历
08-31
然而，实际应用中，为了优化性能，二叉搜索树可能会进一步演化为自平衡树，例如AVL树或红黑树，以确保在最坏情况下仍保持较好的性能。在Java 8中，HashMap内部就使用了红黑树来处理链表过长的情况，以提高哈希表的...
C#，自平衡二叉查找树（AVL Tree）的算法与源代码
03-24
AVL树本质上还是一棵二叉搜索树，它的特点是： 1.本身首先是一棵二叉搜索树。 2.带有平衡条件：每个结点的左右子树的高度之差的绝对值（平衡因子）最多为1。 也就是说，AVL树，本质上是带了平衡功能的二叉查找树...
平衡搜索树包括平衡二叉搜索树和红黑树介绍
11-28
主要包含平衡搜索树中的平衡二叉搜索树红黑的介绍，代码嵌入其中
基于springboot的青年公寓服务平台源码数据库
最新发布
s123456sj的博客
06-16 1182
本青年公寓服务平台分为管理员还有用户两个权限，管理员可以管理用户的基本信息内容，可以管理房屋投诉信息以及房屋投诉的租赁信息，能够与用户进行相互交流等操作，用户可以查看房屋信息，可以查看房屋投诉以及查看管理员回复信息等操作。
【仿真建模-anylogic】FlowchartPort原理解析
zhaoyaxuan001的博客
06-14 405
FlowchartPort是流图组件端口的基类，一般不会直接使用；如果需要自行封装组件库时会用到；FlowchartPort继承Port类，并定义了一系列抽象函数；用于输入端口判定此刻是否不能接收Agent。用于输出端口判定是否有Agent准备离开。判定端口是否发生错误。
（Javascript）AI数字人mp4转canvas播放并去除背景绿幕
lx_nhs的博客
06-12 583
去除前：去除后： 3、可能会出现的报错 （1）视频路径跨域问题：解决：vue开启代理
Spring Boot集成antlr实现词法和语法分析
HBLOG
06-13 979
Antlr4 是一款强大的语法生成器工具，可用于读取、处理、执行和翻译结构化的文本或二进制文件。基本上是当前 Java 语言中使用最为广泛的语法生成器工具。Twitter搜索使用ANTLR进行语法分析，每天处理超过20亿次查询；Hadoop生态系统中的Hive、Pig、数据仓库和分析系统所使用的语言都用到了ANTLR；Lex Machina将ANTLR用于分析法律文本；Oracle公司在SQL开发者IDE和迁移工具中使用了ANTLR；NetBeans公司的IDE使用ANTLR来解析C++；
SpringBoot之请求映射原理
好记性不如烂笔头
06-12 1285
我们发出的请求，SpringMVC是如何精准定位到那个Controller以及具体方法？其实这都是 HandlerMapping 发挥的作用，这篇博文我们以 RequestMappingHandlerMapping 为例并结合源码一步步进行分析。默认 HandlerMapping 主要定义在和其祖父类中获取所有类型是 Object 的 beans，并且 beanName 不以开头根据 beanName 获取 beanType如果 beanType 上存在注解则进行处理。
微型操作系统内核源码详解系列四（3）：操作系统调度算法（FreeRTOS内核篇上）
2301_77061352的博客
06-12 881
-uxTopPriority，被设定为是代表最大优先级的数字，自减操作代表从就绪列表最后一个链表（优先级最高的链表）开始查找，直到找到任务链表不为空的优先级任务，那么这个任务肯定也是所有任务中优先级最大的任务，然后获取这个任务的TCB并更新pxCurrentTCB（切换的具体函数），最后更新uxTopReadyPriority的值。容笔者说一下个人看法，从c语言和数据结构算法的层面学习，只能说是舍本逐末，透过Freertos这个小型系统，窥见庞大的操作系统架构的一角，这才是我们学习的重点。
从零手写实现 nginx-20-placeholder 占位符 $
06-12 1168
大家好，我是老马。很高兴遇到你。我们为 java 开发者实现了 java 版本的 nginx如果你想知道 servlet 如何处理的，可以参考我的另一个项目：手写从零实现简易版 tomcatminicat除了内置变量，Nginx 还允许用户自定义变量。自定义变量可以在set指令中定义。在这个例子中，定义了一个自定义变量，其值为，并在响应中返回这个值。Nginx 支持占位符的主要目的是提供更高的灵活性和动态性，使其能够适应各种复杂的应用场景和需求。
写一个平衡二叉搜索树
09-10
平衡二叉搜索树（AVL树）是一种自平衡的二叉搜索树，它的左右子树的高度差不超过1。下面是一个实现平衡二叉搜索树的例子： 1. 首先，定义节点类。节点类包含一个键和对应的值，以及左右子树的指针。 ``` class Node...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

颜 然

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值