java实现AVL树

最新推荐文章于 2024-04-23 22:31:49 发布
最新推荐文章于 2024-04-23 22:31:49 发布
阅读量2.5k 收藏 17
点赞数 9
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiewenfeng520/article/details/93385911
版权

文章目录

1.AVL概念

AVL树是带有平衡条件的二叉查找树，也称为平衡二叉树。
最简单的实现方法就是保证树的左右子树具有相同的高度，保证树的深度是O(log N)，但是这个条件过于严格难以使用需要放宽条件。

一棵AVL树是其每个节点的左子树和右子树的高度最多差1的二叉查找树

即AVL树要求对于每一个节点来说，它的左右子树的高度之差不能超过1，如果插入或者删除一个节点使得高度之差大于1，就要进行节点之间的旋转，将二叉树重新维持在一个平衡状态。

2.图解分析

2.1 模拟器地址

AVL树：https://www.cs.usfca.edu/~galles/visualization/AVLtree.html
所有数据结构：https://www.cs.usfca.edu/~galles/visualization/Algorithms.html

2.2 普通树和AVL树

图左，节点6的左边子树高度为3，而右边子树的高度为1，左右子树的高度之差不能超过1
在这里插入图片描述

2.3 最简单的旋转

依次插入1 2 3节点，1的左子树为空高度为0，而右子树高度为2，旋转后，左右高度都为1
在这里插入图片描述

2.4单旋转

依次插入6 3 7 1 4，插入2时，树的平衡被破坏
在这里插入图片描述
在这里插入图片描述
步骤：

  • 获取k1节点=k2的左边节点
  • 设置k2的左边节点为k1的右边节点Y
  • 设置k1的右边节点为k2
  • 重新计算k2和k1的高度
 private AvlNode<T> rotateWithLeftChild(AvlNode<T> k2) {
        AvlNode k1 = k2.left;
        k2.left = k1.right;
        k1.right = k2;
        k2.height = Math.max(height(k2.left), height(k2.right)) + 1;
        k1.height = Math.max(height(k1.left), k2.height) + 1;
        return k1;
    }

2.5双旋转

依次插入6 2 7 1 4，插入3时，树的平衡被破坏
在这里插入图片描述
下面的图解C节点实际上应该没有，因为插入B的时候已经影响平衡
在这里插入图片描述
步骤：

  • k3的左边子树进行一次右边的单旋转
  • k3进行一次左边的单旋转
 private AvlNode<T> doubleWithLeftChild(AvlNode<T> k3) {
        k3.left = rotateWithRightChild(k3.left);
        return rotateWithLeftChild(k3);
    }

2.6实现

平衡二叉树实现的大部分过程和二叉查找树是一样的，区别就在于插入和删除之后要判断树左右子树高度之差是否大于1，如果大于1需要进行旋转维持平衡
其它的两种插入影响平衡的情况和以上两种刚好相反

3.代码

3.1树节点

public class AvlNode<T> {
    T element;
    int height;
    AvlNode<T> left;
    AvlNode<T> right;

    public AvlNode(T element) {
        this(element, null, null);
    }

    public AvlNode(T element, AvlNode<T> left, AvlNode<T> right) {
        this.element = element;
        this.left = left;
        this.right = right;
        this.height = 0;
    }
}

3.2平衡代码

private AvlNode<T> balance(AvlNode<T> t) {
        if (t == null) {
            return t;
        }

        if (height(t.left) - height(t.right) > ALLOWED_IMBALANCE) {
            if (height(t.left.left) >= height(t.left.right)) {
                t = rotateWithLeftChild(t);
            } else {
                t = doubleWithLeftChild(t);
            }
        } else if (height(t.right) - height(t.left) > ALLOWED_IMBALANCE) {
            if (height(t.right.right) >= height(t.right.left)) {
                t = rotateWithRightChild(t);
            } else {
                t = doubleWithRightChild(t);
            }
        }
        t.height = Math.max(height(t.left), height(t.right)) + 1;
        return t;
    }

3.3完整代码

public class AvlTree<T extends Comparable<? super T>> {

    private AvlNode<T> root;

    public void insert(T x) {
        root = insert(x, root);
    }

    public void remove(T x) {
        root = remove(x, root);
    }

    public T findMin() {
        return findMin(root).element;
    }


    public void makeEmpty() {
        root = null;
    }

    public boolean isEmpty() {
        return root == null;
    }

    /**
     * 添加节点
     *
     * @param x 插入节点
     * @param t 父节点
     */
    private AvlNode<T> insert(T x, AvlNode<T> t) {

        //如果根节点为空，则当前x节点为根及诶单
        if (null == t) {
            return new AvlNode(x);
        }

        int compareResult = x.compareTo(t.element);

        //小于当前根节点 将x插入根节点的左边
        if (compareResult < 0) {
            t.left = insert(x, t.left);
        } else if (compareResult > 0) {
            //大于当前根节点 将x插入根节点的右边
            t.right = insert(x, t.right);
        } else {

        }
        return balance(t);
    }

