java实现数据结构12（AVLTree详解代码之自定义AVLTree）

最新推荐文章于 2023-05-11 23:44:25 发布
最新推荐文章于 2023-05-11 23:44:25 发布
阅读量145 收藏 1
点赞数
分类专栏： java实现数据结构 文章标签： 数据结构 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liangruilz/article/details/103679581
版权

AVLTree

import java.util.ArrayList;

/**
 * @description: AVLTree是具有调节二分搜索树平衡的树，使得二分搜索树保持左右深度差的绝对值不超过1
 * @author: liangrui
 * @create: 2019-12-23 21:34
 **/
public class AVLTree<K extends Comparable<K>,V> {

    private class Node{
        public K key;
        public V value;
        public Node left,right;
        public int height;

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

    private Node root;
    private int size;

    public AVLTree(){
        root=null;
        size=0;
    }

    public int getSize(){
        return size;
    }

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

    /**
     * 判断该二叉树是否是一颗二分搜索树
     * @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);
    }

    /**
     * 判断Node为根的二叉树是否是一棵平衡二叉树，递归算法
     * @param node
     * @return
     */
    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的平衡因子
     * @param node
     * @return
     */
    private int getBalanceFactor(Node node){
        if (node==null){
            return 0;
        }
        return getHeight(node.left)-getHeight(node.right);
    }

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

    // 对节点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;

        //更新height
        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;

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

        return x;
    }

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

    /**
     * 向以node为根的二分搜索树插入元素(key,value),递归算法
     * @param node
     * @param key
     * @param value
     * @return 返回插入新节点后二分搜索树的根
     */
    private 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=Math.max(getHeight(node.left),getHeight(node.right))+1;

        //计算平衡因子
        int balanceFactor=getBalanceFactor(node);

        //平衡维护
        if (balanceFactor>1&&getBalanceFactor(node.left)>=0){
            return rightRotate(node);
        }

        if (balanceFactor<-1&&getBalanceFactor(node.right)<=-1){
            return leftRotate(node);
        }

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

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

        return node;
    }

    /**
     * 返回以node为根节点的二分搜索树中，key所在的节点
     * @param node
     * @param key
     * @return
     */
    private 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);
        return node==null?null:node.value;
    }

    public void set(K key,V newValue){
        Node node=getNode(root,key);
        if (node==null){
            throw new IllegalArgumentException(key+"doesn't exist.");
        }
        node.value=newValue;
    }

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

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

    private Node remove(Node node, K key) {
        if (node==null){
            return null;
        }

        Node retNode=null;
        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);
        }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 reNode=getMinNode(node.right);
                reNode.right=remove(node.right,reNode.key);
                reNode.left=node.left;
                node.left=node.right=null;
                retNode=reNode;
            }
        }

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

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

        // 计算平衡因子
        int balanceFactor = getBalanceFactor(retNode);

        // 平衡维护
        if (balanceFactor > 1 && getBalanceFactor(retNode.left) >= 0)
            return rightRotate(retNode);

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

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

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

        return retNode;
    }

}

基于AVLTree创建自定义AVLSet

1.自定义Set接口
/**
 * @description: 自定义Set接口
 * @author: liangrui
 * @create: 2019-12-24 10:37
 **/
public interface Set<E> {
    void add(E e);
    boolean contains(E e);
    void remove(E e);
    int getSize();
    boolean isEmpty();
}
2.AVLSet
/**
 * @description: 基于AVLTree创建自定义AVLSet
 * @author: liangrui
 * @create: 2019-12-24 10:45
 **/
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 boolean contains(E e) {
        return avlTree.contains(e);
    }

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

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

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

基于AVLTree创建自定义AVLMap

1.自定义Map接口
/**
 * @description: 自定义map接口
 * @author: liangrui
 * @create: 2019-12-24 10:35
 **/
