Avl平衡树的Java代码实现

最新推荐文章于 2022-02-14 10:01:48 发布
最新推荐文章于 2022-02-14 10:01:48 发布
阅读量146 收藏
点赞数 1
分类专栏： 数据结构-二叉树 文章标签： 数据结构 java 二叉树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39286922/article/details/106661895
版权

Avl平衡树的java代码实现

Avl平衡树的结点数据结构

public class AvlTreeNode {

    private int val;

    private int height;

    private AvlTreeNode leftTree;

    private AvlTreeNode rightTree;

    public AvlTreeNode() {
    }

    public AvlTreeNode(int val) {
        this.val = val;
    }

    public int getVal() {
        return val;
    }

    public void setVal(int val) {
        this.val = val;
    }

    public AvlTreeNode getLeftTree() {
        return leftTree;
    }

    public void setLeftTree(AvlTreeNode leftTree) {
        this.leftTree = leftTree;
    }

    public AvlTreeNode getRightTree() {
        return rightTree;
    }

    public void setRightTree(AvlTreeNode rightTree) {
        this.rightTree = rightTree;
    }

    public int getHeight() {
        return height;
    }

    public void setHeight(int height) {
        this.height = height;
    }

    @Override
    public String toString() {
        return "AvlTreeNode{" +
                "val=" + val +
                ", height=" + height +
                '}';
    }

}

Avl树的代码结构

class AvlTree {

    /**
     * 树的根结点
     */
    private AvlTreeNode rootTreeNode;

    public AvlTreeNode search(int val) {
        return search(val, rootTreeNode);
    }

    /**
     * 前序遍历树
     */
    private void preOrder(AvlTreeNode avlTreeNode){
       if(null != avlTreeNode){
           System.out.println(avlTreeNode);
       }
       if(avlTreeNode.getLeftTree() != null ){
           preOrder(avlTreeNode.getLeftTree());
       }

       if(avlTreeNode.getRightTree() != null){
           preOrder(avlTreeNode.getRightTree());
       }
    }

    public void preOrder(){
        preOrder(rootTreeNode);
    }

    private AvlTreeNode search(int val, AvlTreeNode avlTreeNode) {
        if (null == avlTreeNode) {
            return null;
        }
        if (avlTreeNode.getVal() == val) {
            return avlTreeNode;
        } else if (avlTreeNode.getVal() > val) {
            return search(val, avlTreeNode.getLeftTree());
        } else {
            return search(val, avlTreeNode.getRightTree());
        }
    }

    public void insert(int val) {
        if (null == rootTreeNode) {
            rootTreeNode = new AvlTreeNode(val);
            rootTreeNode.setHeight(0);
            return;
        }
         rootTreeNode = insert(val, rootTreeNode);
    }

    private AvlTreeNode insert(int val, AvlTreeNode avlTreeNode) {
        if (null == avlTreeNode) {
            avlTreeNode = new AvlTreeNode(val);
            avlTreeNode.setHeight(0);
            return avlTreeNode;
        } else if (val == avlTreeNode.getVal()) {
            throw new RuntimeException("val is exist, not add again!");
        } else if (val > avlTreeNode.getVal()) {
            avlTreeNode.setRightTree(insert(val, avlTreeNode.getRightTree()));
            avlTreeNode.setHeight(Math.max(height(avlTreeNode.getLeftTree()), height(avlTreeNode.getRightTree())) + 1);
            if(height(avlTreeNode.getRightTree()) - height(avlTreeNode.getLeftTree()) == 2){
                if(val > avlTreeNode.getRightTree().getVal()){
                    //RR旋转
                    avlTreeNode = rightRightRotation(avlTreeNode);
                }else{
                    avlTreeNode = rightLeftRotation(avlTreeNode);
                }
            }
        } else {
            //插入到左边
            avlTreeNode.setLeftTree(insert(val, avlTreeNode.getLeftTree()));
            avlTreeNode.setHeight(Math.max(height(avlTreeNode.getLeftTree()), height(avlTreeNode.getRightTree())) + 1);
            if (height(avlTreeNode.getLeftTree()) - height(avlTreeNode.getRightTree()) == 2) {
                if (val < avlTreeNode.getLeftTree().getVal()) {
                    //LL旋转
                    avlTreeNode = leftLeftRotation(avlTreeNode);
                } else {
                    //LR型旋转
                    avlTreeNode = leftRightRotation(avlTreeNode);
                }
            }
        }
        return avlTreeNode;
    }

    /**
     * 计算结点的高度
     * @param avlTreeNode
     * @return
     */
    private int height(AvlTreeNode avlTreeNode) {
        if (null == avlTreeNode) {
            return 0;
        }
        return avlTreeNode.getHeight();
    }

