常见的查找算法（五）：树表查找之二 ---- 红黑树

红黑树是每个节点都带有颜色属性的二叉查找树，颜色为 红色 或 黑色。在二叉查找树强制一般要求以外，对于任何有效的红黑树我们增加了如下的额外要求：

1. 节点是红色或黑色。
2. 根是黑色。
3. 所有叶子都是黑色（叶子是NIL节点）。
4. 每个红色节点必须有两个黑色的子节点。（从每个叶子到根的所有路径上不能有两个连续的红色节点。）
5. 从任一节点到其每个叶子的所有简单路径都包含相同数目的黑色节点。

下面是一个具体的红黑树的图例：

旋转 

 旋转是一种能保持二叉搜索树性质的搜索树局部操作。其中两种旋转分别为左旋和右旋：

 在某个结点 x 上进行左旋时，假设它的右孩子为y而不是树的 T.nil 结点；x为其右孩子而不是 T.nil 结点的树内任意节点。

 左旋以 x 到 y 的链为“支轴”进行，使得 y 成为该子树的新的根节点，x 成为 y 的左孩子，y 的左孩子变成 x 的右孩子；右旋与此相反。

左旋代码：

    /**
     * 左旋
     * 左旋示意图（对节点x进行左旋）：
     * 　　  px                               px
     * 　　  /                                /
     * 　　  x                                y
     * 　　 /           --(左旋)-->         /  
     * 　　lx   y                           x   ry
     *    /                         　　 /  
     *  ly  ry                     　　 lx   ly
     *
     * @param x
     */
    private void leftRotate(RBTNode<T> x) {
        RBTNode<T> y = x.right; // y是x的右节点

        x.right = y.left;       // 把x的左节点变为y的右节点
        // 若y有左子节点，把y的左节点的父节点换成x
        if (y.left != null) {
            y.left.parent = x;
        }

        y.parent = x.parent;    // y的父节点（原来是x）设为x的父节点

        // 若x是根节点，y直接变根节点
        if (x.parent == null) {
            this.mRoot = y;
        } else {
            if (x.parent.left == x) {
                x.parent.left = y;  // 如果x是x父节点的左孩子，把x的父节点的左孩子指向y
            } else {
                x.parent.right = y; // 如果x是x父节点的右孩子，把x的父节点的右孩子指向y
            }
        }

        y.left = x;     // 将y的左节点指向x
        x.parent = y;   // 将x的父节点设为y
    }

右旋代码：

    /**
     * 右旋，操作和左旋相反
     * 右旋示意图（对节点y进行左旋）：
     * 　　   py                              py
     * 　　  /                                /
     * 　　  y                                x
     * 　　 /           --(右旋)-->         /  
     * 　　x  ry                           lx   y
     *   /                                   / 
     *  lx  rx                               rx  ry
     *
     * @param y
     */
    private void rightRotate(RBTNode<T> y) {
        RBTNode<T> x = y.left;  // y的左孩子

        y.left = x.right;
        if (x.right != null) {
            x.right.parent = y;
        }

        x.parent = y.parent;

        if (y.parent == null) {
            this.mRoot = x;
        } else {
            if (y.parent.left == y) {
                y.parent.left = x;
            } else {
                y.parent.right = x;
            }
        }

        x.right = y;
        y.parent = x;
    }

红黑树新结点插入代码：

就像一个普通的二叉搜索树一样，将新结点插入树中，并将其着为红色。之后为了能保证红黑的性质，还需要一个辅助代码对结点重新着色并且旋转。

    /**
     * 插入操作
     *
     * @param node
     */
    private void insert(RBTNode<T> node) {
        int result;
        RBTNode<T> y = null;
        RBTNode<T> x = this.mRoot;

        // 查找树中插入点的父结点y的位置
        while (x != null) {
            y = x;  // 注意这里，y不是空的
            result = node.key.compareTo(x.key);
            if (result < 0) {
                x = x.left;
            } else {
                x = x.right;
            }
        }

        node.parent = y;
        if (y != null) {
            result = node.key.compareTo(y.key);
            if (result < 0) {
                y.left = node;
            } else {
                y.right = node;
            }
        } else {
            this.mRoot = node;
        }

        node.color = RED;

        // 插入后修正树
        insertFixUp(node);
    }

