数据结构(三)----平衡二叉树

最新推荐文章于 2024-06-10 20:39:17 发布
最新推荐文章于 2024-06-10 20:39:17 发布
阅读量280 收藏 2
点赞数 1
分类专栏： 数据结构与算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45690436/article/details/109988508
版权
  • 平衡二叉树 又叫AVL树

1. 性质 :

  • 可以是空树
  • 任意一个节点的左子树和右子树都是平衡二叉树 且高度之差的绝对值 <=1
    在这里插入图片描述

2.失衡的4种情况

  • 在结点的左子树的左子树插入元素,LL 插入；
  • 在结点的左子树的右子树插入元素,LR 插入；
  • 在结点的右子树的左子树插入元素,RL 插入；
  • 在结点的右子树的右子树插入元素,RR 插入;
    在这里插入图片描述

3.解决方法 代码实现

  • 定义节点类和一些基本方法
public class AVLTree {
    //当前树
    private AvlNode tree;

    //获取节点高度
    public int hight(AvlNode node) {
        return node == null ? 0 : node.hight;
    }

    //获取树的高度
    public int hight() {
        return hight(tree);
    }

    //获取高度最大值
    private int getMaxHeight(int height1, int height2) {
        return height1 > height2 ? height1 : height2;
    }

    /**
     * 中序遍历
     * 先打印左子树
     * 然后打印自身
     * 最后打印右子树
     * @param node
     */
    public void inOrder(AvlNode node){
        if(node == null ){
            return;
        }
        inOrder(node.left);
        System.out.print(node.getValue()+"->");
        inOrder(node.right);
    }

    /**
     * 前序遍历
     * 先打印自身
     * 然后打印左子树
     * 最后打印右子树
     * @param node
     */
    public void preOrder(AvlNode node){
        if(node == null){
            return;
        }
        System.out.print(node.getValue()+"->");
        preOrder(node.left);
        preOrder(node.right);
    }
    /**
     * 后续遍历
     * 先打印左子树
     * 然后打印右子树
     * 最后打印自身
     * @param node
     */
    public void postOrder(AvlNode node){
        if(node == null){
            return;
        }
        postOrder(node.left);
        postOrder(node.right);
        System.out.print(node.getValue()+"->");
    }

    //avl树节点类
    private static class AvlNode {
        private int value;
        private AvlNode left;
        private AvlNode right;
        private int hight;//定义节点高度

        public AvlNode(int value, AvlNode left, AvlNode right, int hight) {
            this.value = value;
            this.left = left;
            this.right = right;
            this.hight = hight;
        }

        public AvlNode(int value, AvlNode left, AvlNode right) {
            this(value, left, right, 0);
        }

        public int getValue() {
            return value;
        }

        public void setValue(int value) {
            this.value = value;
        }

        public AvlNode getLeft() {
            return left;
        }

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

        public AvlNode getRight() {
            return right;
        }

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

        public int getHight() {
            return hight;
        }

        public void setHight(int hight) {
            this.hight = hight;
        }
    }
}
3.1**LL : 左左旋转 **

在这里插入图片描述

/**
     * LL
     *
     * @param node 失衡节点
     * @return 左旋后的根节点
     */
    public AvlNode llRotaing(AvlNode node) {
        AvlNode avl_lift = node.left;//失衡节点的左子树节点 旋转后的根节点
        //把失衡节点左子树的右子树节点挂到失衡节点的左子树上
        node.left = avl_lift.right;
        //把失衡节点作为该节点左子树的右子树
        avl_lift.right = node;
        //重新计算失衡节点和失衡节点左子树(即旋转后的根节点)旋转后的节点高度
        node.hight = getMaxHeight(hight(node.left), hight(node.right)) + 1;
        avl_lift.hight = getMaxHeight(hight(avl_lift.left), hight(avl_lift.right)) + 1;//得到左子树和右子树中最大的高度 + 1
        return avl_lift;
    }
3.2RR 右右旋转

在这里插入图片描述

 /**
     * RR
     *
     * @param node 失衡节点
     * @return 右旋后的根节点
     */
    public AvlNode rrRotaing(AvlNode node) {
        AvlNode avl_right = node.right;//失衡节点的右子树节点 旋转后的根节点
        //把失衡节点右子树的左子树节点挂到失衡节点的右子树上
        node.right = avl_right.left;
        //把失衡节点作为该节点右子树的左子树
        avl_right.left = node;
        //重新计算失衡节点和失衡节点右子树(即旋转后的根节点)旋转后的节点高度
        node.hight = getMaxHeight(hight(node.left), hight(node.right)) + 1;
        avl_right.hight = getMaxHeight(hight(avl_right.left), hight(avl_right.right)) + 1;//得到左子树和右子树中最大的高度 + 1
        return avl_right;
    }