    /**
     * LL 旋转 【主要针对左树的左子树插入导致平衡被破坏】右旋
     *
     *           4[avlTreeNode]           2[key1]
     *        2      5                 1      4
     *      1   3                    0      3    5
     *   0
     *  avlTreeNode为平衡被破坏的点，将其进行LL旋转重新获得平衡
     *
     * @param avlTreeNode
     * @return
     */
    private AvlTreeNode leftLeftRotation(AvlTreeNode avlTreeNode) {
        AvlTreeNode key1;
        key1 = avlTreeNode.getLeftTree();
        avlTreeNode.setLeftTree(key1.getRightTree());
        key1.setRightTree(avlTreeNode);
        //计算重新移动过后的高度
        avlTreeNode.setHeight(Math.max(height(avlTreeNode.getLeftTree()),height(avlTreeNode.getRightTree())) + 1);
        key1.setHeight(Math.max(height(key1.getLeftTree()),avlTreeNode.getHeight()) + 1);
        return key1;
    }

    /**
     * RR 旋转  【主要针对右树的右子树插入 导致平衡被破坏】  左旋
     *
     *      1  【avlTreeNode】                 3  【key1】
     *   0      3                        1          5
     *       2     5                 0      2            6
     *                 6
     *
     * avlTreeNode 为平衡被破坏的点，将其进行RR旋转重新获取平衡
     *
     * @param avlTreeNode
     * @return
     */
    private AvlTreeNode rightRightRotation(AvlTreeNode avlTreeNode){
        AvlTreeNode key1;
        key1 = avlTreeNode.getRightTree();
        avlTreeNode.setRightTree(key1.getLeftTree());
        key1.setLeftTree(avlTreeNode);

        avlTreeNode.setHeight(Math.max(height(avlTreeNode.getLeftTree()),height(avlTreeNode.getRightTree())) + 1);
        key1.setHeight(Math.max(height(avlTreeNode.getRightTree()),avlTreeNode.getHeight()) + 1);
        return key1;
    }


    /**
     * LR旋转【主要针对在左树的 右子树进行插入 导致平衡被破坏】
     *          A              先对A的左树进行RR旋转==>>        A         再对A进行LL旋转  ====>>       E
     *    [1] B      C                                [1] E       C                              B      A
     *     D    E                                      B                                       D    H       C
     *        H                                      D    H
     *
     * @param avlTreeNode
     * @return
     */
    private AvlTreeNode leftRightRotation(AvlTreeNode avlTreeNode){
        avlTreeNode.setLeftTree(rightRightRotation(avlTreeNode.getLeftTree()));
        return leftLeftRotation(avlTreeNode);
    }

    /**
     * RL旋转
     * 与LR对称 主要针对 右树的左子树插入导致平衡被破坏
     *         A           现对平衡被破坏的点A的右子树进行一次LL旋转 ====>>          A                再对A进行一次RR旋转完成平衡          D
     *    B         C                                                       B        D                                        A        C
     *           D     E                                                          F      C                                 B     F         E
     *        F                                                                              E
     *
     *
     * @param avlTreeNode
     * @return
     */
    private AvlTreeNode rightLeftRotation(AvlTreeNode avlTreeNode){
        avlTreeNode.setRightTree(leftLeftRotation(avlTreeNode.getRightTree()));
        return rightRightRotation(avlTreeNode);
    }

    /**
     * 删除指定结点
     * @param val
     */
    public void deleteAvlTreeNode(int val){
        if(null == rootTreeNode){
            return;
        }
        rootTreeNode = deleteAvlTreeNode(val,rootTreeNode);
    }

