[ 数据结构 ] 平衡二叉树(AVL)--------左旋、右旋、双旋

最新推荐文章于 2024-07-10 21:00:44 发布
最新推荐文章于 2024-07-10 21:00:44 发布
阅读量2k 收藏 4
点赞数 1
分类专栏： 数据结构与算法 文章标签： 数据结构 java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jason_bone_/article/details/128612600
版权
文章讲述了如何构建二叉排序树，并讨论了当树失去平衡时查询效率下降的问题。为了解决这个问题，文章介绍了平衡二叉树的概念，特别是AVL树，以及如何通过左旋、右旋和双旋操作来保持树的平衡，从而确保高效的查询性能。示例代码展示了如何在插入节点后进行旋转操作以维护AVL树的平衡。
摘要由CSDN通过智能技术生成

0 引出

数列{1,2,3,4,5,6}，要求创建一颗二叉排序树(BST), 并分析问题所在 回顾:二叉搜索树

image-20230108221827379.png

  1. 左子树全部为空，从形式上看，更像一个单链表.
  2. 插入速度没有影响
  3. 查询速度明显降低(因为需要依次比较), 不能发挥 BST的优势，因为每次还需要比较左子树，其查询速度比单链表还慢
  4. 解决方案-平衡二叉树(AVL)

1 平衡二叉树

  1. 平衡二叉树也叫平衡二叉搜索树（Self-balancing binary search tree）又被称为 AVL 树， 可以保证查询效率较高。
  2. 具有以下特点：它是一棵空树或它的左右两个子树的高度差的绝对值不超过 1，并且左右两个子树都是一棵平衡二叉树。平衡二叉树的常用实现方法有红黑树、AVL、替罪羊树、Treap、伸展树等
  3. 如何保证在创建二叉排序树的过程中,一直都满足平衡二叉树呢?
  4. 在添加节点add方法的末尾判断(也可以说在非叶子节点处):如果左右子树高度差>1,那么考虑左旋/右旋/双旋
//添加节点
    public void add(BNode bnode) {
        if (bnode == null) {
            return;
        }
        if (bnode.value < this.value) {
            if (this.left == null) {
                this.left = bnode;
            } else {
                this.left.add(bnode);
            }
        } else {
            if (this.right == null) {
                this.right = bnode;
            } else {
                this.right.add(bnode);
            }
        }

        //考虑左旋
//        if (rightTreeHeight() - leftTreeHeight() > 1) {
//            leftRotate();
//        }
        //考虑右旋
//        if (leftTreeHeight()-rightTreeHeight() > 1) {
//            rightRotate();
//        }
        //考虑双旋(单独的左旋/右旋可能不能解决问题)
        if (rightTreeHeight() - leftTreeHeight() > 1) {
            if (right != null && right.leftTreeHeight() > right.rightTreeHeight()) {
                right.rightRotate();
            }
            leftRotate();
            return;//省的走下面代码,影响效率(因为涉及递归调用)
        }
        if (leftTreeHeight()-rightTreeHeight() > 1) {
            if (left != null && left.leftTreeHeight() < left.rightTreeHeight()) {
                left.leftRotate();
            }
            rightRotate();
        }
    }
    
    //返回当前节点的高度
    public int getHeight() {
        return Math.max(left == null ? 0 : left.getHeight(), right == null ? 0 : right.getHeight())+1;
    }
    //左子树高度
    public int leftTreeHeight() {
        if (left == null) {
            return 0;
        } else {
            return left.getHeight();
        }
    }
    //右子树高度
    public int rightTreeHeight() {
        if (right == null) {
            return 0;
        } else {
            return right.getHeight();
        }
    }

2 左旋

image-20230108223734856.png

  1. 主要操作就是改变左旋节点4和其右子节点6的指针指向
  2. 首先拷贝4,新的4左指向3,右指向5
  3. 原来的4改为6,左指向新的4,右指向7
  4. 原来的6由于没有被指向,GC回收
  5. 左旋完成
//左旋
    public void leftRotate() {
        BNode newNode = new BNode(value);
        newNode.left = this.left;
        newNode.right = this.right.left;
        this.setValue(right.value);
        this.setLeft(newNode);
        this.setRight(this.right.right);
    }

3 右旋

image-20230109115239759.png

  1. 属于左旋的镜像操作,改变右旋节点10和其左子节点8的指针指向
  2. 首先拷贝10,新的10左指向9,右指向12
  3. 原来的10改为8,左指向7,右指向新的10
  4. 原来的8由于没有被指向,GC回收
  5. 右旋完成
