红黑树详解

前言

红黑树的起源，自然是二叉查找树了，这种树结构从根节点开始，左子节点小于它，右子节点大于它。每个节点都符合这个特性，所以易于查找，是一种很好的数据结构。但是它有一个问题，就是容易偏向某一侧，这样就像一个链表结构了，失去了树结构的优点，查找时间会变坏。

所以我们都希望树结构都是矮矮胖胖的，像这样：

而不是像这样：

在这种需求下，平衡树（AVL）的概念就应运而生了。
红黑树就是一种平衡树，它可以保证二叉树基本符合矮矮胖胖的结构，但是理解红黑树之前，必须先了解另一种树，叫2-3树，红黑树背后的逻辑就是它。

好吧来看2-3树吧。
2-3树是二叉查找树的变种，树中的2和3代表两种节点，以下表示为2-节点和3-节点。
2-节点即普通节点：包含一个元素，两条子链接。
3-节点则是扩充版，包含2个元素和三条链接：两个元素A、B，左边的链接指向小于A的节点，中间的链接指向介于A、B值之间的节点，右边的链接指向大于B的节点。
2-节点：

3-节点：

在这两种节点的配合下，2-3树可以保证在插入值过程中，任意叶子节点到根节点的距离都是相同的。完全实现了矮胖矮胖的目标。怎么配合的呢，下面来看2-3树的构造过程。
所谓构造，就是从零开始一个节点一个节点的插入。
在二叉查找树中，插入过程从根节点开始比较，小于节点值往右继续与左子节点比，大于则继续与右子节点比，直到某节点左或右子节点为空，把值插入进去。这样无法避免偏向问题。在2-3树中，插入的过程是这样的。
如果将值插入一个2-节点，则将2-节点扩充为一个3-节点。
如果将值插入一个3-节点，分为以下几种情况。

(1).3-节点没有父节点，即整棵树就只有它一个三节点。此时，将3-节点扩充为一个4-节点，即包含三个元素的节点，然后将其分解，变成一棵二叉树。

此时二叉树依然保持平衡。

(2).3-节点有一个2-节点的父节点，此时的操作是，3-节点扩充为4-节点，然后分解4-节点，然后将分解后的新树的父节点融入到2-节点的父节点中去。

(3).3-节点有一个3-节点的父节点，此时操作是：3-节点扩充为4-节点，然后分解4-节点，新树父节点向上融合，上面的3-节点继续扩充，融合，分解，新树继续向上融合，直到父节点为2-节点为止，如果向上到根节点都是3-节点，将根节点扩充为4-节点，然后分解为新树，至此，整个树增加一层，仍然保持平衡。

第三种情况稍微复杂点，为了便于直观理解，现在我们从零开始构建2-3树，囊括上面所有的情况，看完所以步骤后，你也可以自己画一画。

我们将{7,8,9,10,11,12}中的数值依次插入2-3树，画出它的过程：

所以，2-3树的设计完全可以保证二叉树保持矮矮胖胖的状态，保持其性能良好。但是，将这种直白的表述写成代码实现起来并不方便，因为要处理的情况太多。这样需要维护两种不同类型的节点，将链接和其他信息从一个节点复制到另一个节点，将节点从一种类型转换为另一种类型等等。

因此，红黑树出现了，红黑树的背后逻辑就是2-3树的逻辑，但是由于用红黑作为标记这个小技巧，最后实现的代码量并不大。(但是，要直接理解这些代码是如何工作的以及背后的道理，就比较困难了。所以你一定要理解它的演化过程，才能真正的理解红黑树)

我们来看看红黑树和2-3树的关联，首先，最台面上的问题，红和黑的含义。红黑树中，所有的节点都是标准的2-节点，为了体现出3-节点，这里将3-节点的两个元素用左斜红色的链接连接起来，即连接了两个2-节点来表示一个3-节点。这里红色节点标记就代表指向其的链接是红链接，黑色标记的节点就是普通的节点。

所以才会有那样一条定义，叫“从任一节点到其每个叶子的所有简单路径都包含相同数目的黑色节点”，因为红色节点是可以与其父节点合并为一个3-节点的，红黑树实现的其实是一个完美的黑色平衡，如果你将红黑树中所有的红色链接放平，那么它所有的叶子节点到根节点的距离都是相同的。所以它并不是一个严格的平衡二叉树，但是它的综合性能已经很优秀了。

借一张别人的图来看：

红链接放平：

所以，红黑树的另一种定义是满足下列条件的二叉查找树：

1. 链接均为左链接。
2. 没有任何一个结点同时和两条红链接相连。(这样会出现4-节点)
3. 该树是完美黑色平衡的，即任意空链接到根结点的路径上的黑链接数量相同。

红黑树（一）——基本概念

1. 红黑树基本特性

1.1 红黑树定义

红黑树是一种特殊的二叉树，且必须要满足以下几个特性：

1. 每个节点或是黑色或是红色
2. 根节点是黑色
3. 每个叶节点是黑色（叶节点为空节点）
4. 如果一个节点是红色，则它的两个子节点必须是黑色
5. 从任意的一个节点到该节点的所有叶节点的路径包含相同数目的黑色节点
6. 红黑树是一种平衡二叉树，当不是完全的平衡二叉树，红黑树只要求最多三次旋转来尽可能达到平衡 【也就是说没有规定左子树与右子树的高度差必须<=1!!!】

1.2 红黑树时间复杂度

定理：红黑树的时间复杂度为0（log2n）。
定义：

1. h（v）为以节点v为根节点的子树的高度。
2. bh（v）为从节点v到其子树叶节点路径中黑色节点的数量。

根据特性5可知，bh（v）是唯一值。
又根据特性4可知，从一个节点到其叶节点路径上的黑色节点数目≥路径上的红色节点数目。也就是说h（x）≤2bh（x）

引理：以v为根节点的红黑树，至少有2bh（v）-1 个内部节点。
使用数学归纳法证明引理：

1. 当树的高度h=0时，内部节点个数为0，bh（v）=0，则2bh（v）-1=0，显然满足内部节点个数≥2bh（v）-1.
2. 当h>0，且当h-1时，包含的内部节点数至少为2bh（v）-1-1，
   那么对于根节点x，其左子树的内部节点个数至少为2bh（v）-1-1，其右子节点的内部节点个数至少为2bh（v）-1-1，则高度为h，内部节点个数至少为（2bh（v）-1-1）+（2hb（v）-1-1）+1=2bh（v）-1。引理得证。

