玩转数据结构之Java实现AVL树

于 2023-02-17 10:32:49 发布
阅读量150 收藏
点赞数 1
分类专栏： 数据结构与算法 文章标签： java 数据结构 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a734474820/article/details/129079925
版权

前言

AVL树是一种高度平衡的二叉搜索树，即任意节点的左子树和右子树高度之差都不超过1；

当一棵二叉搜索树进行增加或删除操作时，就有可能产生不平衡的情况。我们要做的就是在出现不平衡的状况时及时进行调整，让整棵树恢复平衡。具体实现方式为左旋转以及右旋转，详细请参考AVL树详解

代码实现

基于二分搜索树实现平衡二叉树
package com.sjgd.avltree;

import java.util.ArrayList;

/**
 * @author 平衡二叉树
 * on 2023/2/16
 */
public class AVLTree<K extends Comparable<K>, V> {
    private class Node {
        private K key;
        private V value;
        /**
         * 分别对应左右节点
         */
        private Node left, right;
        /**
         * 节点的高度
         */
        private int height;

        public Node(K key, V value) {
            this.key = key;
            this.value = value;
            this.height = 1;
        }
    }

    private Node root;
    private int size;

    /**
     * 获取节点node对应的高度
     *
     * @param node
     * @return
     */
    public int getHeight(Node node) {
        if (node == null) {
            return 0;
        }
        return node.height;
    }

    /**
     * 获取节点node对应的平衡因子
     *
     * @return
     */
    public int getBalanceFactor(Node node) {
        if (node == null) {
            return 0;
        }
        return getHeight(node.left) - getHeight(node.right);
    }

    public int getSize() {
        return size;
    }

    public boolean isEmpty() {
        return size == 0;
    }

    // 对节点y进行向右旋转操作，返回旋转后新的根节点x
    //        y                              x
    //       / \                           /   \
    //      x   T4     向右旋转 (y)        z     y
    //     / \       - - - - - - - ->    / \   / \
    //    z   T3                       T1  T2 T3 T4
    //   / \
    // T1   T2
    private Node rightRotate(Node y) {
        Node x = y.left;
        Node T3 = x.right;
        //向右旋转
        x.right = y;
        y.left = T3;
        y.height = Math.max(getHeight(y.left), getHeight(y.right)) + 1;
        x.height = Math.max(getHeight(x.left), getHeight(x.right)) + 1;
        return x;
    }


    // 对节点y进行向左旋转操作，返回旋转后新的根节点x
    //    y                             x
    //  /  \                          /   \
    // T1   x      向左旋转 (y)       y     z
    //     / \   - - - - - - - ->   / \   / \
    //   T2  z                     T1 T2 T3 T4
    //      / \
    //     T3 T4
    private Node leftRotate(Node y) {
        Node x = y.right;
        Node T2 = x.left;
        x.left = y;
        y.right = T2;
        y.height = Math.max(getHeight(y.left), getHeight(y.right)) + 1;
        x.height = Math.max(getHeight(x.left), getHeight(x.right)) + 1;
        return x;
    }

    /**
     * 向二分搜索树中添加新的元素
     *
     * @param key
     * @param value
     */
    public void add(K key, V value) {
        root = add(root, key, value);
    }

    public Node add(Node node, K key, V value) {
        if (node == null) {
            size++;
            return new Node(key, value);
        }
        if (key.compareTo(node.key) < 0) {
            node.left = add(node.left, key, value);
        } else if (key.compareTo(node.key) > 0) {
            node.right = add(node.right, key, value);
        } else {
            node.value = value;
        }

        //更新height
        node.height = 1 + Math.max(getHeight(node.left), getHeight(node.right));

        //计算平衡因子
        int balanceFactor = getBalanceFactor(node);
        if (balanceFactor > 1 && getBalanceFactor(node.left) >= 0) {
            //说明向左倾斜，需要进行右旋转LL
            return rightRotate(node);
        }

        if (balanceFactor < -1 && getBalanceFactor(node.right) <= 0) {
            //说明向右倾斜，需要进行左旋转 RR
            return leftRotate(node);
        }

        if (balanceFactor > 1 && getBalanceFactor(node.left) < 0) {
            //说明满足LR条件
            node.left = leftRotate(node.left);
            return rightRotate(node);
        }

        if (balanceFactor < -1 && getBalanceFactor(node.left) > 0) {
            //说明满足RL条件
            node.right = rightRotate(node.right);
            return leftRotate(node);
        }
        return node;
    }

