平衡树简介、AVL树详解及Java实现

最新推荐文章于 2023-05-05 01:00:00 发布
最新推荐文章于 2023-05-05 01:00:00 发布
阅读量417 收藏 1
点赞数
分类专栏： 数据结构与算法 文章标签： AVL树 平衡树 旋转 Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sc179/article/details/114009124
版权

目录

1 平衡树和AVL树

  1. 平衡树(Balance Tree，BT) ：任意节点的子树的高度差都小于等于1。常见的符合平衡树的有：B树（多路平衡搜索树）、AVL树（二叉平衡搜索树）等；
  2. AVL树：首先是一棵二叉搜索树，其次是高度平衡的二叉树，树中任意节点的两个子树的高度差都小于等于1；

在这里插入图片描述

2 结点

  1. AVLTree是AVL树对应的类，而AVLTreeNode是AVL树节点，它是AVLTree的内部类；

  2. AVLTree包含了AVL树的根节点，AVL树的基本操作也定义在AVLTree中；

  3. AVLTreeNode包括以下几部分:

    （1）key – 关键字，用来对AVL树的节点进行排序；
    （2）left – 左子结点；
    （3）right – 右子结点；
    （4）height – 高度；

3 旋转

  1. 在AVL树中进行插入或删除节点后，可能导致AVL树失去平衡；
  2. 失去平衡的可以概括为4种姿态：LL(左左)，LR(左右)，RL(右左)，RR(右右)；
  3. LL：也称左左，插入或删除一个结点后，根结点的左子树高度-右子树高度=2，且左子树的左子树高度-左子树的右子树高度=1；
  4. LR：也称左右，插入或删除一个结点后，根结点的左子树高度-右子树高度=2，且左子树的右子树高度-左子树的左子树高度=1；
  5. RL：也称右左，插入或删除一个结点后，根结点的右子树高度-左子树高度=2，且右子树的左子树高度-右子树的右子树高度=1；
  6. RR：也称右右，插入或删除一个结点后，根结点的右子树高度-左子树高度=2，且右子树的右子树高度-右子树的左子树高度=1；

在这里插入图片描述
在这里插入图片描述

3.1 LL的旋转

LL失去平衡的情况，可以通过一次右旋转让AVL树恢复平衡。如下图：

在这里插入图片描述

3.2 RR的旋转

RR失去平衡的情况，可以通过一次左旋转让AVL树恢复平衡。如下图：

在这里插入图片描述

3.3 LR的旋转

LR失去平衡的情况，需要经过两次旋转才能让AVL树恢复平衡，即一次左子节点的左旋转+一次右旋转。如下图：

在这里插入图片描述

3.4 RL的旋转

RL失去平衡的情况，需要经过两次旋转才能让AVL树恢复平衡，即一次右子节点的右旋转+一次左旋转。如下图：

在这里插入图片描述

4 完整代码

public class AVLTree<T extends Comparable<T>> {
    private AVLTreeNode<T> mRoot;    // 根结点

    // AVL树的节点(内部类)
    private class AVLTreeNode<T extends Comparable<T>> {
        T key; // 键值
        AVLTreeNode<T> left; // 左子结点
        AVLTreeNode<T> right; // 右子结点
        int height; // 高度

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

    // 获取AVL树高
    public int height() {
        return height(mRoot);
    }

    // 获取当前结点为根结点对应的树高
    private int height(AVLTreeNode<T> tree) {
        if (tree != null) {
            return tree.height;
        }
        return 0;
    }

    // 获取两值的最大值
    private int max(int a, int b) {
        return a > b ? a : b;
    }

    // 前序遍历AVL树
    public void preOrder() {
        preOrder(mRoot);
    }

    private void preOrder(AVLTreeNode<T> tree) {
        if(tree != null) {
            System.out.print(tree.key + " ");
            preOrder(tree.left);
            preOrder(tree.right);
        }
    }


    // 中序遍历AVL树
    public void inOrder() {
        inOrder(mRoot);
    }

    private void inOrder(AVLTreeNode<T> tree) {
        if(tree != null)
        {
            inOrder(tree.left);
            System.out.print(tree.key + " ");
            inOrder(tree.right);
        }
    }

