数据结构与算法学习 AVL平衡二叉树

定义

        如果一个{1,2,3,4,5,6}的二叉排序树，它的左子树为空，每个节点都堆积在右子树上。看起来更像一个单链表。它的插入速度虽然没有影响，但是查询速度明显降低(因为需要依次比较)，不能发挥BST的查询优势。

解决方案就是AVL平衡二叉树

        平衡二叉树，又称AVL树，它是一种特殊的二叉排序树。AVL树或者是一棵空树，或者是具有以下性质的二叉树：

（1）左子树和右子树都是平衡二叉树；

（2）左子树和右子树的深度（高度）之差的绝对值不超过1。

应用案例-单旋转(左旋转)

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

2) 思路分析 ( 示意图 )

        

首先获取左子树和右子树以及根节点自身的高度

 /**
     * 返回该节点为根节点的，左右子树的高度
     * @return
     */
    public int leftHeight(){
        if (left == null){
            return 0;
        }else {
            return left.height();
        }
    }
    public int rightHeight(){
        if (right == null){
            return 0;
        }else {
            return right.height();
        }
    }


    /**
     * 返回当前节点的高度，以该节点为根节点的树的高度
     * @return
     */
    public int height(){
        //从两边递归
        //为什么加一，因为只是统计到了左子树和右子树的高度，自己本身也算是一层，所以加1
        return Math.max(left == null ? 0:left.height(),
                right == null ? 0 : right.height())+1;
    }

 /**
     * AVL树的左旋转 把它放到添加节点的时候，如果右子树的高度-左子树的高度 > 1，则调用左旋转
     */
    private void leftRotate(){
        //创建新的节点，以当前根节点的值创建
        Node temp = new Node(this.value);
        //把新的节点的左子树设置为当前节点的左子树
        temp.left = this.left;
        //把新的节点的右子树设置成当前节点的右子树的左子树
        temp.right = this.right.left;
        //把当前节点的值替换成右子节点的值
        this.value = this.right.value;
        //把当前节点的右子树设置为右子树的右子树
        this.right = this.right.right;
        //把当前节点的左子树设置成新的节点
        this.left = temp;

    }

/**
     * 递归的形式添加节点，前提是需要满足AVL树的要求
     *
     * @param node
     */
    public void add(Node node) {
        if (node == null) {
            return;
        }

        //判断传入节点的值和当前子树的根节点的值之间的关系
        if (node.value < this.value) {
            //如果当前节点的左子节点为空，那node直接挂到当前节点的左子节点
            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 ,则调用左旋转
        if (rightHeight() - leftHeight() > 1){
            leftRotate();
        }
    }

可以看到完成了平衡

应用案例-单旋转(右旋转)

1) 要求 : 给你一个数列，创建出对应的平衡二叉树 . 数列 {10,12, 8, 9, 7, 6}

2) 思路分析 ( 示意图 )

 

 /**
     * AVL树的右旋转 把它放到添加节点的时候，如果左子树的高度 - 右子树的高度 > 1 ,则调用右旋转
     */
    private void rightRotate(){
        //创建新的节点，以当前根节点的值创建
        Node temp = new Node(this.value);
        //新节点的右子节点指向当前节点的右子节点
        temp.right = this.right;
        //新节点的左子节点指向当前节点的左子节点的右子节点
        temp.left = this.left.right;
        //当前节点的值换成左子节点的值
        this.value = this.left.value;
        //当前节点的左子节点换成左子节点的左子节点
        this.left = this.left.left;
        //当前节点的右子节点换成新节点
        this.right = temp;
    }

应用案例-双旋转

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

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

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

 

 

 当符合右旋转的条件时

如果他的左子树的右子树高度大于它的左子树

先对这个左节点进行左旋转

再对当前节点进行右旋转

 /**
     * 递归的形式添加节点，前提是需要满足AVL树的要求
     *
     * @param node
     */
    public void add(Node node) {
        if (node == null) {
            return;
        }

        //判断传入节点的值和当前子树的根节点的值之间的关系
        if (node.value < this.value) {
            //如果当前节点的左子节点为空，那node直接挂到当前节点的左子节点
            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 ,则调用左旋转
        if (rightHeight() - leftHeight() > 1){
            //如果当前节点的【右子树的左子树的高度】大于【当前节点的右子树的高度】
            if (this.right.leftHeight() > this.right.rightHeight()){
                //先对当前节点的右子树进行旋转
                right.rightRotate();
            }
            leftRotate();
            return;
        }
        //如果左子树的高度 - 右子树的高度 > 1 ,则调用右旋转
        //增加一个双旋转的条件：如果当前节点的【左子树的右子树的高度】大于【当前节点的左子树的高度】
        if (leftHeight() - rightHeight() > 1){
            //如果当前节点的【左子树的右子树的高度】大于【当前节点的左子树的高度】
            if (this.left.rightHeight() > this.left.leftHeight()){
                //先对当前节点的左子树进行旋转
                left.leftRotate();
            }
            //旋转右子树
            rightRotate();
        }
    }

完成了平衡二叉树的创建