3.3 LR 左右旋转

在这里插入图片描述

    /**
     * LR
     *  1. 先把失衡节点的左子树做一次rr旋转
     *  2. 把该数做一次ll旋转
     * @param node 失衡节点
     * @return
     */
    public AvlNode lrRotaing(AvlNode node){
        node.left = rrRotaing(node.left);
        AvlNode avlNode = llRotaing(node);
        return avlNode;
    }
3.4RL 右左旋转

在这里插入图片描述

    /**
     * RL
     *  1. 先把失衡节点的右子树做一次ll旋转
     *  2. 把该数做一次rr旋转
     * @param node 失衡节点
     * @return
     */
    public AvlNode rlRotaing(AvlNode node){
        node.right = llRotaing(node.right);
        AvlNode avlNode = rrRotaing(node);
        return avlNode;
    }
3.5 添加方法
    /**
     * 添加方法
     *
     * @param value
     */
    public void insert(int value){
        this.tree = insert(tree,value);
    }

    private AvlNode insert(AvlNode node,int value){
        AvlNode p;//最左边或者最右边的节点  用于判断数是RR RL LL LR的那种失衡
        if (node == null){
            node = createNode(value,0);
        }else {
            if (value > node.value){
                node.right = insert(node.right, value);
                if (Math.abs(hight(node.right) - hight(node.left)) > 1) {//失衡类型为 RR or RL
                    p = node;
                    while (p.right != null){
                        p = p.right;
                    }
                    if (value == p.value) {//说明是RR
                        node = rrRotaing(node);
                    } else {
                        node = rlRotaing(node);
                    }
                }
            }else if (value < node.value){
                node.left = insert(node.left,  value);
                if (Math.abs(hight(node.right) - hight(node.left)) > 1) {//失衡类型为 LL or LR
                    p = node;
                    while (p.left != null){
                        p = p.left;
                    }
                    if (value == p.value) {//说明是LL
                        node = llRotaing(node);
                    } else {//否则为LR
                        node = lrRotaing(node);
                    }
                }
            }
        }
        node.hight = getMaxHeight(hight(node.left), hight(node.right)) + 1;
        return node;
    }
3.5 断点测试
    public static void main(String[] args) {
        AVLTree avlTree = new AVLTree();
        avlTree.insert(10);
        avlTree.insert(8);
        avlTree.insert(3);
        avlTree.insert(12);
        avlTree.insert(9);
        avlTree.insert(4);
        avlTree.insert(5);
        avlTree.insert(7);
        avlTree.insert(1);
        avlTree.insert(11);
        avlTree.insert(17);

    }

4.完整代码

public class AVLTree {

    public static void main(String[] args) {
        AVLTree avlTree = new AVLTree();
        avlTree.insert(10);
        avlTree.insert(8);
        avlTree.insert(3);
        avlTree.insert(12);
        avlTree.insert(9);
        avlTree.insert(4);
        avlTree.insert(5);
        avlTree.insert(7);
        avlTree.insert(1);
        avlTree.insert(11);
        avlTree.insert(17);

    }

    //根节点
    private AvlNode tree;

    private int i;

    /**
     * 添加方法
     *
     * @param value
     */
    public void insert(int value){
        this.tree = insert(tree,value);
    }

    private AvlNode insert(AvlNode node,int value){
        AvlNode p;
        if (node == null){
            node = createNode(value,0);
        }else {
            if (value > node.value){
                node.right = insert(node.right, value);
                if (Math.abs(hight(node.right) - hight(node.left)) > 1) {//失衡类型为 RR or RL
                    p = node;
                    while (p.right != null){
                        p = p.right;
                    }
                    if (value == p.value) {//说明是RR
                        node = rrRotaing(node);
                    } else {
                        node = rlRotaing(node);
                    }
                }
            }else if (value < node.value){
                node.left = insert(node.left,  value);
                if (Math.abs(hight(node.right) - hight(node.left)) > 1) {//失衡类型为 LL or LR
                    p = node;
                    while (p.left != null){
                        p = p.left;
                    }
                    if (value == p.value) {//说明是LL
                        node = llRotaing(node);
                    } else {//否则为LR
                        node = lrRotaing(node);
                    }
                }
            }
        }
        node.hight = getMaxHeight(hight(node.left), hight(node.right)) + 1;
        return node;
    }