    /**
     * 判断当前二叉树是否是二分搜索树【中序遍历结果是顺序的】
     *
     * @return
     */
    public boolean isBST() {
        ArrayList<K> keys = new ArrayList<>();
        inOrder(root, keys);
        for (int i = 1; i < keys.size(); i++) {
            if (keys.get(i - 1).compareTo(keys.get(i)) > 0) {
                return false;
            }
        }
        return true;
    }

    /**
     * 对二叉树进行中序遍历
     *
     * @param node
     * @param keys
     */
    private void inOrder(Node node, ArrayList<K> keys) {
        if (node == null) {
            return;
        }
        inOrder(node.left, keys);
        keys.add(node.key);
        inOrder(node.right, keys);
    }

    /**
     * 判断该二叉树是否是一颗平衡二叉树
     *
     * @return
     */
    public boolean isBalanced() {
        return isBalanced(root);
    }

    private boolean isBalanced(Node node) {
        if (node == null) {
            return true;
        }
        int balanceFactor = getBalanceFactor(node);
        if (Math.abs(balanceFactor) > 1) {
            return false;
        }
        return isBalanced(node.left) && isBalanced(node.right);
    }

    /**
     * 返回以node为根节点的二分搜索树中，key所在的节点
     *
     * @return
     */
    public Node getNode(Node node, K key) {
        if (node == null) {
            return null;
        }
        if (key.equals(node.key)) {
            return node;
        } else if (key.compareTo(node.key) < 0) {
            return getNode(node.left, key);
        } else {
            return getNode(node.right, key);
        }
    }

    public boolean contains(K key) {
        return getNode(root, key) != null;
    }

    public V get(K key) {
        Node node = getNode(root, key);
        if (node == null) {
            return null;
        }
        return node.value;
    }


    public void set(K key, V newValue) {
        Node node = getNode(root, key);
        if (node == null) {
            throw new IllegalArgumentException("This Key is not exist.");
        }
        node.value = newValue;
    }

    /**
     * 返回以node为根的二分搜索树的最小值所在的节点
     *
     * @param node
     * @return
     */
    private Node minimum(Node node) {
        if (node.left == null) {
            return node;
        }
        return minimum(node.left);
    }

    /**
     * 删除掉以node为根的二分搜索树中的最小节点
     *
     * @param node 返回删除节点后新的二分搜索树的根
     * @return
     */
    public Node removeMin(Node node) {
        if (node.left == null) {
            Node rightNode = node.right;
            node.right = null;
            size--;
            return rightNode;
        }
        node.left = removeMin(node.left);
        return node;
    }


    /**
     * 从二分搜索树中删除键为key的节点
     *
     * @param key
     * @return
     */
    public V remove(K key) {
        Node node = getNode(root, key);
        if (node == null) {
            return null;
        }
        root = remove(root, key);
        return node.value;
    }

    private Node remove(Node node, K key) {
        if (node == null) {
            return null;
        }
        Node retNode;
        if (key.compareTo(node.key) < 0) {
            node.left = remove(node.left, key);
            retNode = node;
        } else if (key.compareTo(node.key) > 0) {
            node.right = remove(node.right, key);
            retNode = node;
        } else {
            if (node.left == null) {
                Node rightNode = node.right;
                node.right = null;
                size--;
                retNode = rightNode;
            } else if (node.right == null) {
                Node leftNode = node.left;
                node.left = null;
                size--;
                retNode = leftNode;
            } else {
                //待删除的节点左右子树都不为空的时候
                //找到比待删除节点大的最小节点，即待删除节点的右子树中的最小节点
                //使用这个节点顶替待删除的节点的位置
                Node successor = minimum(node.right);
                //调用removemin方法可能会导致平衡性被打破
                successor.right = remove(node.right, successor.key);
                successor.left = node.left;
                node.left = node.right = null;
                retNode = successor;
            }
        }
        if (retNode == null) {
            return null;
        }
        //更新数的高度
        retNode.height = 1 + Math.max(getHeight(retNode.left), getHeight(retNode.right));
        int balanceFactor = getBalanceFactor(retNode);
        if (balanceFactor > 1 && getBalanceFactor(retNode.left) >= 0) {
            //LL
            return rightRotate(retNode);
        }

        if (balanceFactor < -1 && getBalanceFactor(retNode.right) <= 0) {
            //RR
            return leftRotate(retNode);
        }


        if (balanceFactor > 1 && getBalanceFactor(retNode.left) < 0) {
            //LR
            retNode.left = leftRotate(retNode.left);
            return rightRotate(retNode);
        }


        if (balanceFactor < -1 && getBalanceFactor(retNode.right) > 0) {
            //RL
            retNode.right = rightRotate(retNode.right);
            return leftRotate(retNode);
        }

        return retNode;


    }

}
基于平衡二叉树实现集合（Set）和映射（Map）
  • Set集合
