平衡二叉树(AVL)

最新推荐文章于 2024-06-08 22:34:04 发布

Quare_feifei

最新推荐文章于 2024-06-08 22:34:04 发布

阅读量2.8k

点赞数

分类专栏：数据结构和算法

本文链接：https://blog.csdn.net/m0_49374492/article/details/119045823

版权

数据结构和算法专栏收录该内容

11 篇文章 0 订阅

订阅专栏

在这里插入图片描述
上图BST存在的问题分析：

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

平衡二叉树

1.平衡二叉树也叫平衡二叉搜索树，又被称为AVL树，可以保证查询效率较高

2.具有以下特点：它是一棵空树或它的左右两个子树的高度差的绝对值不超过一，并且左右两个子树都是一棵平衡二叉树。平衡二叉树的常用实现方法有红黑树、avl、替罪羊树、Treap、伸展树等

3.举例说明，看看下边哪些AVL树，为什么？

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-wuqPoh1r-1627051685501)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20210722205314203.png)]$

对于第一幅图的根节点来说，左子树的高度为2，右子树的高度为1，所以是AVL树

对于第二幅图的根节点来说，左子树的高度为2，右子树的高度为2，所以是AVL树

对于第三幅图来说左子树的高度为3，右子树的高度为1，所以不是avl树
当然这里的左旋、右旋和双旋转都是建立在二叉排序的基础上，要不然没有啥意义啊啊啊啊啊！

应用案例-单旋转（左旋转）

1.要求：给你一个数列，创建出对应的平衡二叉树，数列为{4，3，6，5，7，8}

2.思路分析
在这里插入图片描述首先进行左旋处理是为了降低右子树的高度

问题：当插入8时

righthight()-leftheight()>1成立，此时，不再是一棵avl树了

怎么处理-进行左旋转

1.创建一个新的节点newnode(以4这个值创建)，创建一个新的节点，值等于当前根节点的值

//把新节点的左子树设置了当前节点的左子树

2.newnode.left=left

//把新节点的右子树设置为当前节点的右子树的左子树

3.newnode.right=right.left

把当前节点的值换为右子节点的值

4.value=right.value

//把当前节点的右子树设置为右子树的右子树

5.right=right.right

把当前节点的左子树设置为新节点

6.left=newnode

3.代码实现
统一放在文末的代码中

右旋转

在这里插入图片描述如图所示当最后将6插入后，原来的树就不再是一棵avl树

怎么处理呢？我们此时就需要进行右旋转(就是要降低左子树的高度)，这里是将9这个节点，通过右旋转，到左子树

1.创建一个新的节点new node（以10这个值创建）,创建一个新的节点，值等于当前根节点的值

//把新结点的右子树设置为当前节点的右子树

2.newnode.right=right

//把新节点的左子树设置为当前节点的右子树

3.newnode.left=left.right

//将新节点额度左子树设置为当前节点左子树的右子树

4.value=left.value

//当前节点的值重新赋值为当前节点的左子树的值

5.left=left.left;

//把当前节点的右子树设置为新节点

6.right=newleft

应用案例双旋转

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

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

int[] arr={2,1,6,5,7,3}运行原来的代码可以看到，并没有转成avl树
在这里插入图片描述
如图该数组当最后的9进行插入后，明显的根节点左子树的高度为3，根节点右子树的高度为1，此时是不符合平衡二叉树的要求的即二叉排序树的跟节点左右子树的高度差的绝对值不超过1，按照上边的探讨我们此时可能会进行右旋来降低左子树高度，但右旋后就会发现问题，右旋后仍然不是平衡二叉树，此时就需要进行双旋
如果是进行右旋的话
就要root.left.rightHight>root.left.leftHight?root.left.LeftSpin:root.rightSpin.

总体的代码如下：
大体等同于二叉排序树的代码，在add方法中添加了判断是否为平衡二叉树的判断，当然你也可以在delete中添加判断的方法和左右旋的方法，这也是必要的