    // 后序遍历AVL树
    public void postOrder() {
        postOrder(mRoot);
    }

    private void postOrder(AVLTreeNode<T> tree) {
        if(tree != null) {
            postOrder(tree.left);
            postOrder(tree.right);
            System.out.print(tree.key + " ");
        }
    }

    /*
     * (递归实现)查找"AVL树x"中键值为key的节点
     */
    public AVLTreeNode<T> recursiveSearch(T key) {
        return recursiveSearch(mRoot, key);
    }

    private AVLTreeNode<T> recursiveSearch(AVLTreeNode<T> x, T key) {
        if (x == null) {
            return null;
        }
        int cmp = key.compareTo(x.key);
        if (cmp < 0) {
            return recursiveSearch(x.left, key);
        }
        else if (cmp > 0) {
            return recursiveSearch(x.right, key);
        }
        else {
            return x;
        }
    }

    /*
     * (迭代实现)查找"AVL树x"中键值为key的节点
     */
    public AVLTreeNode<T> iterativeSearch(T key) {
        return iterativeSearch(mRoot, key);
    }

    private AVLTreeNode<T> iterativeSearch(AVLTreeNode<T> x, T key) {
        while (x!=null) {
            int cmp = key.compareTo(x.key);

            if (cmp < 0)
                x = x.left;
            else if (cmp > 0)
                x = x.right;
            else
                return x;
        }
        return x;
    }

    /*
     * 求最小结点的键值
     */
    public T minimum() {
        AVLTreeNode<T> p = minimum(mRoot);
        if (p != null)
            return p.key;
        return null;
    }

    private AVLTreeNode<T> minimum(AVLTreeNode<T> tree) {
        if (tree == null)
            return null;

        while(tree.left != null)
            tree = tree.left;
        return tree;
    }

    /*
     * 求最大结点的键值
     */
    public T maximum() {
        AVLTreeNode<T> p = maximum(mRoot);
        if (p != null)
            return p.key;

        return null;
    }

    private AVLTreeNode<T> maximum(AVLTreeNode<T> tree) {
        if (tree == null)
            return null;

        while(tree.right != null)
            tree = tree.right;
        return tree;
    }

    /*
     * LL：左左对应的情况(右旋转)。
     */
    private AVLTreeNode<T> leftLeftRotation(AVLTreeNode<T> k1) {
        AVLTreeNode<T> k2;

        k2 = k1.left;
        k1.left = k2.right;
        k2.right = k1;

        k1.height = max(height(k1.left), height(k1.right)) + 1;
        k2.height = max(height(k2.left), height(k2.right)) + 1;

        return k2;
    }

    /*
     * RR：右右对应的情况(左旋转)。
     */
    private AVLTreeNode<T> rightRightRotation(AVLTreeNode<T> k1) {
        AVLTreeNode<T> k2;

        k2 = k1.right;
        k1.right = k2.left;
        k2.left = k1;

        k1.height = max(height(k1.left), height(k1.right)) + 1;
        k2.height = max(height(k2.left), height(k2.right)) + 1;

        return k2;
    }

    /*
     * LR：左右对应的情况(先左子节点左旋后右旋)。
     */
    private AVLTreeNode<T> leftRightRotation(AVLTreeNode<T> k3) {
        k3.left = rightRightRotation(k3.left);

        return leftLeftRotation(k3);
    }

    /*
     * RL：右左对应的情况(先右子节点右旋后左旋)。
     */
    private AVLTreeNode<T> rightLeftRotation(AVLTreeNode<T> k1) {
        k1.right = leftLeftRotation(k1.right);

        return rightRightRotation(k1);
    }

    /*
     * 将新结点插入到AVL树中
     */
    public void insert(T key) {
        mRoot = insert(mRoot, key);
    }

