平衡二叉树

最新推荐文章于 2024-10-17 11:39:06 发布
最新推荐文章于 2024-10-17 11:39:06 发布
阅读量78 收藏
点赞数
分类专栏： 数据结构与算法 文章标签： 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_48776531/article/details/129762488
版权

章节目录：

一、相关概念

1.1 问题引出

  • 需求：给你一个数列{1,2,3,4,5,6}，要求创建一棵二叉排序树（BST）。

  • 存在问题分析：

    • 左子树全部为空，从形式上看，更像一个单链表。
    • 插入速度没有影响。
    • 查询速度明显降低（因为需要依次比较）, 不能发挥二叉排序树的优势，因为每次还需要比较左子树，其查询速度比单链表还慢。

  • 示意图：

在这里插入图片描述

  • 解决方案：使用平衡二叉树（AVL）。

1.2 基本介绍

  • 概念：平衡二叉树也叫平衡二叉搜索树（Self-balancing binary search tree）又被称为 AVL 树， 可以保证查询效率较高。

  • 特点：它是一棵空树或它的左右两个子树的高度差的绝对值不超过 1，并且左右两个子树都是一棵平衡二叉树。

  • 平衡二叉树的常用实现方法有红黑树、AVL、替罪羊树、Treap、伸展树等。

  • 示意图：

在这里插入图片描述

二、基本应用

2.1 左旋转

  • 需求：给你一个元素为{4,3,6,5,7,8}的数列，创建出对应的平衡二叉树。

  • 场景：假设我们有一棵二叉排序树（如下图），当你的右子树的高度比左子树高度要高的时候，我们需要通过左旋转的方式来降低右子树的高度，从而构建出平衡二叉树。

  • 示意图：

在这里插入图片描述

  • 代码示例：
    /**
     * 左旋转。
     */
    private void leftRotate() {

        // 1.以当前根节点的值，创建新的节点。
        Node newNode = new Node(this.getId());

        // 2.把新节点的左子树设置为当前节点的左子树。
        newNode.setLeft(this.getLeft());

        // 3.把新节点的右子树设置为当前节点的右子树的左子树。
        Node r = this.getRight();
        newNode.setRight(r.getLeft());

        // 4.把当前节点的值替换成右子节点的值。
        this.setId(r.getId());

        // 5.把当前节点的右子树设置成当前节点右子树的右子树。
        this.setRight(r.getRight());

        // 6.把当前节点的左子树设置成新的节点。
        this.setLeft(newNode);
    }

2.2 右旋转

  • 需求：给你一个元素为{10,12,8,9,7,6}的数列，创建出对应的平衡二叉树。

  • 与左旋转类似的，我们需要降低左子树高度时，就要进行右旋转操作。

  • 示意图：

在这里插入图片描述

  • 代码示例：
    /**
     * 右旋转。
     * 操作方式与左旋转相反。
     */
    private void rightRotate() {
        Node newNode = new Node(this.getId());
        newNode.setRight(this.getRight());
        Node l = this.getLeft();
        newNode.setLeft(l.getRight());
        this.setId(l.getId());
        this.setLeft(l.getLeft());
        this.setRight(newNode);
    }

2.3 双旋转

  • 前面的两个数列，进行单旋转（即一次旋转）就可以将非平衡二叉树转成平衡二叉树，但是在某些情况下，单旋转不能完成平衡二叉树的转换。
  • 单旋转问题分析-示意图：

在这里插入图片描述

  • 双旋转-示意图：

在这里插入图片描述

  • 代码示例：
    /**
     * 双旋转。
     */
    private void doubleRotate() {
        // 当添加完一个节点后，如果: (右子树的高度-左子树的高度) > 1 , 进行左旋转。
        if ((this.getRightHeight() - this.getLeftHeight()) > 1) {
            // 如果它的右子树的左子树的高度，大于它的右子树的右子树的高度。
            Node r = this.getRight();
            if (null != r && r.getLeftHeight() > r.getRightHeight()) {
                // 先对右子节点进行右旋转。
                r.rightRotate();
                // 然后再对当前节点进行左旋转。
                this.leftRotate();
            } else {
                // 否则，直接进行左旋转即可。
                this.leftRotate();
            }
            // 操作完成，退出。
            return;
        }

        // 与上一个操作相反。
        if ((this.getLeftHeight() - this.getRightHeight()) > 1) {
            Node l = this.getLeft();
            if (null != l && l.getRightHeight() > l.getLeftHeight()) {
                l.leftRotate();
                this.rightRotate();
            } else {
                this.rightRotate();
            }
        }
    }