    public AvlTreeNode deleteAvlTreeNode(int val,AvlTreeNode avlTreeNode){
       if(null == avlTreeNode) {
           return null;
       }
       if(val == avlTreeNode.getVal()){
           //找到为当前结点  进行删除
           if(avlTreeNode.getLeftTree() != null && null != avlTreeNode.getRightTree()){
               //左子树比右子树高
               if(height(avlTreeNode.getLeftTree()) > height(avlTreeNode.getRightTree())){
                   //找到该子树左子树中最大的结点
                   AvlTreeNode maxAvlTreeNode = maximum(avlTreeNode.getLeftTree());
                   avlTreeNode.setVal(maxAvlTreeNode.getVal());
                   avlTreeNode.setLeftTree(deleteAvlTreeNode(maxAvlTreeNode.getVal(),avlTreeNode.getLeftTree()));
               }else{
                   //右子树比左子树高或者相等
                   AvlTreeNode minTreeNode = minimum(avlTreeNode.getRightTree());
                   avlTreeNode.setVal(minTreeNode.getVal());
                   avlTreeNode.setRightTree(deleteAvlTreeNode(minTreeNode.getVal(),avlTreeNode.getRightTree()));
               }
           }else{
               avlTreeNode = avlTreeNode.getLeftTree() == null ? avlTreeNode.getRightTree() : avlTreeNode.getLeftTree();
           }
       }else if(val < avlTreeNode.getVal()){
           avlTreeNode.setLeftTree(deleteAvlTreeNode(val,avlTreeNode.getLeftTree()));
           //删除之后判断是否树失去平衡   删除的节点在树的左边
           if(height(avlTreeNode.getRightTree()) - height(avlTreeNode.getLeftTree()) == 2){
                //删除导致不平衡则进行旋转   因为被影响的右子树的高度高于左子树
               //则需要判断  右子树的左子树高 还是右子树高
               AvlTreeNode rTreeNode = avlTreeNode.getRightTree();
               if(height(rTreeNode.getLeftTree()) > height(rTreeNode.getRightTree())){
                   //符合RL情况
                   //解释： 如果平衡被影响的结点的 右结点的的右左子树高于 右右子树 则等同于 结点插入到右结点的左子树的情况符合（RL）
                   avlTreeNode = rightLeftRotation(avlTreeNode);
               }else{
                   //符合RR情况
                   //解释： 如果平衡被影响的结点的 右结点的右左子树等于小于右右子树  则符合RR型插入结构
                   //        A
                   //    B        C
                   //  G       D     E
                   //        F     H
                   //
                   //如果G结点被删除 则A结点平衡型被影响  则通过查看A的右结点C的左右子树情况  判断影响平衡的结点满足的类型
                   //   右结点的左子树高度等于右结点的右子树 时：
                   //        A                                              C
                   //    B        C                                    A        E
                   //           D     E     ==》 进型一个RR型左旋      B    D   H
                   //         F     H                                   F

                   //右结点的 左子树高度小于右结点的右子树时
                   //        A                                    A                                         C
                   //    B        C                           B       C                                   A       E
                   //  G       D      E   ===》 删除结点G             D    E    ===》 进行一次RR型左旋转    B    D  H
                   //               H                                   H
                   //   打到平衡  所以 符合LL型与LR型同此推理   通过递归达到局部平衡从而达到一个整体的平衡
                    avlTreeNode = rightRightRotation(avlTreeNode);
               }
           }
       }else{
           avlTreeNode.setRightTree(deleteAvlTreeNode(val,avlTreeNode.getRightTree()));
           //删除之后判断是否树失去平衡  删除的节点在树的右边
           if(height(avlTreeNode.getLeftTree()) - height(avlTreeNode.getRightTree()) == 2){
               //删除导致不平衡则进行旋转
               AvlTreeNode lTreeNode = avlTreeNode.getLeftTree();
               if(height(lTreeNode.getRightTree()) > height(lTreeNode.getLeftTree())){
                   //被删除结点的 左边结点子树的高度   右子树如果高于左子树 则满足LR型
                   avlTreeNode = leftRightRotation(avlTreeNode);
               }else{
                   //否则相等或者小于则舒服 LL型
                   avlTreeNode = leftLeftRotation(avlTreeNode);
               }
           }
       }
       if(null != avlTreeNode){
           //如果没有左右子树则为叶子结点
           if(null == avlTreeNode.getLeftTree() && null == avlTreeNode.getRightTree()){
               avlTreeNode.setHeight(0);
           }else{
               avlTreeNode.setHeight(Math.max(height(avlTreeNode.getLeftTree()),height(avlTreeNode.getRightTree())) + 1);
           }
       }
       return avlTreeNode;
    }

    /**
     * 寻找指定结点子结点的 最大结点
     * @param avlTreeNode
     * @return
     */
    private AvlTreeNode maximum(AvlTreeNode avlTreeNode){
        if(null == avlTreeNode){
            return null;
        }
        AvlTreeNode maxTreeNode = avlTreeNode;
        while(maxTreeNode != null){
            if(maxTreeNode.getRightTree() != null){
                maxTreeNode = maxTreeNode.getRightTree();
            }else{
                return maxTreeNode;
            }
        }
        return maxTreeNode;
    }

    /**
     * 寻找指定结点的最小子结点
     * @param avlTreeNode
     * @return
     */
    private AvlTreeNode minimum(AvlTreeNode avlTreeNode){
        if(null == avlTreeNode){
            return null;
        }

        AvlTreeNode minTreeNode = avlTreeNode;
        while(null != minTreeNode){
            if(null != minTreeNode.getLeftTree()){
                minTreeNode = minTreeNode.getLeftTree();
            }else{
                return minTreeNode;
            }
        }
        return minTreeNode;
    }
}