package com.sjgd.avltree;

/**
 * @author XiXu
 * on 2023/2/17
 * @description 基于AVL树实现Set集合
 */
public class AVLSet<E extends Comparable<E>> implements Set<E> {
    private AVLTree<E, Object> avlTree;

    public AVLSet() {
        avlTree = new AVLTree<>();
    }

    @Override
    public void add(E e) {
        avlTree.add(e, null);
    }

    @Override
    public void remove(E e) {
        avlTree.remove(e);
    }

    @Override
    public boolean contains(E e) {
        return avlTree.contains(e);
    }

    @Override
    public int getSize() {
        return avlTree.getSize();
    }

    @Override
    public boolean isEmpty() {
        return avlTree.isEmpty();
    }
}
  • Map映射
package com.sjgd.avltree;

/**
 * @author XiXu
 * on 2023/2/17
 * @description 基于AVL树实现Map集合
 */
public class AVLMap<K extends Comparable<K>, V> implements Map<K, V> {
    private AVLTree<K, V> avlTree;

    public AVLMap() {
        avlTree = new AVLTree<>();
    }

    @Override
    public void add(K key, V value) {
        avlTree.add(key, value);
    }

    @Override
    public V remove(K key) {
        return avlTree.remove(key);
    }

    @Override
    public boolean contains(K key) {
        return avlTree.contains(key);
    }

    @Override
    public V get(K key) {
        return avlTree.get(key);
    }

    @Override
    public void set(K key, V newValue) {
        avlTree.set(key, newValue);
    }

    @Override
    public int getSize() {
        return avlTree.getSize();
    }

    @Override
    public boolean isEmpty() {
        return avlTree.isEmpty();
    }
}

时间复杂度

增加删除操作：O(logn)

结语

