Rhyme/ AVL 平衡二叉数 插入平衡操作 Java版

AVL 平衡二叉数 插入平衡操作 Java版

package com.maple.avl.tree;

/**
 * 实现一棵AVL二叉平衡树的插入平衡操作
 * <p>
 * 树的深度为logN
 *
 * @author RhymeChiang
 * @date 2018/01/18
 **/
public class AVLTree<T extends Comparable<? super T>> {

    private AvlNode<T> root;
    /**
     * 被允许的最大子树差
     */
    private final int ALLOWED_IMBALANCE = 1;

    /**
     * AVL数静态内部类
     *
     * @param <T>
     */
    private static class AvlNode<T> {
        private T element;
        private int height;
        private AvlNode<T> left;
        private AvlNode<T> right;

        public AvlNode() {
        }

        public AvlNode(T element, int height) {
            this.element = element;
            this.height = height;
        }

        public AvlNode(T element, int height, AvlNode<T> left, AvlNode<T> right) {
            this.element = element;
            this.height = height;
            this.left = left;
            this.right = right;
        }
    }

    private int height(AvlNode<T> node) {
        if (node != null) {
            return node.height;
        }
        return -1;
    }

    /**
     * 插入一个元素element
     *
     * @param element
     */
    public void insert(T element) {
        root = insert(element,root);
    }

    /**
     * 插入一个元素到AVL树中
     *
     * @param element
     * @param node
     * @return
     */
    private AvlNode<T> insert(T element, AvlNode<T> node) {
        if (node == null) {
            return new AvlNode<>(element, 0);
        }

        int compareResult = node.element.compareTo(element);

        if (compareResult < 0) {
            node.left = insert(element, node.left);
        } else if (compareResult > 0) {
            node.right = insert(element, node.right);
        }
        return balance(node);
    }

    /**
     * 节点的平衡操作
     *
     * @param node
     * @return
     */
    private AvlNode<T> balance(AvlNode<T> node) {
        if (node == null) {
            return node;
        }

        // 调整左子树
        if (height(node.left) - height(node.right) > ALLOWED_IMBALANCE) {
            // 左左单旋转
            if (height(node.left.left) >= height(node.left.right)) {
                node = rotateLeftLeft(node);
            }
            // 左右双旋转
            else {
                node = doubleRotateLeftRight(node);
            }

        }

        // 调整右子树
        else if (height(node.right) - height(node.left) > ALLOWED_IMBALANCE) {
            // 右右单旋转
            if (height(node.right.right) >= height(node.right.left)) {
                node = rotateRightRight(node);
            }
            // 右左双旋转
            else {
                node = doubleRotateRightLeft(node);
            }
        }

        node.height = Math.max(height(node.left), height(node.right)) + 1;

        return node;

    }

    /**
     * 单旋转之左左旋转
     *
     * @param node
     * @return
     */
    private AvlNode<T> rotateLeftLeft(AvlNode<T> node) {
        node.left = node.left.right;
        node.left.right = node;
        node.height = Math.max(height(node.left), height(node.right)) + 1;
        node.left.height = Math.max(height(node.left.left), height(node.left.right)) + 1;
        return node.left;
    }

    /**
     * 单旋转之右右旋转
     *
     * @param k2
     * @return
     */
    private AvlNode<T> rotateRightRight(AvlNode<T> k2) {
        AvlNode k1 = k2.right;
        k2.right = k1.left;
        k1.left = k2;
        k2.height = Math.max(height(k2.left), height(k2.right)) + 1;
        k1.height = Math.max(height(k1.left), height(k1.right));
        return k1;
    }

    /**
     * 双旋转之右左旋转
     *
     * @param k2
     * @return
     */
    private AvlNode<T> doubleRotateRightLeft(AvlNode<T> k2) {
        k2.right = rotateLeftLeft(k2.right);
        return rotateRightRight(k2);
    }

    /**
     * 双旋转之左右旋转
     *
     * @param k2
     * @return
     */
    private AvlNode<T> doubleRotateLeftRight(AvlNode<T> k2) {
        k2.left = rotateRightRight(k2.left);
        return rotateLeftLeft(k2);
    }

}