三、完整代码

public class AVLTreeDemo {

    public static void main(String[] args) {

        // 数列。
        int[] arr = {10, 11, 7, 6, 8, 9};

        // 测试一：不使用双旋转添加。
        AVLTree noUseDoubleRotateTree = new AVLTree();
        for (int i : arr) {
            noUseDoubleRotateTree.add(new Node(i), false);
        }
        printTreeInfo(noUseDoubleRotateTree);
        System.out.println();
        // 中序遍历，结果如下：
        // 6、7、8、9、10、11
        // 树的总高度=[4],其中左子树高度=[3],右子树高度=[1],当前根节点=Node:{id:10}。

        System.out.println("-----------------------------");

        // 测试二：使用双旋转添加。
        AVLTree useDoubleRotateTree = new AVLTree();
        for (int i : arr) {
            // 添加时，开启双旋转操作。
            useDoubleRotateTree.add(new Node(i), true);
        }
        printTreeInfo(useDoubleRotateTree);
        System.out.println();
        // 中序遍历，结果如下：
        // 6、7、8、9、10、11
        // 树的总高度=[3],其中左子树高度=[2],右子树高度=[2],当前根节点=Node:{id:8}。
    }

    /**
     * 遍历打印节点及树的高度信息。
     *
     * @param avlTree 平衡二叉树
     */
    public static void printTreeInfo(AVLTree avlTree) {
        System.out.println("中序遍历，结果如下：");
        avlTree.infixOrder();
        Node root = avlTree.getRoot();
        System.out.printf(
                "树的总高度=[%d],其中左子树高度=[%d],右子树高度=[%d],当前根节点=%s。",
                root.getHeight(),
                root.getLeftHeight(),
                root.getRightHeight(),
                root
        );
    }
}


/**
 * 平衡二叉树。
 */
class AVLTree {

    private Node root;

    public Node getRoot() {
        return root;
    }

    public void setRoot(Node root) {
        this.root = root;
    }

    public void add(Node node, boolean useDoubleRotate) {
        if (null == this.getRoot()) {
            this.setRoot(node);
        } else {
            this.getRoot().add(node, useDoubleRotate);
        }
    }

    public void infixOrder() {
        if (null == this.getRoot()) {
            System.out.println("binary tree is null.");
        } else {
            this.getRoot().infixOrder();
        }
    }
}


/**
 * 节点。
 */
class Node {
    private int id;
    private Node left;
    private Node right;