辅助修正函数：

    /**
     * 红黑树插入修正函数
     *
     * @param node
     */
    private void insertFixUp(RBTNode<T> node) {
        RBTNode<T> parent, gparent; // 父节点，祖父节点

        while (((parent = parentOf(node)) != null) && isRed(parent)) {
            gparent = parentOf(parent);

            // 父节点是祖父节点的左孩子
            if (parent == gparent.left) {
                RBTNode<T> uncle = gparent.right; // 叔叔节点，祖父的右节点

                // ① 叔叔节点是红色的
                if ((uncle != null) && isRed(uncle)) {
                    node.setColor(BLACK);
                    parent.setColor(BLACK);
                    gparent.setColor(RED);
                    node = gparent;
                    continue;
                }

                // ② 叔叔是黑色，且当前节点是右孩子
                if (parent.right == node) {
                    RBTNode<T> tmp;
                    leftRotate(parent);
                    tmp = parent;
                    parent = node;
                    node = tmp;
                }

                // ③ 叔叔是黑色，且当前节点是左孩子
                parent.setColor(BLACK);
                gparent.setColor(RED);
                rightRotate(gparent);

            } else {    // 父节点是祖父节点的右孩子

                RBTNode<T> uncle = gparent.left; // 叔叔节点，祖父的左节点

                // ① 叔叔节点是红色的
                if ((uncle != null) && isRed(uncle)) {
                    uncle.setColor(BLACK);
                    parent.setColor(BLACK);
                    gparent.setColor(RED);
                    node = gparent;
                    continue;
                }

                // ② 叔叔是黑色，且当前节点是左孩子
                if (parent.left == node) {
                    RBTNode<T> tmp;
                    rightRotate(parent);
                    tmp = parent;
                    parent = node;
                    node = tmp;
                }

                // ③ 叔叔是黑色，且当前节点是右孩子
                parent.setColor(BLACK);
                gparent.setColor(RED);
                leftRotate(gparent);
            }
        }

        this.mRoot.setColor(BLACK);
    }

修正过程实例：

以下图中的 z 为插入后的结点，y 表示叔结点uncle，图中的每个子树的低端的节点是红黑树代码中的边界，边界中每个节点有黑色的哨兵没有画出来。

下面是介绍的是上面代码中 父节点是祖父节点的左孩子 的代码。

先看图中的第一个树，插入的 z 结点和 z.parent 父节点都是 RED，这违反了性质四。

情况 1（得到的是图中的第二个树）：由于图中的第一个树中叔结点是红色，z 结点和 z.parent 父节点都是 RED，结点都要被重新着色，并沿着指针 z 上升；

情况 2（得到的是图中的第三个树）：由于图中的第二个树中 z 及其父节点 z.parent 都为红色，其叔结点为黑色，左旋父节点 z.parent后得到；

情况 3（得到的是图中的第四个树）：z 是其父节点的左孩子，重新着色后右旋的到图中的第四个树，这样之后就是合法的红黑树了。

分析红黑树的插入时间复杂度：

一颗具有 n 个节点的红黑树高度为O(log n)，则按照一个普通的二叉查找树的方式插入结点需要花费 O(log n)；修正代码中，当情况 1发生，指针 z沿着树上升2层，才会执行 while 循环，while 循环可能执行的总次数为 O(log n)。所以红黑树的插入的总的时间复杂度为 O(log n)。此外，插入算法中总的来说旋转次数不超过 2 次。