根据引理可以得出，一个节点数为n的红黑树，bh（v）≤log2（n+1）。又因为h（x）≤2bh（x），可得，h≤2log2（n+1）。
**（结论1）**红黑树是一种特殊的二又树，对于有n个节点的二又树而言，当其为满二又树时，树的高度最小。

满二又树的节点数量与高度的关系为n=2h-1。
那么可以得出，h≥log2（n+1）。
**（结论2）**由结论1和结论2可知，log2（n+1）≤h≤2log2（n+1）。
所以，红黑树的时间复杂度为：0（log2n）

1.3 节点结构定义

红黑树的节点结构与一般的二叉树类似，但是多了一个标记颜色的变量。

enum RBTColor{RED, BLACK};
template <class T>
class RBTNode{
public:
    RBTColor color;    // 颜色
    T key;            // 关键字(键值)
    RBTNode *left;    // 左孩子
    RBTNode *right;    // 右孩子
    RBTNode *parent; // 父结点
	RBTNode(T value, RBTColor c, RBTNode *p, RBTNode *l, RBTNode *r):
        key(value),color(c),parent(),left(l),right(r) {}
};

2. 红黑树旋转操作

红黑树的旋转操作目的是在插入或删除节点后，尽可能的保持红黑树的特性。旋转操作分为左旋和右旋。

2.1 左旋操作

左旋操作效果如图所示。左旋操作会使当前节点与其右子节点位置互换。

template <class T>
void RBTree<T>::leftRotate(RBTNode<T>* &root, RBTNode<T>* x)
{
// 设置x的右孩子为y
RBTNode<T> *y = x->right;
	// 将 “y的左孩子” 设为 “x的右孩子”；
// 如果y的左孩子非空，将 “x” 设为 “y的左孩子的父亲”
x->right = y->left;
if (y->left != NULL)
    y->left->parent = x;
	// 将 “x的父亲” 设为 “y的父亲”
y->parent = x->parent;
	if (x->parent == NULL)
{
    root = y;            // 如果 “x的父亲” 是空节点，则将y设为根节点
}
else
{
    if (x->parent->left == x)
        x->parent->left = y;    // 如果 x是它父节点的左孩子，则将y设为“x的父节点的左孩子”
    else
        x->parent->right = y;    // 如果 x是它父节点的左孩子，则将y设为“x的父节点的左孩子”
}
// 将 “x” 设为 “y的左孩子”
y->left = x;
// 将 “x的父节点” 设为 “y”
x->parent = y;
}

2.2 右旋操作

右旋操作效果如图所示。右旋操作会使当前节点与其左子节点位置互换。

template <class T>
void RBTree<T>::rightRotate(RBTNode<T>* &root, RBTNode<T>* y)
{
// 设置x是当前节点的左孩子。
RBTNode<T> *x = y->left;
	// 将 “x的右孩子” 设为 “y的左孩子”；
// 如果"x的右孩子"不为空的话，将 “y” 设为 “x的右孩子的父亲”
y->left = x->right;
if (x->right != NULL)
    x->right->parent = y;
	// 将 “y的父亲” 设为 “x的父亲”
x->parent = y->parent;
	if (y->parent == NULL) 
{
    root = x;            // 如果 “y的父亲” 是空节点，则将x设为根节点
}
else
{
    if (y == y->parent->right)
        y->parent->right = x;    // 如果 y是它父节点的右孩子，则将x设为“y的父节点的右孩子”
    else
        y->parent->left = x;    // (y是它父节点的左孩子) 将x设为“x的父节点的左孩子”
}
// 将 “y” 设为 “x的右孩子”
x->right = y;
// 将 “y的父节点” 设为 “x”
y->parent = x;
}

3.总结

本篇文章主要介绍了红黑树的基本概念，包括红黑树的定义、时间复杂度及其证明、节点定义和旋转操作。

红黑树（二）——数据操作

1. 查找

红黑树的查找方式很简单，是一个递归过程。如果查找的元素小于当前节点，那么查找其左子树；如果查找的元素大于当前元素，则查找其右子树。查找的时间复杂度为O(log2n)。

2. 插入

（图例：C表示当前节点，P表示父节点，U表示叔节点，G表示祖父节点）

插入操作首先需要通过查找操作找到合适的插入点，然后插入新节点。如果在插入节点后，发生了违背红黑树特性的情况时，需要对红黑树进行旋转染色等操作，使其重新满足特性。

2.1 插入新节点

第一步:
将红黑树当作一颗二叉查找树，将节点插入。
红黑树本身就是一颗二叉查找树，将节点插入后，该树仍然是一颗二叉查找树。也就意味着，树的键值仍然是有序的。此外，无论是左旋还是右旋，若旋转之前这棵树是二叉查找树，旋转之后它一定还是二叉查找树。这也就意味着，任何的旋转和重新着色操作，都不会改变它仍然是一颗二叉查找树的事实。

第二步：
将插入的节点着色为"红色"。
为什么着色成红色，而不是黑色呢？为什么呢？我们需要重新温习一下红黑树的特性：

• (1) 每个节点或者是黑色，或者是红色。
• (2) 根节点是黑色。
• (3) 每个叶子节点是黑色。 [注意：这里叶子节点，是指为空的叶子节点！]
• (4) 如果一个节点是红色的，则它的子节点必须是黑色的。
• (5) 从一个节点到该节点的子孙节点的所有路径上包含相同数目的黑节点。

将插入的节点着色为红色，不会违背"特性(5)"！少违背一条特性，就意味着我们需要处理的情况越少。接下来，就要努力的让这棵树满足其它性质即可；满足了的话，它就又是一颗红黑树了。

第三步:
通过一系列的旋转或着色等操作，使之重新成为一颗红黑树。
第二步中，将插入节点着色为"红色"之后，不会违背"特性(5)"。那它到底会违背哪些特性呢？
对于"特性(1)"，显然不会违背了。因为我们已经将它涂成红色了。
对于"特性(2)"，显然也不会违背。在第一步中，我们是将红黑树当作二叉查找树，然后执行的插入操作。而根据二叉查找数的特点，插入操作不会改变根节点。所以，根节点仍然是黑色。
对于"特性(3)"，显然不会违背了。这里的叶子节点是指的空叶子节点，插入非空节点并不会对它们造成影响。
对于"特性(4)"，是有可能违背的！
那接下来，想办法使之"满足特性(4)"，就可以将树重新构造成红黑树了。

