Java——AVL树

于 2022-12-12 13:36:49 发布
阅读量516 收藏 1
点赞数
分类专栏： 数据结构 java 文章标签： java 数据结构 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_60867520/article/details/128284196
版权

平衡二叉树

在之前的blog中讲到，平衡二叉树是一棵树，任意一个节点的左树的所有节点都小于这个节点，右树的所有节点都大于这个节点
因此，可以利用这个性质来中序遍历，就可以得到一个有序的序列，而如果我们要查找某一个值所在的节点，如果这个平衡二叉树的每个子树的左右子树高度接近，那么就会和二分查找一样，每经过一个节点就会直接淘汰一半的值，因此时间复杂度就是log以2为底的n
但是，由于并不是所有平衡二叉树都是左右子树高度接近，因此，假如出现了一棵平衡二叉树所有节点都是只有右子树，那么查找速度就会退化为链表
为了避免这种情况发生，AVL树应运而生

AVL树

是一颗平衡二叉树，并且满足左右子树的高度差不超过1
这样的话，我们的查找效率就得到了保证

平衡因子

就是用来计算二叉树左右子树的高度差的
平衡因子 = 右子树高度 - 左子树高度

节点定义

在AVL树中，不仅要定义左右孩子，还要定义平衡因子，和父亲树

