AVL平衡树

package net.liuyx.algorithm;

import java.util.Comparator;

public class AVL<T> {

private static class AvlNode<E> {
@SuppressWarnings("unused")
public AvlNode(E theElement) {
this(theElement, null, null);
}

AvlNode(E theElement, AvlNode<E> lt, AvlNode<E> rt) {
element = theElement;
left = lt;
right = rt;
height = 0;
}

E element; // The data in the node
AvlNode<E> left;
AvlNode<E> right;
int height;
}

private Comparator<? super T> cmp;

public AVL(Comparator<? super T> c) {
cmp = c;
}

private int height(AvlNode<T> t) {
return t == null ? -1 : t.height;
}

private AvlNode<T> insert(T x, AvlNode<T> t) {
if (t == null)
return new AvlNode<T>(x, null, null);

int compareResult = compare(x, t.element);

if (compareResult < 0) {
t.left = insert(x, t.left);
if (height(t.left) - height(t.right) == 2) {
if (compare(x, 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 (compare(x, t.right.element) > 0)
t = rotateWithRightChild(t);
else
t = doubleWithRightChild(t);
} else
; // Duplicate; do nothing
t.height = Math.max(height(t.left), height(t.right)) + 1;
return t;
}

private AvlNode<T> rotateWithLeftChild(AvlNode<T> k2) {
AvlNode<T> k1 = k2.left;
k2.left = k1.right;
k1.right = k2;
k2.height = Math.max(height(k2.left), height(k2.right)) + 1;
k1.height = Math.max(height(k1.left), k2.height) + 1;
return k1;
}

private AvlNode<T> rotateWithRightChild(AvlNode<T> k2) {
AvlNode<T> 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), k2.height) + 1;
return k2;
}

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

private AvlNode<T> doubleWithRightChild(AvlNode<T> k3) {
k3.right = rotateWithRightChild(k3.right);
return rotateWithLeftChild(k3);
}

@SuppressWarnings("unchecked")
private int compare(T x, T y) {
if (cmp != null)
return cmp.compare(x, y);
return ((Comparable<T>) x).compareTo(y);
}
}