//右旋
    public void rightRotate() {
        BNode newNode = new BNode(value);
        newNode.right = this.right;
        newNode.left = this.left.right;
        this.setValue(left.value);
        this.setRight(newNode);
        this.setLeft(this.left.left);
    }

4 双旋

image-20230109120404116.png

  1. 问题:前面的两个数列，进行单旋转(即一次旋转)就可以将非平衡二叉树转成平衡二叉树,但是在某些情况下，单旋转不能完成平衡二叉树的转换。比如数列

    int[] arr = { 10, 11, 7, 6, 8, 9 }; 运行原来的代码可以看到，并没有转成 AVL 树.

    int[] arr = {2,1,6,5,7,3}; // 运行原来的代码可以看到，并没有转成 AVL 树

  2. 解决如下:

  3. 当符合右旋转的条件时,如果它的左子树的右子树高度大于它的左子树的高度,先对当前这个结点的左节点进行左旋转,再对当前结点进行右旋转的操作即可

  4. 当符合左旋转的条件时,如果它的右子树的左子树高度大于它的右子树的高度,先对当前这个结点的右节点进行右旋转,再对当前结点进行左旋转的操作即可

//添加节点
    public void add(BNode bnode) {
        if (bnode == null) {
            return;
        }
        if (bnode.value < this.value) {
            if (this.left == null) {
                this.left = bnode;
            } else {
                this.left.add(bnode);
            }
        } else {
            if (this.right == null) {
                this.right = bnode;
            } else {
                this.right.add(bnode);
            }
        }

        //考虑左旋
//        if (rightTreeHeight() - leftTreeHeight() > 1) {
//            leftRotate();
//        }
        //考虑右旋
//        if (leftTreeHeight()-rightTreeHeight() > 1) {
//            rightRotate();
//        }
        //考虑双旋(单独的左旋/右旋可能不能解决问题)
        if (rightTreeHeight() - leftTreeHeight() > 1) {
            if (right != null && right.leftTreeHeight() > right.rightTreeHeight()) {
                right.rightRotate();
            }
            leftRotate();
            return;//省的走下面代码,影响效率(因为涉及递归调用)
        }
        if (leftTreeHeight()-rightTreeHeight() > 1) {
            if (left != null && left.leftTreeHeight() < left.rightTreeHeight()) {
                left.leftRotate();
            }
            rightRotate();
        }
    }

5 完整AVL树代码

//平衡二叉树
public class App05_AVLTree {
    public static void main(String[] args) {
        AVLTree tree = new AVLTree();
//        int[] arr = {4,3,6,5,7,8};
//        int[] arr = {10,12, 8, 9, 7, 6};
//        int[] arr = {10, 11, 7, 6, 8, 9};
        int[] arr = {2,1,6,5,7,3};
        for (int i : arr) {
            tree.add(new BNode(i));
        }
        tree.infixOrder();
        System.out.println("根高度:"+tree.getRoot().getHeight());
        System.out.println("左子树高度:"+tree.getRoot().leftTreeHeight());
        System.out.println("右子树高度:"+tree.getRoot().rightTreeHeight());
    }
}

class AVLTree {
    private BNode root;

    public BNode getRoot() {
        return root;
    }

    //中序遍历
    public void infixOrder() {
        if (root != null) {
            root.infixOrder();
        } else {
            System.out.println("树为空!!!");
        }
    }

    //添加节点
    public void add(BNode nd) {
        if (root == null) {
            root = nd;
        } else {
            root.add(nd);
        }
    }

    //找到删除节点及其父节点
    public BNode search(int value) {
        if (root == null) {
            return null;
        } else {
            return root.search(value);
        }
    }
    public BNode searchParent(int value) {
        if (root == null) {
            return null;
        } else {
            if (root.getLeft() == null && root.getRight() == null) {
                return null;
            } else {
                return root.searchParent(value);
            }
        }
    }