/* 
* 将结点插入到红黑树中
*
* 参数说明：
*     root 红黑树的根结点
*     node 插入的结点        
*/
template <class T>
void RBTree<T>::insert(RBTNode<T>* &root, RBTNode<T>* node)
{
RBTNode<T> *y = NULL;
RBTNode<T> *x = root;
	    // 1. 将红黑树当作一颗二叉查找树，将节点添加到二叉查找树中。
while (x != NULL)
{
    y = x;
    if (node->key < x->key)
        x = x->left;
    else
        x = x->right;
}
	node->parent = y;
if (y!=NULL)
{
    if (node->key < y->key)
        y->left = node;
    else
        y->right = node;
}
else
    root = node;
	   // 2. 设置节点的颜色为红色
node->color = RED;
	   // 3. 将它重新修正为一颗二叉查找树
insertFixUp(root, node);
}

2.2 调整子树

那么，在违反了特性4的时候，新节点的父节点为红色节点。根据特性2可知，父节点不是根节点，则新节点必有祖父节点。
又根据特性3可推论出红色节点必有两个黑色子节点（空节点为黑色）。
此时会出现两种情况：叔节点为红色、叔节点为黑色。

####（1）父节点与叔节点都为红色的情况

在这种情况下，需要将父节点和叔节点变为黑色，再将祖父节点变为红色。这样，图上所展示的子树就满足了红黑树的特性。如下图所示。

但是这里又可能会产生新的违法特性情况，因为祖父节点变成了红色，那么它可能会造成违反特性4的情况。所以，这里就将祖父节点作为当前节点，进行新一轮的调整操作。

####（2）父节点为红色, 叔节点为黑色的情况

在这种情况下，对其调整的核心就是保持父节点分支符合特性4，而叔节点分支保持符合特性5。
第一步，旋转。
对祖父节点进行左旋或者右旋。如果父节点是祖父节点的右子节点，那么对祖父节点进行左旋；否则，对祖父节点进行右旋。

第二步，染色。
将祖父节点染为红色，而父节点染为黑色。
进过这两步，上图的情况会转换为下图所示。

可以看出，父节点这一分支进过调整后，当前节点与父节点的颜色不再是连续红色，满足特性4。而叔节点这一分支的黑色节点数目没有发生变化，满足特性5。
对原祖父节点的父节点来说，该子树没有发生违反特性的变化。该子树调整完成。

2.3 检查根节点

当上述调整执行完后，还有最后一步，就是检查是否满足特性2。这一步只需要将根节点染成黑色就可以，无需再多加判断。

/*
* 红黑树插入修正函数
*
* 在向红黑树中插入节点之后(失去平衡)，再调用该函数；
* 目的是将它重新塑造成一颗红黑树。
*
* 参数说明：
*     root 红黑树的根
*     node 插入的结点        // 对应《算法导论》中的z
*/
template <class T>
void RBTree<T>::insertFixUp(RBTNode<T>* &root, RBTNode<T>* node)
{
RBTNode<T> *parent, *gparent;
	    // 若“父节点存在，并且父节点的颜色是红色”
while ((parent = rb_parent(node)) && rb_is_red(parent))
{
    gparent = rb_parent(parent);
	       //若“父节点”是“祖父节点的左孩子”
    if (parent == gparent->left)
    {
        // Case 1条件：叔叔节点是红色
        {
            RBTNode<T> *uncle = gparent->right;
            if (uncle && rb_is_red(uncle))
            {
                rb_set_black(uncle);
                rb_set_black(parent);
                rb_set_red(gparent);
                node = gparent;
                continue;
            }
        }
	             // Case 2条件：叔叔是黑色，且当前节点是右孩子
        if (parent->right == node)
        {
            RBTNode<T> *tmp;
            leftRotate(root, parent);
            tmp = parent;
            parent = node;
            node = tmp;
        }
	            // Case 3条件：叔叔是黑色，且当前节点是左孩子。
        rb_set_black(parent);
        rb_set_red(gparent);
        rightRotate(root, gparent);
    } 
    else//若“z的父节点”是“z的祖父节点的右孩子”
    {
        // Case 1条件：叔叔节点是红色
        {
            RBTNode<T> *uncle = gparent->left;
            if (uncle && rb_is_red(uncle))
            {
                rb_set_black(uncle);
                rb_set_black(parent);
                rb_set_red(gparent);
                node = gparent;
                continue;
            }
        }
	           // Case 2条件：叔叔是黑色，且当前节点是左孩子
        if (parent->left == node)
        {
            RBTNode<T> *tmp;
            rightRotate(root, parent);
            tmp = parent;
            parent = node;
            node = tmp;
        }
	            // Case 3条件：叔叔是黑色，且当前节点是右孩子。
        rb_set_black(parent);
        rb_set_red(gparent);
        leftRotate(root, gparent);
    }
}
	   // 将根节点设为黑色
rb_set_black(root);
}

3. 删除

（图例：D表示当前节点，P表示父节点，B表示兄弟节点，BR表示兄弟节点的右子节点，BL表示兄弟节点的左子节点）

删除操作要比插入操作略微复杂一些。因为删除的节点可能是出现在树的中间层的节点，此时删除该节点会遇到很复杂的情况。所以，在删除节点的时候，需要先对红黑树进行一些调整，使得删除节点对整个树的影响降到最低。

第一步：将红黑树当作一颗二叉查找树，将节点删除。

这和"删除常规二叉查找树中删除节点的方法是一样的"。分3种情况：

1. 被删除节点没有儿子，即为叶节点。那么，直接将该节点删除就OK了。
2. 被删除节点只有一个儿子。那么，直接删除该节点，并用该节点的唯一子节点顶替它的位置。
3. 被删除节点有两个儿子。那么，先找出它的后继节点；然后把“它的后继节点的内容”复制给“该节点的内容”；之后，删除“它的后继节点”。在这里，后继节点相当于替身，在将后继节点的内容复制给"被删除节点"之后，再将后继节点删除。这样就巧妙的将问题转换为"删除后继节点"的情况了，下面就考虑后继节点。 在"被删除节点"有两个非空子节点的情况下，它的后继节点不可能是双子非空。既然"的后继节点"不可能双子都非空，就意味着"该节点的后继节点"要么没有儿子，要么只有一个儿子。若没有儿子，则按"情况① "进行处理；若只有一个儿子，则按"情况② "进行处理。