红黑树的删除：

    /**
     * 删除树中某个节点
     *
     * @param node 要删除的结点
     */
    private void remove(RBTNode<T> node) {
        RBTNode<T> child, parent;
        boolean color;

        // 要删除的结点node有2个子结点
        if ((node.left != null) && (node.right != null)) {
            RBTNode<T> replace = node;

            // 寻找后继结点
            replace = replace.right;
            while (replace.left != null) {
                replace = replace.left;
            }

            // 判断删除的结点是不是根结点
            if (parentOf(node) != null) {
                if (parentOf(node).left == node) {
                    parentOf(node).left = replace;
                } else {
                    parentOf(node).right = replace;
                }
            } else {
                this.mRoot = replace;
            }


            child = replace.right; // 后继结点的右孩子？左孩子呢？左孩子有早就是后继结点了，所以直接看后继结点还有没有右孩子
            parent = parentOf(replace); // 后继结点的父结点
            color = replace.color;  // 后继结点的颜色

            // 要删除的结点node是后继结点的父结点
            if (parent == node) {
                parent = replace;   // 这里应该后继结点直接替换node，留下后继结点的右子树
            } else {    // 后继结点的父结点不是要删除的结点node
                // 后继结点的孩子不为空
                if (child != null)
                    child.setParent(parent); // 把<后继结点的右孩子>的<父结点>设为<后继结点的父结点>
                parent.left = child;    // <后继结点的父结点>的<左孩子>指向<后继结点的右孩子>

                replace.right = node.right; // 后继结点的右孩子指向删除结点的右子树
                node.right.setParent(replace);  //删除结点的右子树的父结点设置为后继结点
            }

            replace.parent = node.parent;
            replace.color = node.color;
            replace.left = node.left;
            node.left.parent = replace;

            if (color == BLACK)
                removeFixup(child, parent);

            node = null;

            return;
        }

        // 选一个要删除的结点的孩子
        if (node.left != null) {
            child = node.left;
        } else {
            child = node.right;
        }

        parent = node.parent;
        color = node.color;

        // 要删除的结点的孩子不为空
        if (child != null)
            child.parent = parent;

        // 要删除的结点的父结点是不是树根
        if (parent != null) {
            if (parent.left == node) {
                parent.left = child;
            } else {
                parent.right = child;
            }
        } else {
            this.mRoot = child;
        }

        if (color == BLACK)
            removeFixup(child, parent);

        node = null;
    }

删除修正函数：

    /**
     * 删除修正函数
     *
     * @param x
     * @param parent
     */
    private void removeFixup(RBTNode<T> x, RBTNode<T> parent) {
        RBTNode<T> w;

        while ((x == null || isBlack(x)) && (x != this.mRoot)) {
            if (parent.left == x) {
                w = parent.right;

                // ① x的兄弟结点w是红色的
                if (isRed(w)) {
                    w.setColor(BLACK); // w染黑
                    parent.setColor(RED);
                    leftRotate(parent);
                    w = parent.right;
                }

                // ② x的兄弟结点w是黑色的，而且w的两个孩子结点都是黑色的
                if ((w.left == null || isBlack(w.left)) &&
                        (w.right == null || isBlack(w.right))) {
                    w.setColor(RED);
                    x = parent;
                    parent = parentOf(x);

                } else {

                    // ③ x的兄弟结点w是黑色的，w的右孩子是黑色的，w的左孩子是红色的
                    if ((w.right == null || isBlack(w.right)) &&
                            (w.left == null || isBlack(w.left))) {
                        w.left.setColor(BLACK);
                        w.setColor(RED);
                        rightRotate(w);
                        w = parent.right;
                    }

                    // ④ x的兄弟结点w是黑色的，w的右孩子是红色的
                    w.setColor(parent.color);
                    parent.setColor(BLACK);
                    w.right.setColor(BLACK);
                    leftRotate(parent);
                    x = this.mRoot;

                    break;
                }

            } else {

                w = parent.left;
                // ① x的兄弟结点w是红色的
                if (isRed(w)) {
                    w.setColor(BLACK);
                    parent.setColor(RED);
                    rightRotate(parent);
                    w = parent.left;
                }

                // ②  x的兄弟结点w是黑色的，而且w的两个孩子结点都是黑色的
                if ((w.left == null || isBlack(w.left)) &&
                        (w.right == null || isBlack(w.right))) {
                    w.setColor(RED);
                    x = parent;
                    parent = parentOf(x);
                } else {

                    // ③ x的兄弟结点w是黑色的，w的右孩子是黑色的，w的左孩子是红色的
                    if (w.left == null || isBlack(w.left)) {
                        w.right.setColor(BLACK);
                        w.setColor(RED);
                        leftRotate(w);
                        w = parent.left;
                    }

                    // ④ x的兄弟结点w是黑色的，w的右孩子是红色的
                    w.setColor(parent.color);
                    parent.setColor(BLACK);
                    w.left.setColor(BLACK);
                    rightRotate(parent);
                    x = this.mRoot;

                    break;
                }
            }
        }

        if (x != null)
            x.setColor(BLACK);
    }

红黑树总的代码（包含测试代码）：

