Java实现AVL树

最新推荐文章于 2024-05-19 20:00:00 发布
最新推荐文章于 2024-05-19 20:00:00 发布
阅读量625 收藏 10
点赞数 21
分类专栏： 数据结构 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_79602614/article/details/138030568
版权

AVI树

如果一颗二叉搜索树不平衡,那么搜索效率会受影响

二叉搜索树如果不是这种不平衡的情况,时间复杂度可以达到O(logn) 但是像图中的这种不平衡情况时间复杂度为O(n),那么如何解决呢? 可以通过旋转解决

旋转之后并不会破坏二叉搜索树的特性

判断是否平衡有一个规则:如果一个节点的左右孩子,高度差超过1,则此节点失衡,才需要旋转

这就是引出这样一棵树:自平衡二叉搜索树

ta的实现有很多种,但其中一种比较著名的实现叫做AVL,为什么叫AVL呢?是因为有两位作者一位取了名字中的AV,另外一个取了L,所以叫AVL树

实现:

/**
 * <h3>AVL树</h3>
 *
 * <ul>
 *     <li>二叉搜索树在插入和删除时,节点可能失衡</li>
 *     <li>如果在插入和删除时通过旋转,始终让二叉搜索树保持平衡,称为自平衡的二叉搜索树</li>
 *     <li>AVL是自平衡二叉树的实现之一</li>
 * </ul>
 */
public class AVLTree {

    static class AVLNode{
        int key;
        Object value;
        AVLNode left;
        AVLNode right;
        int height=1;//高度

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

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

        public AVLNode(int key, Object value, AVLNode left, AVLNode right) {
            this.key = key;
            this.value = value;
            this.left = left;
            this.right = right;
        }
    }
    // 求节点高度
    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) = 左子树高度 - 右子树高度
    private int bf(AVLNode node){
        return height(node.left) - height(node.right);
    }
    //0 -1 1 平衡的
    //> 1 <-1不平衡  bf > 1时,表示左边太高   bf<-1时,表示右边太高

}

求节点高度的时候可以参照前面写过的求二叉树最大深度的题目

AVI树的旋转 

第一种需要旋转的: LL类型 

 

第二种情况:LR类型 - 

另外两种情况就RR  RL 跟上面两种对称

总的来讲:

旋转:对于LL就是一次右旋;RR就是一次左旋;LR就是对左子树一次左旋;失衡节点右旋;RL就是对右子树进行一次右旋,失衡节点进行一次左旋;

虽然分了四种情况但是无非也就是左旋和右旋

 

 // 参数:要旋转的点,返回值:新的根节点
    private AVLNode rightRotate(AVLNode node){//这里的node相当于red
        AVLNode left = node.left;//left相当于yellow

        left.right = node;
        return left;
    }

 相当于:

  // 参数:要旋转的点,返回值:新的根节点
    private AVLNode rightRotate(AVLNode red){
        AVLNode yellow = red.left;
        
        yellow.right = red;
        return yellow;
    }

那来看一种稍微复杂一点的情况:

上面的例子中没有考虑黄色节点有右孩子(绿色节点)的情况

 // 参数:要旋转的点,返回值:新的根节点
    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;
    }


    // 先左旋左子树,再右旋根节点 LR
    private AVLNode LeftRightRotate(AVLNode node){
        node.left = leftRotate(node.left);//左旋完成了
        return rightRotate(node);
    }
    // 先右旋右子树,再左旋根节点
    private AVLNode RightLeftRotate(AVLNode node){
        node.right = rightRotate(node.right);
        return leftRotate(node);
    }

旋转后节点需要更新

 // 参数:要旋转的点,返回值:新的根节点
    private AVLNode rightRotate(AVLNode red){
        AVLNode yellow = red.left;
        AVLNode green = yellow.right;
        yellow.right = red; // 上位
        red.left=green; // 换爹
        updateHeight(red);//不带颜色的节点颜色都不会变 和 绿色也不会变
        updateHeight(yellow);
        return yellow;
    }
    // 参数:要旋转的点,返回值:新的根节点
    private AVLNode leftRotate(AVLNode red){
        AVLNode yellow = red.right;
        AVLNode green = yellow.left;
        yellow.left = red;
        red.right = green;
        updateHeight(red);//不带颜色的节点颜色都不会变 和 绿色也不会变
        updateHeight(yellow);//这两行不能调位置
        return yellow;
    }