第二步：通过"旋转和重新着色"等一系列来修正该树，使之重新成为一棵红黑树。

因为"第一步"中删除节点之后，可能会违背红黑树的特性。所以需要通过"旋转和重新着色"来修正该树，使之重新成为一棵红黑树。

3.1 替换删除节点

首先根据BST删除节点的规则，使用当前节点左子树的最大值节点【最右】或者右子树的最小值节点【最左】代替其删除（这两个节点是其子树中数值上最贴近当前节点数值的节点）。

为了方便讲解，我们默认采用的是右子树的最小值节点代替。
那么现在需要考虑的情况就减少了，只可能会出现以下几种情况（因为需要满足红黑树特性）：

1. 无子节点，节点为红色
2. 无子节点，节点为黑色
3. 只有右子节点，右子节点为红色，节点本身为黑色
   
   情况1，只需要直接删除节点就可以。

情况2，删除节点后，违反了红黑树特性5，需要调整（不考虑待删除节点为根节点的情况）

情况3，用右子节点占据待删除节点，再将其染成黑色即可，不违反红黑树特性。

在这三种情况中，情况1和情况3比较简单，不需要多余的调整。情况2则需要后续的调整步骤使其满足红黑树特性。

/* 
* 删除结点(node)，并返回被删除的结点
*
* 参数说明：
*     root 红黑树的根结点
*     node 删除的结点
*/
template <class T>
void RBTree<T>::remove(RBTNode<T>* &root, RBTNode<T> *node)
{
RBTNode<T> *child, *parent;
RBTColor color;
		   // 被删除节点的"左右孩子都不为空"的情况。
if ( (node->left!=NULL) && (node->right!=NULL) ) 
{
    // 被删节点的后继节点。(称为"取代节点")
    // 用它来取代"被删节点"的位置，然后再将"被删节点"去掉。
    RBTNode<T> *replace = node;
		        // 获取后继节点
    replace = replace->right;
    while (replace->left != NULL)
        replace = replace->left;
		        // "node节点"不是根节点(只有根节点不存在父节点)
    if (rb_parent(node))
    {
        if (rb_parent(node)->left == node)
            rb_parent(node)->left = replace;
        else
            rb_parent(node)->right = replace;
    } 
    else 
       // "node节点"是根节点，更新根节点。
        root = replace;
		         // child是"取代节点"的右孩子，也是需要"调整的节点"。
    // "取代节点"肯定不存在左孩子！因为它是一个后继节点。
    child = replace->right;
    parent = rb_parent(replace);
    // 保存"取代节点"的颜色
    color = rb_color(replace);
		        // "被删除节点"是"它的后继节点的父节点"
    if (parent == node)
    {
        parent = replace;
    } 
    else
    {
        // child不为空
        if (child)
            rb_set_parent(child, parent);
        parent->left = child;
		replace->right = node->right;
        rb_set_parent(node->right, replace);
    }
	replace->parent = node->parent;
    replace->color = node->color;
    replace->left = node->left;
    node->left->parent = replace;
	if (color == BLACK)
        removeFixUp(root, child, parent);
	delete node;
    return ;
}
if (node->left !=NULL)
    child = node->left;
else 
    child = node->right;
parent = node->parent;
// 保存"取代节点"的颜色
color = node->color;
if (child)
	child->parent = parent;
// "node节点"不是根节点
if (parent)
{
    if (parent->left == node)
        parent->left = child;
    else
        parent->right = child;
}
else
    root = child;
if (color == BLACK)
    removeFixUp(root, child, parent);
delete node;
}

3.2 调整红黑树

上述情况2的调整比较复杂。下面对各种情况进行讲解。
根据红黑树的特性5，待删除节点必然有兄弟节点。下面根据其兄弟节点所在分支的不同，来分情况讨论。
（以下是以关注节点为父节点的左子节点进行描述，如果遇到关注节点为父节点的右子节点的情况，则镜像处理）

（1）兄弟节点为红色

先对父节点进行左旋操作，然后将父节点染成红色，兄弟节点染成黑色。此时就转换为了（4），之后按照（4）继进行调整。

（2）兄弟节点为黑色，远侄节点为红色

这种情况下，不需要考虑父节点的颜色。
**第一步：**对父节点P进行左旋操作
**第二步：**将父节点P与兄弟节点B的颜色互换
**第三步：**将兄弟节点的右子节点BR染成黑色
可以看到，经过这三步的调整后，直接删除节点D后满足红黑树的特性，调整完成。

####（3）兄弟节点为黑色，远侄节点为黑色，近侄节点为红色

这种情况下，先对兄弟节点B进行右旋操作，然后BL节点染成黑色，B节点染成红色。此时的状况就和（2）一样了。之后就通过（2）的调整方式进行调整。

####（4）父节点为红色，兄弟节点为黑色，兄弟节点无子节点

这种情况下，将父节点P染成黑色，再将兄弟节点染成红色。
经过这样的操作后，除去节点D后，以P为根节点的子树的黑节点深度没有发生。调整完成。

####（5）父节点为黑色，兄弟节点为黑色，兄弟节点无子节点

这种情况下，为了在删除节点D后使以P为根节点的子树能满足红黑树特性5，将兄弟节点B染成红色。但是这样操作后，以P为根节点的子树的黑色节点深度变小了。所以需要继续调整。
因为P节点子树的黑色深度发生了减少，可以把其当作待删除节点，那么此时就以P节点为关注节点进行进一步调整。

