数据结构算法爬坑日记十五

平衡二叉树(AVL)

介绍:在使用二叉排序树时,如果出现类似依次增大或依次减小的这种情况,此时的二叉树便类似于单链表了,因
为二叉树在查找的时候每次还需要进行判断才能往下走,此时查询速度明显降低,所以便需要平衡二叉树来解决,
平衡二叉树也叫平衡二叉搜索树,属于一种特殊的二叉排序树,特点是:它是一棵空树或者左右子树的高度差的绝
对值不超过1且左右子树也分别是一颗平衡二叉树,在不符合上述要求时,就需要通过一些策略来对树进行调整来
满足平衡二叉树要求

调整策略:
  ** 左旋转:当出现右子树的高度-左子树高度大于1时,进行左旋转,实现步骤,以根节点权值来创建一个新节
  点,新节点的左指针指向根节点的左子树,右指针指向根节点的右子树的左节点,将根节点权值设为右子节点的
  值,并且修改根节点的左指针指向为新节点,右指针的指向为右子树的右子树(上述子树如果不存在就将相应的
  指向置空)
  ** 右旋转:当出现左子树的高度-右子树高度大于1时,进行右旋转,思路类似左旋转
  ** 双旋转:以左旋转为例,左旋转实际效果就是将根节点右子节点设置为根节点,右子节点的左子节点放到根
  节点左子树,以此来达到降右子树高度来增加左子树高度,但当右子节点的左子树高度大于右子节点的右子树
  高度时,便会出现旋转之后左子树又过高,所以出现这种情况时,必须先对根节点的右子树进行右旋转,来降低
  右子树的左子树高度再进行左旋转


 代码实现(在节点进行改变时,都判断是否平衡,不平衡就调整,以添加节点为例)
 ** 平衡二叉树节点类
 //二叉平衡树节点
public class Node {
    int value;//节点权值
    Node left;
    Node right;

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

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

    //求树的高度
    public int height() {
        return Math.max(left == null ? 0 : left.height(), right == null ? 0 : right.height()) + 1;
    }

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

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

    //左旋转
    public void leftRotate() {
        //创建新节点,权值等于原根节点的权值
        Node newNode = new Node(value);
        //新节点左指向原根节点的左子树,右指向为原根节点的右子树的左子树
        newNode.left = left;
        newNode.right = right.left;
        //原根节点的权值改为右节点权值,左指向新节点,右指向右节点的右子树
        value = right.value;
        left = newNode;
        right = right.right;
    }

    //右旋转(类似左旋)
    public void rightRotate(){
        Node newNode=new Node(value);
        newNode.right=right;
        newNode.left=left.right;
        value=left.value;
        right=newNode;
        left=left.left;
    }

    //添加节点
    public void addNode(Node node) {
        if (node == null) {
            return;
        }
        //添加的节点值小于当前节点值,向左递归
        if (node.value < this.value) {
            if (this.left != null) {
                this.left.addNode(node);
            } else {
                this.left = node;
            }
        } else {//不小于当前节点向右递归
            if (this.right != null) {
                this.right.addNode(node);
            } else {
                this.right = node;
            }
        }
        //添加完一个新节点之后判断是否需要左旋转进行二叉树平衡
        if (rightHeight() - leftHeight() > 1) {
            //如果右节点的左子树高度大于右子树高度,需要先将右节点右旋转
            if (right.leftHeight() > right.rightHeight()) {
                right.rightRotate();
                leftRotate();
            } else {
                leftRotate();
            }
        }
        //判断是否需要右旋
        if (leftHeight() - rightHeight() > 1) {
            //如果左节点的右子树高度大于左子树高度,需要先将左节点左旋转
            if (left.rightHeight() > left.leftHeight()) {
                left.leftRotate();
                rightRotate();
            } else {
                rightRotate();
            }
        }
    }

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

 ** 平衡二叉树类
 //二叉平衡树
public class AVLTree {
    Node root;//头节点
    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();
        }
    }
    //添加节点
    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.mid();
        }
    }
}

 ** 测试类
public class AVLTreeTest {
    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 : arr) {
            avlTree.addNode(new Node(i));
        }
        avlTree.midOrder();
        System.out.println("树的高度" + avlTree.height());
        System.out.println("左子树高度" + avlTree.leftHeight());
        System.out.println("右子树高度" + avlTree.rightHeight());
    }
}