    //删除节点
    public void delNode(int value) {
        if (root == null) {
            return;
        } else {
            BNode target = search(value);
            BNode parent = searchParent(value);//为空则只能是删根节点
            //有的删才行
            if (target != null) {
                if (parent != null) {
                    //删叶子节点
                    if (target.getLeft() == null && target.getRight() == null) {
                        if (parent.getLeft()!=null&&parent.getLeft().getValue() == value) {
                            parent.setLeft(null);
                        } else {
                            parent.setRight(null);
                        }

                        //删有双子树的节点
                    } else if (target.getLeft() != null && target.getRight() != null) {
                        //target为左子树
                        if (parent.getLeft().getValue() == value) {
                            int max = delLeftTreeMax(target);
                            target.setValue(max);
                            //target为右子树
                        } else {
                            int min = delRightTreeMin(target);
                            target.setValue(min);
                        }

                        //删有单子树的节点
                    } else {
                        //4种可能,左左,左右,右左,右右
                        if (parent.getLeft()!=null&& parent.getLeft().getValue() == value && target.getLeft() != null) {
                            parent.setLeft(target.getLeft());
                        } else if (parent.getLeft() != null && parent.getLeft().getValue() == value && target.getRight() != null) {
                            parent.setLeft(target.getRight());
                        } else if (parent.getRight().getValue() == value && target.getLeft() != null) {
                            parent.setRight(target.getLeft());
                        } else {
                            parent.setRight(target.getRight());
                        }
                    }
                } else {//没有父节点,说明就是删root,因为删除的节点存在
                    //叶子
                    if (root.getLeft() == null && root.getRight() == null) {
                        root = null;
                        //有双子树
                    } else if (root.getLeft() != null && root.getRight() != null) {
                        //用左子树最大或右子树最小都可以
                        root.setValue(delLeftTreeMax(root.getLeft()));

                        //有单子树
                    } else {
                        if (root.getRight() != null) {
                            root = root.getRight();
                        } else {
                            root = root.getLeft();
                        }
                    }
                }
            } else {
                System.out.println("删除的节点不存在!!!");
            }
        }
    }

    //删左子树,最大值
    public int delLeftTreeMax(BNode nd) {
        BNode temp = nd;
        while (true) {
            if (temp.getRight() == null) {
                break;
            }
            temp = temp.getRight();
        }
        delNode(temp.getValue());
        return temp.getValue();
    }
    //删右子树,最小值
    public int delRightTreeMin(BNode nd) {
        BNode temp = nd;
        while (true) {
            if (temp.getLeft() == null) {
                break;
            }
            temp = temp.getLeft();
        }
        delNode(temp.getValue());
        return temp.getValue();
    }
}

class BNode {
    private int value;
    private BNode left;
    private BNode right;

    public BNode(int value) {
        this.value = value;
    }

    public int getValue() {
        return value;
    }

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

    public BNode getLeft() {
        return left;
    }

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

    public BNode getRight() {
        return right;
    }

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

    @Override
    public String toString() {
        return "BNode [value=" + value + "]";
    }

    //中序遍历
    public void infixOrder() {
        if (this.left != null) {
            this.left.infixOrder();
        }
        System.out.println(this);
        if (this.right != null) {
            this.right.infixOrder();
        }
    }

    //添加节点
    public void add(BNode bnode) {
        if (bnode == null) {
            return;
        }
        if (bnode.value < this.value) {
            if (this.left == null) {
                this.left = bnode;
            } else {
                this.left.add(bnode);
            }
        } else {
            if (this.right == null) {
                this.right = bnode;
            } else {
                this.right.add(bnode);
            }
        }

        //考虑左旋
//        if (rightTreeHeight() - leftTreeHeight() > 1) {
//            leftRotate();
//        }
        //考虑右旋
//        if (leftTreeHeight()-rightTreeHeight() > 1) {
//            rightRotate();
//        }
        //考虑双旋(单独的左旋/右旋可能不能解决问题)
        if (rightTreeHeight() - leftTreeHeight() > 1) {
            if (right != null && right.leftTreeHeight() > right.rightTreeHeight()) {
                right.rightRotate();
            }
            leftRotate();
            return;//省的走下面代码,影响效率(因为涉及递归调用)
        }
        if (leftTreeHeight()-rightTreeHeight() > 1) {
            if (left != null && left.leftTreeHeight() < left.rightTreeHeight()) {
                left.leftRotate();
            }
            rightRotate();
        }
    }

    //查找要删除节点
    public BNode search(int value) {
        if (this.value == value) {
            return this;
        } else if (value < this.value) {//这里对于==的处理与add方法保持一致
            if (this.left != null) {
                return this.left.search(value);
            }
        } else {
            if (this.right != null) {
                return this.right.search(value);
            }
        }
        return null;
    }

    //查找要删除的节点的父节点
    public BNode searchParent(int value) {
        if ((this.left != null && this.left.value == value) ||
                this.right != null && this.right.value == value) {
            return this;
        } else {
            if (value < this.value && this.left != null) {
                return this.left.searchParent(value);
            } else if (value >= this.value && this.right != null) {
                return this.right.searchParent(value);
            } else {
                return null;
            }
        }
    }