/*
* 红黑树删除修正函数
*
* 在从红黑树中删除插入节点之后(红黑树失去平衡)，再调用该函数；
* 目的是将它重新塑造成一颗红黑树。
*
* 参数说明：
*     root 红黑树的根
*     node 待修正的节点
*/
template <class T>
void RBTree<T>::removeFixUp(RBTNode<T>* &root, RBTNode<T> *node, RBTNode<T> *parent)
{
RBTNode<T> *other;
	while ((!node || rb_is_black(node)) && node != root)
{
    if (parent->left == node)
    {
        other = parent->right;
        if (rb_is_red(other))
        {
            // Case 1: x的兄弟w是红色的  
            rb_set_black(other);
            rb_set_red(parent);
            leftRotate(root, parent);
            other = parent->right;
        }
        if ((!other->left || rb_is_black(other->left)) &&
            (!other->right || rb_is_black(other->right)))
        {
            // Case 2: x的兄弟w是黑色，且w的俩个孩子也都是黑色的  
            rb_set_red(other);
            node = parent;
            parent = rb_parent(node);
        }
        else
        {
            if (!other->right || rb_is_black(other->right))
            {
                // Case 3: x的兄弟w是黑色的，并且w的左孩子是红色，右孩子为黑色。  
                rb_set_black(other->left);
                rb_set_red(other);
                rightRotate(root, other);
                other = parent->right;
            }
            // Case 4: x的兄弟w是黑色的；并且w的右孩子是红色的，左孩子任意颜色。
            rb_set_color(other, rb_color(parent));
            rb_set_black(parent);
            rb_set_black(other->right);
            leftRotate(root, parent);
            node = root;
            break;
        }
    }
    else
    {
        other = parent->left;
        if (rb_is_red(other))
        {
            // Case 1: x的兄弟w是红色的  
            rb_set_black(other);
            rb_set_red(parent);
            rightRotate(root, parent);
            other = parent->left;
        }
        if ((!other->left || rb_is_black(other->left)) &&
            (!other->right || rb_is_black(other->right)))
        {
            // Case 2: x的兄弟w是黑色，且w的俩个孩子也都是黑色的  
            rb_set_red(other);
            node = parent;
            parent = rb_parent(node);
        }
        else
        {
            if (!other->left || rb_is_black(other->left))
            {
                // Case 3: x的兄弟w是黑色的，并且w的左孩子是红色，右孩子为黑色。  
                rb_set_black(other->right);
                rb_set_red(other);
                leftRotate(root, other);
                other = parent->left;
            }
            // Case 4: x的兄弟w是黑色的；并且w的右孩子是红色的，左孩子任意颜色。
           
	                rb_set_color(other, rb_color(parent));
            rb_set_black(parent);
            rb_set_black(other->left);
            rightRotate(root, parent);
            node = root;
            break;
        }
    }
}
if (node)
    rb_set_black(node);
}

3.3 检查根节点及删除节点

经过上述的调整后，此时基本满足了红黑树的特性。但是存在根节点变成红色的情况。所以需要将根节点染成黑色的操作。
最后，执行删除操作，将待删除节点删掉。

###4. 总结
本篇文章讲解了红黑树的数据操作，包括除了左旋"、“右旋”、“添加”、“删除”、“遍历”、“查找”、“打印”、“最小值”、“最大值”、“创建”、"销毁"等接口。
注意：
红黑树中的private中的函数都是public中函数的内部实现函数，也就是说，为了确保红黑树的封装，几乎所有的操作都是在内部的私有属性函数中完成的，而public中的函数仅仅只是一个接口而已

/**
 * C++ 语言: 红黑树
 *
 * @author skywang
 * @date 2013/11/07
 */
    #ifndef _RED_BLACK_TREE_HPP_
#define _RED_BLACK_TREE_HPP_ 
    #include <iomanip>
#include <iostream>
using namespace std;
    enum RBTColor{RED, BLACK};
    template <class T>
class RBTNode{
    public:
        RBTColor color;    // 颜色
        T key;            // 关键字(键值)
        RBTNode *left;    // 左孩子
        RBTNode *right;    // 右孩子
        RBTNode *parent; // 父结点
    RBTNode(T value, RBTColor c, RBTNode *p, RBTNode *l, RBTNode *r):
            key(value),color(c),parent(),left(l),right(r) {}
};
    template <class T>
class RBTree {
    private:
        RBTNode<T> *mRoot;    // 根结点
    public:
        RBTree();
        ~RBTree();
    // 前序遍历"红黑树"
        void preOrder();
        // 中序遍历"红黑树"
        void inOrder();
        // 后序遍历"红黑树"
        void postOrder();
    // (递归实现)查找"红黑树"中键值为key的节点
        RBTNode<T>* search(T key);
        // (非递归实现)查找"红黑树"中键值为key的节点
        RBTNode<T>* iterativeSearch(T key);
    // 查找最小结点：返回最小结点的键值。
        T minimum();
        // 查找最大结点：返回最大结点的键值。
        T maximum();
    // 找结点(x)的后继结点。即，查找"红黑树中数据值大于该结点"的"最小结点"。
        RBTNode<T>* successor(RBTNode<T> *x);
        // 找结点(x)的前驱结点。即，查找"红黑树中数据值小于该结点"的"最大结点"。
        RBTNode<T>* predecessor(RBTNode<T> *x);
    // 将结点(key为节点键值)插入到红黑树中
        void insert(T key);
    // 删除结点(key为节点键值)
        void remove(T key);
    // 销毁红黑树
        void destroy();
    // 打印红黑树
        void print();
    private:
        // 前序遍历"红黑树"
        void preOrder(RBTNode<T>* tree) const;
        // 中序遍历"红黑树"
        void inOrder(RBTNode<T>* tree) const;
        // 后序遍历"红黑树"
        void postOrder(RBTNode<T>* tree) const;
    // (递归实现)查找"红黑树x"中键值为key的节点
        RBTNode<T>* search(RBTNode<T>* x, T key) const;
        // (非递归实现)查找"红黑树x"中键值为key的节点
        RBTNode<T>* iterativeSearch(RBTNode<T>* x, T key) const;
    // 查找最小结点：返回tree为根结点的红黑树的最小结点。
        RBTNode<T>* minimum(RBTNode<T>* tree);
        // 查找最大结点：返回tree为根结点的红黑树的最大结点。
        RBTNode<T>* maximum(RBTNode<T>* tree);
    // 左旋
        void leftRotate(RBTNode<T>* &root, RBTNode<T>* x);
        // 右旋
        void rightRotate(RBTNode<T>* &root, RBTNode<T>* y);
        // 插入函数
        void insert(RBTNode<T>* &root, RBTNode<T>* node);
        // 插入修正函数
        void insertFixUp(RBTNode<T>* &root, RBTNode<T>* node);
        // 删除函数
        void remove(RBTNode<T>* &root, RBTNode<T> *node);
        // 删除修正函数
        void removeFixUp(RBTNode<T>* &root, RBTNode<T> *node, RBTNode<T> *parent);
    // 销毁红黑树
        void destroy(RBTNode<T>* &tree);
    // 打印红黑树
        void print(RBTNode<T>* tree, T key, int direction);
    #define rb_parent(r)   ((r)->parent)
#define rb_color(r) ((r)->color)
#define rb_is_red(r)   ((r)->color==RED)
#define rb_is_black(r)  ((r)->color==BLACK)
#define rb_set_black(r)  do { (r)->color = BLACK; } while (0)
#define rb_set_red(r)  do { (r)->color = RED; } while (0)
#define rb_set_parent(r,p)  do { (r)->parent = (p); } while (0)
#define rb_set_color(r,c)  do { (r)->color = (c); } while (0)
};
    /* 
 * 构造函数
 */