    public Node(int id) {
        this.id = id;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public Node getLeft() {
        return left;
    }

    public void setLeft(Node left) {
        this.left = left;
    }

    public Node getRight() {
        return right;
    }

    public void setRight(Node right) {
        this.right = right;
    }

    @Override
    public String toString() {
        return "Node:{id:" + id + "}";
    }

    /**
     * 双旋转。
     *
     * @param use 决定是否使用双旋转（该参数仅仅是为了对比效果）。
     */
    private void doubleRotate(boolean use) {
        if (use) {
            // 当添加完一个节点后，如果: (右子树的高度-左子树的高度) > 1 , 进行左旋转。
            if ((this.getRightHeight() - this.getLeftHeight()) > 1) {
                // 如果它的右子树的左子树的高度，大于它的右子树的右子树的高度。
                Node r = this.getRight();
                if (null != r && r.getLeftHeight() > r.getRightHeight()) {
                    // 先对右子节点进行右旋转。
                    r.rightRotate();
                    // 然后再对当前节点进行左旋转。
                    this.leftRotate();
                } else {
                    // 否则，直接进行左旋转即可。
                    this.leftRotate();
                }
                // 操作完成，退出。
                return;
            }

            // 与上一个操作相反。
            if ((this.getLeftHeight() - this.getRightHeight()) > 1) {
                Node l = this.getLeft();
                if (null != l && l.getRightHeight() > l.getLeftHeight()) {
                    l.leftRotate();
                    this.rightRotate();
                } else {
                    this.rightRotate();
                }
            }
        }
    }

    /**
     * 左旋转。
     */
    private void leftRotate() {

        // 1.以当前根节点的值，创建新的节点。
        Node newNode = new Node(this.getId());

        // 2.把新节点的左子树设置为当前节点的左子树。
        newNode.setLeft(this.getLeft());

        // 3.把新节点的右子树设置为当前节点的右子树的左子树。
        Node r = this.getRight();
        newNode.setRight(r.getLeft());

        // 4.把当前节点的值替换成右子节点的值。
        this.setId(r.getId());

        // 5.把当前节点的右子树设置成当前节点右子树的右子树。
        this.setRight(r.getRight());

        // 6.把当前节点的左子树设置成新的节点。
        this.setLeft(newNode);
    }

    /**
     * 右旋转。
     * 操作方式与左旋转相反。
     */
    private void rightRotate() {
        Node newNode = new Node(this.getId());
        newNode.setRight(this.getRight());
        Node l = this.getLeft();
        newNode.setLeft(l.getRight());
        this.setId(l.getId());
        this.setLeft(l.getLeft());
        this.setRight(newNode);
    }

    /**
     * 得到左子树高度。
     *
     * @return int
     */
    public int getLeftHeight() {
        if (null == this.getLeft()) {
            return 0;
        } else {
            return this.getLeft().getHeight();
        }
    }

    /**
     * 得到右子树高度。
     *
     * @return int
     */
    public int getRightHeight() {
        if (null == this.getRight()) {
            return 0;
        } else {
            return this.getRight().getHeight();
        }
    }

    /**
     * 返回以该节点为根的树的高度。
     *
     * @return int
     */
    public int getHeight() {

        int leftMaxHeight;
        int rightMaxHeight;

        if (null == this.getLeft()) {
            leftMaxHeight = 0;
        } else {
            // 左子树递归获取高度。
            leftMaxHeight = this.getLeft().getHeight();
        }

        if (null == this.getRight()) {
            rightMaxHeight = 0;
        } else {
            // 右子树递归获取高度。
            rightMaxHeight = this.getRight().getHeight();
        }

        // 比较最大高度。
        return Math.max(leftMaxHeight, rightMaxHeight) + 1;
    }

    /**
     * 添加节点。
     *
     * @param node            节点
     * @param useDoubleRotate 是否使用双旋转
     */
    public void add(Node node, boolean useDoubleRotate) {

        if (null == node) {
            return;
        }

        // 判断传入的节点的值，和当前子树的根节点的值关系。
        if (this.getId() > node.getId()) {
            if (null == this.getLeft()) {
                this.setLeft(node);
            } else {
                // 左子树递归添加。
                this.getLeft().add(node, useDoubleRotate);
            }
        } else {
            if (null == this.getRight()) {
                this.setRight(node);
            } else {
                // 右子树递归添加。
                this.getRight().add(node, useDoubleRotate);
            }
        }

        // 双旋转。
        this.doubleRotate(useDoubleRotate);
    }

    /**
     * 中序遍历。
     */
    public void infixOrder() {
        if (null != this.getLeft()) {
            this.getLeft().infixOrder();
        }
        System.out.println(this);
        if (null != this.getRight()) {
            this.getRight().infixOrder();
        }
    }
}

四、结束语

“-------怕什么真理无穷,进一寸有一寸的欢喜。”

微信公众号搜索：饺子泡牛奶。

饺子泡牛奶
关注
专栏目录
数据结构与算法（一）：红黑树、B树与B+树
weixin_48922154的博客
08-17 385
文章目录1. AVL 树1.1 AVL 树的左单旋转1.2 AVL 树的右单旋转1.3 AVL 树的双旋转1.4 完整代码和测试2. 多叉树2.1 2-3 树2.2 B 树2.2 B+ 树2.2.1 B+ 树的插入2.2.2 B+ 树的删除3. 红黑树 1. AVL 树 平衡二叉搜索树（Self-balancing binary search tree）又被称为AVL树，可以保证查询效率，且具有以下性质： 它是一 棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。
【题集】AVL树、伸展树、红黑树、二叉查找树、替罪羊树的时间复杂度
王博（Kings）的博客
07-18 6528
目录 1. AVL树 2.伸展树 3.红黑树 4.二叉查找树 5.替罪羊树 1. AVL树 AVL树是最先发明的自平衡二叉查找树。在AVL树中任何节点的两个子树的高度最大差别为一，所以它也被称为高度平衡树。查找、插入和删除在平均和最坏情况下都是O(log n)。 2.伸展树 伸展树(Splay Tree)，也叫分裂树，是一种二叉排序树，它能在O(log n)内完成插入、查找...
数据结构学习笔记：B树、B+树、红黑树、AVL树
庚午步雲
09-15 830
B树、B+树、红黑树、AVL树
平衡二叉树详解 通俗易懂
热门推荐
半亩方糖
01-10 13万+
平衡二叉树（AVL） 阅读之前请先了解 二叉搜索树 平衡二叉树定义：任意节点的子树的高度差都小于等于 1 1. 为什么使用「平衡二叉树」 二叉树能提高查询的效率 O(logn)，但是当你插入 {1,2,3,4,5,6} 这种数据的时候，你的二叉树就像一个「链表」一样，搜索效率变为 O(n) 于是在 1962 年，一个姓 AV 的大佬（G. M. Adelson-Velsky） 和一个姓 L 的大佬（ Evgenii Landis）提出「平衡二叉树」（AVL） 。 于是插入 {1,2,3,4,5,6}
数据结构之——平衡二叉树（内容详解）
m0_37914588的博客
12-29 5万+
一、基本概念 平衡二叉树也叫AVL树，它或者是一颗空树，或者具有以下性质的二叉排序树：它的左子树和左子树的高度之差(平衡因子)的绝对值不超过1，且它的左子树和右子树都是一颗平衡二叉树。 二、结构 如基本概念所树，它具有一个左子树和一个左子树，且对于任意一个子树而言，左子树和右子树高度只差不超过1. 2.1 平衡二叉树判别 如下有3棵树，分别判断下哪个是平衡二叉树？ 图1： 图2：...
平衡二叉树详解
尽量致力于发表微服务、中间件和算法等原创作品。
06-17 4万+
平衡二叉树（Balanced Binary Tree）又被称为AVL树（有别于AVL算法），且具有以下性质：它是一 棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。这个方案很好的解决了二叉查找树退化成链表的问题，把插入，查找，删除的时间复杂度最好情况和最坏情况都维持在O(logN)。但是频繁旋转会使插入和删除牺牲掉O(logN)左右的时间，不过相对二叉查找树来说，时间上稳定了很多。 平衡二叉树大部分操作和二叉查找树类似，主要不同在于插入删除的时候平衡二叉树的平衡可
平衡二叉树时间复杂度计算1
08-08
"平衡二叉树时间复杂度计算1" 在计算机科学中，平衡二叉树是一种特殊的二叉树数据结构，它的时间复杂度计算是非常重要的。下面我们将详细介绍平衡二叉树的时间复杂度计算。 首先，让我们了解什么是平衡二叉树。...
c++实现平衡二叉树管理的学生管理系统项目
07-02
1. 完成 学生, 课程,选课,成绩 的增删改查 学生ID 学生名 选课名 成绩 001 张三 C++ 60 ...1.采用平衡二叉树的可靠管理，源码规范，文档齐备：80分 2.采用动态数组的可靠管理，源码规范，文档齐备：60分
平衡二叉树的左右旋以及双旋转的图文详解
08-26
平衡二叉树是一种特殊的二叉搜索树，它的主要特性是左右子树的高度差不超过1，这使得在平衡二叉树中的查找、插入和删除操作的时间复杂度都能保持在O(log n)。平衡二叉树的一个典型代表是AVL树，它在插入新节点后可能...
生成平衡二叉树.cpp_C++_二叉树_数据结构_
10-01
本话题将深入探讨“生成平衡二叉树”的概念，以及如何使用C++语言实现这一过程。平衡二叉树，如AVL树或红黑树，确保了树的高度平衡，从而在查找、插入和删除操作中保持较高的效率。 首先，我们需要了解平衡二叉树的...
Javascript算法——双指针法移除元素、数组去重、比较含退格字符、有序数组平方
最新发布
警警的博客
10-17 459
暴力求解法（两层for循环）,length单词拼写错误❌二次嵌套for的length设置。return位置❌ ,核心基础。双指针法（一层for循环）
【文档智能】文本文字识别、公式识别、表格文字识别核心算法及思路及实践-DBNet、CRNN、TrOCR
余俊晖，NLP炼丹师，目前专注自然语言处理领域研究。曾获得国内外自然语言处理算法竞赛TOP奖项近二十项。
10-13 1413
OCR技术作为文档智能解析链路中的核心组件之一，贯穿整个技术链路，包括：文字识别、表格文字识别、公式识别，参看下面这张架构图：前期介绍了很多关于文档智能解析相关核心技术及思路，本着连载的目的，本次迎来介绍整个链路中的最后一块拼图-OCR。本文简要介绍OCR常见落地的算法模型-DBNet、CRNN，并基于这两个模型，简单介绍文字识别在表格识别中参与的角色；并且额外介绍TrOCR这个端到端的模型，基于这个模型引入公式识别解析的思路及微调方法。
【算法】双指针
2303_80828380的博客
10-13 811
力扣oj题之双指针算法
C++中的vector介绍（常用函数）
zxybf_的博客
10-15 883
vector的文档介绍vector是序列容器，表示可以改变大小的数组。(constructor)构造函数声明接口说明vector()（重点）无参构造构造并初始化n个val（重点）拷贝构造使用迭代器进行初始化构造int main()//无参的构造//n个val的构造//拷贝构造//迭代器区间构造return 0;
在顺序结构和链式结构的线性表上实现顺序检索算法
m0_56332819的博客
10-13 326
在顺序结构和链式结构的线性表上实现顺序检索算法，C语言
Python 使用 Jarvis 算法或包装的凸包（Convex Hull using Jarvis’ Algorithm or Wrapping）
csdn_aspnet的专栏
10-14 1234
例如，当输入 (0, 3), (0, 0), (0, 1), (3, 0), (3, 3) 时，它产生 (0, 3) (0, 0) (3, 0) (3, 3) 的输出；当输入 (0, 3), (0, 1), (0, 0), (3, 0), (3, 3) 时，输出为 (0, 3) (0, 1) (0, 0) (3, 0) (3, 3)。下一个点被选为在逆时针方向上领先于所有其他点的点，即，如果对于任何其他点 r，我们有“orientation(p, q, r) = 逆时针”，则下一个点是 q。
力扣10.13
qq_40052678的博客
10-13 477
如果鸡蛋碎了，你就不能再次使用它。如果某枚鸡蛋扔下后没有摔碎，则可以在之后的操作中 重复使用 这枚鸡蛋。每次操作，你可以取一枚 没有碎 的鸡蛋并把它从任一楼层。，以此类推，因此只需要判断最后的层数是否超过建筑高即可。楼层或比它低 的楼层落下的鸡蛋都 不会碎。函数传入操作次数k，可以发现，最优情况一定先在。确切的值 的 最小操作次数 是多少？的楼层落下的鸡蛋都 会碎 ，从。枚相同 的鸡蛋，和一栋从第。请你计算并返回要确定。
平衡二叉树的插入与操作
"平衡二叉树的实现与操作" 平衡二叉树是一种特殊的二叉树数据结构，它的左右两个子树的高度差不超过1，并且左右两个子树都是一棵平衡二叉树。这种结构保证了在进行查找、插入和删除等操作时能够保持较高的效率，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值