AVL平衡二叉树

AVL平衡二叉树：是一颗二叉排序树，并且左右两个子树的高度差的绝对值不超过1；
AVL平衡二叉树可以进行高效的数据查找，最差的情况下查找一个数据时间复杂度为log2n，是二叉树结构里面单点数据查询最快的结构；

以下demo在之前章节《BST二叉排序树》的算法基础上实现的；

基本的4种需要平衡情况：

LL：node.left树高>node.right树高，且node.left.left树高>node.left.right树高，执行node节点的右旋操作；
LR：node.left树高>node.right树高，且node.left.left树高<node.left.right树高，先执行node.left节点的左旋->再执行node节点的右旋；
RR：node.right树高>node.left树高，且node.right.right树高>node.right.left树高，执行node节点的左旋操作；
RL：node.right树高>node.left树高，且node.right.right树高<node.right.left树高，先执行node.right节点的右旋->再执行node节点的左旋；

AVL平衡二叉树类 AVLTree.java 继承《BST二叉排序树》章节的 BinarySortTree.java，在 BinarySortTree.java 节点类基础上：增加左旋leftRotate、增加右旋rightRotate方法，重写覆盖添加元素addBSTNode、重写覆盖删除节点deleteBSTNode方法；

AVL树的添加和删除节点，均仅仅在每次BST二叉排序树调用 addNode 添加完节点和调用 deleteNode 删除节点之后递归回溯调用 avl 方法对节点进行平衡；

AVL树的添加和删除节点方法，仅仅是在最后的一行不同，其余均相同，只是加了个递归回溯调用 avl 方法对节点进行平衡；

添加节点方 

删除节点方法

demo中用到的测试用例数据

AVL平衡二叉树类 AVLTree.java

/**
 * @Author: ltx
 * @Description: AVL平衡二叉树
 */
public class AVLTree extends BinarySortTree {
    /**
     * 初始化AVL树
     *
     * @param arr 树的元素
     * @return
     */
    public static AVLTree initAVLTree(int[] arr) {
        AVLTree avlTree = new AVLTree();
        for (int value : arr) {
            avlTree.addBSTNode(new TreeNode(value));
        }
        return avlTree;
    }

    /**
     * 添加元素-AVL树添加节点
     *
     * @param node    添加元素的节点
     * @param element 要添加的节点
     * @return
     */
    @Override
    public TreeNode addBSTNode(TreeNode node, TreeNode element) {
        //root节点为空，则直接返回要添加的节点
        if (node == null) {
            return element;
        }
        if (element.value < node.value) {
            if (node.left == null) {
                node.left = element;
            } else {
                //递归回溯赋值
                node.left = addBSTNode(node.left, element);
            }
        } else {
            //右边空切值大于等于节点
            if (node.right == null) {
                node.right = element;
            } else {
                //递归回溯赋值
                node.right = addBSTNode(node.right, element);
            }
        }
        //回溯平衡node节点
        return avl(node);
    }

    /**
     * 删除节点
     *
     * @param value      要查找的节点值
     * @param node       节点
     * @param parentNode 要查找节点的父节点(顺便获取查找节点父节点, 方便删除节点使用)
     * @return
     */
    @Override
    public TreeNode deleteBSTNode(Integer value, TreeNode node, TreeNode parentNode) {
        if (node.value.equals(value)) {
            System.out.printf("找到, targetNode: %s, parentNode: %s\n", node, parentNode);
            //这里返回的是被删除节点的位置
            return deleteNode(node, parentNode);
        }
        if (value < node.value) {
            if (node.left != null) {
                //这里的node是父节点
                node.left = deleteBSTNode(value, node.left, node);
            } else {
                System.out.println("未找到!");
                return null;
            }
        } else {
            if (node.right != null) {
                //这里的node是父节点
                node.right = deleteBSTNode(value, node.right, node);
            } else {
                System.out.println("未找到!");
                return null;
            }
        }
        //对父节点做回溯平衡
        return avl(node);
    }