package cxf.xiangxiang.avl;

public class avl {
    public static void main(String[] args) {
        int [] arr={10,11,7,6,8,9};
        AvlTree avlTree = new AvlTree();
        for (int i = 0; i < arr.length; i++) {
            avlTree.add(new Node(arr[i]));
        }
        avlTree.midorder();
        int i = avlTree.leftHeight();
        int i1 = avlTree.rightHeight();
        System.out.println("树的高度"+avlTree.height());
        System.out.println("左子树的高度"+i);
        System.out.println("右子树的高度"+i1);
        System.out.println(avlTree.root.left.value);
        System.out.println(avlTree.root.right.value);

    }

}
class AvlTree{
    public  Node root;
    //获取左子树的高度
    public int leftHeight(){
        if(root==null){
            return 0;
        }
        return root.leftHeight();
    }
    //获取右子树的高度
    public int rightHeight(){
        if(root==null){
            return  0;
        }
        return root.rightHeight();
    }
    //当前节点的高度
    public int height(){
        return root.height();
    }
    //删除节点
    public void del(int value){
        if(root==null){
            return;
        }else{
            Node targetNode = search(value);
            //如果没有找到要删除的节点直接返回
            if(targetNode==null){
                return;
            }
            //找到了 要删除的节点  并且bst只有一个根节点 就直接删除根节点
            if(root.left==null && root.right==null){
                root=null;
                return;
            }
            //找节点的父节点
            Node node = searchParent(value);
            //如果要删除的节点是叶子节点
            if(targetNode.left==null && targetNode.right==null){
                if(node.right!=null && node.right.value==value){
                    node.right=null;
                }else if (node.left!=null && node.left.value==value){
                    node.left=null;
                }
            }else if(targetNode.left!=null && targetNode.right!=null){
                int i = delRightTreeMin(targetNode.right);
                targetNode.value=i;

            }else{//删除只有一个子树的节点
                //如果删除的节点只有左子节点
                if(targetNode.left!=null){
                    if( node.left!=null && node.left.value==value ){
                        node.left=targetNode.left;
                    }else if(node.right!=null && node.left.value==value ){
                        node.right=targetNode.left;
                    }
                }else{//要删除的节点只有右子树
                    if(node.left!=null && node.left.value==value){
                        node.left=targetNode.right;
                    }else if(node.right!=null && node.right.value==value){
                        node.right=targetNode.right;
                    }
                }

            }


        }
    }

    /**
     *
     * @param node   传入的节点（当前二叉排序树的根节点）
     * @return   返回的以node  为根节点的二叉排序树的最小值
     */
    public int delRightTreeMin(Node node){
        Node target=node;
        while(target.left!=null){
            target=target.left;
        }
        //将该根节点的二叉排序树的最小值删除并返回
        del(target.value);
        return target.value;
    }
    //查找要删除的节点
    public Node search(int value){
        if(root==null){
            return null;
        }else{
            return root.search(value);
        }
    }
    //查找要删除节点的父节点
    public Node searchParent(int value){
        if(root==null){
            return null;
        }else{
            return root.searchParent(value);
        }
    }
    public void add(Node node){
        if(root==null){
            root=node;
        }else{
            root.add(node);
        }

    }
    public void midorder(){
        if(root!=null){
            root.midOrder();
        }else{
            System.out.println("二叉排序树为空");
        }
    }
}
class Node{
    int value;
    Node left;
    Node right;