    /**
     * LL
     *
     * @param node 失衡节点
     * @return 左旋后的根节点
     */
    public AvlNode llRotaing(AvlNode node) {
        AvlNode avl_lift = node.left;//失衡节点的左子树节点 旋转后的根节点
        //把失衡节点左子树的右子树节点挂到失衡节点的左子树上
        node.left = avl_lift.right;
        //把失衡节点作为该节点左子树的右子树
        avl_lift.right = node;
        //重新计算失衡节点和失衡节点左子树(即旋转后的根节点)旋转后的节点高度
        node.hight = getMaxHeight(hight(node.left), hight(node.right)) + 1;
        avl_lift.hight = getMaxHeight(hight(avl_lift.left), hight(avl_lift.right)) + 1;//得到左子树和右子树中最大的高度 + 1
        return avl_lift;
    }

    /**
     * RR
     *
     * @param node 失衡节点
     * @return 右旋后的根节点
     */
    public AvlNode rrRotaing(AvlNode node) {
        AvlNode avl_right = node.right;//失衡节点的右子树节点 旋转后的根节点
        //把失衡节点右子树的左子树节点挂到失衡节点的右子树上
        node.right = avl_right.left;
        //把失衡节点作为该节点右子树的左子树
        avl_right.left = node;
        //重新计算失衡节点和失衡节点右子树(即旋转后的根节点)旋转后的节点高度
        node.hight = getMaxHeight(hight(node.left), hight(node.right)) + 1;
        avl_right.hight = getMaxHeight(hight(avl_right.left), hight(avl_right.right)) + 1;//得到左子树和右子树中最大的高度 + 1
        return avl_right;
    }

    /**
     * LR
     * 1. 先把失衡节点的左子树做一次rr旋转
     * 2. 把该数做一次ll旋转
     *
     * @param node 失衡节点
     * @return
     */
    public AvlNode lrRotaing(AvlNode node) {
        node.left = rrRotaing(node.left);
        AvlNode avlNode = llRotaing(node);
        return avlNode;
    }

    /**
     * RL
     * 1. 先把失衡节点的右子树做一次ll旋转
     * 2. 把该数做一次rr旋转
     *
     * @param node 失衡节点
     * @return
     */
    public AvlNode rlRotaing(AvlNode node) {
        node.right = llRotaing(node.right);
        AvlNode avlNode = rrRotaing(node);
        return avlNode;
    }

    //获取节点高度
    public int hight(AvlNode node) {
        return node == null ? 0 : node.hight;
    }

    //获取树的高度
    public int hight() {
        return hight(tree);
    }

    //获取高度最大值
    private int getMaxHeight(int height1, int height2) {
        return height1 > height2 ? height1 : height2;
    }

    /**
     * 中序遍历
     * 先打印左子树
     * 然后打印自身
     * 最后打印右子树
     *
     * @param node
     */
    public void inOrder(AvlNode node) {
        if (node == null) {
            return;
        }
        inOrder(node.left);
        System.out.print(node.getValue() + "->");
        inOrder(node.right);
    }

    /**
     * 前序遍历
     * 先打印自身
     * 然后打印左子树
     * 最后打印右子树
     *
     * @param node
     */
    public void preOrder(AvlNode node) {
        if (node == null) {
            return;
        }
        System.out.print(node.getValue() + "->");
        preOrder(node.left);
        preOrder(node.right);
    }

    /**
     * 后续遍历
     * 先打印左子树
     * 然后打印右子树
     * 最后打印自身
     *
     * @param node
     */
    public void postOrder(AvlNode node) {
        if (node == null) {
            return;
        }
        postOrder(node.left);
        postOrder(node.right);
        System.out.print(node.getValue() + "->");
    }

    public static AvlNode createNode(int value, AvlNode left, AvlNode right, int hight) {
        return new AvlNode(value, left, right, hight);
    }

    public static AvlNode createNode(int value, int hight) {
        return new AvlNode(value, null, null, hight);
    }

    public static AvlNode createNode(int value, AvlNode left, AvlNode right) {
        return new AvlNode(value, left, right);
    }

    public static AvlNode createNode(int value) {
        return new AvlNode(value, null, null);
    }

    //avl树节点类
    private static class AvlNode {
        private int value;
        private AvlNode left;
        private AvlNode right;
        private int hight;//定义节点高度

        public AvlNode(int value, AvlNode left, AvlNode right, int hight) {
            this.value = value;
            this.left = left;
            this.right = right;
            this.hight = hight;
        }

