红黑树

/**
 * @author damei
 * @Time 2020/3/10 08:52
 * @Description:
 */
public class RBTree <T extends Comparable<T>>{

    private RBNode<T> mRoot;//根结点
    private static final boolean RED = false;
    private static final boolean BLACK = true;

    public RBTree() {
        mRoot = null;
    }

    public class RBNode<T extends Comparable<T>>{
        boolean color;//颜色
        T key;//关键字
        RBNode<T> left;//左孩子
        RBNode<T> right;//右孩子
        RBNode<T> parent;//父结点

        public RBNode(boolean color, T key, RBNode<T> left, RBNode<T> right, RBNode<T> parent) {
            this.color = color;
            this.key = key;
            this.left = left;
            this.right = right;
            this.parent = parent;
        }

        public T getKey() {
            return key;
        }

        @Override
        public String toString() {
            return "RBNode{" +
                    "color=" + color +
                    ", key=" + key +
                    ", left=" + left +
                    ", right=" + right +
                    ", parent=" + parent +
                    '}';
        }
    }

    /**
     * 递归实现查找“红黑树x”中的键值为key的节点
     */
    private RBNode<T> search(RBNode<T> x,T key){
        if(x==null){return x;}
        int cmp = key.compareTo(x.key);
        if(cmp<0){
            return search(x.left,key);
        }else if(cmp>0){
            return search(x.right,key);
        }else{
            return x;
        }
    }
    public RBNode<T> serach(T key){
        return search(mRoot,key);
    }
    /**
     * 非递归实现查找“红黑树x”中键值为key的节点
     */
    private RBNode<T> iterativeSearch(RBNode<T> x,T key){
        while(x!=null){
            int cmp = key.compareTo(x.key);
            if(cmp<0){
                x = x.left;
            }else if(cmp>0){
                x = x.right;
            }else {
                return x;
            }
        }
        return x;
    }
    public RBNode<T> iterativeSearch(T key){
        return iterativeSearch(mRoot,key);
    }

    /**
     * 查找最小结点
     */
    private RBNode<T> minimum(RBNode<T> tree){
        if(tree==null){
            return null;
        }
        while(tree.left!=null){
            tree = tree.left;
        }
        return tree;
    }
    public T minimum(){
        RBNode<T> p = minimum(mRoot);
        if(p!=null){
            return p.key;
        }
        return null;
    }
    /**
     * 找出最大结点 返回tree为根结点的红黑树的最大结点
     */
    private RBNode<T> maximum(RBNode<T> tree){
        if(tree==null){
            return null;
        }
        while (tree.right!=null){
            tree = tree.right;
        }
        return tree;
    }
    public T maximum(){
        RBNode<T> p = maximum(mRoot);
        if(p!=null){
            return p.key;
        }
        return null;
    }

    /**
     * 查找结点（x）的后继结点
     * 即大于该结点的最小结点
     */
    public RBNode<T> successor(RBNode<T> x){
        //如果该结点存在右孩子，那么大于该结点的最小结点一定是右孩子的最小结点
        if(x.right!=null){
            return minimum(x.right);
        }
        //如果该结点没有孩子
        //1.该结点是一个左孩子 ,则该结点的后继结点为它的父结点
        //2.该结点是一个右孩子，则查找该结点的最低的父结点，并且该父结点要具有左孩子
        //找到这个最低父结点就是该结点的后继结点
        RBNode<T> y = x.parent;
        while ((y!=null)&&(x==y.right)){
            x = y;
            y = y.parent;
        }
        return y;
    }

    /**
     * 查找前驱结点
     */
    public RBNode<T> predecessor(RBNode<T> x){
        //如果存在左孩子，则x的前驱结点就是以左孩子为根的最大结点
        if(x.left!=null){
            return maximum(x.left);
        }
        //如果该结点没有左孩子
        //1.该结点是一个右孩子 则它的前驱结点就是它的父结点
        //2.该结点是一个左孩子 查找该结点的最低父结点

        RBNode<T> y = x.parent;
        while((y!=null)&&(x==y.left)){
            x=y;
            y=y.parent;
        }
        return y;
    }
	//待完成
	
    
}