实现一个红黑树

enum Color{
    RED,BLACK;    
}
public class RedBlackTree {
    static class TreeNode{
        int val;
        TreeNode left;
        TreeNode right;
        TreeNode father;
        Color color;
    }
    private TreeNode head;
    
    public RedBlackTree() {
    }
    
//    public void print() {
//        ArrayList<TreeNode> lists = new ArrayList<TreeNode>();
//        lists.add(head);
//        while(lists.size()>0) {
//            int size = lists.size();
//            for(int i=0;i<size;i++) {
//                TreeNode node = lists.remove(0);
//                if(node!=null)
//                    System.out.print(node.val+","+node.color.name()+" ");
//                else
//                    System.out.print("NIL,BLACK"+" ");
//                if(node!=null)
//                     lists.add(node.left);
//                if(node!=null)
//                     lists.add(node.right);
//            }
//            System.out.println();
//        }
//    }
    
    public void put(int val) {
        if(head==null) {
            TreeNode node = new TreeNode();
            node.color=Color.BLACK;
            node.val=val;
            head=node;
        }else{
            TreeNode node = new TreeNode();
            node.color = Color.RED;
            node.val=val;
            TreeNode start = head;
            while(true) {
                if(start.val>val) {
                    if(start.left!=null) {
                        start=start.left;
                    }else {
                        start.left=node;
                        node.father=start;
                        break;
                    }
                }else {
                    if(start.val<val) {
                        if(start.right!=null) {
                            start=start.right;
                        }else {
                            start.right=node;
                            node.father=start;
                            break;
                        }
                    }else {
                        break;
                    }
                }
            }
            RBINSERTFIXUP(node);
        }
    }

    private void RBINSERTFIXUP(TreeNode node) {
            //父节点为红色
            while(node.father!=null&&node.father.color==Color.RED) {
                //当前节点的父节点是祖父节点的左节点
                if(node.father.father.left==node.father) {
                    //叔叔节点
                    TreeNode uncle = node.father.father.right;
                    //如果叔叔节点是黑色节点
                    if(uncle==null||uncle.color==Color.BLACK) {
                        if(node.father.right==node) {
                              //如果当前节点是父节点的右节点
                              node = node.father;//将当前节点的父节点设置为当前节点
                              //左旋
                              TreeNode newFather = node.right;//当前节点的右节点是新的父节点
                              node.father.left=newFather;
                              newFather.father=node.father;
                              node.right=newFather.left;
                              node.father=newFather;
                              newFather.left=node;
                        }else {
                             //如果当前节点是父节点的左节点
                             node.father.color=Color.BLACK;//将父节点设置为黑色
                             node.father.father.color=Color.RED;//将祖父节点设置为红色
                             //以当前节点的父节点为支点进行右旋
                             TreeNode newBro = node.father.father;
                             node.father.father=newBro.father;
                             if(newBro.father!=null) {
                                 if(newBro.father.left==newBro) {
                                     newBro.father.left=node.father;
                                 }else {
                                     newBro.father.right=node.right;
                                 }
                             }else {
                                 head = node.father;
                             }
                             newBro.left=node.father.right;
                             if(newBro.left!=null)
                                  newBro.left.father=newBro;
                             node.father.right=newBro;
                             newBro.father=node.father;
                        }
                    }else {
                        node.father.color=Color.BLACK;//将父节点设置为黑色
                        node.father.father.color=Color.RED;//将祖父节点设置为红色
                        node.father.father.right.color=Color.BLACK;//将叔叔节点设置为黑色
                        node=node.father.father;
                        if(node.father==null) {
                            node.color=Color.BLACK;
                            head=node;
                            break;
                        }
                    }
                }else {
                    //叔叔节点
                    TreeNode uncle = node.father.father.left;
                    //如果叔叔节点是黑色节点
                    if(uncle==null||uncle.color==Color.BLACK) {
                        if(node.father.left==node) {
                              //如果当前节点是父节点的左节点
                              node = node.father;//将当前节点的父节点设置为当前节点
                              //右旋
                              TreeNode newFather = node.left;//当前节点的右节点是新的父节点
                              node.father.right=newFather;
                              newFather.father=node.father;
                              node.left=newFather.right;
                              node.father=newFather;
                              newFather.right=node;
                        }else {
                             //如果当前节点是父节点的右节点
                             node.father.color=Color.BLACK;//将父节点设置为黑色
                             node.father.father.color=Color.RED;//将祖父节点设置为红色
                             //以当前节点的父节点为支点进行左旋
                             TreeNode newBro = node.father.father;
                             node.father.father=newBro.father;
                             if(newBro.father!=null) {
                                 if(newBro.father.right==newBro) {
                                     newBro.father.right=node.father;
                                 }else {
                                     newBro.father.left=node.right;
                                 }
                             }else {
                                 head = node.father;
                             }
                             newBro.right=node.father.left;
                             if(newBro.right!=null) 
                                  newBro.right.father=newBro;
                             node.father.left=newBro;
                             newBro.father=node.father;
                        }
                    }else {
                        node.father.color=Color.BLACK;//将父节点设置为黑色
                        node.father.father.color=Color.RED;//将祖父节点设置为红色
                        node.father.father.left.color=Color.BLACK;//将叔叔节点设置为黑色
                        node=node.father.father;
                        if(node.father==null) {
                            node.color=Color.BLACK;
                            head=node;
                            break;
                        }
                    }
                }
            }
    }
}