平衡二叉树(AVL)

看一个案例

给你一个数列{1,2,3,4,5,6},要求创建一棵二叉排序树(BST),并分析问题所在.

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

基本介绍

• 平衡二叉树也叫二叉搜索树又被称为AVL树,可以保证查询效率较高.
• 具有以下特点:它是一棵空树或它的左右两个子树的高度差的绝对值不超过1,并且左右两个子树都是一棵平衡二叉树.平衡二叉树的常用实现方法有红黑树,AVL,替罪羊树,Treap,伸展树等.
• 举例说明,看看下面哪些是AVL树.
  

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

• 要求:给你一个数列,创建出对应的平衡二叉树.数列{4,3,6,5,7,8}
• 思路分析(示意图)
  

//左旋转 当rightHeight - leftHeight >1 时,进行左旋转
    public void leftRotate() {
        //1.创建一个新的节点,值等于当前根节点
        Node newNode = new Node(val);
        //2.把新节点的左子树设置为根节点的左子树
        newNode.left = this.left;
        //3.把新节点的右子树,设置为根节点的右子树的左子树
        newNode.right = this.right.left;
        //4.把根节点右子节点的值赋给根节点
        this.val = this.right.val;
        //5.根节点的右子树设置为右子树的右子树
        this.right  =right.right;
        //6.根节点的左子树为新节点
        this.left = newNode;
    }

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

• 要求:给你一个数列,创建出对应的平衡二叉树.数列{10,12,8,9,7,6}
• 思路分析(示意图)
  

//右旋转 leftHeight - rightHeight > 1
    public void rightRotate(){
        //1.创建一个新的节点,值等于当前根节点
        Node newNode = new Node(val);
        //2.新节点的右子树为根节点的右子树
        newNode.right = right;
        //3.新节点的左子树为根节点左子树的右子树
        newNode.left = left.right;
        //4.把根节点左子树的值赋给根节点
        this.val = left.val;
        //5.根节点的左子节点为左子节点的左子节点
        left = left.left;
        //6.根节点的右子节点为新节点
        right = newNode;
    }

左右旋转代码

public class AVLTreeDemo {
    public static void main(String[] args) {
//        int[] arr = {4, 3, 6, 5, 7, 8};
        int[] arr = {10,12, 8, 9, 7, 6};

        AVLTree avlTree = new AVLTree();
        for (int i = 0; i < arr.length; i++) {
            avlTree.addNode(new Node(arr[i]));
        }
        //中序遍历
        avlTree.midOrder();
        //打印根节点
        System.out.println("根节点为:" + avlTree.getRoot());
        System.out.println("树高为:" + avlTree.height());
        System.out.println("左子树高:" + avlTree.leftHeight());
        System.out.println("右子树高:" + avlTree.rightHeight());
    }
}

//平衡二叉树
class AVLTree {
    private Node root;

    public Node getRoot() {
        return root;
    }

    //添加节点
    public void addNode(Node node) {
        if (root == null) {
            root = node;
        } else {
            root.addNode(node);
        }
    }

    //中序遍历
    public void midOrder() {
        if (root == null) {
            System.out.println("平衡二叉树为空");
        } else {
            root.midOrder();
        }
    }

    //计算树高
    public int height() {
        if (root == null) {
            return 0;
        } else {
            return root.height();
        }
    }

    public int leftHeight() {
        if (root == null) {
            return 0;
        } else {
            return root.leftHeight();
        }
    }

    public int rightHeight() {
        if (root == null) {
            return 0;
        } else {
            return root.rightHeight();
        }
    }
}

//节点
class Node {
    int val;
    Node left;
    Node right;

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

    @Override
    public String toString() {
        return "Node{" +
                "val=" + val +
                '}';
    }