package tree;

/**
 * @program: MyPractice
 * @description: 红黑树
 * @author: Mr.Wu
 * @create: 2019-08-28 17:19
 **/
public class RBTree<T extends Comparable<T>> {
    // 根节点
    private RBTNode<T> mRoot;

    private static final boolean RED = false;
    private static final boolean BLACK = true;

    private static final int a[] = {10, 40, 30, 60, 90, 70, 20, 50, 80};
    private static final boolean mDebugInsert = false;
    private static final boolean mDebugDelete = true;

    /**
     * 左旋
     * 左旋示意图（对节点x进行左旋）：
     * px                               px
     * /                                /
     * x                                y
     * /           --(左旋)-->         /  
     * lx   y                           x   ry
     * /                         /  
     * ly  ry                     lx   ly
     *
     * @param x
     */
    private void leftRotate(RBTNode<T> x) {
        RBTNode<T> y = x.right; // y是x的右节点

        x.right = y.left;       // 把y的左节点变为x的右节点
        // 若y有左子节点，把y的左节点的父节点换成x
        if (y.left != null) {
            y.left.parent = x;
        }

        y.parent = x.parent;    // y的父节点（原来是x）设为x的父节点

        // 若x是根节点，y直接变根节点
        if (x.parent == null) {
            this.mRoot = y;
        } else {
            if (x.parent.left == x) {
                x.parent.left = y;  // 如果x是x父节点的左孩子，把x的父节点的左孩子指向y
            } else {
                x.parent.right = y; // 如果x是x父节点的右孩子，把x的父节点的右孩子指向y
            }
        }

        y.left = x;     // 将y的左节点指向x
        x.parent = y;   // 将x的父节点设为y
    }

    /**
     * 右旋，操作和左旋相反
     * 右旋示意图（对节点y进行左旋）：
     * py                              py
     * /                                /
     * y                                x
     * /           --(右旋)-->         /  
     * x  ry                           lx   y
     * /                                   / 
     * lx  rx                               rx  ry
     *
     * @param y
     */
    private void rightRotate(RBTNode<T> y) {
        RBTNode<T> x = y.left;  // y的左孩子

        y.left = x.right;
        if (x.right != null) {
            x.right.parent = y;
        }

        x.parent = y.parent;

        if (y.parent == null) {
            this.mRoot = x;
        } else {
            if (y.parent.left == y) {
                y.parent.left = x;
            } else {
                y.parent.right = x;
            }
        }

        x.right = y;
        y.parent = x;
    }

    /**
     * 插入结点
     *
     * @param key
     */
    public void insert(T key) {
        RBTNode<T> node = new RBTNode<>(BLACK, key, null, null, null);
        if (node != null) {
            insert(node);
        }
    }

    /**
     * 插入操作
     *
     * @param node
     */
    private void insert(RBTNode<T> node) {
        int result;
        RBTNode<T> y = null;
        RBTNode<T> x = this.mRoot;

        // 查找树中插入点的父结点y的位置
        while (x != null) {
            y = x;  // 注意这里，y不是空的
            result = node.key.compareTo(x.key);
            if (result < 0) {
                x = x.left;
            } else {
                x = x.right;
            }
        }

        node.parent = y;
        if (y != null) {
            result = node.key.compareTo(y.key);
            if (result < 0) {
                y.left = node;
            } else {
                y.right = node;
            }
        } else {
            this.mRoot = node;
        }

        node.color = RED;

        // 插入后修正树
        insertFixUp(node);
    }