static class TreeNode {
        public int val;
        public int bf;// 平衡因子
        public TreeNode left;
        public TreeNode right;
        public TreeNode parent;

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

插入操作

由于AVL树需要时刻满足左右子树的高度差不大于1，那么在插入一个元素时就需要不断的调整

首先按照平衡二叉树的方法进行插入
先判断根节点是否为空，为空则直接插入
然后定义一个cur和parent，cur先为root，cur一直向下遍历，如果val小于cur.val，cur就变成cur.left，大于的话就变成cur.right，如果等于，就说明已经有这个节点了，return false，在cur遍历的过程中，使parent始终为cur的上一个节点，使得当cur变成空时，能够记录上一个节点的位置
然后判断val和parent.val的大小关系，插到对应的位置上

TreeNode node = new TreeNode(val);
        if(root == null){
            root = node;
            return true;
        }
        TreeNode parent = null;
        TreeNode cur = root;
        while(cur != null){
            if (cur.val < val){
                parent = cur;
                cur = cur.right;
            } else if (cur.val > val){
                parent = cur;
                cur = cur.left;
            } else {
                return false;
            }
        }
        if(parent.val < val){
            parent.right = node;
        } else {
            parent.left = node;
        }
        node.parent = parent;
        cur = node;

接下来，让cur重新变成插入的节点，parent变成插入节点的父节点，然后就应该调整树的结构，修改平衡因子，分为以下几种情况

如果插入节点是右子树，那么说明父亲节点的平衡因子应该++，否则就应该–

如果parent的bf已经是0了，那么上面也就不需要继续调整了，可以直接break

如果parent的bf是1或者-1，说明其子树已经平衡了，但是上面的结构不一定平衡，因此需要向上迭代，让cur为parent，parent为parent的parent

如果parent的平衡因子是2，cur的平衡因子是1，也就是下图的情况，那么需要左单旋（后面讲）
在这里插入图片描述

如果parent的平衡因子是2，cur的平衡因子是-1，也就是下图的情况，那么需要右左双旋（后面讲）
在这里插入图片描述

如果parent的平衡因子是-2，cur的平衡因子是-1，也就是下图的情况，那么需要右单旋（后面讲）
在这里插入图片描述

如果parent的平衡因子是-2，cur的平衡因子是1，也就是下图的情况，那么需要左右双旋，也就是先左旋，再右旋（后面讲）
在这里插入图片描述

//调节平衡因子
        while(parent != null){
            //判断cur是parent的左还是右，决定parent的平衡因子变换
            if(cur == parent.right){
                parent.bf++;
            } else {
                parent.bf--;
            }

            if(parent.bf == 0){
                //整个树已经平衡
                break;
            } else if (parent.bf == 1 || parent.bf == -1){
                //子树平衡了，继续向上判断平衡因子
                cur = parent;
                parent = cur.parent;
            }else {
                if(parent.bf == 2){
                    //右树高，降低右树的高度
                    if(cur.bf == 1){
                        //左单旋
                        rotateLeft(parent);
                    } else {
                        //cur.bf == -1
                        rotateRL(parent);
                    }
                } else {
                    //左树高，降低左树的高度
                    //parent.bf = -2
                    if(cur.bf == -1){
                        //右单旋
                        rotateRight(parent);
                    } else {
                        //cur.bf == 1
                        rotateLR(parent);
                    }
                }

                //调整后就平衡了
                break;
            }
        }
        return true;

而对于循环条件，此循环是为了从下到上调节所有与插入节点有关的节点的平衡因子，因此需要向上迭代，最终的终止条件就是cur迭代到根，parent迭代到空

左单旋

定义parent的右孩子为subR，subR的左孩子为subRL，并依据图上关系重新组织其之间的结构。判断parent是不是根节点，如果为根就让subR为根，如果不为根，就让parent的父节点的孩子指针指向subR

然后更改平衡因子，按照图上关系，subR的平衡因子应该改为0，parent的平衡因子应该改成0（subRR的平衡因子在第一次迭代的时候就改过了）
在这里插入图片描述

private void rotateLeft(TreeNode parent) {
        TreeNode subR = parent.right;
        TreeNode subRl = subR.left;

        parent.right = subRl;
        subR.left = parent;
        if(subRl != null){
            subRl.parent = parent;
        }

        TreeNode pParent = parent.parent;

        parent.parent = subR;

        if(root == parent){
            root = subR;
            root.parent = null;
        } else {
            if (pParent.left == parent){
                pParent.left = subR;
            } else {
                pParent.right = subR;
            }
            subR.parent = pParent;
        }

        parent.bf = 0;
        subR.bf = 0;
    }

右单旋

定义parent的左孩子为subL，subL的右孩子为subLR，并依据图上关系重新组织其之间的结构。判断parent是不是根节点，如果为根就让subL为根，如果不为根，就让parent的父节点的孩子指针指向subL

然后更改平衡因子，按照图上关系，subL的平衡因子应该改为0，parent的平衡因子应该改成0（subLL的平衡因子在第一次迭代的时候就改过了）
在这里插入图片描述

private void rotateRight(TreeNode parent) {
        TreeNode subL = parent.left;
        TreeNode subLR = subL.right;

        parent.left = subLR;
        subL.right = parent;
        if(subLR != null) {
            subLR.parent = parent;
        }

        TreeNode pParent = parent.parent;

        parent.parent = subL;

        //检查是否parent为根节点
        if(parent == root){
            //使subL为根节点
            root = subL;
            root.parent = null;
        } else {
            //使得parent的原parent节点的孩子为subL
            if (pParent.left == parent) {
                pParent.left = subL;
            } else {
                pParent.right = subL;
            }
            subL.parent = pParent;
        }

        //修改平衡因子
        parent.bf = 0;
        subL.bf = 0;
    }

右左双旋

定义parent的右孩子为subR，subR的左孩子为subRL，并记录subRL的平衡因子bf

右左双旋有两种情况：

情况一：
新节点插到subRL的右孩子处，也就是bf为1
在这里插入图片描述
情况二：
新节点插到subRL的左孩子处，也就是bf为-1
在这里插入图片描述
这两种情况的修改树结构的流程是一样的，但是在修改平衡因子时有所不同

先修改树的结构：
先让parent的右孩子进行右旋转，然后让parent进行左旋转

修改平衡因子：
判断bf为-1还是1还是0
如果是1，那么就是第一张图的情况，所以parent的平衡因子会修改成-1，subRL和subR的平衡因子会修改为0

如果是-1，那么就是第二张图的情况，所以subR的平衡因子会修改为1，subRL和parent的平衡因子是0

如果是0，就相当于没插新孩子，那么就不用修正平衡因子了

private void rotateRL(TreeNode parent) {
        TreeNode subR = parent.right;
        TreeNode subRL = subR.left;
        int bf = subRL.bf;

        rotateRight(parent.right);
        rotateLeft(parent);

        //修改负载因子,依据subRL的负载因子的大小
        if(bf == -1){
            subR.bf = 0;
            subRL.bf = 1;
            parent.bf = 0;
        } else if (bf == 1){
            //bf == 1
            subR.bf = 0;
            subRL.bf = 0;
            parent.bf = -1;
        }
        //bf为0不需要修改平衡因子
    }

左右双旋

和右左双旋的思路大致相同

定义parent的左孩子为subL，subL的右孩子为subLR，并记录subLR的平衡因子bf

右左双旋有两种情况：
情况一：
新节点插到subRL的右孩子处，也就是bf为1
在这里插入图片描述

情况二：
新节点插到subRL的左孩子处，也就是bf为-1
在这里插入图片描述
这两种情况的修改树结构的流程是一样的，但是在修改平衡因子时有所不同

先修改树的结构：
先让parent的右孩子进行右旋转，然后让parent进行左旋转

修改平衡因子：
判断bf为-1还是1还是0
如果是1，那么就是第一张图的情况，所以subL的平衡因子会修改成-1，subLR和parent的平衡因子会修改为0

如果是-1，那么就是第二张图的情况，所以parent的平衡因子会修改为1，subLR和subL的平衡因子是0

如果是0，就相当于没插新孩子，那么就不用修正平衡因子了

private void rotateLR(TreeNode parent) {
        TreeNode subL = parent.left;
        TreeNode subLR = subL.right;
        int bf = subLR.bf;

        rotateLeft(parent.left);
        rotateRight(parent);

        //修改负载因子,依据subLR的负载因子的大小
        if(bf == -1){
            subL.bf = 0;
            subLR.bf = 0;
            parent.bf = 1;
        } else if (bf == 1){
            subL.bf = -1;
            subLR.bf = 0;
            parent.bf = 0;
        }
        //bf为0不需要修改平衡因子
    }

到这里，插入代码就写完了

删除节点

删除节点和平衡二叉树是一样的，先找到一个替罪的，然后交换位置后再删除，唯一设计到的就是调节平衡因子，具体方法和添加节点是一样的，这里就不详细讲解了

验证AVL树

avl树不仅要通过平衡因子来判定是否正确，还需要判断其中序遍历是否为有序的，判断其是否为平衡二叉树（因为我们的平衡因子有可能算错了），因此下面的代码就比较简单了

中序遍历

public void inorder(TreeNode root){
        if(root == null){
            return;
        }
        inorder(root.left);
        System.out.println(root.val);
        inorder(root.right);
    }

判断一个节点的高度

private int height(TreeNode root){
        if(root == null){
            return 0;
        }
        int left = height(root.left);
        int right = height(root.right);
        return Math.max(left,right) + 1;
    }

判断是否为平衡二叉树

public boolean isBalance(TreeNode root){
    if (root == null){
        return true;
    }
    int leftHeight = height(root.left);
    int rightHeight = height(root.right);

    if(rightHeight - leftHeight != root.bf){
        System.out.println("次节点：" + root.val + "平衡因子异常！");
        return false;
    }

    return Math.abs(leftHeight - rightHeight) <= 1
            && isBalance(root.left)
            && isBalance(root.right);
}

如果平衡因子和高度不一致，那么可以直接终止判定，打印一个错误

验证代码

package AVLTree;

public class Test {
    public static void main(String[] args) {
        //int[] array = {16,3,7,11,9,26,18,14,15};
        int[] array = {4,2,6,1,3,5,15,7,16,14};
        AVLTree avlTree = new AVLTree();
        for (int i = 0; i < array.length; i++) {
            avlTree.insert(array[i]);
        }

        System.out.println(avlTree.isBalance(avlTree.root));
        avlTree.inorder(avlTree.root);
    }
}

通过上述代码，可以看到，我们的avl树的插入是正确的

完整插入和验证代码

package AVLTree;

import apple.laf.JRSUIUtils;

public class AVLTree {
    static class TreeNode {
        public int val;
        public int bf;// 平衡因子
        public TreeNode left;
        public TreeNode right;
        public TreeNode parent;

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