    /**
     * AVL树平衡节点
     * 原理-AVL树节点的平衡操作有4种情况
     * LL：node.left树高>node.right树高，且node.left.left树高>node.left.right树高，执行node节点的右旋操作；
     * LR：node.left树高>node.right树高，且node.left.left树高<node.left.right树高，先执行node.left节点的左旋->再执行node节点的右旋；
     * RR：node.right树高>node.left树高，且node.right.right树高>node.right.left树高，执行node节点的左旋操作；
     * RL：node.right树高>node.left树高，且node.right.right树高<node.right.left树高，先执行node.right节点的右旋->再执行node节点的左旋；
     *
     * @param node 要平衡的节点
     * @return
     */
    public TreeNode avl(TreeNode node) {
        //左子树高度
        int lH = node.left == null ? 0 : getHeight(node.left);
        //右子树高度
        int rH = node.right == null ? 0 : getHeight(node.right);
        //左右子树平衡因子不超1，则不用做什么，直接返回
        if (Math.abs(lH - rH) <= 1) {
            //avl树, 不用平衡处理
            return node;
        }
        if (lH > rH) {
            //左左子树高度
            int llH = node.left.left == null ? 0 : getHeight(node.left.left);
            //左右子树高度
            int lrH = node.left.right == null ? 0 : getHeight(node.left.right);
            if (llH > lrH) {
                //右旋
                System.out.println("LL");
            } else {
                //llH < lrH 则 左旋->右旋
                System.out.println("LR");
                node.left = leftRotate(node.left);
            }
            return rightRotate(node);
        } else {
            //右左子树高度
            int rlH = node.right.left == null ? 0 : getHeight(node.right.left);
            //右右子树高度
            int rrH = node.right.right == null ? 0 : getHeight(node.right.right);
            if (rrH > rlH) {
                //左旋
                System.out.println("RR");
            } else {
                //rrH < rlH 则 右旋->左旋
                System.out.println("RL");
                node.right = rightRotate(node.right);
            }
            return leftRotate(node);
        }
    }

    /**
     * 节点左旋
     *
     * @param node 旋转的节点
     * @return
     */
    public TreeNode leftRotate(TreeNode node) {
        //暂存root的右子树-指针
        TreeNode tempR = node.right;
        //暂存root的右子树的左子树-指针
        TreeNode tempRL = tempR.left;
        //tempR的左指针指向root
        tempR.left = node;
        //root的右指针指向tempRL
        node.right = tempRL;
        return tempR;
    }

    /**
     * 节点右旋
     *
     * @param node 要旋转的节点
     * @return
     */
    public TreeNode rightRotate(TreeNode node) {
        //暂存root的左子树-指针
        TreeNode tempL = node.left;
        //暂存root的左子树的右子树-指针
        TreeNode tempLR = tempL.right;
        //tempL的右指针指向root
        tempL.right = node;
        //root的左指针指向tempLR
        node.left = tempLR;
        return tempL;
    }

    public static void main(String[] args) {
        //初始化一个树
        int[] arr = {7, 3, 8, 10, 12, 5, 1, 9, 2, 6, 4};
        AVLTree avlTree = AVLTree.initAVLTree(arr);
        //前中后序遍历节点
//        avlTree.show();
//        System.out.println("搜索: ");
//        avlTree.search(9);
//        System.out.println("树高: ");
//        System.out.println(avlTree.getHeight(avlTree.root));
        System.out.println("中序:");
        avlTree.midOrder(avlTree.root);
        System.out.println();
        System.out.println("删除节点: ");
        avlTree.deleteBSTNode(7);
//        avlTree.deleteBSTNode(3);
//        avlTree.deleteBSTNode(2);
        System.out.println("中序:");
        avlTree.midOrder(avlTree.root);
        System.out.println();
    }
}