    //添加节点
    public void addNode(Node node) {
        if (val > node.val) {
            if (left == null) {
                left = node;
            } else {
                left.addNode(node);
            }
        } else {
            if (right == null) {
                right = node;
            } else {
                right.addNode(node);
            }
        }
        if (this.rightHeight() - this.leftHeight() >1){
            leftRotate();
        }
        if (this.leftHeight() - this.rightHeight() >1){
            rightRotate();
        }

    }

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

    //计算以该节点为根节点的树的高度
    public int height() {
        if (left == null && right == null) {
            return 1;
        }
        int ld = 0;
        int rd = 0;
        if (left != null) {
            ld = left.height();
        }
        if (right != null) {
            rd = right.height();
        }
        return Math.max(ld, rd) + 1;
    }

    //计算左子树高度
    public int leftHeight() {
        if (left == null) {
            return 0;
        } else {
            return left.height();
        }
    }

    //计算右子树高度
    public int rightHeight() {
        if (right == null) {
            return 0;
        } else {
            return right.height();
        }
    }

    //左旋转 当rightHeight - leftHeight >1 时,进行左旋转
    public void leftRotate() {
        //1.创建一个新的节点,值等于当前根节点
        Node newNode = new Node(val);
        //2.把新节点的左子树设置为根节点的左子树
        newNode.left = this.left;
        //3.把新节点的右子树,设置为根节点的右子树的左子树
        newNode.right = this.right.left;
        //4.把根节点右子节点的值赋给根节点
        this.val = this.right.val;
        //5.根节点的右子树设置为右子树的右子树
        this.right  =right.right;
        //6.根节点的左子树为新节点
        this.left = newNode;
    }
    //右旋转 leftHeight - rightHeight > 1
    public void rightRotate(){
        //1.创建一个新的节点,值等于当前根节点
        Node newNode = new Node(val);
        //2.新节点的右子树为根节点的右子树
        newNode.right = right;
        //3.新节点的左子树为根节点左子树的右子树
        newNode.left = left.right;
        //4.把根节点左子树的值赋给根节点
        this.val = left.val;
        //5.根节点的左子节点为左子节点的左子节点
        left = left.left;
        //6.根节点的右子节点为新节点
        right = newNode;
    }
}

应用案例 -双旋转

前面的两个数列,进行单旋转(即一次旋转)就可以将非平衡二叉树转成平衡二叉树,但在某些情况下,单旋转不能完成平衡二叉树的转换.比如数列{10,11,7,6,8,9} {2,1,6,5,7,3}

解决思路

• 当符合右旋转的条件时:
  • 如果它的左子节点的右子树高度大于它的左子树高度,先对当前节点的左节点进行左旋转,再对当前节点进行右旋转.
  • 否则直接进行右旋转
• 当符合左旋转的条件时:
  • 如果它的右子节点的左子树高度大于它的右子树高度,先对当前节点的右子节点进行右旋转,再对当前节点进行左旋转.
  • 否则直接进行左旋转

完整代码如下

public class AVLTreeDemo {
    public static void main(String[] args) {
//        int[] arr = {4, 3, 6, 5, 7, 8};
//        int[] arr = {10,12, 8, 9, 7, 6};
        int[] arr = {10, 11, 7, 6, 8, 9};
        AVLTree avlTree = new AVLTree();
        for (int i = 0; i < arr.length; i++) {
            avlTree.addNode(new Node(arr[i]));
        }
        //中序遍历
        avlTree.midOrder();
        //打印根节点
        System.out.println("根节点为:" + avlTree.getRoot());
        System.out.println("树高为:" + avlTree.height());
        System.out.println("左子树高:" + avlTree.leftHeight());
        System.out.println("右子树高:" + avlTree.rightHeight());
    }
}

//平衡二叉树
class AVLTree {
    private Node root;

    public Node getRoot() {
        return root;
    }

    //添加节点
    public void addNode(Node node) {
        if (root == null) {
            root = node;
        } else {
            root.addNode(node);
        }
    }