template <class T>
RBTree<T>::RBTree():mRoot(NULL)
{
    mRoot = NULL;
}
    /* 
 * 析构函数
 */
template <class T>
RBTree<T>::~RBTree() 
{
    destroy();
}
    /*
 * 前序遍历"红黑树"
 */
template <class T>
void RBTree<T>::preOrder(RBTNode<T>* tree) const
{
    if(tree != NULL)
    {
        cout<< tree->key << " " ;
        preOrder(tree->left);
        preOrder(tree->right);
    }
}
    template <class T>
void RBTree<T>::preOrder() 
{
    preOrder(mRoot);
}
    /*
 * 中序遍历"红黑树"
 */
template <class T>
void RBTree<T>::inOrder(RBTNode<T>* tree) const
{
    if(tree != NULL)
    {
        inOrder(tree->left);
        cout<< tree->key << " " ;
        inOrder(tree->right);
    }
}
    template <class T>
void RBTree<T>::inOrder() 
{
    inOrder(mRoot);
}
    /*
 * 后序遍历"红黑树"
 */
template <class T>
void RBTree<T>::postOrder(RBTNode<T>* tree) const
{
    if(tree != NULL)
    {
        postOrder(tree->left);
        postOrder(tree->right);
        cout<< tree->key << " " ;
    }
}
    template <class T>
void RBTree<T>::postOrder() 
{
    postOrder(mRoot);
}
    /*
 * (递归实现)查找"红黑树x"中键值为key的节点
 */
template <class T>
RBTNode<T>* RBTree<T>::search(RBTNode<T>* x, T key) const
{
    if (x==NULL || x->key==key)
        return x;
    if (key < x->key)
        return search(x->left, key);
    else
        return search(x->right, key);
}
    template <class T>
RBTNode<T>* RBTree<T>::search(T key) 
{
    search(mRoot, key);
}
    /*
 * (非递归实现)查找"红黑树x"中键值为key的节点
 */
template <class T>
RBTNode<T>* RBTree<T>::iterativeSearch(RBTNode<T>* x, T key) const
{
    while ((x!=NULL) && (x->key!=key))
    {
        if (key < x->key)
            x = x->left;
        else
            x = x->right;
    }
    return x;
}
    template <class T>
RBTNode<T>* RBTree<T>::iterativeSearch(T key)
{
    iterativeSearch(mRoot, key);
}
    /* 
 * 查找最小结点：返回tree为根结点的红黑树的最小结点。
 */
template <class T>
RBTNode<T>* RBTree<T>::minimum(RBTNode<T>* tree)
{
    if (tree == NULL)
        return NULL;
    while(tree->left != NULL)
        tree = tree->left;
    return tree;
}
    template <class T>
T RBTree<T>::minimum()
{
    RBTNode<T> *p = minimum(mRoot);
    if (p != NULL)
        return p->key;
    return (T)NULL;
}
 
/* 
 * 查找最大结点：返回tree为根结点的红黑树的最大结点。
 */
template <class T>
RBTNode<T>* RBTree<T>::maximum(RBTNode<T>* tree)
{
    if (tree == NULL)
        return NULL;
    while(tree->right != NULL)
        tree = tree->right;
    return tree;
}
    template <class T>
T RBTree<T>::maximum()
{
    RBTNode<T> *p = maximum(mRoot);
    if (p != NULL)
        return p->key;
    return (T)NULL;
}
    /* 
 * 找结点(x)的后继结点。即，查找"红黑树中数据值大于该结点"的"最小结点"。
 */
template <class T>
RBTNode<T>* RBTree<T>::successor(RBTNode<T> *x)
{
    // 如果x存在右孩子，则"x的后继结点"为 "以其右孩子为根的子树的最小结点"。
    if (x->right != NULL)
        return minimum(x->right);
    // 如果x没有右孩子。则x有以下两种可能：
    // (01) x是"一个左孩子"，则"x的后继结点"为 "它的父结点"。
    // (02) x是"一个右孩子"，则查找"x的最低的父结点，并且该父结点要具有左孩子"，找到的这个"最低的父结点"就是"x的后继结点"。
    RBTNode<T>* y = x->parent;
    while ((y!=NULL) && (x==y->right))
    {
        x = y;
        y = y->parent;
    }
    return y;
}
 
/* 
 * 找结点(x)的前驱结点。即，查找"红黑树中数据值小于该结点"的"最大结点"。
 */
template <class T>
RBTNode<T>* RBTree<T>::predecessor(RBTNode<T> *x)
{
    // 如果x存在左孩子，则"x的前驱结点"为 "以其左孩子为根的子树的最大结点"。
    if (x->left != NULL)
        return maximum(x->left);
    // 如果x没有左孩子。则x有以下两种可能：
    // (01) x是"一个右孩子"，则"x的前驱结点"为 "它的父结点"。
    // (01) x是"一个左孩子"，则查找"x的最低的父结点，并且该父结点要具有右孩子"，找到的这个"最低的父结点"就是"x的前驱结点"。
    RBTNode<T>* y = x->parent;
    while ((y!=NULL) && (x==y->left))
    {
        x = y;
        y = y->parent;
    }
    return y;
}
    /* 
 * 对红黑树的节点(x)进行左旋转
 *
 * 左旋示意图(对节点x进行左旋)：
 *      px                              px
 *     /                               /
 *    x                               y                
 *   /  \      --(左旋)-->           / \                #
 *  lx   y                          x  ry     
 *     /   \                       /  \
 *    ly   ry                     lx  ly  
 *
 *
 */