基于以上的实现,我们可以写一个方法检查节点是否失衡,重新平衡代码

 // 检查节点是否失衡,重新平衡代码
    private AVLNode balance(AVLNode node){
        if(node==null){
            return null;
        }
        int bf = bf(node);
        if(bf>1 && bf(node.left)>0){//LL
            return rightRotate(node);
        }else if(bf>1&&bf(node.left)<0){//LR
            return LeftRightRotate(node);
        }else if(bf<-1 && bf(node.right)>0){//RL
            return RightLeftRotate(node);
        }else if(bf<-1&&bf(node.right)>0){//RR
            return leftRotate(node);
        }
        return node;

    }

但是有两种情况无法处理:发生在删除中

但其实一次右旋即可 所以应该是

最终代码:

// 检查节点是否失衡,重新平衡代码
    private AVLNode balance(AVLNode node){
        if(node==null){
            return null;
        }
        int bf = bf(node);
        if(bf>1 && bf(node.left)>=0){//LL
            return rightRotate(node);
        }else if(bf>1&&bf(node.left)<0){//LR
            return LeftRightRotate(node);
        }else if(bf<-1 && bf(node.right)>0){//RL
            return RightLeftRotate(node);
        }else if(bf<-1&&bf(node.right)<=0){//RR
            return leftRotate(node);
        }
        return node;

    }

新增

 AVLNode root;

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


    private AVLNode doPut(AVLNode node,int key, Object value){
        // 1.找到空位,创建新节点
        if(node==null){
            return new AVLNode(key,value);//刚创建高度为1
        }
        // 2.key 已存在, 更新
        if(key == node.key){
            node.value = value;
            return node;
        }
        // 3.继续查找
        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){
        //1.node == null
        if(node==null){
            return null;
        }
        //2.没找到key
        if(node.key>key){
            node.left = doRemove(node.left,key);
        }else if(node.key<key){
            node.right = doRemove(node.right,key);
        }
        //3.找到key   1) 没有  2) 只有一个孩子  3) 有两个孩子
        else{
            if(node.left==null&&node.right==null){
                return null;//删剩下的
            }else if(node.left==null){
                node = node.right;
            }else if(node.right==null){
                node = node.left;
            }else{
                //找后继
                AVLNode s = node.left;
                while(s.left!=null){
                    s= s.left;
                }
                //s:后继节点
                //处理后继节点后事
                s.right = doRemove(node.right,s.key);
                s.left =node.left;
                node = s;
            }
        }
        //4.更新高度
        updateHeight(node);
        //5.检查失衡balance
        return balance(node);
    }

AVI树完整代码

/**
 * <h3>AVL树</h3>
 *
 * <ul>
 *     <li>二叉搜索树在插入和删除时,节点可能失衡</li>
 *     <li>如果在插入和删除时通过旋转,始终让二叉搜索树保持平衡,称为自平衡的二叉搜索树</li>
 *     <li>AVL是自平衡二叉树的实现之一</li>
 * </ul>
 */
public class AVLTree {

    static class AVLNode{
        int key;
        Object value;
        AVLNode left;
        AVLNode right;
        int height=1;//高度

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

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

        public AVLNode(int key, Object value, AVLNode left, AVLNode right) {
            this.key = key;
            this.value = value;
            this.left = left;
            this.right = right;
        }
    }
    // 求节点高度
    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) = 左子树高度 - 右子树高度
    private int bf(AVLNode node){
        return height(node.left) - height(node.right);
    }
    //0 -1 1 平衡的
    //> 1 <-1不平衡  bf > 1时,表示左边太高   bf<-1时,表示右边太高