    private static final int ALLOWED_IMBALANCE = 1;

    private AvlNode<T> balance(AvlNode<T> t) {
        if (t == null) {
            return t;
        }

        if (height(t.left) - height(t.right) > ALLOWED_IMBALANCE) {
            if (height(t.left.left) >= height(t.left.right)) {
                t = rotateWithLeftChild(t);
            } else {
                t = doubleWithLeftChild(t);
            }
        } else if (height(t.right) - height(t.left) > ALLOWED_IMBALANCE) {
            if (height(t.right.right) >= height(t.right.left)) {
                t = rotateWithRightChild(t);
            } else {
                t = doubleWithRightChild(t);
            }
        }
        t.height = Math.max(height(t.left), height(t.right)) + 1;
        return t;
    }

    private AvlNode<T> doubleWithRightChild(AvlNode<T> k3) {
        k3.right = rotateWithLeftChild(k3.right);
        return rotateWithRightChild(k3);
    }

    private AvlNode<T> rotateWithRightChild(AvlNode<T> k2) {
        AvlNode k1 = k2.right;
        k2.right = k1.left;
        k1.left = k2;
        k2.height = Math.max(height(k2.right), height(k2.left)) + 1;
        k1.height = Math.max(height(k1.right), k2.height) + 1;
        return k1;
    }

    private AvlNode<T> doubleWithLeftChild(AvlNode<T> k3) {
        k3.left = rotateWithRightChild(k3.left);
        return rotateWithLeftChild(k3);
    }

    private AvlNode<T> rotateWithLeftChild(AvlNode<T> k2) {
        AvlNode k1 = k2.left;
        k2.left = k1.right;
        k1.right = k2;
        k2.height = Math.max(height(k2.left), height(k2.right)) + 1;
        k1.height = Math.max(height(k1.left), k2.height) + 1;
        return k1;
    }

    private int height(AvlNode<T> t) {
        return t == null ? -1 : t.height;
    }

    /**
     * 删除节点
     *
     * @param x    节点
     * @param t    父节点
     */
    private AvlNode<T> remove(T x, AvlNode<T> t) {

        if (null == t) {
            return t;
        }

        int compareResult = x.compareTo(t.element);

        //小于当前根节点
        if (compareResult < 0) {
            t.left = remove(x, t.left);
        } else if (compareResult > 0) {
            //大于当前根节点
            t.right = remove(x, t.right);
        } else if (t.left != null && t.right != null) {
            //找到右边最小的节点
            t.element = findMin(t.right).element;
            //当前节点的右边等于原节点右边删除已经被选为的替代节点
            t.right = remove(t.element, t.right);
        } else {
            t = (t.left != null) ? t.left : t.right;
        }
        return balance(t);
    }

    /**
     * 找最小节点
     *
     * @param root 根节点
     */
    private AvlNode<T> findMin(AvlNode<T> root) {
        if (root == null) {
            return null;
        } else if (root.left == null) {
            return root;
        }
        return findMin(root.left);
    }

    /**
     * 找最大节点
     *
     * @param root 根节点
     */
    private AvlNode<T> findMax(AvlNode<T> root) {
        if (root == null) {
            return null;
        } else if (root.right == null) {
            return root;
        } else {
            return findMax(root.right);
        }
    }

    public void printTree() {
        if (isEmpty()) {
            System.out.println("节点为空");
        } else {
            printTree(root);
        }
    }


    public void printTree(AvlNode<T> root) {
        if (root != null) {
            System.out.print(root.element);
            if (null != root.left) {
                System.out.print("左边节点" + root.left.element);
            }
            if (null != root.right) {
                System.out.print("右边节点" + root.right.element);
            }
            System.out.println();
            printTree(root.left);
            printTree(root.right);
        }
    }

}

4.测试

代码：

 @Test
    public void test1(){
        AvlTree testTree = new AvlTree();
        testTree.insert(1);
        testTree.insert(2);
        testTree.insert(3);
        testTree.printTree();
    }

测试截图：
在这里插入图片描述
代码：

    @Test
    public void test4(){
        AvlTree testTree = new AvlTree();
        testTree.insert(6);
        testTree.insert(2);
        testTree.insert(7);
        testTree.insert(1);
        testTree.insert(4);
        testTree.insert(3);

        testTree.printTree();
    }

测试截图：
在这里插入图片描述

5.参考书籍

6.系列链接

上一篇：java实现二叉查找树