    //中序遍历
    public void midOrder() {
        if (root == null) {
            System.out.println("平衡二叉树为空");
        } else {
            root.midOrder();
        }
    }

    //计算树高
    public int height() {
        if (root == null) {
            return 0;
        } else {
            return root.height();
        }
    }

    public int leftHeight() {
        if (root == null) {
            return 0;
        } else {
            return root.leftHeight();
        }
    }

    public int rightHeight() {
        if (root == null) {
            return 0;
        } else {
            return root.rightHeight();
        }
    }
}

//节点
class Node {
    int val;
    Node left;
    Node right;

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

    @Override
    public String toString() {
        return "Node{" +
                "val=" + val +
                '}';
    }

    //添加节点
    public void addNode(Node node) {
        if (val > node.val) {
            if (left == null) {
                left = node;
            } else {
                left.addNode(node);
            }
        } else {
            if (right == null) {
                right = node;
            } else {
                right.addNode(node);
            }
        }
        //当添加完一个结点后，如果: (右子树的高度-左子树的高度) > 1 , 左旋转
        if (this.rightHeight() - this.leftHeight() > 1) {
            //如果它的右子树的左子树的高度大于它的右子树的右子树的高度
            if (this.right != null && this.right.leftHeight() > this.right.rightHeight()) {
                //先对右子结点进行右旋转
                this.right.rightRotate();
                //然后在对当前结点进行左旋转
                leftRotate();
            } else {
                //直接进行左旋转即可
                leftRotate();
            }

            return;  //非常重要
        }
        //当添加完一个结点后，如果 (左子树的高度 - 右子树的高度) > 1, 右旋转
        if (this.leftHeight() - this.rightHeight() > 1) {
            //如果它的左子树的右子树高度大于它的左子树的高度
            if (this.left != null && this.left.rightHeight() > this.left.leftHeight()) {
                //先对当前结点的左结点(左子树)->左旋转
                this.left.leftRotate();
                //再对当前结点进行右旋转
                this.rightRotate();
            } else {
                //直接进行右旋转即可
                this.rightRotate();
            }

        }

    }

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

    //计算以该节点为根节点的树的高度
    public int height() {
        if (left == null && right == null) {
            return 1;
        }
        int ld = 0;
        int rd = 0;
        if (left != null) {
            ld = left.height();
        }
        if (right != null) {
            rd = right.height();
        }
        return Math.max(ld, rd) + 1;
    }

    //计算左子树高度
    public int leftHeight() {
        if (left == null) {
            return 0;
        } else {
            return left.height();
        }
    }

    //计算右子树高度
    public int rightHeight() {
        if (right == null) {
            return 0;
        } else {
            return right.height();
        }
    }

    //左旋转 当rightHeight - leftHeight >1 时,进行左旋转
    public void leftRotate() {
        //1.创建一个新的节点,值等于当前根节点
        Node newNode = new Node(val);
        //2.把新节点的左子树设置为根节点的左子树
        newNode.left = this.left;
        //3.把新节点的右子树,设置为根节点的右子树的左子树
        newNode.right = this.right.left;
        //4.把根节点右子节点的值赋给根节点
        this.val = this.right.val;
        //5.根节点的右子树设置为右子树的右子树
        this.right = right.right;
        //6.根节点的左子树为新节点
        this.left = newNode;
    }

    //右旋转 leftHeight - rightHeight > 1
    public void rightRotate() {
        //1.创建一个新的节点,值等于当前根节点
        Node newNode = new Node(val);
        //2.新节点的右子树为根节点的右子树
        newNode.right = right;
        //3.新节点的左子树为根节点左子树的右子树
        newNode.left = left.right;
        //4.把根节点左子树的值赋给根节点
        this.val = left.val;
        //5.根节点的左子节点为左子节点的左子节点
        left = left.left;
        //6.根节点的右子节点为新节点
        right = newNode;
    }
}