java语言实现红黑树 仅仅实现了插入算法

package cn.itcast.shujujiegou.tree;

/**
 * Created by likailong on 2016/10/13.
 */
public class RedBlackTree<T extends Comparable<? super T>> {
    private RedBlackNode<T> header;
    private RedBlackNode<T> nullNode;
    private static final int RED=0;
    private static final int BLACK=1;

    public boolean isEmpty() {
        return header==nullNode;
    }

    private static class RedBlackNode <T>{
        T element;
        int color;
        RedBlackNode<T> left;
        RedBlackNode<T> right;
        RedBlackNode(T theElement){
            this(theElement,null,null);
        }
        RedBlackNode(T theElement,RedBlackNode<T> lt,RedBlackNode<T> rt){
            element=theElement;
            left=lt;
            right=rt;
            color= RedBlackTree.BLACK;
        }

    }
    public RedBlackTree(){
        nullNode=new RedBlackNode<T>(null);
        nullNode.left=nullNode.right=nullNode;
        header=new RedBlackNode<T>(null);
        header.left=header.right=nullNode;
    }
    private RedBlackNode<T> rotate(T item,RedBlackNode<T> parent){
        if(compare(item,parent)<0)
            return parent.left=compare(item,parent.left)<0?rotateWithLeftChild(parent.left):rotateWithRightChild(parent.left);
        else
            return parent.right=compare(item,parent.right)<0?rotateWithLeftChild(parent.right):rotateWithRightChild(parent.right);
    }

    private RedBlackNode<T> rotateWithRightChild(RedBlackNode<T> k2) {
        RedBlackNode<T> k1=k2.right;
        k2.right=k1.left;
        k1.right=k2;
        return k1;
    }

    private RedBlackNode<T> rotateWithLeftChild(RedBlackNode<T> k2) {
        RedBlackNode<T> k1=k2.left;
        k2.left=k1.right;
        k1.right=k2;
        return k1;
    }

    private final int compare(T item,RedBlackNode<T> t ){
        if(t==header)
            return 1;
        else
            return item.compareTo(t.element);
    }
    private RedBlackNode<T> current;
    private RedBlackNode<T> parent;
    private RedBlackNode<T> grand;
    private RedBlackNode<T> great;
    private void handleReorient(T item){
        current.color=RED;
        current.left.color=BLACK;
        current.right.color=BLACK;
        if(parent.color==RED){
            grand.color=RED;
            if((compare(item,grand)<0)!=(compare(item,parent)<0))
                parent=rotate(item,grand);
            current=rotate(item,great);
            current.color=BLACK;
        }
        header.right.color=BLACK;
    }
    public void insert(T item){
        current=parent=grand=header;
        nullNode.element=item;
        while (compare(item,current)!=0){
            great=grand;
            grand=parent;
            parent=current;
            current=compare(item,current)<0?current.left:current.right;
            if(current.left.color==RED&¤t.right.color==RED){
                handleReorient(item);
            }
        }
        if(current!=nullNode)
            return;
        current=new RedBlackNode<>(item,nullNode,nullNode);
        if(compare(item,parent)<0)
            parent.left=current;
        else
            parent.right=current;
        handleReorient(item);}
    public void printTree(){
        if(isEmpty()){
            System.out.println("tree is empty");
        }else
            printTree(header.right);
    }
    private void printTree(RedBlackNode<T> t){
        if(t!=nullNode){
            printTree(t.left);
            System.out.println(t.element);
            printTree(t.right);
        }
    }
}