    //返回当前节点的高度
    public int getHeight() {
        return Math.max(left == null ? 0 : left.getHeight(), right == null ? 0 : right.getHeight())+1;
    }
    //左子树高度
    public int leftTreeHeight() {
        if (left == null) {
            return 0;
        } else {
            return left.getHeight();
        }
    }
    //右子树高度
    public int rightTreeHeight() {
        if (right == null) {
            return 0;
        } else {
            return right.getHeight();
        }
    }

    //左旋
    public void leftRotate() {
        BNode newNode = new BNode(value);
        newNode.left = this.left;
        newNode.right = this.right.left;
        this.setValue(right.value);
        this.setLeft(newNode);
        this.setRight(this.right.right);
    }
    //右旋
    public void rightRotate() {
        BNode newNode = new BNode(value);
        newNode.right = this.right;
        newNode.left = this.left.right;
        this.setValue(left.value);
        this.setRight(newNode);
        this.setLeft(this.left.left);
    }
}
bone_ds
关注
专栏目录
平衡二叉树(C++) -- 左旋旋右旋旋
sal.keZ
04-16 1444
平衡二叉树平衡二叉树(C++) -- 左旋旋右旋旋平衡二叉树 -- 左单旋平衡二叉树 -- 右单旋平衡二叉树 -- 左右双旋平衡二叉树 -- 右左双旋平衡二叉树 -- 插入和删除实现 平衡二叉树(C++) – 左旋旋右旋旋   平衡二叉树全称平衡二叉搜索树，所以首先具备了二叉搜索树的特性，因为二叉搜索树并未对树的高做限制，只要求了左小右大，这就可能再极端情况下，出现左斜树或右斜树，这是查找就从O(...
广工数据结构课程设计大作业-平衡二叉树-Java实现（数据结构期末）
11-13
1. 插入节点：当新插入的节点导致树失去平衡时，需要进行相应的左旋、右旋或双旋操作来重新调整树的平衡。 2. 删除节点：删除操作可能涉及单子节点、双子节点和无子节点的情况，需要考虑如何保持树的平衡。 3. 查找...
自平衡二叉树（AVL）及四种旋转方式详解
weixin_49561506的博客
05-30 1680
介绍AVL树的概念，以及AVL树旋转的四种方式
二叉平衡树（左单旋，右单旋，左右双旋、右左双旋）
最新发布
he20021221的博客
07-10 554
二叉平衡树的插入（右单旋，左单旋，左右双旋，右左双旋）
day062：平衡二叉树——左旋、右旋
ZuoQi的博客
10-19 4529
左旋：指将根节点的右侧往左拉，原先的右子节点变成新的父节点，并把多余的左子节点出让，给已经降级的根节点当右子节点右旋：指将根节点的左侧往右拉，原先的左子节点变成新的父节点，并把多余的右子节点出让，给已经降级的根节点当左子节点左子树高：右旋；右子树高：左旋。
平衡二叉树（AVL Tree）（左旋、右旋）
Leon_Jinhai_Sun的博客
02-21 1072
AVL Trees (Balanced binary search trees) 平衡二叉树的定义：左右子树深度差绝对值不能超过1。 是什么意思呢？比如左子树的深度是2，右子树的深度只能是1 或者3。 这个时候我们再按顺序插入1、2、3、4、5、6，一定是这样，不会变成一棵“斜树”。 那它的平衡是怎么做到的呢？怎么保证左右子树的深度差不能超过1 呢？ https://www.cs.usfca.edu/~galles/visualization/AVLtree.html 插入1、2、3。 我们注
平衡二叉树的左旋和右旋
小霆的博客
04-15 4019
文章目录复习树1. 树的概念2. 二叉树(Binary Tree)3. 满二叉树4. 完全二叉树5. 二叉堆6. 二叉搜索树左旋和右旋7. 平衡二叉树(平衡二叉搜索树) 本文章是我的库存文章，本来不发的，但还是发吧，请跳到第7节，那才是讲左旋和右旋的。至于前面的复习树要看也可以，只是一堆概念，并不复杂。 复习树 1. 树的概念   生活中的树跟程序中的树其实大同小异，比如生活中的树是不是有树根，在树根的基础上是不是会有分叉，而在这些分叉中是不是也可能会继续分叉，而在这些分叉上是不是也可能会生出叶子。  
【数据结构】平衡二叉树左旋右旋与红黑树
2301_79977698的博客
06-07 1476
平衡二叉树是二叉搜索树的一种特殊形式。而平衡二叉树（Balanced Binary Tree）在满足了二叉搜索树的所有性质的基础上，还额外保证了树的高度尽可能小，即任意节点的左右子树高度差不超过1。
AVL-tree.zip_AVL高效实现_avl 旋转_二叉树旋转_树 旋转
09-19
旋转有四种类型：左旋、右旋、左右旋和右左旋，它们用于调整树的结构以恢复平衡。 1. 左旋（Left Rotation）：当一个节点的右子节点的左子树过高时，需要进行左旋。左旋操作将右子节点提升为当前节点的父节点，然后...
平衡二叉树的左右旋以及双旋转的图文详解
08-26
- **先左后右双旋转**：当插入节点使得父节点的左子树的右子树过高，先执行左旋操作，然后对父节点执行右旋。这个过程相当于先修复了左子树的不平衡，然后调整父节点的平衡。 - **先右后左双旋转**：与先左后右...
二叉树-基于C++实现的平衡二叉树的旋转.zip
04-26
- **右旋（Right Rotation）**：与左旋相反，当一个节点的左子节点高度大于其右子节点，并且左子节点的右子树高度大于左子树时，需要进行右旋。同样，这将把高的左子节点上移，而将其原位置替换为其右子节点。 3. ...
二叉树的左旋和右旋
07-21
树的旋转，分为左旋和右旋，以下借助图来做形象的解释和介绍
【算法】平衡二叉搜索树的左旋和右旋
hui_zai_的博客
05-29 845
平衡二叉搜索树的左旋和右旋
平衡二叉树的旋转（左旋和右旋）
diechi0288的博客
05-16 439
右旋： void RightSpin(Tree** ppTree) { Tree* pTree = *ppTree; Tree* ptmp = pTree->pleft; pTree->pleft = ptmp->pright; if(ptmp->pright) ptmp->pright-&g...
二叉树的左旋与右旋
ONEMORE6499的博客
03-11 3292
对于在一颗结点和层数比较多的二叉树上查找一个元素时， 二叉排序树的查找效率远远高于一颗普通的树。 如下为普通二叉树和二叉排序树： 假设查找结点20 在普通二叉树上查找： //查找结点 static int ct = 0;//记录比较次数 public static boolean isExistTreeNode(TreeNode root, TreeNode target){ i...
平衡二叉树（AVL）的左旋和右旋
weixin_45950398的博客
03-23 928
平衡二叉树（AVL）的左旋和右旋 最近算法和数据结构受虐，于是开始从二叉树学习，诸君共勉，同时也作为笔记。其实要理解思想不难，关键是要有耐心，不要觉得它难！ 构建左平衡： bf :平衡度，可取值LH(左高），EH(等高），RH(右高) 根节点记作T，根节点的左孩子记作L 判断左孩子L的平衡因子bf L-bf ： 若 LH, 说明插入结点在T的左孩子的左子树上，此时单右旋就可以了（因为根节点和左孩子的平衡度同个方向） 若 RH,则要双旋处理，即先左孩子左旋，在根节点右旋 接下来是重难点了，先说结论 若 Lr
平衡二叉树的左旋右旋详解 看不懂你打我
yyg15的博客
09-22 7598
平衡二叉树的左旋右旋 看不懂你打我左旋右旋的操作为什么要左旋右旋左旋右旋能保持排序二叉排序树的性质吗 左旋右旋的操作 1.左旋：对X节点左旋，即以X的右孩子Y为轴，将X节点转下来，变为Y的左孩子， 简单记为左旋即把该节点变为左孩子。 例题1.如对A左旋 注意2个问题： 1.既然要左旋要以右孩子为轴，那么右孩子是必须存在的，即不能为空。 2.左旋后B的左指针指向A，那原来B的左孩子C怎么办，谁去指向它？ A原来的右指针指向B，在左旋后该怎么办，它指向谁？ 所以我们将左旋后A的右指针指向B原来的左孩子C即可
图示AVL平衡二叉树的左旋、右旋以及树高
tmax52HZ的博客
08-16 761
/** * AVL树 * 1.先BST树添加节点 * 是否需要左旋 * 是否先右旋 * 是否需要右旋 * 是否先左旋 */ public class Main33 { private static void avl(Node root, Node temp, int ele) { //1.二叉搜索树的创建，完全和二叉排序数新增节点一样 if
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值