测试代码

class Main{
    public static void main(String[] args) {
        AvlTree avlTree = new AvlTree();
        //              6
        //        3             10
        //   2        4      7
        //1
        avlTree.insert(6);
        avlTree.insert(3);
        avlTree.insert(10);
        avlTree.insert(7);
        avlTree.insert(2);
        avlTree.insert(4);
        avlTree.insert(1);
        avlTree.preOrder();
        System.out.println("================");
        avlTree.deleteAvlTreeNode(7);
        System.out.println("================");
        avlTree.preOrder();
        System.out.println(avlTree.search(3));
    }
}
DML的日常
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
平衡二叉树详解及java代码的实现
01-19
平衡二叉树（Balanced Binary Tree）又被称为AVL树（有别于AVL算法），且具有以下性质：它是一 棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树（递归定义）的二叉排序树。...
AVL树的完整实现（含比较器，Java语言描述）
12-22
前情提要 之前只写了一些AVL树核心算法，这里给出一个AVL树的完整...对初学者来说，一定要掌握的是检测和调整AVL树平衡（含四种旋转）的代码，随着学习的深入，应该尝试编写AVL树的完整代码。 这里就给大家提供一份可用
Java中的平衡树
11-19 272
leetcode 729 给定一堆线段，每个线段都有一个起点、一个终点，用数组[(beg1,end1),(beg2,end2),(beg3,end3)......]来表示。可以提出以下问题： 这些线段是否有重合部分 这些线段的总长度是多少（多条线段重合部分只计算一次），这个问题相当于上面那个问题的加强版 如果一次性给定了这些线段，只需对这些线段进行排序即可O(nlog(n))，然后从...
平衡树（AVL树）java代码
qq_51955445的博客
02-05 1231
debug了好久才写出来的平衡树，可能有代码冗余或者有误的地方，欢迎指出错误 推荐一个网站（数据结构操作可视化） (我这里给出的是平衡树界面) AVL Tree Visualzation (我debug就是看着可视化的树查错的) import java.util.LinkedList; /** * @author 20级三班刘宇阳 * @create 2022/2/3 */ /** * 平衡樹 * @param <K> key的类型 元素必须可比较 * @param <V&
java实现二叉平衡树
xiaoxiaohunke的专栏
06-05 207
节点数据结构:class Node { int balanceDegree;//结点有平衡度(左子树高 -  右子树高), 在 [-1,01] 表示当前节点是平衡的 int val; Node left,right,parent;// 左/右子树，parent指向父节点}插入数据需要调节平衡度,(1) 插入节点 i(2)从i节点开始向上回溯到根节点(3)如果i节点是其父节点的左子树 则父节点平衡度...
AVL 二叉平衡树 C++ 实现
weixin_30521649的博客
08-21 81
头文件 #ifndef DEBUG_LRN_AVL_H #define DEBUG_LRN_AVL_H #include <iostream> using namespace std; template <class T> class AVLTreeNode { public: T key; int height; // AVLTreeNod...
java 实现平衡树
Sun_Ru的博客
08-02 541
package 平衡树; public class Tree { public Node root; //二叉树的：中序遍历 public void inOrder(Node temp){ if(temp!=null){ inOrder(temp.leftChild); System.out.println("--中序--"+temp.data);
AVLTree 的数据结构
04-25
自平衡树的数据结构 树的克隆 合并 和树的视图打印
AVLTree.zip
01-14
Java代码实现，从文件中读取数据，根据AVL树的构建规则，构建一棵AVL树（平衡二叉树），并输出平均查找长度ASL。
java实现别踩白块儿源码-don.juan.matus:Java二进制搜索树实现：avl，红黑，AA树，替罪羊树，笛卡尔树，展开树。奖励：跳
05-24
权重平衡树（BinTreeW） AVL（AVLBinTree） 红黑树（RedBlackTree） AA二叉树-（AATree） 替罪羊（ScapegoatTree） RandomRotateBinTree（RandomRotateBinTree） 随机树（RndBinTree） 笛卡尔树（CartesianBinTree）...
AVLTrees:Java中的AVL树实现
05-05
AVL树 Java中的AVL树实现 有两个基本操作，使用这些操作树本身会保持平衡。 左旋转。 右旋。 然后将有四种可能性 左-左情况：— x是y的左子代，y是z的左子代。 左右案例：— x是y的右子代，y是z的左子代。 左右案例：— x是y的左子代，y是z的右子代。 右案例：— x是y的正确子代，y是z的正确子代。
平衡二叉索引树
heianzhiye333的博客
09-27 115
#include <stdio.h> #include <stdio.h> #include <stdlib.h> static int arr[]= {3,2,1,4,5,6,7,16,15,14,13,12,11,10,8,9}; #define TBL_SIZE(a) ( (sizeof(a)) / (sizeof(a[0])) ) typ...
avl tree
dqsjqian的博客
01-12 144
#ifndef_AVL_TREE_HPP_ #define_AVL_TREE_HPP_ #include<iomanip> #include<iostream> usingnamespacestd; template<classKeyType> classAVLTreeNode { public: Key...
AVL平衡二叉树图+代码详解
氵青-风的博客
11-29 1046
平衡二叉树的定义：是一种二叉排序树（可以是空树），其中每一个节点的左右两个子树的高度差的绝对值不超过1。 注意：二叉排序树不一定是平衡二叉树！平衡因子的概念： 二叉树上节点的左子树深度减去右子树深度的值称为平衡因子BF（Balance Factor）例如： 下面这棵树就不是平衡二叉树，因为58、88节点都不符合平衡二叉树的定义，BF分别为2，-2下面这棵树也不是平衡二叉树，因为58节点
平衡二叉树（AVL）的实现，附可运行C语言代码
ringrang的专栏
08-31 1302
最近几月一直在自学C语言和数据结构，先是写了排序二叉树，觉得平衡二叉树作为一个经典数据结构，有必要实现一下。 网上看了些资料，在AVL和红黑树之间考虑，最后个人还是倾向于AVL。 不同于标准AVL的是，笔者没有使用平衡因子，直接根据左右孩子的高度差值判断是否平衡。整个平衡二叉树是在普通二叉查找树的基础上修改得到的，对于学习数据结构的同学来说，这样逐步提高难度，写起来挑战性没那么大。
AVL树-自平衡二叉查找树(Java实现)
热门推荐
且行且码且思且娱
06-07 1万+
在计算机科学中，AVL树是最先发明的自平衡二叉查找树。AVL树得名于它的发明者 G.M. Adelson-Velsky 和 E.M. Landis，他们在 1962 年的论文 "An algorithm for the organization of information" 中发表了它。 一、AVL树的旋转规律       AVL树的基本操作一般涉及运做同在不平衡的二叉查找树所运做的同样的算
Java-AVL树
weixin_45203607的博客
01-20 935
AVL树简介 AVL树其实就是二叉查找树,不同的是在二叉查找树的基础上进行了加强,弥补了二叉树会有可能退化为链表情况 AVL的核心原理就是自璇,自动调整树的高度,使树始终保存接近完全二叉树的结构,这样就能最大化利用二叉树查找树的查询特性完成高效处理,但是缺点也是很明显增加和删除就会慢上很多 AVL树必要条件： 条件一：它必须是二叉查找树。 条件二：每个节点的左子树和右子树的高度最多为1,否则就要进行自璇来调整 AVL树相关概念 平衡因子 将二叉树上节点的左子树高度减去右子树高度的值称为该节点的平衡因子BF
AVL添加节点后的平衡操作（二）代码实现
Demon_LMMan的博客
03-16 122
平衡思路 在上篇博客（https://blog.csdn.net/Demon_LMMan/article/details/114835679）中已经详细描述了添加节点的平衡思路，下面进行代码实现。 代码实现 public class AVL<E> extends BST<E>{ ... } 显然AVL树应该继承自BST，但由于平衡操作和高度息息相关，所以需要在节点中增加高度属性，并增加一些适当的方法。此外由于BST于AVL所使用的节点不同，我们应新建一个方法用于创建新节点，并在A
AVL树详解
Allence的博客
02-14 1万+
一、简介 AVL树是根据它的发明者G.M. Adelson-Velsky和E.M. Landis命名的。它是最先发明的自平衡二叉查找树，也被称为高度平衡树。 上面的两张图片，左边的是AVL树，它的任何节点的两个子树的高度差别都<=1；而右边的不是AVL树，因为7的两颗子树的高度相差为2(以2为根节点的树的高度是3，而以8为根节点的树的高度是1)。 AVL树的查找、插入和删除在平均和最坏情况下都是O(logn)。 如果在AVL树中插入或删除节点后，使得高度之差大于1。此时，AVL树的平衡状..
AVL平衡树(非指针实现）
最新发布
06-01
下面是一个非指针实现的AVL平衡树的代码示例： ```c++ #include using namespace std; template class AVLTree { private: struct Node { T data; int height; Node *left; Node *right; Node(T data) : ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值