    @Override
    public String toString() {
        return "Node{" +
                "value=" + value +
                '}';
    }
    //右旋的代码
    public void rightSpin(){
        //创建一个新的节点将当前节点的值赋值给他
        Node node = new Node(this.value);
        //新创建的节点右指针指向当前节点的右子树
        node.right=this.right;
        //新创建的左子节点指向当前节点的左子节点的右子节点
        node.left=this.left.right;
        //将当前节点的左子节点的值赋值给当前节点
        this.value=this.left.value;
        //当前节点的左子针指向左子节点的左子节点
        this.left=this.left.left;
        //当前节点的右指针指向新创建的节点
        this.right=node;
    }
    //左旋的代码
    public void leftSpin(){
        //创建一个新的节点将当前节点的值赋给它
        Node node = new Node(this.value);
        //将当前节点的左指针指向新创建的节点
        node.left=this.left;
        //新的节点的右指针指向当前节点的右子节点的左子节点
        node.right=this.right.left;
        //将当前节点的右子节点的右子节点的值赋给当前节点
        this.value=this.right.value;
        //当前节点的右指针指向当前节点的右子节点的右子节点
        this.right=this.right.right;
        //把当前节点的左子树设置为新的节点
        this.left=node;
    }

    public Node(int value){
        this.value=value;
    }
    //求左子树的高度
    public int leftHeight(){
        if(left==null){
            return 0;
        }
        return left.height();
    }
    //求右子树的高度
    public int rightHeight(){
        if(right==null){
            return 0;
        }
        return right.height();
    }
    //求以该点为根节点的树的高度
    public int height(){
        return Math.max(left==null?0:left.height(),right==null?0:right.height())+1;
    }

    /**
     *
     * @param value 要删除的节点的值
     * @return  如果找到就返回，如果找不到就返回null
     */
    public Node search(int value){
        if(value==this.value){
            return this;
        }else if (value <this.value){
            if(this.left==null){
                return null;
            }
            return this.left.search(value);
        }else{
            if(this.right==null){
                return null;
            }
            return this.right.search(value);
        }
    }
    //查找要删除节点的父节点
    public Node searchParent(int value){
        //如果当前节点就是要查找的节点的父节点就直接返回
        if((this.left!=null && this.left.value==value) || (this.right!=null && this.right.value==value)){
            return this;
        }else{
            //如果值小于当前值就向左去寻找
            if(this.left!=null && value<this.value){
                return this.left.searchParent(value);
            }else if(this.right!=null && value>=this.value){
                return this.right.searchParent(value);
            }else{
                return null;//没有找到父节点  同样的根节点的父节点也是null
            }
        }
    }
    //add方法往二叉排序树中添加节点
    public void add(Node node){
        if(node==null){
            return;
        }
        //判断传入节点的值，和当前节点值的关系
        if(node.value<this.value){
            if(this.left==null){
                this.left=node;
            }else{
                this.left.add(node);
            }
        }else{
            if(this.right==null){
                this.right=node;
            }else{
                this.right.add(node);
            }
        }
        //每次添加完后都要判断，右子树的高度是否比左子树的高度大1，如果大于1的话就要进行左旋转
        if(rightHeight()-leftHeight()>1){
            if(right!=null && right.leftHeight()>right.rightHeight()){
                rightSpin();
            }
            leftSpin();
            return;
        }
        //判断每次添加完后，左子树的高度如果比右子树高度大于1，就要进行右旋转
        if(leftHeight()-rightHeight()>1){
            if(left!=null && left.rightHeight()>left.leftHeight()){
                left.leftSpin();
            }
            rightSpin();
        }

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

Quare_feifei

关注

0
点赞
踩
3

收藏

觉得还不错? 一键收藏
打赏
0
评论
平衡二叉树(AVL)

上图BST存在的问题分析：左子树全部为空，从形式上看，更像是一个单链表插入速度没有影响查询速度明显降低(因为需要依次比较)，不能发挥BST的优势，因此每次还需要比较左子树，其查询速度比单链表还慢解决方案平衡二叉树平衡二叉树1.平衡二叉树也叫平衡二叉搜索树，又被称为AVL树，可以保证查询效率较高2.具有以下特点：它是一棵空树或它的左右两个子树的高度差的绝对值不超过一，并且左右两个子树都是一棵平衡二叉树。平衡二叉树的常用实现方法有红黑树、avl、替罪羊树、Treap、伸展树等3.举例说明，.
复制链接

扫一扫