不懂的浪漫
关注
  • 9
    点赞
  • 踩
  • 17
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
AVLTrees:Java中的AVL树实现
05-05
AVL树Java中的AVL树实现有两个基本操作，使用这些操作树本身会保持平衡。 左旋转。 右旋。 然后将有四种可能性左-左情况：— x是y的左子代，y是z的左子代。 左右案例：— x是y的右子代，y是z的左子代。 左右案例：—...
AVL树及JAVA实现
04-14
NULL 博文链接：https://128kj.iteye.com/blog/1735464
Java手写AVL树（非常详细）
fengxiandada的博客
04-08 2675
文章目录1. 二叉搜索树复杂度2. BST的平衡3. 改进二叉搜索树4. 平衡二叉搜索树（Balanced Binary Search Tree）5. AVL树5.1 AVL树的相关概念及特点5.2 普通BST和AVL树添加对比6. AVL树设计6.1 继承结构6.2 普通BST添加导致失衡例子6.3 解决添加失衡——LL-右旋转(单旋)6.4 解决添加失衡——RR-左旋转(单旋)6.5 解决添加失衡——LR-RR左旋转，LL右旋转(双旋)6.6 解决添加失衡——RL-LL右旋转，RR左旋转(双旋)6.7
2—3树 Java实现
qq_45672914的博客
08-25 426
最适合新手的暴力实现2—3树方法。
java 实现 avl 树
最新发布
fanghailiang2016的博客
04-23 156
java 实现 avl 树
2-3树原理+代码实现！超简单java入门版！
title_martin的博客
01-21 445
2-3查找树 为了保证树的平衡性，我们需要一些灵活性，因此在这里我们允许树中的一个结点保存多个键，确切的说，我们将一颗标准的二叉查找树的结点称为2-结点(含有一个键和两条链)。而现在我们引入3-结点，它含有两个键和3条链。2-和3-结点中的每条链对应着其中保存的键所产生的一个区间。 定义： 一颗2-3树要么为空，要么满足下面两个要求： 2-结点： 含有一个键，及其对应值得两条链，左链接指向2-3树中的键都小于该结点，右链接指向2-3树中的键都大于该结点 3-结点： 含有两个键(及其对应的值)和3条链
Java中的AVL树
weixin_74144099的博客
01-17 480
int key;int height;每个节点包含一个键、一个值、一个左子节点、一个右子节点以及一个表示节点高度的字段。
AVL树（Java）
2301_76161469的博客
01-13 2853
目录一、什么是AVL树二、AVL树的实现AVL树的节点AVL树的插入AVL树的旋转右单旋左单旋左右双旋 右左双旋AVL树的验证三、AVL树的性能分析在了解什么是AVL树之前，我们先回顾二叉搜索树的概念二叉搜索树（二叉排序树），它或是一棵空树，或具有以下性质：根据二叉搜索树的性质，我们可以发现：1. 二叉搜索树中最左侧的节点是树中最小的节点，最右侧的节点是树中最大的节点2. 若采用中序遍历二叉搜索树，则可得到一个有序的序列二叉搜索树最主要的作用就是用于进行查询：当二叉搜索树是一颗完全二叉树时：其查询的平均查找
基于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 树的实现。
Java-AVL树
weixin_45203607的博客
01-20 939
AVL树简介 AVL树其实就是二叉查找树,不同的是在二叉查找树的基础上进行了加强,弥补了二叉树会有可能退化为链表情况 AVL的核心原理就是自璇,自动调整树的高度,使树始终保存接近完全二叉树的结构,这样就能最大化利用二叉树查找树的查询特性完成高效处理,但是缺点也是很明显增加和删除就会慢上很多 AVL树必要条件： 条件一：它必须是二叉查找树。 条件二：每个节点的左子树和右子树的高度最多为1,否则就要进行自璇来调整 AVL树相关概念 平衡因子 将二叉树上节点的左子树高度减去右子树高度的值称为该节点的平衡因子BF
Java实现AVL树的添加和删除
糖气包的博客
01-10 3509
  前言 AVL树的基本性质 AVL树节点设计 插入时会出现什么问题？ 2为3的左节点，1为2的左节点 2为1的右节点，3为2的右节点 1为3的左节点，2为1的右节点 3为1的右节点，2为3的左节点 AVL树的插入 AVL树的判断 AVL树的删除 后记 前言         前面写过两篇关于二叉搜索树的博文，但是它不具有平衡性，最差情况时，会退化成链表，查找的效率会降至...