    public TreeNode root;

    public boolean insert(int val){
        TreeNode node = new TreeNode(val);
        if(root == null){
            root = node;
            return true;
        }
        TreeNode parent = null;
        TreeNode cur = root;
        while(cur != null){
            if (cur.val < val){
                parent = cur;
                cur = cur.right;
            } else if (cur.val > val){
                parent = cur;
                cur = cur.left;
            } else {
                return false;
            }
        }
        if(parent.val < val){
            parent.right = node;
        } else {
            parent.left = node;
        }
        node.parent = parent;
        cur = node;

        //调节平衡因子
        while(parent != null){
            //判断cur是parent的左还是右，决定parent的平衡因子变换
            if(cur == parent.right){
                parent.bf++;
            } else {
                parent.bf--;
            }

            if(parent.bf == 0){
                //整个树已经平衡
                break;
            } else if (parent.bf == 1 || parent.bf == -1){
                //子树平衡了，继续向上判断平衡因子
                cur = parent;
                parent = cur.parent;
            }else {
                if(parent.bf == 2){
                    //右树高，降低右树的高度
                    if(cur.bf == 1){
                        //左单旋
                        rotateLeft(parent);
                    } else {
                        //cur.bf == -1
                        rotateRL(parent);
                    }
                } else {
                    //左树高，降低左树的高度
                    //parent.bf = -2
                    if(cur.bf == -1){
                        //右单旋
                        rotateRight(parent);
                    } else {
                        //cur.bf == 1
                        rotateLR(parent);
                    }
                }

                //调整后就平衡了
                break;
            }
        }
        return true;
    }