/*
LL
    - 失衡节点的bf>1,即左边更高
    - 失衡节点的左孩子的bf>=0,即做孩子这边也是左边更高或等高

LR
    - 失衡节点的bf>1,即左边更高
    - 失衡节点的做孩子的bf<0,即做孩子这边是右边更高

RL
    - 失衡节点的bf<-1,即右边更高
    - 失衡接地那的右孩子的bf>0,即右孩子这边左边更高

RR
    - 失衡节点的bf<-1,即右边更高
    - 失衡节点的右孩子的bf<=0,即右孩子这边右边更高或等高
*/

    // 参数:要旋转的点,返回值:新的根节点
    private AVLNode rightRotate(AVLNode red){
        AVLNode yellow = red.left;
        AVLNode green = yellow.right;
        yellow.right = red; // 上位
        red.left=green; // 换爹
        updateHeight(red);//不带颜色的节点颜色都不会变 和 绿色也不会变
        updateHeight(yellow);
        return yellow;
    }
    // 参数:要旋转的点,返回值:新的根节点
    private AVLNode leftRotate(AVLNode red){
        AVLNode yellow = red.right;
        AVLNode green = yellow.left;
        yellow.left = red;
        red.right = green;
        updateHeight(red);//不带颜色的节点颜色都不会变 和 绿色也不会变
        updateHeight(yellow);//这两行不能调位置
        return yellow;
    }

    // 先左旋左子树,再右旋根节点 LR
    private AVLNode LeftRightRotate(AVLNode node){
        node.left = leftRotate(node.left);//左旋完成了
        return rightRotate(node);
    }
    // 先右旋右子树,再左旋根节点
    private AVLNode RightLeftRotate(AVLNode node){
        node.right = rightRotate(node.right);
        return leftRotate(node);
    }

    // 检查节点是否失衡,重新平衡代码
    private AVLNode balance(AVLNode node){
        if(node==null){
            return null;
        }
        int bf = bf(node);
        if(bf>1 && bf(node.left)>=0){//LL
            return rightRotate(node);
        }else if(bf>1&&bf(node.left)<0){//LR
            return LeftRightRotate(node);
        }else if(bf<-1 && bf(node.right)>0){//RL
            return RightLeftRotate(node);
        }else if(bf<-1&&bf(node.right)<=0){//RR
            return leftRotate(node);
        }
        return node;

    }
    AVLNode root;

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


    private AVLNode doPut(AVLNode node,int key, Object value){
        // 1.找到空位,创建新节点
        if(node==null){
            return new AVLNode(key,value);//刚创建高度为1
        }
        // 2.key 已存在, 更新
        if(key == node.key){
            node.value = value;
            return node;
        }
        // 3.继续查找
        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){
        //1.node == null
        if(node==null){
            return null;
        }
        //2.没找到key
        if(node.key>key){
            node.left = doRemove(node.left,key);
        }else if(node.key<key){
            node.right = doRemove(node.right,key);
        }
        //3.找到key   1) 没有  2) 只有一个孩子  3) 有两个孩子
        else{
            if(node.left==null&&node.right==null){
                return null;//删剩下的
            }else if(node.left==null){
                node = node.right;
            }else if(node.right==null){
                node = node.left;
            }else{
                //找后继
                AVLNode s = node.left;
                while(s.left!=null){
                    s= s.left;
                }
                //s:后继节点
                //处理后继节点后事
                s.right = doRemove(node.right,s.key);
                s.left =node.left;
                node = s;
            }
        }
        //4.更新高度
        updateHeight(node);
        //5.检查失衡balance
        return balance(node);
    }

}