    /**
     * 红黑树插入修正函数
     *
     * @param node
     */
    private void insertFixUp(RBTNode<T> node) {
        RBTNode<T> parent, gparent; // 父节点 与 祖父节点

        while (((parent = parentOf(node)) != null) && isRed(parent)) {
            gparent = parentOf(parent);

            // 父节点是祖父节点的左孩子
            if (parent == gparent.left) {
                RBTNode<T> uncle = gparent.right; // 叔叔节点，祖父的右节点

                // ① 叔叔节点是红色的
                if ((uncle != null) && isRed(uncle)) {
                    node.setColor(BLACK);
                    parent.setColor(BLACK);
                    gparent.setColor(RED);
                    node = gparent;
                    continue;
                }

                // ② 叔叔是黑色，且当前节点是右孩子
                if (parent.right == node) {
                    RBTNode<T> tmp;
                    leftRotate(parent);
                    tmp = parent;
                    parent = node;
                    node = tmp;
                }

                // ③ 叔叔是黑色，且当前节点是左孩子
                parent.setColor(BLACK);
                gparent.setColor(RED);
                rightRotate(gparent);

            } else {    // 父节点是祖父节点的右孩子

                RBTNode<T> uncle = gparent.left; // 叔叔节点，祖父的左节点

                // ① 叔叔节点是红色的
                if ((uncle != null) && isRed(uncle)) {
                    uncle.setColor(BLACK);
                    parent.setColor(BLACK);
                    gparent.setColor(RED);
                    node = gparent;
                    continue;
                }

                // ② 叔叔是黑色，且当前节点是左孩子
                if (parent.left == node) {
                    RBTNode<T> tmp;
                    rightRotate(parent);
                    tmp = parent;
                    parent = node;
                    node = tmp;
                }

                // ③ 叔叔是黑色，且当前节点是右孩子
                parent.setColor(BLACK);
                gparent.setColor(RED);
                leftRotate(gparent);
            }
        }

        this.mRoot.setColor(BLACK);
    }

    /**
     * 删除树中某个值
     *
     * @param key
     */
    public void remove(T key) {
        RBTNode<T> node;

        if ((node = search(mRoot, key)) != null)
            remove(node);
    }

    /**
     * 删除树中某个节点
     *
     * @param node 要删除的结点
     */
    private void remove(RBTNode<T> node) {
        RBTNode<T> child, parent;
        boolean color;

        // 要删除的结点node有2个子结点
        if ((node.left != null) && (node.right != null)) {
            RBTNode<T> replace = node;

            // 寻找后继结点
            replace = replace.right;
            while (replace.left != null) {
                replace = replace.left;
            }

            // 判断删除的结点是不是根结点
            if (parentOf(node) != null) {
                if (parentOf(node).left == node) {
                    parentOf(node).left = replace;
                } else {
                    parentOf(node).right = replace;
                }
            } else {
                this.mRoot = replace;
            }


            child = replace.right; // 后继结点的右孩子？左孩子呢？左孩子有早就是后继结点了，所以直接看后继结点还有没有右孩子
            parent = parentOf(replace); // 后继结点的父结点
            color = replace.color;  // 后继结点的颜色

            // 要删除的结点node是后继结点的父结点
            if (parent == node) {
                parent = replace;   // 这里应该后继结点直接替换node，留下后继结点的右子树
            } else {    // 后继结点的父结点不是要删除的结点node
                // 后继结点的孩子不为空
                if (child != null)
                    child.setParent(parent); // 把<后继结点的右孩子>的<父结点>设为<后继结点的父结点>
                parent.left = child;    // <后继结点的父结点>的<左孩子>指向<后继结点的右孩子>

                replace.right = node.right; // 后继结点的右孩子指向删除结点的右子树
                node.right.setParent(replace);  //删除结点的右子树的父结点设置为后继结点
            }

            replace.parent = node.parent;
            replace.color = node.color;
            replace.left = node.left;
            node.left.parent = replace;

            if (color == BLACK)
                removeFixup(child, parent);

            node = null;

            return;
        }

        // 选一个要删除的结点的孩子
        if (node.left != null) {
            child = node.left;
        } else {
            child = node.right;
        }

        parent = node.parent;
        color = node.color;

        // 要删除的结点的孩子不为空
        if (child != null)
            child.parent = parent;

        // 要删除的结点的父结点是不是树根
        if (parent != null) {
            if (parent.left == node) {
                parent.left = child;
            } else {
                parent.right = child;
            }
        } else {
            this.mRoot = child;
        }

        if (color == BLACK)
            removeFixup(child, parent);

        node = null;
    }