2-3 查找树及其Java实现
weixin_30289831的博客
07-26 367
2-3 查找树 定义（来源：wiki） 查找 插入 2-3 查找树 定义（来源：wiki） 2–3树是一种树型数据结构，内部节点（存在子节点的节点）要么有2个孩子和1个数据元素，要么有3个孩子和2个数据元素，叶子节点没有孩子，并且有1个或2个数据元素。 2个结点 ...
AVL树（java）
奔跑的蜗牛@1997
04-22 588
1、AVL树的定义 AVL树又称平衡二叉搜索树，它能保证二叉树高度相对平衡，尽量降低二叉树的高度，提高搜索效率 2、AVL树的特点 （1）AVL的左右子树高度之差的绝对值不超过1 （2）树中的每个左子树和右子树都是AVL树 （3）每个节点都有一个平衡因子,任一节点的平衡因子只能是（-1、0、1）。(每个节点的平衡因子等于右子树的高度减去左子 树的高度 ) （4）平衡二叉树的高度和结点数量之间的关系...
AVL树原理及实现（C语言实现以及Java语言实现）
weixin_30258027的博客
11-17 320
欢迎探讨，如有错误敬请指正 如需转载，请注明出处http://www.cnblogs.com/nullzx/ 1. AVL定义 AVL树是一种改进版的搜索二叉树。对于一般的搜索二叉树而言，如果数据恰好是按照从小到大的顺序或者从大到小的顺序插入的，那么搜索二叉树就对退化成链表，这个时候查找，插入和删除的时间都会上升到O(n)，而这对于海量数据而言，是我们无法忍受的。即使是一颗由完全随机的数据构造...
java数据结构与算法之平衡二叉树(AVL树)的设计与实现
热门推荐
zejian的博客
12-31 3万+
【版权申明】未经博主同意，不允许转载！（请尊重原创，博主保留追究权） http://blog.csdn.net/javazejian/article/details/53892797 出自【zejian的博客】 关联文章:java数据结构与算法之顺序表与链表设计与实现分析 java数据结构与算法之双链表设计与实现 java数据结构与算法之改良顺序表与双链表类似ArrayList和L
AVL树的java实现
dahlwuyn的专栏
03-31 5037
AVL树的定义自己百度去，这里给出自己用java的一个实现。 package test; /** * @时间 2014-3-30 * @version 0.1 * @encode UTF-8 * @功能 * 1、AVL树的生成 * 2、插入元素 * 3、删除元素 * 4、查找某一元素 * @notice 树元素需实现Comparor接口 * @see 《数据结构与算法分析》
java实现avl树升序遍历
02-23
AVL树是一种自平衡的二叉搜索树，它的升序遍历可以通过中序遍历来实现。下面是Java实现AVL树升序遍历的示例代码： ```java // AVL树节点定义 class Node { int key; int height; Node left; Node right; Node(int key) { this.key = key; this.height = 1; } } // AVL树类定义 class AVLTree { Node root; // 获取节点的高度 int getHeight(Node node) { if (node == null) { return 0; } return node.height; } // 更新节点的高度 void updateHeight(Node node) { node.height = Math.max(getHeight(node.left), getHeight(node.right)) + 1; } // 获取节点的平衡因子 int getBalanceFactor(Node node) { if (node == null) { return 0; } return getHeight(node.left) - getHeight(node.right); } // 右旋操作 Node rotateRight(Node y) { Node x = y.left; Node T2 = x.right; x.right = y; y.left = T2; updateHeight(y); updateHeight(x); return x; } // 左旋操作 Node rotateLeft(Node x) { Node y = x.right; Node T2 = y.left; y.left = x; x.right = T2; updateHeight(x); updateHeight(y); return y; } // 插入节点 Node insertNode(Node node, int key) { if (node == null) { return new Node(key); } if (key < node.key) { node.left = insertNode(node.left, key); } else if (key > node.key) { node.right = insertNode(node.right, key); } else { return node; // 不允许插入重复的节点 } updateHeight(node); int balanceFactor = getBalanceFactor(node); // 左旋操作 if (balanceFactor > 1 && key < node.left.key) { return rotateRight(node); } // 右旋操作 if (balanceFactor < -1 && key > node.right.key) { return rotateLeft(node); } // 左右旋操作 if (balanceFactor > 1 && key > node.left.key) { node.left = rotateLeft(node.left); return rotateRight(node); } // 右左旋操作 if (balanceFactor < -1 && key < node.right.key) { node.right = rotateRight(node.right); return rotateLeft(node); } return node; } // 中序遍历 void inorderTraversal(Node node) { if (node != null) { inorderTraversal(node.left); System.out.print(node.key + " "); inorderTraversal(node.right); } } } // 测试代码 public class Main { public static void main(String[] args) { AVLTree tree = new AVLTree(); tree.root = tree.insertNode(tree.root, 10); tree.root = tree.insertNode(tree.root, 20); tree.root = tree.insertNode(tree.root, 30); tree.root = tree.insertNode(tree.root, 40); tree.root = tree.insertNode(tree.root, 50); tree.root = tree.insertNode(tree.root, 25); System.out.println("AVL树的升序遍历结果："); tree.inorderTraversal(tree.root); } } ``` 运行以上代码，输出结果为：10 20 25 30 40 50，即AVL树的升序遍历结果。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值