public interface Map<K,V> {
    void add(K key, V value);
    boolean contains(K key);
    V get(K key);
    void set(K key, V newValue);
    V remove(K key);
    int getSize();
    boolean isEmpty();
}
2.AVLMap
/**
 * @description: 基于AVLTree自定义Map
 * @author: liangrui
 * @create: 2019-12-24 10:38
 **/
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 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 V remove(K key) {
        return avlTree.remove(key);
    }

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

    @Override
    public boolean isEmpty() {
        return avlTree.isEmpty();
    }
}
良睿
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构之AVL树详解
12-26
AVL树是最早提出的自平衡二叉树，在AVL树中任何节点的两个子树的高度最大差别为一，所以它也被称为高度平衡树。AVL树得名于它的发明者G.M. Adelson-Velsky和E.M. Landis。AVL树种查找、插入和删除在平均和最坏情况下...
java实现AVL树
bcgg的博客
07-31 156
思路比较简单不过多描述,只贴实现代码 import java.util.Comparator; /** * AVLTree * @param <T> */ public class AVLTree<T> { private static final int ALLOWED_IMBALANCE = 1;//最小不平衡因子 private AvlNode&...
Java实现创建平衡二叉树(AVL 树)和AVL树的增删改查
当一个合格的软件工程师
10-12 2531
11.5 平衡二叉树(AVL 树) 11.5.1 看一个案例(说明二叉排序树可能的问题) 给你一个数列{1,2,3,4,5,6}，要求创建一颗二叉排序树(BST), 并分析问题所在。 左边 BST 存在的问题分析: 左子树全部为空，从形式上看，更像一个单链表。 插入速度没有影响。 查询速度明显降低(因为需要依次比较), 不能发挥 BST的优势，因为每次还需要比较左子树，其查询速度比单链表还慢。 解决方案-平衡二叉树(AVL) 11.5.2 基本介绍 平衡二叉树也叫平衡二叉搜索树（Self-balan
AVL树Java语言实现
weixin_42111859的博客
01-21 357
AVL树理解、证明
数据结构与算法——AVL树的学习与java实现
l118
03-02 227
二叉平衡树 二叉平衡树又叫做AVL树，它继承了二叉搜索树的规则。 且每个节点的左子树和右子树的高度差最多差1。 二叉平衡树由于不会产生像二叉搜索树那样的极端情况，所以查找，删除(懒惰删除)的时间复杂度为o(logn)。插入操作需要对树作出调整，所以时间复杂度略高于o(logn)。 如下图所示：第一张图为AVL树，第二张图则不是AVL树 AVL树的旋转 插入操作需要满足AVL树的特性：每个节点的...
AVL树的实现
最新发布
Ryujianli的博客
05-11 617
AVL树
AVLTree.rar_avl_java avltree_tree
09-24
AVLTree.java文件应该包含了AVL树的实现，包括节点类的定义、插入、删除、旋转等核心功能。通过阅读和理解这个源代码，你可以深入学习AVL树的原理和操作，这对于理解和使用自平衡二叉查找树是非常有价值的。在实际...
AVLtree.zip_avl_avl java_avl tree_avltree_class A
09-19
AVL tree using node from data structure and algorithm java class, create a minimum AVL tree with minimum number of nodes at given high
03平衡二叉树_AVLTree.rar_03平衡二叉树_AVLTree_大话数据结构_平衡二叉树
09-21
在数据结构的学习中，理解并掌握AVL树的概念、特性以及操作是至关重要的。 平衡二叉树的概念： 平衡二叉树的主要目标是解决普通二叉搜索树可能产生的高度不平衡问题，以提高查找、插入和删除操作的效率。在AVL树中...
AVL树 之 Java的实现
Code-lover's Learning Notes
07-21 1721
AVL树的介绍AVL树是高度平衡的而二叉树。它的特点是：AVL树中任何节点的两个子树的高度最大差别为1。 上面的两张图片，左边的是AVL树，它的任何节点的两个子树的高度差别都<=1；而右边的不是AVL树，因为7的两颗子树的高度相差为2(以2为根节点的树的高度是3，而以8为根节点的树的高度是1)。AVL树的Java实现1. 节点1.1 节点定义public class AVLTree<T extend
Java Swing自定义观感（仅以自定义treeUI为例）
02-15
Java Swing自定义观感的一个小例子（仅以自定义treeUI为例）。仅仅举例如何实现java SWing自定义观感，并不完整，童鞋可以根据treeUI编写其他控件的UI。
AVL树【图示详解+代码实现】
smf12138的博客
08-23 2642
对AVL树这个较复杂的数据结构进行讲解，重点讲解了对AVL树的四种旋转操作，对于这四种旋转都做了非常详细的画图分析，并且对代码进行了实现，还有对于AVL树的验证代码及AVL树的性能分析也做了介绍.
玩转数据结构之Java实现AVL树
故不积跬步无以至千里
02-17 155
AVL树是一种高度平衡的二叉搜索树，即任意节点的左子树和右子树高度之差都不超过1；当一棵二叉搜索树进行增加或删除操作时，就有可能产生不平衡的情况。我们要做的就是在出现不平衡的状况时及时进行调整，让整棵树恢复平衡。具体实现方式为左旋转以及右旋转，详细请参考AVL树详解ღ( ´･ᴗ･` )
Java手写AVL树（非常详细）
fengxiandada的博客
04-08 2730
文章目录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
AVL树原理及实现（C语言实现以及Java语言实现）
weixin_30258027的博客
11-17 324
欢迎探讨，如有错误敬请指正 如需转载，请注明出处http://www.cnblogs.com/nullzx/ 1. AVL定义 AVL树是一种改进版的搜索二叉树。对于一般的搜索二叉树而言，如果数据恰好是按照从小到大的顺序或者从大到小的顺序插入的，那么搜索二叉树就对退化成链表，这个时候查找，插入和删除的时间都会上升到O(n)，而这对于海量数据而言，是我们无法忍受的。即使是一颗由完全随机的数据构造...
Java实现AVL的一系列操作
崔洪振367
11-01 1388
1、定义AVL（带有平衡条件的二叉查找树）的结构的定义 //定义平衡二叉树Avl的结构 public class AvlNode> { public AvlNode(T value){ this(value, null, null); } public AvlNode(T value, AvlNode lt, AvlNode rt){ data = value; left
AVL树的Java实现（递归方法）
火星日立的博客
12-18 628
AVL树是一种自平衡的二叉查找树。首先它是一种二叉查找树，满足任意一个节点(叶子节点除外)的值大于它左子树上任意一个节点，且小于它右子树上任意一个节点。因为二叉查找树的深度可能为O(N)，这样的效率较低，因此衍生出了AVL树，它具有自平衡的效果，能保持树的深度为O(logN)。AVL树满足：任意一个节点它的左子树的高度和右子树的高度差不超过1。（假设叶子节点的高度为0，null节点的高度为-1）
AVL树的 java 代码实现
CHOOOU的博客
07-16 564
代码public class AvlTree&lt;Type extends Comparable&lt;? super Type&gt;&gt;{ private static class AvlNode&lt;Type&gt; { private Type data; private int height; private AvlNode&lt;Type&gt; leftChild;
AVL树的Java实现
qq_51536995的博客
05-03 1299
AVL树的java实现
严蔚敏版数据结构与算法代码详解
在"数据结构算法代码（严蔚敏版）"这份资料中，包含了丰富的数据结构与算法相关的实现细节。内容覆盖了多个核心的数据结构概念和典型问题的解决方案。以下是一些关键知识点的概述： 1. **线性表的表示与实现**： -...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值