    /**
     * 删除修正函数
     *
     * @param x
     * @param parent
     */
    private void removeFixup(RBTNode<T> x, RBTNode<T> parent) {
        RBTNode<T> w;

        while ((x == null || isBlack(x)) && (x != this.mRoot)) {
            if (parent.left == x) {
                w = parent.right;

                // ① x的兄弟结点w是红色的
                if (isRed(w)) {
                    w.setColor(BLACK); // w染黑
                    parent.setColor(RED);
                    leftRotate(parent);
                    w = parent.right;
                }

                // ② x的兄弟结点w是黑色的，而且w的两个孩子结点都是黑色的
                if ((w.left == null || isBlack(w.left)) &&
                        (w.right == null || isBlack(w.right))) {
                    w.setColor(RED);
                    x = parent;
                    parent = parentOf(x);

                } else {

                    // ③ x的兄弟结点w是黑色的，w的右孩子是黑色的，w的左孩子是红色的
                    if ((w.right == null || isBlack(w.right)) &&
                            (w.left == null || isBlack(w.left))) {
                        w.left.setColor(BLACK);
                        w.setColor(RED);
                        rightRotate(w);
                        w = parent.right;
                    }

                    // ④ x的兄弟结点w是黑色的，w的右孩子是红色的
                    w.setColor(parent.color);
                    parent.setColor(BLACK);
                    w.right.setColor(BLACK);
                    leftRotate(parent);
                    x = this.mRoot;

                    break;
                }

            } else {

                w = parent.left;
                // ① x的兄弟结点w是红色的
                if (isRed(w)) {
                    w.setColor(BLACK);
                    parent.setColor(RED);
                    rightRotate(parent);
                    w = parent.left;
                }

                // ②  x的兄弟结点w是黑色的，而且w的两个孩子结点都是黑色的
                if ((w.left == null || isBlack(w.left)) &&
                        (w.right == null || isBlack(w.right))) {
                    w.setColor(RED);
                    x = parent;
                    parent = parentOf(x);
                } else {

                    // ③ x的兄弟结点w是黑色的，w的右孩子是黑色的，w的左孩子是红色的
                    if (w.left == null || isBlack(w.left)) {
                        w.right.setColor(BLACK);
                        w.setColor(RED);
                        leftRotate(w);
                        w = parent.left;
                    }

                    // ④ x的兄弟结点w是黑色的，w的右孩子是红色的
                    w.setColor(parent.color);
                    parent.setColor(BLACK);
                    w.left.setColor(BLACK);
                    rightRotate(parent);
                    x = this.mRoot;

                    break;
                }
            }
        }

        if (x != null)
            x.setColor(BLACK);
    }

    private boolean isRed(RBTNode<T> node) {
        return (node != null) && (node.color == RED);
    }

    private boolean isBlack(RBTNode<T> node) {
        return !isRed(node);
    }

    /**
     * 二叉查找，递归
     *
     * @param x
     * @param key
     * @return
     */
    private RBTNode<T> search(RBTNode<T> x, T key) {
        if (x == null)
            return x;

        int result = key.compareTo(x.key);
        if (result < 0) {
            return search(x.left, key);
        } else if (result > 0) {
            return search(x.right, key);
        } else {
            return x;
        }
    }

    /**
     * 找结点的父节点
     *
     * @param node
     * @return
     */
    private RBTNode<T> parentOf(RBTNode<T> node) {
        return (node != null) ? node.parent : null;
    }

    /**
     * 置空树
     */
    public void clear() {
        destroy(mRoot);
        mRoot = null;
    }

    /**
     * 销毁树
     *
     * @param tree
     */
    private void destroy(RBTNode<T> tree) {
        if (tree == null) {
            return;
        }
        if (tree.left != null) {
            destroy(tree.left);
        }
        if (tree.right != null) {
            destroy(tree.right);
        }

        tree = null;
    }

    /**
     * 先序遍历
     */
    public void preOrder() {
        preOrder(mRoot);
    }

    /**
     * 先序遍历
     *
     * @param tree
     */
    private void preOrder(RBTNode<T> tree) {
        if (tree != null) {
            System.out.print(tree.key + " ");
            preOrder(tree.left);
            preOrder(tree.right);
        }
    }

    public void inOrder() {
        inOrder(mRoot);
    }

    /**
     * 中序遍历
     *
     * @param tree
     */
    private void inOrder(RBTNode<T> tree) {
        if (tree != null) {
            inOrder(tree.left);
            System.out.print(tree.key + " ");
            inOrder(tree.right);
        }
    }

    /**
     * 后序遍历
     */
    public void postOrder() {
        postOrder(mRoot);
    }