    private AVLTreeNode<T> insert(AVLTreeNode<T> tree, T key) {
        if (tree == null) {
            // 新建节点
            tree = new AVLTreeNode<T>(key, null, null);
        } else {
            int cmp = key.compareTo(tree.key);

            if (cmp < 0) { // 将key插入到tree的左子树
                tree.left = insert(tree.left, key);
                // 插入节点后，若AVL树失去平衡，则进行相应的调节
                if (height(tree.left) - height(tree.right) == 2) {
                    if (key.compareTo(tree.left.key) < 0)
                        tree = leftLeftRotation(tree);
                    else
                        tree = leftRightRotation(tree);
                }
            }
            else if (cmp > 0) { // 将key插入到tree的右子树
                tree.right = insert(tree.right, key);
                // 插入节点后，若AVL树失去平衡，则进行相应的调节
                if (height(tree.right) - height(tree.left) == 2) {
                    if (key.compareTo(tree.right.key) > 0)
                        tree = rightRightRotation(tree);
                    else
                        tree = rightLeftRotation(tree);
                }
            }
            else { // cmp == 0
                System.out.println("添加失败：不允许添加相同的节点！");
            }
        }

        tree.height = max(height(tree.left), height(tree.right)) + 1;
        return tree;
    }


    /*
     * 删除键值为k的结点
     */
    public void remove(T key) {
        AVLTreeNode<T> z = recursiveSearch(mRoot, key);

        if (z != null)
            mRoot = remove(mRoot, z);
    }

    private AVLTreeNode<T> remove(AVLTreeNode<T> tree, AVLTreeNode<T> z) {
        int cmp = z.key.compareTo(tree.key);
        if (cmp < 0) { // 待删除的节点在"tree的左子树"中
            tree.left = remove(tree.left, z);
            // 删除节点后，若AVL树失去平衡，则进行相应的调节
            if (height(tree.right) - height(tree.left) == 2) {
                AVLTreeNode<T> r = tree.right;
                if (height(r.left) > height(r.right))
                    tree = rightLeftRotation(tree);
                else
                    tree = rightRightRotation(tree);
            }
        } else if (cmp > 0) { // 待删除的节点在"tree的右子树"中
            tree.right = remove(tree.right, z);
            // 删除节点后，若AVL树失去平衡，则进行相应的调节
            if (height(tree.left) - height(tree.right) == 2) {
                AVLTreeNode<T> l =  tree.left;
                if (height(l.right) > height(l.left))
                    tree = leftRightRotation(tree);
                else
                    tree = leftLeftRotation(tree);
            }
        } else { // tree是对应要删除的节点
            // tree的左右孩子都非空
            if ((tree.left!=null) && (tree.right!=null)) {
                if (height(tree.left) > height(tree.right)) {
                    // 如果tree的左子树比右子树高；
                    // 则(01)找出tree的左子树中的最大节点
                    //   (02)将该最大节点的值赋值给tree
                    //   (03)删除该最大节点
                    // 采用这种方式的好处是：删除"tree的左子树中最大节点"之后，AVL树仍然是平衡的
                    AVLTreeNode<T> max = maximum(tree.left);
                    tree.key = max.key;
                    tree.left = remove(tree.left, max);
                } else {
                    // 如果tree的左子树不比右子树高(即它们相等，或右子树比左子树高1)
                    // 则(01)找出tree的右子树中的最小节点
                    //   (02)将该最小节点的值赋值给tree
                    //   (03)删除该最小节点
                    // 采用这种方式的好处是：删除"tree的右子树中最小节点"之后，AVL树仍然是平衡的
                    AVLTreeNode<T> min = minimum(tree.right);
                    tree.key = min.key;
                    tree.right = remove(tree.right, min);
                }
            } else {
                tree = (tree.left!=null) ? tree.left : tree.right;
            }
        }

        return tree;
    }

    /*
     * 打印AVL树
     *
     * key        -- 节点的键值
     * direction  --  0，表示该节点是根节点;
     *               -1，表示该节点是它的父结点的左孩子;
     *                1，表示该节点是它的父结点的右孩子。
     */
    public void print() {
        if (mRoot != null)
            print(mRoot, mRoot.key, 0);
    }

    private void print(AVLTreeNode<T> tree, T key, int direction) {
        if(tree != null) {
            if(direction==0) // tree是根节点
                System.out.printf("%d is root\n", tree.key);
            else // tree是分支节点
                System.out.printf("%d is %d's %s child\n", tree.key, key, direction==1?"right" : "left");

            print(tree.left, tree.key, -1);
            print(tree.right,tree.key,  1);
        }
    }