    /**
     * 先右旋，再左旋
     * @param parent
     */
    private void rotateRL(TreeNode parent) {
        TreeNode subR = parent.right;
        TreeNode subRL = subR.left;
        int bf = subRL.bf;

        rotateRight(parent.right);
        rotateLeft(parent);

        //修改负载因子,依据subRL的负载因子的大小
        if(bf == -1){
            subR.bf = 1;
            subRL.bf = 0;
            parent.bf = 0;
        } else if (bf == 1){
            //bf == 1
            subR.bf = 0;
            subRL.bf = 0;
            parent.bf = -1;
        }
        //bf为0不需要修改平衡因子
    }

    /**
     * 先左旋，后右旋
     * @param parent
     */
    private void rotateLR(TreeNode parent) {
        TreeNode subL = parent.left;
        TreeNode subLR = subL.right;
        int bf = subLR.bf;

        rotateLeft(parent.left);
        rotateRight(parent);

        //修改负载因子,依据subLR的负载因子的大小
        if(bf == -1){
            subL.bf = 0;
            subLR.bf = 0;
            parent.bf = 1;
        } else if (bf == 1){
            subL.bf = -1;
            subLR.bf = 0;
            parent.bf = 0;
        }
        //bf为0不需要修改平衡因子
    }

    /**
     * 左单旋
     * @param parent
     */
    private void rotateLeft(TreeNode parent) {
        TreeNode subR = parent.right;
        TreeNode subRl = subR.left;

        parent.right = subRl;
        subR.left = parent;
        if(subRl != null){
            subRl.parent = parent;
        }

        TreeNode pParent = parent.parent;

        parent.parent = subR;

        if(root == parent){
            root = subR;
            root.parent = null;
        } else {
            if (pParent.left == parent){
                pParent.left = subR;
            } else {
                pParent.right = subR;
            }
            subR.parent = pParent;
        }

        parent.bf = 0;
        subR.bf = 0;
    }

    /**
     * 右单旋
     * @param parent
     */
    private void rotateRight(TreeNode parent) {
        TreeNode subL = parent.left;
        TreeNode subLR = subL.right;

        parent.left = subLR;
        subL.right = parent;
        if(subLR != null) {
            subLR.parent = parent;
        }

        TreeNode pParent = parent.parent;

        parent.parent = subL;

        //检查是否parent为根节点
        if(parent == root){
            //使subL为根节点
            root = subL;
            root.parent = null;
        } else {
            //使得parent的原parent节点的孩子为subL
            if (pParent.left == parent) {
                pParent.left = subL;
            } else {
                pParent.right = subL;
            }
            subL.parent = pParent;
        }

        //修改平衡因子
        parent.bf = 0;
        subL.bf = 0;
    }

    /**
     * 中序遍历
     * @param root
     */
    public void inorder(TreeNode root){
        if(root == null){
            return;
        }
        inorder(root.left);
        System.out.println(root.val);
        inorder(root.right);
    }

    private int height(TreeNode root){
        if(root == null){
            return 0;
        }
        int left = height(root.left);
        int right = height(root.right);
        return Math.max(left,right) + 1;
    }