如果以上文章对您有一点点帮助，希望您不要吝啬的点个赞加个关注，您每一次小小的举动都是我坚持写作的不懈动力！ღ( ´･ᴗ･` )

惜许
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构之AVL树详解
12-26
AVL树是最早提出的自平衡二叉树，在AVL树中任何节点的两个子树的高度最大差别为一，所以它也被称为高度平衡树。AVL树得名于它的发明者G.M. Adelson-Velsky和E.M. Landis。AVL树种查找、插入和删除在平均和最坏情况下...
C语言数据结构之平衡二叉树（AVL树）实现方法示例
08-28
主要介绍了C语言数据结构之平衡二叉树（AVL树）实现方法,结合实例形式分析了C语言平衡二叉树的相关定义与使用技巧,需要的朋友可以参考下
java实现AVL树
Groot-lin的博客
11-07 266
java实现AVL树
AVL树(Java实现)
weixin_30376163的博客
12-07 100
AVL树基本介绍 AVL树是一种自平衡的二叉查找树，在AVL树中任何节点的两个子树的高度差不能超过1。就是相当于在二叉搜索树的基础上，在插入和删除时进行了平衡处理。 不平衡的四种情况 LL：结构介绍 看如下图，假设最初只有k1, k2, k3, y, z五个结点，这时该树两边的高度分别为3和 2，相差为1，满足AVL平衡的概念。 随后插入了结点 x ，导致了不平衡。k1.left....
avl树 java_AVL树之 Java的实现
weixin_39865866的博客
02-16 197
AVL树的介绍AVL树是高度平衡的而二叉树。它的特点是：AVL树中任何节点的两个子树的高度最大差别为1。上面的两张图片，左边的是AVL树，它的任何节点的两个子树的高度差别都<=1；而右边的不是AVL树，因为7的两颗子树的高度相差为2(以2为根节点的树的高度是3，而以8为根节点的树的高度是1)。AVL树的Java实现1. 节点1.1 节点定义public class AVLTree> {...
AVL树（Java语言）
qq_49306008的博客
12-05 2558
平衡二叉树 平衡二叉树也叫平衡二叉查找树，又被称为AVL树，可以保证查询效率较高。它的特点是：它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。 结点的平衡因子定义为：结点的左子树高度与右子树高度之差。显然，对一棵AVL树而言，其所有结点的平衡因子只能是-1，0，1.挡在一棵AVL树上插入一个结点时，有可能导致失衡，即出现绝对值大于1的平衡因子。 单旋转（左旋转） 插入70后失去平衡，调整过程如下：。 思路： 1、创建一个新的结点，值等于当前根节点的值。 2、把新
JAVA实现平衡二叉树（AVL）
qicha3705的博客
08-05 4275
数据结构与算法-平衡二叉树（AVL） 1.平衡二叉树简介1.1什么是平衡二叉树1.2平衡二叉树的作用2.关键词概述3.JAVA代码实现3.1节点类（TreeNode） 前言 本文主要探讨平衡二叉树的实现过程，对于原理还请自行翻阅其它资料进行学习 1.平衡二叉树简介 1.1什么是平衡二叉树 了解平衡二叉树之前我们首先需要知道什么是树结构 . 树结构 树是一种数据结构，它是由n（n>=1）个有限节点组成一个具有层次关系的集合。 树的定义： 把它叫做“树”是因为它看起来像一棵倒挂的树，也就是说它
数据结构课程设计（AVL树实现图书管理系统）
02-01
数据结构课程设计（AVL树实现图书管理系统）
基于java语言手动实现的AVL树代码
11-09
基于java语言手动实现的AVL树代码，该树形结构适用于查找，实现的逻辑可以查看博主的原创作品《用JAVA代码手动实现AVL树》
Java数据结构——平衡二叉树(AVL树)
m0_62969222的博客
05-31 3143
AVL树的引入 搜索二叉树有着极高的搜索效率，但是搜索二叉树会出现以下极端情况： 这样的二叉树搜索效率甚至比链表还低。在搜索二叉树基础上出现的平衡二叉树(AVL树)就解决了这样的问题。当平衡二叉树(AVL树)的某个节点左右子树高度差的绝对值大于1时，就会通过旋转操作减小它们的高度差。 基本概念 AVL树本质上还是一棵二叉搜索树，它的特点是： 本身首先是一棵二叉搜索树。 每个结点的左右子树的高度之差的绝对值（平衡因子）最多为1。也就是说，AVL树，本质上是带了平衡功能的二叉查找树（二叉排序树，二叉搜索树）
Java实现AVL树
上庸者-不服周
06-13 382
AVL树
平衡二叉树(AVL Tree)的JAVA实现
qq_24320957的博客
08-01 425
平衡二叉树的Java实现
平衡树（AVL树）java代码
qq_51955445的博客
02-05 1225
debug了好久才写出来的平衡树，可能有代码冗余或者有误的地方，欢迎指出错误 推荐一个网站（数据结构操作可视化） (我这里给出的是平衡树界面) AVL Tree Visualzation (我debug就是看着可视化的树查错的) import java.util.LinkedList; /** * @author 20级三班刘宇阳 * @create 2022/2/3 */ /** * 平衡樹 * @param <K> key的类型 元素必须可比较 * @param <V&
Java——AVL树
m0_60867520的博客
12-12 502
AVL树的概念与插入详解，图解步骤，附带具体代码
数据结构之Java实现AVL Tree
zhangjun62的博客
09-28 1707
AVL Tree是最早的自平衡二分搜索树结构。平衡二叉树对于任意结点左子树与右子树高度差不超过1，平衡二叉树高度与结点数量为O(log n)关系。每一个结点需要记录每一个结点的高度，计算平衡因子，平衡因子等于左子树高度减去右子树高度。对于一个二分搜索树，当添加元素时会破坏平衡，这时需要维护，删除元素时也会造成平衡破坏，需要维护平衡。主要有四种情况，分别如下 1.LL，平衡因子大于1，左子树平衡因...
java平衡二叉树_Java实现平衡二叉树（AVLTree）的构建
weixin_42370434的博客
02-20 378
近期在学习数据结构上关于平衡二叉树的知识，看了严老师的思路，感觉用java写出递归的构建方式有点困难，由于当中的递归须要把引用传进去，所以感觉是要实现起来比較麻烦，所以就首先想到使用非递归的方式来实现构建平衡二叉树。使用非递归的方式，思路也非常easy，就是为每个结点都要定义一个平衡因子的属性，当成功向树中插入一个数据时，我就要进行回溯，看看有没有平衡因子的绝对值等于2的结点，假设有，那就须要进行...
Java实现AVL树（自平衡二叉搜索树）
m0_60936579的博客
10-12 962
一、AVL树的概念 AVL树本质上是一棵二叉搜索树，即它或者是一棵空树，或者是具有下列性质的二叉树： 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值； 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值； 它的左、右子树也分别为二叉搜索树。另外，AVL树每个结点的左右子树的高度之差，即平衡因子的绝对值不超过1，以实现查询操作的时间复杂度从传统二叉搜索树的O(N)降为O(logN)。 二、平衡调整 首先，为什么AVL树需要有“自平衡”的功能？其实从A...
AVL树的Java实现
qq_51536995的博客
05-03 1287
AVL树的java实现
AVL树的java实现方法
m0_53541401的博客
07-30 351
众所周知avl树是一种基于bst改进防止弱化成链表的一种树形数据结构，兼具了益于查找，删除，添加，排序的优点，是一种必须掌握的数据结构
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、付费专栏及课程。

余额充值