        public AvlNode(int value, AvlNode left, AvlNode right) {
            this(value, left, right, 0);
        }

        public int getValue() {
            return value;
        }

        public void setValue(int value) {
            this.value = value;
        }

        public AvlNode getLeft() {
            return left;
        }

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

        public AvlNode getRight() {
            return right;
        }

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

        public int getHight() {
            return hight;
        }

        public void setHight(int hight) {
            this.hight = hight;
        }
    }
}
@沐帆
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
详解AVL树（平衡二叉树）
水澹澹兮生烟
09-20 2万+
插入节点后对树进行旋转调整，分为四种情况。 1.右单旋 当一个平衡二叉树满足具有较高左子树时（如下图A），且要插入的节点插入到了较高左子树的左侧，此时进行右单旋。
AVL树（动图详解）
2021dragon的博客
12-02 1万+
AVL树（C++实现）
【数据结构】AVL树（平衡二叉树）
最新发布
liuty0125的博客
06-10 1138
AVL树是一个平衡的二叉搜索树，它的每个节点的左右子树高度差的绝对值不超过1，因此，哪怕最坏也只是查找高度次，保证了查询时高效的时间复杂度O(log_n)。 但是它的缺陷也很明显：如果我们要对AVL树做一些修改方面的操作时，它的性能就十分低了，因为在修改时我们还要维护它的绝对平衡，旋转的次数比较多，而且在删除时，最坏情况可能会更新到根节点。 所以，如果只是需要一种查询高效且有序的数据结构，且数据个数为静态（不改变），比较适合AVL树，但如果你需要经常修改的话，AVL树可能就不太适合了
数据结构--AVL树（全）
weixin_48560325的博客
05-01 8753
目录 什么是AVL树？ AVL树的特点及形成原因 二叉搜索树基本概念 二叉搜索的特点 二叉搜索树的优点及缺点 改进的二叉搜索树——AVL树 AVL树的定义 AVL树的特点 结点的平衡因子balance 构建一个AVL树 构建一个AVL树的节点 什么是AVL树？ AVL树是最先发明的自平衡二叉查找树。在AVL树中任何节点的两个子树的高度最大差别为1，所以它也被称为高度平衡树。增加和删除可能需要通过一次或多次树旋转来重新平衡这个树。 AVL树的特点及形成原因 AVL树本质.
AVL树详解
夜槿笙歌的博客
06-05 5497
二叉搜索树有了经典的二叉搜索树做铺垫，我们就可以正式开始讲解由它衍生出的几种改进的二叉搜索树结构。首先是AVL树，也就是我们常说的平衡二叉树。从名字就可以看出，AVL树是一种高度平衡的二叉搜索树，即任意节点的左子树和右子树高度之差都不超过1。那么我们为什么要让一棵二叉搜索树尽量平衡呢？我们假设现在有一组输入数据[1,2,3,4,5]，按照先前的插入逻辑，就会形成如下结构的二叉树：这棵树的高度和它的元素个数是一致的，因为二叉搜索树各种操作所消耗的时间与其高度密切相关，因此这棵树所形成的的结构显然不是我们想看到
数据结构（高阶）—— AVL树
M的博客
11-25 1229
高阶数据结构——AVL树
数据结构--二叉树--思维导图.pdf
08-29
"数据结构--二叉树--思维导图" 二叉树是一种常见的数据结构，它是一种树形结构，每个节点最多有两个孩子节点，分别是左子树和右子树。二叉树可以用来存储大量数据，并且可以快速地查找、插入和删除数据。 二叉树的...
数据结构-二叉树相关功能及算法
06-11
二叉树是数据结构中的重要概念，它是一种特殊的树形数据结构，每个节点最多有两个子节点，通常称为左子节点和右子节点。在计算机科学中，二叉树的应用广泛，涉及搜索、排序、编译器设计等多个领域。本主题将深入探讨...
广工数据结构实验课程设计-平衡二叉树的演示
12-18
广工数据结构课程设计——平衡二叉树操作的演示 内含源代码、可执行程序以及相应的说明文档 实验的功能包括： [实现提示] (1) 初始，平衡二叉树为空树，操作界面给出查找、插入和删除三种操作供选择。每种操作均要...
2015广工数据结构实验--平衡二叉树(包含源码和实验报告
01-07
平衡二叉树（Balanced Binary Tree）是数据结构中的一个重要概念，尤其在算法设计和数据库系统中发挥着关键作用。本实验是针对广东工业大学（简称“广工”）学生的一次数据结构课程实践，旨在让学生深入理解平衡...
平衡二叉树-精简.cpp
04-09
个人手写的平衡二叉树。仅供参考，可以直接运行。
【数据结构】AVL树
Hello_World_213的博客
11-07 1255
数据结构 -- AVL树详解与代码实现: 更新平衡因子+四种旋转, 检验AVL树, 以及AVL树的效率
AVL树简介
小白的博客
02-24 1万+
一、AVL树简介 AVL树的名字来源于它的发明作者G.M. Adelson-Velsky 和 E.M. Landis。AVL树是最先发明的自平衡二叉查找树（Self-Balancing Binary Search Tree,简称平衡二叉树）。 平衡二叉树定义(AVL)：它或者是一颗空树，或者具有以下性质的二叉排序树：它的左子树和右子树的深度之差(平衡因子)的绝对值不超过1，且它的左子树和右子树都是...
数据结构:AVL树详解(平衡二叉树)
机会是给有准备的人
11-11 3058
假如以 parent 为根的子树不平衡，即 parent 的平衡因子为2或者-2，分以下情况考虑parent的平衡因子为2，说明parent的右子树高，设parent的右子树的根为subR当subR的平衡因子为1时，执行左单旋当subR的平衡因子为-1时，执行右左双旋parent的平衡因子为-2，说明parent的左子树高，设parent的左子树的根为subL当subL的平衡因子为-1是，执行右单旋当subL的平衡因子为1时，执行左右双旋。
详细图文——AVL树
热门推荐
带翅膀的猫的博客
04-09 12万+
平衡二叉搜索树（Self-balancing binary search tree）又被称为AVL树（有别于AVL算法），且具有以下性质：它是一 棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。快来学习吧！详细图文。
高度平衡二叉搜索树（AVLTree）
qq_49613557的博客
11-15 3549
高度平衡搜索二叉树（AVLTree） 目录AVL树的概念AVL树节点的定义AVL树的插入AVL树的旋转右单旋左单旋左右双旋右左双旋 AVL树的概念 二叉搜索树虽可以缩短查找的效率，但如果数据有序或接近有序二叉搜索树将退化为单支树，查找元素相当于在顺序表中搜索元素，效率低下。因此，两位俄罗斯的数学家G.M.Adelson-Velskii和E.M.Landis在1962年发明了一种解决上述问题的方法：当向二叉搜索树中插入新结点后，如果能保证每个结点的左右子树高度之差的绝对值不超过1(需要对树中的结点进行调整)，
详解AVL树，图文并茂
qq_52906742的博客
08-18 969
如果搜索树的高度总是O(logN)O(log_N)O(logN​),我们就能保证查找、插入和删除的时间为O(logN)O(log_N)O(logN​),最坏情况下的高度为O(logN)O(log_N)O(logN​)的树称为平衡树。比较流行的一种平衡树是AVL树，AVL树得名于它的发明者和。还有一种比较出名的平衡树叫红黑树，map和set的底层实现就是红黑树，后面会出一篇博客专门讲红黑树。.........
史上最详细的AVL树（含代码实现）
qq_56999918的博客
02-01 1万+
1.AVL树的相关概念 二叉搜索树在一定程度上可以提高搜索效率，但是当序列是有序时：如果所示 此时二叉搜索树退化成单链表，搜索效率退化为O（N)。为了解决这个问题科学家引入了AVL树，又称平衡搜索二叉树 AVL简称平衡二叉树。由前苏联的数学家 Adelse-Velskil 和Landis 在 1962 年提出的高度平衡的二叉树，根据科学家的英文名也称为 AVL 树。它具有如下几个性质： 可以是空树。 假如不是空树，任何一个结点的左子树与右子树都是平衡二叉树，并且高度之差的绝值不超过...
AVL树
qq_47406941的博客
05-26 1万+
一、AVL树的概念 1、什么是AVL树？ 当数据有序或者接近有序时，使用二叉搜索树进行存储时，得到的二叉搜索树是一颗单支树，其搜索的时间复杂度为O(N)。 为了解决上述问题，引入了AVL树的概念： AVL树是一颗特殊的二叉搜索树 向AVL树中插入一个节点后，树的所有节点的左右孩子节点的高度差的绝对值小于等于1. 即AVL树是一颗二叉搜索树是，它的左右子子树的高度之差（平衡因子）的绝对值不大于1，并且它的左右子树也是一颗AVL树。 2、AVL树的节点定义 template<cla

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值