    /**
     * 判断是不是平衡二叉树
     * @param root
     * @return
     */
    public boolean isBalance(TreeNode root){
        if (root == null){
            return true;
        }
        int leftHeight = height(root.left);
        int rightHeight = height(root.right);

        if(rightHeight - leftHeight != root.bf){
            System.out.println("次节点：" + root.val + "平衡因子异常！");
            return false;
        }

        return Math.abs(leftHeight - rightHeight) <= 1
                && isBalance(root.left)
                && isBalance(root.right);
    }
}

分析

可以看到，我们的avl树的插入过程十分复杂，如果改动一个数据就需要从下到上重新组织数据，因此avl树只适合查找数据，并不适合频繁的插入删除数据

Xiao8830
关注
专栏目录
数据结构之高度平衡搜索树AVL树（含经典面试题----判断一棵树是否是AVL树）
落叶知秋深的博客
07-08 4531
什么是AVL树 如何创建一个红黑树 满足二叉搜索树 满足红黑树的性质 红黑树的插入 左旋 右旋
平衡二叉树（AVL树）构造、添加/删除元素(Java)
pikachu_plus的博客
08-21 938
在计算机科学中，AVL树是最先发明的自平衡二叉查找树。在AVL树中任何节点的两个子树的高度最大差别为1，所以它也被称为高度平衡树。增加和删除可能需要通过一次或多次树旋转来重新平衡这个树。AVL树得名于它的发明者G. M. Adelson-Velsky和E. M. Landis，他们在1962年的论文《An algorithm for the organization of information》中发表了它。——百度百科。
AVL树(Java实现)
weixin_30376163的博客
12-07 112
AVL树基本介绍 AVL树是一种自平衡的二叉查找树，在AVL树中任何节点的两个子树的高度差不能超过1。就是相当于在二叉搜索树的基础上，在插入和删除时进行了平衡处理。 不平衡的四种情况 LL：结构介绍 看如下图，假设最初只有k1, k2, k3, y, z五个结点，这时该树两边的高度分别为3和 2，相差为1，满足AVL平衡的概念。 随后插入了结点 x ，导致了不平衡。k1.left....
Java-AVL树
weixin_45203607的博客
01-20 966
AVL树简介 AVL树其实就是二叉查找树,不同的是在二叉查找树的基础上进行了加强,弥补了二叉树会有可能退化为链表情况 AVL的核心原理就是自璇,自动调整树的高度,使树始终保存接近完全二叉树的结构,这样就能最大化利用二叉树查找树的查询特性完成高效处理,但是缺点也是很明显增加和删除就会慢上很多 AVL树必要条件： 条件一：它必须是二叉查找树。 条件二：每个节点的左子树和右子树的高度最多为1,否则就要进行自璇来调整 AVL树相关概念 平衡因子 将二叉树上节点的左子树高度减去右子树高度的值称为该节点的平衡因子BF
AVL树（Java语言）
qq_49306008的博客
12-05 2602
平衡二叉树 平衡二叉树也叫平衡二叉查找树，又被称为AVL树，可以保证查询效率较高。它的特点是：它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。 结点的平衡因子定义为：结点的左子树高度与右子树高度之差。显然，对一棵AVL树而言，其所有结点的平衡因子只能是-1，0，1.挡在一棵AVL树上插入一个结点时，有可能导致失衡，即出现绝对值大于1的平衡因子。 单旋转（左旋转） 插入70后失去平衡，调整过程如下：。 思路： 1、创建一个新的结点，值等于当前根节点的值。 2、把新
AVL树（java实现）
tong_yerui的博客
08-22 1345
基本介绍 1）平衡二叉树也平衡二叉搜索树又称为AVL树，可以保证查询效率较高。 2）具有以下特点：它是一棵空树或它的左右子树高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。平衡二叉树的常用实现方法有红黑树、AVL、替罪羊树、Treap、伸展树等。 应用案例-单旋转（左旋转） 1）要求：给你一个数列，创建对应平衡二叉树数列{4，3，6，5，7，8} 思路：①创建一个新的节点newNode（以4这个之创建）创建一个新的节点，值等于当前的节点的值。 ②把新节点的左子树设置为当前的节点的左子
Avl_tree.rar_avl_avl java_avl tree_tree
09-21
在提供的`Drzewo_Avl.java`文件中，可以预期代码会包含AVL树的基本操作，如节点的创建、插入、删除以及平衡旋转的实现。这些方法通常包括： 1. `insert(int key)`: 插入一个新节点，如果插入导致不平衡，需要调用...
AVL树不平衡情况分析及java实现
HuaiRentt的博客
10-13 566
平衡二叉树 平衡查找树（AVL树） AVL树是一种左右子树高度之差不超过1,且左右子树内部也符合高度差不超过1的性质。 下图个节点的左右子树高度差都超过了1，所有不是AVL树。 平衡因子： 某结点的左子树与右子树的高度(深度)差即为该结点的平衡因子（BF,Balance Factor）。平衡二叉树上所有结点的平衡因子只可能是 -1，0 或 1。如果某一结点的平衡因子绝对值大于1则说明此树不是平衡二叉树。为了方便计算每一结点的平衡因子我们可以为每个节点赋予height这一属性，表示此节点的高度。 引起
二叉树之AVL树及其Java实现
liyangxueit的博客
08-26 312
AVL树平衡的定义 下图中，之所以右图的二叉树不是AVL树，是因为在节点7处，其左子树高度为2，右子树高度却为0，所以不平衡。 AVL树不平衡场景 总共不平衡由以下几种情景造成： 边界情景一：研究节点的左儿子的左子树破坏了平衡——>左子树单旋转 ...
数据结构与算法——平衡二叉树（AVL树）与红黑树（R-B树)
nswdiphone6的博客
03-12 371
二叉平衡树（AVL） **二叉排序树存在的问题：**假定给出数组{1，2，3，4，5，6} 问题分析： 左子树全部为空，从形式上看，更像一个单链表。 插入速度没有影响，但查询速度明显降低（需要依次比较）不能发挥BST的优势，因为每次还需要比较左子树，查询速度比单链表还慢。 解决方法：平衡二叉树（AVL） AVL树本质上是一颗二叉排序树，但是它又具有以下特点： 它是一棵空树或它的左右两个子树的高度差的绝对值不超过1。 并且左右两个子树都是一棵平衡二叉树。 平衡因子(bf)：结点的左子树的深度减去
AVL树----java
毛毛虫的小哈
08-20 2090
AVL树----java AVL树是高度平衡的二叉查找树 1.单旋转LL旋转 理解记忆：1.在不平衡的节点的左孩子的左孩子插入导致的不平衡，所以叫LL private AVLTreeNode leftLeftRotation(AVLTreeNode k2) { AVLTreeNode k1; k1 = k2.left; k2.left = k1.right
（树_03）判断是否为AVL树
jasscical's blog
09-12 489
110. 平衡二叉树 解题思路 1.根节点为空 2.一个求各节点高度（深度）的函数height(Treenode*node),就是之前求节点最大深度那个代码 3.当前节点左右孩子高度差不超过1，而且它的子节点也符合这样的规则，那么这就是一颗AVL树 class Solution { public: int height(TreeNode* node) { return node == nullptr ? 0 : max(height(node->le..
AVLTree Java 实现
taotao 的大学墓志
03-29 403
写在前面: 这是一份java实现avl Tree代码，便于供自己以后参阅，笔者java功底弱，实现的只是一个demo没有很好的封装。code/** * */ package oj; import java.io.BufferedInputStream; import java.io.IOException; import java.io.InputStream; import java.util.*;impo
AVLTree的实现（Java）
qq_41587409的博客
04-24 638
前述 二叉搜索树的局限 二叉搜索树的添加，删除，搜索的最坏时间复杂度:O(h) h指的是树的高度，所以当这棵二叉树退化成链表时复杂度就会变为O(n), AVL树概念 导致失衡的因素： 添加，删除元素 解决办法 在二叉搜索树的基础上，需要在添加，删除元素后进行恢复平衡的操作，这样才能使树保持平衡状态，即实现afterAdd()和afterRemove()方法。 a:关于添加的分析 1 添加只会...
Java实现AVL树
上庸者-不服周
06-13 404
AVL树
AVL tree(java详解)
jiaohanhan的博客
05-17 1035
单旋转 双旋转 AVL tree的实现以及源代码
AVL树的Java实现
qq_51536995的博客
05-03 1326
AVL树的java实现
java实现AVL树
最新发布
Groot-lin的博客
11-07 286
java实现AVL树
avl树的java实现代码_AVL树(Java实现)
weixin_33225892的博客
02-26 133
AVL树基本操作未完....待续....AVL树代码public class AVLTree, Value> {private class Node {Key key;//键，相当于词典里的单词Value value;//值，相当于词典里的单词解释int height;//结点的高度Node left;Node right;public Node(Key key, Value value) ...
Java数据结构复习：深入理解树的概念
这篇复习笔记主要涵盖了Java中的数据结构——树的基本概念。树是一种非线性的数据结构，它由n（n>=1）个有限节点组成，这些节点通过边连接形成一个有层次的结构，其中每个节点最多有一个父节点（除了根节点没有父...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值