java数据结构——AvlTree（平衡二叉查找树）

package com.tig.tree;


/**
 * 3, 2, 1, 4, 5, 6, 7, 10, 9, 8
 * Created by Tig on 2017/5/19.
 */
public class AvlTree<E extends Comparable<? super E>> {

    private AvlNode<E> root;

    public AvlTree() {
        root = null;
    }

    public void insert(E x) {
        root = insert(x, root);
    }

    private AvlNode<E> insert(E x, AvlNode<E> t) {

        if (t == null) {
            return new AvlNode<>(x, null, null);
        }

        int compareResult = x.compareTo(t.element);

        if (compareResult < 0) {

            t.left = insert(x, t.left);
            if (height(t.left) - height(t.right) == 2) {

                if (x.compareTo(t.left.element) < 0) {
                    t = rotateWithLeftChild(t);
                } else {
                    t = doubleWithLeftChild(t);
                }
            }
        } else if (compareResult > 0) {

            t.right = insert(x, t.right);

            if (height(t.right) - height(t.left) == 2) {

                if (x.compareTo(t.right.element) > 0) {
                    t = rotateWithRightChild(t);
                } else {
                    t = doubleWithRightChild(t);
                }
            }
        }

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

        return t;
    }

    /**
     *          ③           
     *         /
     *        ②             
     *       /
     *      ①               
     * @param k2
     * @return
     */
    private AvlNode<E> rotateWithLeftChild(AvlNode<E> k2) {
        AvlNode<E> k1 = k2.left;
        k2.left = k1.right;
        k1.right = k2;
        k2.hight = Math.max(height(k2.left), height(k2.right)) + 1;
        k1.hight = Math.max(height(k1.left), k2.hight ) + 1;
        return k1;
    }

    private AvlNode<E> doubleWithLeftChild(AvlNode<E> k3) {
        k3.left = rotateWithRightChild(k3.left);
        return rotateWithLeftChild(k3);
    }

    /**
     *     ③            
     *      \
     *       ④          
     *        \
     *         ⑤        
     * @param k1
     * @return
     */
    private AvlNode<E> rotateWithRightChild(AvlNode<E> k1) {
        AvlNode<E> k2 = k1.right;
        k1.right = k2.left;
        k2.left = k1;
        k1.hight = Math.max(height(k1.left), height(k1.right)) + 1;
        k2.hight = Math.max(height(k2.right), k1.hight ) + 1;
        return k2;
    }
    
    /**
     *     ⑦           
     *      \
     *       ⑩         
     *      /
     *     ⑨            
     * @param k1
     * @return
     */				   
    private AvlNode<E> doubleWithRightChild(AvlNode<E> k1) {
        k1.right = rotateWithLeftChild(k1.right);
        return rotateWithRightChild(k1);
    }

    public int height(AvlNode<E> t){
        return t == null ? -1 : t.hight;
    }

    public static class AvlNode<E> {

        E element;      //the date in the node

        AvlNode<E> left;    //Left child

        AvlNode<E> right;   //right child

        int hight;  //Height

        public AvlNode() {
        }

        public AvlNode(E element) {
            this(element, null, null);
        }

        public AvlNode(E element, AvlNode<E> left, AvlNode<E> right) {
            this.element = element;
            this.left = left;
            this.right = right;
            this.hight = 0;
        }
    }
    
    public static void main(String[] args) {
		
    	  AvlTree<Integer> avlTree = new AvlTree<>();

          avlTree.insert(3);
          avlTree.insert(2);
          avlTree.insert(1);
          avlTree.insert(4);
          avlTree.insert(5);
          avlTree.insert(6);
          avlTree.insert(7);
          avlTree.insert(10);
          avlTree.insert(9);
          avlTree.insert(8);
	}
}