    /**
     * 后序遍历
     *
     * @param tree
     */
    private void postOrder(RBTNode<T> tree) {
        if (tree != null) {
            postOrder(tree.left);
            postOrder(tree.right);
            System.out.print(tree.key + " ");
        }
    }

    /**
     * 打印树的信息
     */
    public void print() {
        if (mRoot != null) {
            print(mRoot, mRoot.key, 0);
        }
    }

    /**
     * 打印树的详细信息
     *
     * @param tree
     * @param key
     * @param direction
     */
    private void print(RBTNode<T> tree, T key, int direction) {
        if (tree != null) {
            if (direction == 0) {
                System.out.printf("%2d(B) is root
", tree.key);
            } else {
                System.out.printf("%2d(%s) is %2d's %6s child
", tree.key, isRed(tree) ? "R" : "B",
                        key, direction == 1 ? "right" : "left");
            }
            print(tree.left, tree.key, -1);
            print(tree.right, tree.key, 1);
        }
    }

    /**
     * 找树中值最大的结点
     *
     * @param tree
     * @return
     */
    private RBTNode<T> maximum(RBTNode<T> tree) {
        if (tree == null)
            return null;
        while (tree.right != null)
            tree = tree.right;
        return null;
    }

    /**
     * 找树中值最大的结点
     *
     * @return
     */
    public T maximum() {
        RBTNode<T> p = maximum(mRoot);
        if (p != null)
            return p.key;
        return null;
    }

    /**
     * 找树中值最小的结点
     *
     * @param tree
     * @return
     */
    private RBTNode<T> minimum(RBTNode<T> tree) {
        if (tree == null)
            return null;
        while (tree.left != null)
            tree = tree.left;
        return tree;
    }

    /**
     * 找树中值最小的结点
     */
    public T minimum() {
        RBTNode<T> p = minimum(mRoot);
        if (p != null)
            return p.key;
        return null;
    }

    /**
     * 测试主函数
     * @param args
     */
    public static void main(String[] args) {
        int i, length = a.length;
        RBTree<Integer> tree = new RBTree<>();

        System.out.printf("== 原始数据: ");
        for (i = 0; i < length; i++)
            System.out.printf("%d ", a[i]);
        System.out.printf("
");

        for (i = 0; i < length; i++) {
            tree.insert(a[i]);
            // 设置mDebugInsert=true,测试"添加函数"
            if (mDebugInsert) {
                System.out.printf("== 添加节点: %d
", a[i]);
                System.out.printf("== 树的详细信息: 
");
                tree.print();
                System.out.printf("
");
            }
        }

        System.out.printf("== 前序遍历: ");
        tree.preOrder();

        System.out.printf("
== 中序遍历: ");
        tree.inOrder();

        System.out.printf("
== 后序遍历: ");
        tree.postOrder();

        System.out.printf("
");

        System.out.printf("== 最小值: %s
", tree.minimum());
        System.out.printf("== 最大值: %s
", tree.maximum());
        System.out.printf("== 树的详细信息: 
");
        tree.print();

        System.out.printf("
");

        // 设置mDebugDelete=true,测试"删除函数"
        if (mDebugDelete) {
            for (i = 0; i < length; i++) {
                tree.remove(a[i]);

                System.out.printf("== 删除节点: %d
", a[i]);
                System.out.printf("== 树的详细信息: 
");
                tree.print();

                System.out.printf("
");
            }
        }

        // 销毁二叉树
        tree.clear();
    }

    /** 红黑树结点 RBTNode **/
    public class RBTNode<T extends Comparable<T>> {
        boolean color;   // 颜色
        T key;           // 关键字
        RBTNode<T> left;
        RBTNode<T> right;
        RBTNode<T> parent;

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

        public boolean isColor() {
            return color;
        }

        public void setColor(boolean color) {
            this.color = color;
        }

        public T getKey() {
            return key;
        }

        public void setKey(T key) {
            this.key = key;
        }

        public RBTNode<T> getLeft() {
            return left;
        }

        public void setLeft(RBTNode<T> left) {
            this.left = left;
        }

        public RBTNode<T> getRight() {
            return right;
        }

        public void setRight(RBTNode<T> right) {
            this.right = right;
        }

        public RBTNode<T> getParent() {
            return parent;
        }

        public void setParent(RBTNode<T> parent) {
            this.parent = parent;
        }
    }
}