    // 主函数
    public static void main(String[] args) {
        AVLTree<Integer> a = new AVLTree<>();
        a.insert(1);a.insert(2);a.insert(3);a.insert(4);a.insert(5);
//        a.remove(2);
//        a.remove(4);
        System.out.println(a.height());
        a.print();
    }
}

3
2 is root
1 is 2's left child
4 is 2's right child
3 is 4's left child
5 is 4's right child
hellosc01
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Java数据结构之AVL树详解
Java_LingFeng的博客
10-26 309
Java数据结构之AVL树详解 本篇文章给大家带来了关于java的相关知识，其中主要介绍了关于平衡二叉树（AVL树）的相关知识，AVL树本质上是带了平衡功能的二叉查找树，下面一起来看一下，希望对大家有帮助。
平衡二叉树详解及java代码的实现
01-19
平衡二叉树（Balanced Binary Tree）又被称为AVL树（有别于AVL算法），且具有以下性质：它是一 棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树（递归定义）的二叉排序树。...
avl树 java_平衡二叉树 AVL树结构详解 [Java实现]
weixin_34116482的博客
02-16 72
作者NeroJings来源https://blog.csdn.net/zhang6622056/article/details/82698859本文思维导图简述先不说平衡二叉树，我们单开来说，这样比较方便理解。先说二叉树，再说平衡条件，没那么多花里胡哨的理论，我只是想让大家看完能明白，能写出来。二叉树什么是二叉树？二叉树数据结构，顾名思义，只有两个叉，在数据结构中，操作性能要远高于线性结构，有O(...
红黑树理论详解与Java实现
渐宽阁读书小弟
05-05 800
红黑树理论详解与Java实现
AVL-平衡二叉查找树-详解及Java插入示例
DRD
10-30 394
AVL-平衡二叉查找树-详解及Java插入示例详解定义性质插入分析及效果图演示左左-左单旋转右右-右单旋转左右双旋转右左双旋转Java例子测试代码左单旋转-测试代码图示其他图示参考 由于AVL删除比较复杂，下面不进行详解。仅对AVL概念及插入进行详解 详解 定义 每个节点的左右子树的高度 最多 差1的二叉查找树。其中空树的高度为-1，单节点的高度为0。 性质 高度n的最少节点数为：a(n) =...
数据结构与算法——二叉平衡树(AVL树)详解
bigsai
08-25 7071
AVL树是带有平衡条件的二叉查找树(平衡二叉树)。这个平衡条件必须要`容易保持`。而且要保证它的深度是O(logN). AVL的条件是左右树的高度差（`平衡因子`）不大于1；并且它的每个子树也都是平衡二叉树。
AVL树【图示详解+代码实现】
smf12138的博客
08-23 2651
对AVL树这个较复杂的数据结构进行讲解，重点讲解了对AVL树的四种旋转操作，对于这四种旋转都做了非常详细的画图分析，并且对代码进行了实现，还有对于AVL树的验证代码及AVL树的性能分析也做了介绍.
平衡二叉树 AVL树结构详解 [Java实现]
csdn_subaodong的博客
11-21 168
package focus.zhishui.tree; import java.util.ArrayList; import java.util.List; /**  *  * Created by Nero on 2018-09-11.  */ public class AvlTreeInteger {     /***      * 遍历方式，      * 1-前序遍历      * 2-中...
B+树详解以及Java代码新增删除实现方式
weixin_43956454的博客
02-18 1789
数据结构模拟网址通俗的说的键是有序的,节点内部的键从左到右依次增大 ,B+树与B树的区别B+树具体信息均存放在叶节点、叶子节点形成一个链表。
数据结构[一] 平衡二叉树 AVL树结构详解 [Java实现]
zhang6622056的专栏
09-14 1107
博客思维导图 简述 先不说平衡二叉树，我们单开来说，这样比较方便理解。 先说二叉树，再说平衡条件，没那么多花里胡哨的理论，我只是想让大家看完能明白，能写出来 二叉树 什么是二叉树？二叉树数据结构，顾名思义，只有两个叉，在数据结构中，操作性能要远高于线性结构，有O(height)的索引性能。与线性结构有相同的空间复杂度,特性如下： 每个节...
BUC.rar_buc_buc算法_java实现BUC算法
09-19
在给定的描述中，BUC算法并未涉及标准模板库（STL），而是利用了自平衡二叉搜索树（AVL Tree）作为基础数据结构来实现其功能。AVL树是一种特殊的二叉搜索树，其特性是任意节点的两个子树的高度最大相差1，从而保证了...
二叉排序树详解.zip
最新发布
05-29
二叉排序树常用于实现自平衡的树结构，如AVL树和红黑树，它们通过旋转操作保持树的平衡，确保操作效率。 在实际应用中，二叉排序树可用于数据库索引、编译器符号表管理、优先队列等场景。例如，文档资料.docx可能...
2018京东java面试详解
01-05
* 平衡二叉树（AVL 树）：一种自平衡的二叉树，用于解决二叉查找树退化成链表的问题。 * B-树：一种平衡的多路查找树，在文件系统中很有用。 * B+树：是一种 B-树的变型树，用于文件系统中。 * 堆（heap）：一种...
深度学习java及其算法详解
09-05
树结构如二叉搜索树、平衡树（AVL树和红黑树）等，为高效查找和排序提供了基础。 然后，我们转向算法。算法是一系列解决问题的明确指令，是编程的灵魂。在这个资源中，你可能会遇到排序算法（如冒泡排序、快速排序...
四大算法思想：贪心，分治，回溯，动态规划
sc179的博客
12-06 8089
这里写目录标题1 贪心算法1.1 介绍1.2 案例（最短路径）2 分治算法2.1 介绍2.2 基本思想2.3 解题步骤2.4 应用场景2.5 分治与递归的联系2.6 案例（海量数据处理）2.6.1 题目要求2.6.2 解题思路3 回溯算法3.1 介绍3.2 解题步骤3.3 案例（八皇后问题）3.3.1 问题描述3.3.2 解题思路3.3.3 代码示例（Java）4 动态规划4.1 介绍4.2 应用场景 1 贪心算法 1.1 介绍 贪心算法（又称贪婪算法）是指，在对问题求解时，总是做出在当前看来是最好的选择
加权无向图与最小生成树（Prim算法和Kruskal算法）
sc179的博客
12-07 6075
0 引入 通过加权无向图结合最小生成树相关算法，可以解决最小成本问题，并找到最小成本对应的顶点和边。 1 图的最小生成树定义及相关约定 图的生成树：图的生成树是它的一个含有其所有顶点的无环连通子图。 图的最小生成树：图的权值（所有边的权重之和）最小的生成树。 约定：最小生成树只存在于连通图中，如果图不是连通的，那么分别计算每个连通子图的最小生成树，再合并到一起形成最小生成森林。 同时为了便于理解，约定所有边的权重都不相同。（如果有权重相同的边，最小生成树可能就不唯一了） 2 最小生成树原理 2.1 性
LeetCode_Database
sc179的博客
01-02 5608
1 大的国家 问题描述 +-----------------+------------+------------+--------------+---------------+ | name | continent | area | population | gdp | +-----------------+------------+------------+--------------+---------------+ | Afghanistan
有向图的定义及Java实现
sc179的博客
11-21 4876
目录1 定义2 相关术语3 Java实现 1 定义 在实际生活中，很多图都具有方向性，比如互联网，从A页面通过链接跳转到B页面，A和B的连接就有方向A->B，就需要使用有向图来表达。 定义：有向图是具有方向性的图，由一组顶点和一组有方向的边组成，每条方向的边都连着一对有序的顶点。 2 相关术语 出度：由某个顶点指出的边的个数； 入度：指向某个顶点的边的个数； 有向路径：由一系列顶点组成，其中的每个顶点都存在一条有向边，从它指向序列中的下一个顶点； 有向环：至少含有一条边，且起点和终点相同的有向路径
Java实现二叉平衡树：数据结构详解
二叉平衡树是Java数据结构中一种重要的数据结构，它在计算机科学与技术领域中扮演着关键角色。本章主要探讨了数据结构的基础概念，特别是针对Java编程环境下的应用。 1.1 数据结构的定义与作用 数据结构是计算机...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

hellosc01

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值