->yjy
关注
  • 21
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
AVLTrees:Java中的AVL树实现
05-05
AVL树Java中的AVL树实现有两个基本操作，使用这些操作树本身会保持平衡。 左旋转。 右旋。 然后将有四种可能性左-左情况：— x是y的左子代，y是z的左子代。 左右案例：— x是y的右子代，y是z的左子代。 左右案例：—...
java实现AVL树
Groot-lin的博客
11-07 266
java实现AVL树
Java实现AVL树（自平衡二叉搜索树）
m0_60936579的博客
10-12 966
一、AVL树的概念 AVL树本质上是一棵二叉搜索树，即它或者是一棵空树，或者是具有下列性质的二叉树： 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值； 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值； 它的左、右子树也分别为二叉搜索树。另外，AVL树每个结点的左右子树的高度之差，即平衡因子的绝对值不超过1，以实现查询操作的时间复杂度从传统二叉搜索树的O(N)降为O(logN)。 二、平衡调整 首先，为什么AVL树需要有“自平衡”的功能？其实从A...
java实现avl树
qq_55278081的博客
09-28 285
【代码】java实现avl树。
avl树的java实现代码_AVL树的java实现
weixin_35780601的博客
02-26 231
AVL树的定义自己百度去，这里给出自己用java的一个实现。package test;/*** @时间 2014-3-30* @version 0.1* @encode UTF-8* @功能* 1、AVL树的生成* 2、插入元素* 3、删除元素* 4、查找某一元素* @notice 树元素需实现Comparor接口* @see 《数据结构与算法分析》第4章4.4节* */public class ...
JAVA实现AVL树
fulin9452的博客
03-24 117
定义：空树或者左子树和右子树高度差小于等于1且左右子树的子树也满足这个要求 在计算机科学中，AVL树是最早被发明的自平衡二叉查找树。在AVL树中，任一节点对应的两棵子树的最大高度差为1，因此它也被称为高度平衡树。查找、插入和删除在平均和最坏情况下的时间复杂度都是。增加和删除元素的操作则可能需要借由一次或多次树旋转，以实现树的重新平衡。 维基百科 public class AVLTreeDemo {...
Java实现AVL树的添加和删除
糖气包的博客
01-10 3485
  前言 AVL树的基本性质 AVL树节点设计 插入时会出现什么问题？ 2为3的左节点，1为2的左节点 2为1的右节点，3为2的右节点 1为3的左节点，2为1的右节点 3为1的右节点，2为3的左节点 AVL树的插入 AVL树的判断 AVL树的删除 后记 前言         前面写过两篇关于二叉搜索树的博文，但是它不具有平衡性，最差情况时，会退化成链表，查找的效率会降至...
avl树 java_AVL树的Java实现
weixin_31058323的博客
02-23 104
importjava.util.Comparator;public class AVLTree>{/*AVL树：左右子树高度绝对值最多差1的二叉搜索树子树也是AVL树*/private Noderoot;class Node>{T key;intheight;Nodeleft;Noderight;public Node(T key, int height, Node left, Nod...
AVL树（java实现）
tong_yerui的博客
08-22 1301
基本介绍 1）平衡二叉树也平衡二叉搜索树又称为AVL树，可以保证查询效率较高。 2）具有以下特点：它是一棵空树或它的左右子树高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。平衡二叉树的常用实现方法有红黑树、AVL、替罪羊树、Treap、伸展树等。 应用案例-单旋转（左旋转） 1）要求：给你一个数列，创建对应平衡二叉树数列{4，3，6，5，7，8} 思路：①创建一个新的节点newNode（以4这个之创建）创建一个新的节点，值等于当前的节点的值。 ②把新节点的左子树设置为当前的节点的左子
Java实现AVL树的判定问题（改编版）
qq_52434831的博客
11-14 242
Java实现AVL树的判定问题
AVL树及JAVA实现
04-14
NULL 博文链接：https://128kj.iteye.com/blog/1735464
基于java语言手动实现的AVL树代码
11-09
基于java语言手动实现的AVL树代码，该树形结构适用于查找，实现的逻辑可以查看博主的原创作品《用JAVA代码手动实现AVL树》
AVLBaum:Java中AVL树的表示
06-20
本项目是一个示例项目，展示了如何在 BlueJ 等简单的编程环境中使用 Java 实现一个 AVL 二叉搜索树。 ###用作图书馆 可以通过实现IData接口来添加数据 BinaryTree是一种基本的二叉搜索树，它以排序的方式插入元素 ...
AVL_Tree_Implementation:Java中的AVL树实现
07-06
作为我的数据结构和算法课程的一部分，我参与了 AVL 树的实现。
【初阶数据结构】带头双向循环链表讲解
s1mplewo的博客
05-15 1227
本文详细讲解了带头双向循环链表的概念及具体实现源码
【数据结构】习题 |树与二叉树 |森林 |哈夫曼树 |线索二叉树
最新发布
2301_77611317的博客
05-19 684
15道题 涉及树与二叉树、哈夫曼树、线索二叉树、森林等知识点本文主要介绍了15道涉及到树与二叉树、哈夫曼树、线索二叉树、森林等知识点的练习题如果文章的论述或代码等出现错误，欢迎前来指正！
数据结构-栈(带图)
2302_78381559的博客
05-16 770
栈（Stack）是一种基本的数据结构，其特点是只允许在同一端进行插入和删除操作，这一端被称为栈顶。遵循后进先出（Last In, First Out, LIFO）原则，即最后存入栈中的元素最先被取出。形象地讲，栈就像是生活中堆放盘子的架子，我们总是把新的盘子放在最上面，而需要拿盘子时也是从最上面开始拿。
每周一算法：恰好经过K条边的最短路
少儿编程乔老师
05-15 755
给定一张由M条边构成的无向图，求从起点S到终点E恰好经过K条边（可以重复经过）的最短路。可以使用快速幂倍增 + Floyd 求解。
java实现avl树升序遍历
02-23
下面是Java实现AVL树升序遍历的示例代码： ```java // AVL树节点定义 class Node { int key; int height; Node left; Node right; Node(int key) { this.key = key; this.height = 1; } } // AVL树类定义...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值