template <class T>
void RBTree<T>::leftRotate(RBTNode<T>* &root, RBTNode<T>* x)
{
    // 设置x的右孩子为y
    RBTNode<T> *y = x->right;
    // 将 “y的左孩子” 设为 “x的右孩子”；
    // 如果y的左孩子非空，将 “x” 设为 “y的左孩子的父亲”
    x->right = y->left;
    if (y->left != NULL)
        y->left->parent = x;
    // 将 “x的父亲” 设为 “y的父亲”
    y->parent = x->parent;
    if (x->parent == NULL)
    {
        root = y;            // 如果 “x的父亲” 是空节点，则将y设为根节点
    }
    else
    {
        if (x->parent->left == x)
            x->parent->left = y;    // 如果 x是它父节点的左孩子，则将y设为“x的父节点的左孩子”
        else
            x->parent->right = y;    // 如果 x是它父节点的左孩子，则将y设为“x的父节点的左孩子”
    }
    
    // 将 “x” 设为 “y的左孩子”
    y->left = x;
    // 将 “x的父节点” 设为 “y”
    x->parent = y;
}
    /* 
 * 对红黑树的节点(y)进行右旋转
 *
 * 右旋示意图(对节点y进行左旋)：
 *            py                               py
 *           /                                /
 *          y                                x                  
 *         /  \      --(右旋)-->            /  \                     #
 *        x   ry                           lx   y  
 *       / \                                   / \                   #
 *      lx  rx                                rx  ry
 * 
 */
template <class T>
void RBTree<T>::rightRotate(RBTNode<T>* &root, RBTNode<T>* y)
{
    // 设置x是当前节点的左孩子。
    RBTNode<T> *x = y->left;
    // 将 “x的右孩子” 设为 “y的左孩子”；
    // 如果"x的右孩子"不为空的话，将 “y” 设为 “x的右孩子的父亲”
    y->left = x->right;
    if (x->right != NULL)
        x->right->parent = y;
    // 将 “y的父亲” 设为 “x的父亲”
    x->parent = y->parent;
    if (y->parent == NULL) 
    {
        root = x;            // 如果 “y的父亲” 是空节点，则将x设为根节点
    }
    else
    {
        if (y == y->parent->right)
            y->parent->right = x;    // 如果 y是它父节点的右孩子，则将x设为“y的父节点的右孩子”
        else
            y->parent->left = x;    // (y是它父节点的左孩子) 将x设为“x的父节点的左孩子”
    }
    // 将 “y” 设为 “x的右孩子”
    x->right = y;
    // 将 “y的父节点” 设为 “x”
    y->parent = x;
}
    /*
 * 红黑树插入修正函数
 *
 * 在向红黑树中插入节点之后(失去平衡)，再调用该函数；
 * 目的是将它重新塑造成一颗红黑树。
 *
 * 参数说明：
 *     root 红黑树的根
 *     node 插入的结点        // 对应《算法导论》中的z
 */
template <class T>
void RBTree<T>::insertFixUp(RBTNode<T>* &root, RBTNode<T>* node)
{
    RBTNode<T> *parent, *gparent;
    // 若“父节点存在，并且父节点的颜色是红色”
    while ((parent = rb_parent(node)) && rb_is_red(parent))
    {
        gparent = rb_parent(parent);
    //若“父节点”是“祖父节点的左孩子”
        if (parent == gparent->left)
        {
            // Case 1条件：叔叔节点是红色
            {
                RBTNode<T> *uncle = gparent->right;
                if (uncle && rb_is_red(uncle))
                {
                    rb_set_black(uncle);
                    rb_set_black(parent);
                    rb_set_red(gparent);
                    node = gparent;
                    continue;
                }
            }
    // Case 2条件：叔叔是黑色，且当前节点是右孩子
            if (parent->right == node)
            {
                RBTNode<T> *tmp;
                leftRotate(root, parent);
                tmp = parent;
                parent = node;
                node = tmp;
            }
    // Case 3条件：叔叔是黑色，且当前节点是左孩子。
            rb_set_black(parent);
            rb_set_red(gparent);
            rightRotate(root, gparent);
        } 
        else//若“z的父节点”是“z的祖父节点的右孩子”
        {
            // Case 1条件：叔叔节点是红色
            {
                RBTNode<T> *uncle = gparent->left;
                if (uncle && rb_is_red(uncle))
                {
                    rb_set_black(uncle);
                    rb_set_black(parent);
                    rb_set_red(gparent);
                    node = gparent;
                    continue;
                }
            }
    // Case 2条件：叔叔是黑色，且当前节点是左孩子
            if (parent->left == node)
            {
                RBTNode<T> *tmp;
                rightRotate(root, parent);
                tmp = parent;
                parent = node;
                node = tmp;
            }
    // Case 3条件：叔叔是黑色，且当前节点是右孩子。
            rb_set_black(parent);
            rb_set_red(gparent);
            leftRotate(root, gparent);
        }
    }
    // 将根节点设为黑色
    rb_set_black(root);
}
    /* 
 * 将结点插入到红黑树中
 *
 * 参数说明：
 *     root 红黑树的根结点
 *     node 插入的结点        // 对应《算法导论》中的node
 */
template <class T>
void RBTree<T>::insert(RBTNode<T>* &root, RBTNode<T>* node)
{
    RBTNode<T> *y = NULL;
    RBTNode<T> *x = root;
    // 1. 将红黑树当作一颗二叉查找树，将节点添加到二叉查找树中。
    while (x != NULL)
    {
        y = x;
        if (node->key < x->key)
            x = x->left;
        else
            x = x->right;
    }
    node->parent = y;
    if (y!=NULL)
    {
        if (node->key < y->key)
            y->left = node;
        else
            y->right = node;
    }
    else
        root = node;
    // 2. 设置节点的颜色为红色
    node->color = RED;
    // 3. 将它重新修正为一颗二叉查找树
    insertFixUp(root, node);
}
    /* 
 * 将结点(key为节点键值)插入到红黑树中
 *
 * 参数说明：
 *     tree 红黑树的根结点
 *     key 插入结点的键值
 */
template <class T>
void RBTree<T>::insert(T key)
{
    RBTNode<T> *z=NULL;
    // 如果新建结点失败，则返回。
    if ((z=new RBTNode<T>(key,BLACK,NULL,NULL,NULL)) == NULL)
        return ;
    insert(mRoot, z);
}
    /*
 * 红黑树删除修正函数
 *
 * 在从红黑树中删除插入节点之后(红黑树失去平衡)，再调用该函数；
 * 目的是将它重新塑造成一颗红黑树。
 *
 * 参数说明：
 *     root 红黑树的根
 *     node 待修正的节点
 */
