黄毅然的JAVA学习（六）

红黑二叉查找树构造与操作

（黄毅然的半月更！）
代码功能如下：
（1）红黑二叉查找树的创建；
（2）红黑二叉查找树插入功能；
（3）红黑二叉查找树的查找功能；
（4）红黑二叉查找树的最小键值删除功能；
（5）红黑二叉查找树的最大键值删除功能；

以下为定义节点类以及各个操作的算法

public class RBTree<T extends Comparable<T>> {
   
    private RBTNode<T> mRoot;    // 根结点
    private static final boolean RED   = false;
    private static final boolean BLACK = true;
    public class RBTNode<T extends Comparable<T>> {
   
        boolean color;        // 颜色
        T key;                // 关键字(键值)
        RBTNode<T> left;    // 左孩子
        RBTNode<T> right;    // 右孩子
        RBTNode<T> parent;    // 父结点

        public RBTNode(T key, boolean color, RBTNode<T> parent, RBTNode<T> left, RBTNode<T> right) {
   
            this.key = key;
            this.color = color;
            this.parent = parent;//构造节点结构类型为RBTNode
            this.left = left;
            this.right = right;
        }
        public T getKey() {
   
            return key;//返回关键字
        }

        public String toString() {
   
            return ""+key+(this.color==RED?"(R)":"B");
        }
    }

    public RBTree() {
   
        mRoot=null;//创建根节点，根节点为空
    }

    private RBTNode<T> parentOf(RBTNode<T> node) {
   
        return node!=null ? node.parent : null;//返回该节点的父母节点
    }
    private boolean colorOf(RBTNode<T> node) {
   
        return node!=null ? node.color : BLACK;//返回颜色
    }
    private boolean isRed(RBTNode<T> node) {
   
        return ((node!=null)&&(node.color==RED)) ? true : false;//判断节点是否为红色
    }
    private boolean isBlack(RBTNode<T> node) {
   
        return !isRed(node);//判断节点是否为黑色
    }
    private void setBlack(RBTNode<T> node) {
   
        if (node!=null)
            node.color = BLACK;//将节点设为黑色
    }
    private void setRed(RBTNode<T> node) {
   
        if (node!=null)
            node.color = RED;//将节点设为红色
    }
    private void setParent(RBTNode<T> node, RBTNode<T> parent) {
   
        if (node!=null)
            node.parent = parent;//将节点设置为父母节点
    }
    private void setColor(RBTNode<T> node, boolean color) {
   
        if (node!=null)
            node.color = color;
    }
    private void preOrder(RBTNode<T> tree) {
   //前序遍历"红黑树"
        if(tree != null) {
   
            System.out.print(tree.key+" ");
            preOrder(tree.left);
            preOrder(tree.right);
        }
    }
    public void preOrder() {
   
        preOrder(mRoot);
    }
    
    private RBTNode<T> iterativeSearch(RBTNode<T> x, T key) {
   //非递归实现查找"红黑树"中键值为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 RBTNode<T> iterativeSearch(T key) {
   
        return iterativeSearch(mRoot, key);
    }

    private RBTNode<T> minimum(RBTNode<T> tree) {
   
        if (tree == null)
            return null;
        while(tree.left != null)//查找最小结点：返回tree为根结点的红黑树的最小结点。
            tree = tree.left;
        return tree;
    }
    public T