template <class T>
void RBTree<T>::removeFixUp(RBTNode<T>* &root, RBTNode<T> *node, RBTNode<T> *parent)
{
    RBTNode<T> *other;
    while ((!node || rb_is_black(node)) && node != root)
    {
        if (parent->left == node)
        {
            other = parent->right;
            if (rb_is_red(other))
            {
                // Case 1: x的兄弟w是红色的  
                rb_set_black(other);
                rb_set_red(parent);
                leftRotate(root, parent);
                other = parent->right;
            }
            if ((!other->left || rb_is_black(other->left)) &&
                (!other->right || rb_is_black(other->right)))
            {
                // Case 2: x的兄弟w是黑色，且w的俩个孩子也都是黑色的  
                rb_set_red(other);
                node = parent;
                parent = rb_parent(node);
            }
            else
            {
                if (!other->right || rb_is_black(other->right))
                {
                    // Case 3: x的兄弟w是黑色的，并且w的左孩子是红色，右孩子为黑色。  
                    rb_set_black(other->left);
                    rb_set_red(other);
                    rightRotate(root, other);
                    other = parent->right;
                }
                // Case 4: x的兄弟w是黑色的；并且w的右孩子是红色的，左孩子任意颜色。
                rb_set_color(other, rb_color(parent));
                rb_set_black(parent);
                rb_set_black(other->right);
                leftRotate(root, parent);
                node = root;
                break;
            }
        }
        else
        {
            other = parent->left;
            if (rb_is_red(other))
            {
                // Case 1: x的兄弟w是红色的  
                rb_set_black(other);
                rb_set_red(parent);
                rightRotate(root, parent);
                other = parent->left;
            }
            if ((!other->left || rb_is_black(other->left)) &&
                (!other->right || rb_is_black(other->right)))
            {
                // Case 2: x的兄弟w是黑色，且w的俩个孩子也都是黑色的  
                rb_set_red(other);
                node = parent;
                parent = rb_parent(node);
            }
            else
            {
                if (!other->left || rb_is_black(other->left))
                {
                    // Case 3: x的兄弟w是黑色的，并且w的左孩子是红色，右孩子为黑色。  
                    rb_set_black(other->right);
                    rb_set_red(other);
                    leftRotate(root, other);
                    other = parent->left;
                }
                // Case 4: x的兄弟w是黑色的；并且w的右孩子是红色的，左孩子任意颜色。
                rb_set_color(other, rb_color(parent));
                rb_set_black(parent);
                rb_set_black(other->left);
                rightRotate(root, parent);
                node = root;
                break;
            }
        }
    }
    if (node)
        rb_set_black(node);
}
    /* 
 * 删除结点(node)，并返回被删除的结点
 *
 * 参数说明：
 *     root 红黑树的根结点
 *     node 删除的结点
 */
template <class T>
void RBTree<T>::remove(RBTNode<T>* &root, RBTNode<T> *node)
{
    RBTNode<T> *child, *parent;
    RBTColor color;
    // 被删除节点的"左右孩子都不为空"的情况。
    if ( (node->left!=NULL) && (node->right!=NULL) ) 
    {
        // 被删节点的后继节点。(称为"取代节点")
        // 用它来取代"被删节点"的位置，然后再将"被删节点"去掉。
        RBTNode<T> *replace = node;
    // 获取后继节点
        replace = replace->right;
        while (replace->left != NULL)
            replace = replace->left;
    // "node节点"不是根节点(只有根节点不存在父节点)
        if (rb_parent(node))
        {
            if (rb_parent(node)->left == node)
                rb_parent(node)->left = replace;
            else
                rb_parent(node)->right = replace;
        } 
        else 
            // "node节点"是根节点，更新根节点。
            root = replace;
    // child是"取代节点"的右孩子，也是需要"调整的节点"。
        // "取代节点"肯定不存在左孩子！因为它是一个后继节点。
        child = replace->right;
        parent = rb_parent(replace);
        // 保存"取代节点"的颜色
        color = rb_color(replace);
    // "被删除节点"是"它的后继节点的父节点"
        if (parent == node)
        {
            parent = replace;
        } 
        else
        {
            // child不为空
            if (child)
                rb_set_parent(child, parent);
            parent->left = child;
    replace->right = node->right;
            rb_set_parent(node->right, replace);
        }
    replace->parent = node->parent;
        replace->color = node->color;
        replace->left = node->left;
        node->left->parent = replace;
    if (color == BLACK)
            removeFixUp(root, child, parent);
    delete node;
        return ;
    }
    if (node->left !=NULL)
        child = node->left;
    else 
        child = node->right;
    parent = node->parent;
    // 保存"取代节点"的颜色
    color = node->color;
    if (child)
        child->parent = parent;
    // "node节点"不是根节点
    if (parent)
    {
        if (parent->left == node)
            parent->left = child;
        else
            parent->right = child;
    }
    else
        root = child;
    if (color == BLACK)
        removeFixUp(root, child, parent);
    delete node;
}
    /* 
 * 删除红黑树中键值为key的节点
 *
 * 参数说明：
 *     tree 红黑树的根结点
 */
template <class T>
void RBTree<T>::remove(T key)
{
    RBTNode<T> *node; 
    // 查找key对应的节点(node)，找到的话就删除该节点
    if ((node = search(mRoot, key)) != NULL)
        remove(mRoot, node);
}
    /*
 * 销毁红黑树
 */
template <class T>
void RBTree<T>::destroy(RBTNode<T>* &tree)
{
    if (tree==NULL)
        return ;
    if (tree->left != NULL)
        return destroy(tree->left);
    if (tree->right != NULL)
        return destroy(tree->right);
    delete tree;
    tree=NULL;
}
    template <class T>
void RBTree<T>::destroy()
{
    destroy(mRoot);
}
    /*
 * 打印"二叉查找树"
 *
 * key        -- 节点的键值 
 * direction  --  0，表示该节点是根节点;
 *               -1，表示该节点是它的父结点的左孩子;
 *                1，表示该节点是它的父结点的右孩子。
 */
template <class T>
void RBTree<T>::print(RBTNode<T>* tree, T key, int direction)
{
    if(tree != NULL)
    {
        if(direction==0)    // tree是根节点
            cout << setw(2) << tree->key << "(B) is root" << endl;
        else                // tree是分支节点
            cout << setw(2) << tree->key <<  (rb_is_red(tree)?"(R)":"(B)") << " is " << setw(2) << key << "'s "  << setw(12) << (direction==1?"right child" : "left child") << endl;
    print(tree->left, tree->key, -1);
        print(tree->right,tree->key,  1);
    }
}
    
template <class T>
void RBTree<T>::print()
{
    if (mRoot != NULL)
        print(mRoot, mRoot->key, 0);
}
#endif