红黑树理论与c++实现

    红黑树（Red-Black Tree）是二叉搜索树（Binary Search Tree）的一种改进。我们知道二叉搜索树在最坏的情况下可能会变成一个链表（当所有节点按从小到大的顺序依次插入后）。而红黑树在每一次插入或删除节点之后都会花O（log N）的时间来对树的结构作修改，以保持树的平衡。也就是说，红黑树的查找方法与二叉搜索树完全一样；插入和删除节点的的方法前半部分节与二叉搜索树完全一样，而后半部分添加了一些修改树的结构的操作。

    红黑树的每个节点上的属性除了有一个key、3个指针：parent、lchild、rchild以外，还多了一个属性：color。它只能是两种颜色：红或黑。而红黑树除了具有二叉搜索树的所有性质之外，还具有以下4点性质：

1. 根节点是黑色的。
2. 空节点是黑色的（红黑树中，根节点的parent以及所有叶节点lchild、rchild都不指向NULL，而是指向一个定义好的空节点）。
3. 红色节点的父、左子、右子节点都是黑色。
4. 在任何一棵子树中，每一条从根节点向下走到空节点的路径上包含的黑色节点数量都相同。

     

    这些约束强制了红黑树的关键属性: 从根到叶子的最长的可能路径不多于最短的可能路径的两倍长。结果是这个树大致上是平衡的。因为操作比如插入、删除和查找某个值都要求与树的高度成比例的最坏情况时间，这个在高度上的理论上限允许红黑树在最坏情况下都是高效的，而不同于普通的二叉查找树。

        要知道为什么这些特性确保了这个结果，注意到属性4导致了路径不能有两个毗连的红色节点就足够了。最短的可能路径都是黑色节点，最长的可能路径有交替的红色和黑色节点。因为根据属性5所有最长的路径都有相同数目的黑色节点，这就表明了没有路径能多于任何其他路径的两倍长。

        在很多树数据结构的表示中，一个节点有可能只有一个儿子，而叶子节点包含数据。用这种范例表示红黑树是可能的，但是这会改变一些属性并使算法复杂。为此，本文中我们使用 "nil 叶子" 或"空(null)叶子"，如上图所示，它不包含数据而只充当树在此结束的指示。这些节点在绘图中经常被省略，导致了这些树好象同上述原则相矛盾，而实际上不是这样。与此有关的结论是所有节点都有两个儿子，尽管其中的一个或两个可能是空叶子。

如下图就是一棵红黑树：



有了这几条规则，就可以保证整棵树的平衡，也就等于保证了搜索的时间为O（log N）。

但是在插入、删除节点后，就有可能破坏了红黑树的性质。所以我们要做一些操作来把整棵树修补好。下面我就来介绍一下。

首先有一个预备知识，那就是节点的Left-Rotate和Right-Rotate操作。所谓Left-Rotate(x)就是把节点x向左下方向移动一格，然后让x原来的右子节点代替它的位置。而Right-Rotate当然就是把Left-Rotate左、右互反一下。如下图：



注意，Left-Rotate(x)后，x的右子树变成了原来y的左子树，Right-Rotate反之。思考一下，这样一次变换后，仍然满足二叉搜索树的性质。在红黑树的插入、删除中，要用到很多Left-Rotate和Right-Rotate操作。

一、 插入

插入首先是按部就班二叉搜索树的插入步骤，把新节点z插入到某一个叶节点的位置上。
接下来把z的颜色设成红色。为什么？还记得红黑树的性质吗，从根节点向下到空节点的每一条路径上的黑色节点数要相同。如果新插入的是黑色节点，那么它所在的路径上就多出了一个黑色的节点了。所以新插入的节点一定要设成红色。但是这样可能又有一个矛盾，如果z的父节点也是红色，怎么办，前面说过红色节点的子节点必须是黑色。因此我们要执行下面一个迭代的过程，称为Insert-Fixup，来修补这棵红黑树。

在Insert-Fixup中，每一次迭代的开始，指针z一定都指向一个红色的节点。如果z->parent是黑色，那我们就大功告成了；如果z->parent是红色，显然这就违返了红黑的树性质，那么我们要想办法把z或者z->parent变成黑色，但这要建立在不破坏红黑树的其他性质的基础上。

这里再引入两个指针：grandfather，指向z->parent->parent，也就是z的爷爷(显然由于z->parent为红色，grandfather一定是黑色)；uncle，指向grandfather除了z->parent之外的另一个子节点，也就是z的父亲的兄弟，所以叫uncle。

（为了说话方便，我们这里都假设z->parent是grandfather的左子节点，而uncle是grandfather的右子节点。如果遇到的实际情况不是这样，那也只要把所有操作中的左、右互反就可以了。）

在每一次迭代中，我们可能遇到以下三种情况。
Case 1. uncle也是红色。这时只要把z->parent和uncle都设成黑色，并把grandfather设成红色。这样仍然确保了每一条路径上的黑色节点数不变。然后把z指向grandfather，并开始新一轮的迭代。如下图：

Case 2. uncle是黑色，并且z是z->parent的右子节点。这时我们只要把z指向z->parent，然后做一次Left-Rotate(z)。就可以把情况转化成Case 3。

Case 3. uncle是黑色，并且z是z->parent的左子节点。到了这一步，我们就剩最后一步了。只要把z->parent设成黑色，把grandfather设成红色，再做一次Right-Rotate(grandfather)，整棵树就修补完毕了。可以思考一下，这样一次操作之后，确实满足了所有红黑树的性质。Case 2和Case 3如下图：



反复进行迭代，直到某一次迭代开始时z->parent为黑色而告终，也就是当遇到Case 3后，做完它而告终。

二、删除

让我们来回顾一下二叉搜索树的删除节点z的过程：如果z没有子节点，那么直接删除即可；如果z只有一个子节点，那么让这个子节点来代替z的位置，然后把z删除即可；如果z有两个子节点，那么找到z在中序遍历中的后继节点s（也就是从z->rchild开始向左下方一直走到底的那一个节点），把s的key赋值给z的key，然后删除s。

红黑树中删除一个节点z的方法也是首先按部就班以上的过程。
如果删除的节点是黑色的，那么显然它所在的路径上就少一个黑色节点，那么红黑树的性质就被破坏了。这时我们就要执行一个称为Delete-Fixup的过程，来修补这棵树。下面我就来讲解一下。

一个节点被删除之后（实际删除的节点是上面的s，不是本来key对应的节点），一定有一个它的子节点代替了它的位置（即使是叶节点被删除后，也会有一个空节点来代替它的位置。前面说过，在红黑树中，空节点是一个实际存在的节点。）。我们就设指针x指向这个代替位置的节点(删除节点这个位置已经被替代了)。
显然，如果x是红色的，那么我们只要把它设成黑色，它所在的路径上就重新多出了一个黑色节点，那么红黑树的性质就满足了。
然而，如果x是黑色的，那我们就要假想x上背负了2个单位的黑色。那么红黑树的性质也同样不破坏，但是我们要找到某一个红色的节点，把x上“超载”的这1个单位的黑色丢给它，这样才算完成。Delete-Fixup做的就是这个工作。

Delete-Fixup同样是一个循环迭代的过程。每一次迭代开始时，如果指针x指向一个红色节点，那么大功告成，把它设成黑色即告终。相反如果x黑色，那么我们就会面对以下4种情况。

这里引入另一个指针w，指向x的兄弟。这里我们都默认x是x->parent的左子节点，则w是x->parent的右子节点。（如果实际遇到相反的情况，只要把所有操作中的左、右互反一下就可以了。）

Case 1. w是红色。这时我们根据红黑树的性质可以肯定x->parent是黑色、w->lchild是黑色。我们把x->parent与w的颜色互换，然后做一次Left-Rotate(x->parent)。做完之后x就有了一个新的兄弟：原w->lchild，前面说过它一定是黑色的。那么我们就在不破坏红黑树性质的前提下，把Case 1转换成了Case2、3、4中的一个，也就是w是黑色的情况。思考一下，这样做不会改变每条路径上黑色节点的个数，如下图：



Case 2. w是黑色，并且w的两个子节点都是黑色。这时我们只要把w设成红色。然后把x移到x->parent，开始下一轮迭代（注意，那“超载”的1单位的黑色始终是跟着指针x走的，直到x走到了一个红色节点上才能把它“卸下”）。思考一下，这一次操作不会破坏红黑树的性质。如下图（图中节点B不一定是红色，也可能是黑色）：



Case 3. w是黑色，并且w的两个子节点左红右黑。这时我们把w与w->lchild的颜色互换，然后做Right-Rotate(w)。思考一下，这样做之后不会破坏红黑树的性质。这时x的新的兄弟就是原w->lchild。而Case 3被转化成了Case 4。



Case 4. w是黑色，并且w的右子节点是红色。一但遇到Case 4，就胜利在望了。我看下面一张图。先把w与x->parent的颜色互换，再做Left-Rotate(x->parent)。这时图中节点E（也就是原w->rchild）所在的路径就肯定少了一个黑色，而x所在的路径则多了一个黑色。那么我们就把x上多余的1个单位的黑色丢给E就可以了。至此，Delete-Fixup就顺利完成了。

1. /*
2.  * File: rbtree.h 
3.  * Purpose: interface for RBTree
4.  * Author: cxf
5.  * Date: 06/08/2008
6.  */
8. #ifndef _RBTREE_H_
9. #define _RBTREE_H_
10. #include 
11. using namespace std;
13. //节点的颜色(红或黑)
14. typedef enum
15. {
16.     BLACK,
17.     RED
18. }NodeColor;
20. typedef enum
21. {
22.     RBT_STATUS_OK,
23.     RBT_STATUS_KEY_NOT_FOUND,
24.     RBT_STATUS_MEM_EXAUSTED,
25.     RBT_STATUS_KEY_DUPLICATE
26. }RBtStatus;
28. typedef  int KeyType;
29. typedef  int ValueType;
31. //比较两个节点key的大小
32. #define compLT(a, b) ((a) < (b))
33. #define compEQ(a, b) ((a) == (b))
35. //红黑树节点类
36. class RBTreeNode
37. {
38. public:
39.     RBTreeNode(NodeColor _color = BLACK, RBTreeNode *_left = NULL, RBTreeNode *_right = NULL, /
40.                RBTreeNode *_parent = NULL, KeyType _key = INT_MAX, ValueType _value = 0);
41.     friend class RBTree;
42. private:
43.     NodeColor color;
44.     RBTreeNode *left;
45.     RBTreeNode *right;
46.     RBTreeNode *parent;
47.     KeyType key;
48.     ValueType value;
49. };
50. //红黑树类
51. class RBTree
52. {
53. public:
54.     RBTree(RBTreeNode *_root = NULL);
55.     ~RBTree();
56.     int Insert(KeyType key, ValueType value);//插入节点
57.     int Delete(KeyType key); //删除对应键的节点
58.     RBTreeNode* Search(KeyType key);//查找特定键
59.     void InOrder(); //中序遍历树
60. private:
61.     RBTreeNode *root;
62.     void InsertFixup(RBTreeNode *x);//插入节点修正函数
63.     void DeleteFixup(RBTreeNode *x);//删除节点修正函数
64.     void RotateLeft(RBTreeNode *x); //左旋转
65.     void RotateRight(RBTreeNode *x);//右旋转
66.     void Destroy(RBTreeNode *x);
67.     void Display(RBTreeNode *x);
68.     void InOrder(RBTreeNode *y, void (RBTree::*callback)(RBTreeNode*));
69. };
71. #endif
74. /*
75.  * File: rbtree.cpp 
76.  * Purpose: implemention for RBTree
77.  * Author: cxf
78.  * Date: 06/08/2008
79.  */
82. #include 
83. #include "rbtree.h"
85. RBTreeNode::RBTreeNode(NodeColor _color /* = BLACK */, RBTreeNode *_left /* = NULL */, /
86.                        RBTreeNode *_right /* = NULL */, RBTreeNode *_parent /* = NULL */, /
87.                        KeyType _key /* = INT_MAX */, ValueType _value /* = 0 */)
88. {
89.     color = _color;
90.     left = _left;
91.     right = _right;
92.     parent = _parent;
93.     key = _key;
94.     value = _value;
95. }
97. RBTree::RBTree(RBTreeNode *_root /* = NULL */)
98. {
99.     root = _root;
100. }
102. RBTree::~RBTree()
103. {
104.     Destroy(root);
105. }
107. //销毁从x节点开始的所有树中节点
108. void RBTree::Destroy(RBTreeNode *x)
109. {
110.     if (NULL == x)
111.     {
112.         return;
113.     }
114.     Destroy(x->left);
115.     Destroy(x->right);
116.     free(x);
117. }
119. /*------------------------------------------------
120. |   x              y
121. |  / /    ==>     / / 
122. | a   y          x   c 
123. |    / /        / / 
124. |    b  c       a  b 
125. ------------------------------------------------*/ 
126. void RBTree::RotateLeft(RBTreeNode *x)
127. {
128.     assert(x != NULL);
129.     
130.     RBTreeNode *y = x->right;
131.     x->right = y->left;
132.     if (y->left != NULL)
133.     {
134.         y->left->parent = x;
135.     }
136.     
137.     if (x == root)
138.     {
139.         root = y;
140.     }
141.     else
142.     {
143.         y->parent = x->parent;      
144.         if (x == x->parent->left)
145.         {
146.             x->parent->left = y;
147.         }
148.         else
149.         {
150.             x->parent->right = y;
151.         }
152.     }
153.     
154.     y->left = x;
155.     x->parent = y;
156. }
158. /*------------------------------------------------
159. |    x              y 
160. |   / /            / / 
161. |  y   c   ==>    a   x 
162. | / /                / / 
163. |a   b              b   c 
164. -------------------------------------------------*/ 
165. void RBTree::RotateRight(RBTreeNode *x)
166. {
167.     assert(x != NULL);
168.     RBTreeNode *y = x->left;
169.     x->left = y->right;
170.     if (y->right != NULL)
171.     {
172.         y->right->parent = x;
173.     }
174.     
175.     if (root == x)
176.     {
177.         root = y;
178.     }
179.     else
180.     {
181.         y->parent = x->parent;
182.         if (x == x->parent->left)
183.         {
184.             x->parent->left = y;
185.         }
186.         else
187.         {
188.             x->parent->right = y;
189.         }
190.     }
191.     
192.     y->right = x;
193.     x->parent = y;
194. }
199. //在树中查找键为key的节点
200. RBTreeNode* RBTree::Search(KeyType key)
201. {
202.     RBTreeNode *p = root;
203.     RBTreeNode *pp = NULL;
204.     while (p != NULL)
205.     {
206.         pp = p;
207.         if (compEQ(key, p->key))
208.         {
209.             break;
210.         }
211.         p = compLT(key, p->key) ? p->left : p->right;       
212.     }
213.     return p;
214. }
216. int RBTree::Insert(KeyType key, ValueType value)
217. {
218.     RBTreeNode *p = root;
219.     RBTreeNode *pp = NULL;
220.     //寻找插入位置，循环结束时，pp保存插入节点的父节点
221.     while (p != NULL)
222.     {
223.         pp = p;
224.         if (compEQ(key, p->key))
225.         {
226.             return RBT_STATUS_KEY_DUPLICATE;
227.         }
228.         p = compLT(key, p->key) ? p->left : p->right;       
229.     }
230.     
231.     //若是空树，将节点设为黑色
232.     if (NULL == root)
233.     {
234.         root = p = new RBTreeNode(BLACK, NULL, NULL, NULL, key, value);
235.     }
236.     //若树非空，将节点设为红色并插入
237.     else
238.     {
239.         p = new RBTreeNode(RED, NULL, NULL, pp, key, value);
240.         if (compLT(key, pp->key))
241.         {
242.             pp->left = p;
243.         }
244.         else
245.         {
246.             pp->right = p;
247.         }   
248.     }
249.     //插入后，进行修正，以符合红黑树的特点
250.     InsertFixup(p);
251.     return RBT_STATUS_OK;
252. }
254. //插入节点后修正函数
255. void RBTree::InsertFixup(RBTreeNode *x)
256. {
257.     RBTreeNode *uncle = NULL; //x的叔叔节点
258.     
259.     //循环直到x的父节点是黑色或x为根结点即可
260.     while (x != root && RED == x->parent->color)
261.     {
262.         //叔叔在爷爷的右子树上
263.         if (x->parent == x->parent->parent->left)
264.         {
265.             uncle = x->parent->parent->right;
266.             //叔叔节点为红色,或没有叔叔节点
267.             if (uncle != NULL && RED == uncle->color)
268.             {
269.                 x->parent->color = BLACK;
270.                 x->parent->parent->color = RED;
271.                 uncle->color = BLACK;
272.                 x = x->parent->parent;
273.             }
274.             //叔叔节点为黑色
275.             else
276.             {
277.                 //x在右子树上，需要转换为x在左子树上
278.                 if (x == x->parent->right)
279.                 {
280.                     x = x->parent;
281.                     RotateLeft(x);
282.                 }
283.                 //x在左子树上
284.                 x->parent->color = BLACK;
285.                 x->parent->parent->color = RED;
286.                 RotateRight(x->parent->parent);
287.             }
288.         }
289.         //叔叔在爷爷的左子树上，与上面算法基本相同，旋转方向需要改变
290.         else
291.         {
292.             uncle = x->parent->parent->left;
293.             if (uncle != NULL && RED == uncle->color)
294.             {
295.                 x->parent->color = BLACK;
296.                 x->parent->parent->color = RED;
297.                 uncle->color = BLACK;
298.                 x = x->parent->parent;
299.             }
300.             else
301.             {
302.                 if (x == x->parent->left)
303.                 {
304.                     x = x->parent;
305.                     RotateRight(x);
306.                 }
307.                 x->parent->color = BLACK;
308.                 x->parent->parent->color = RED;
309.                 RotateLeft(x->parent->parent);
310.             }
311.         }
312.     }
313.     //一定要加这一句，因为可能最后x指向了root，且root的颜色可能被修改过，这时只要将根设为黑色即可
314.     root->color = BLACK;
315. }
318. //删除键为key的节点
319. int RBTree::Delete(KeyType key)
320. {
321.     RBTreeNode *p = NULL; //指向查找到的节点(实际上可能并不删除它)
322.     RBTreeNode *x = NULL; //指向欲删除的节点(可能和p一样)
323.     RBTreeNode *y = NULL; //指向欲删除节点的子节点(欲删除节点只有一个子节点)
324.     // 先寻找节点，并用p指向
325.     if (NULL == (p = Search(key)))
326.     {
327.         return RBT_STATUS_KEY_NOT_FOUND;
328.     }
329.     //p的两个子节点可能存在或不存在，两种情况下用x统一保存真正需要删除的节点
330.     if (NULL == p->left || NULL == p->right)
331.     {
332.         x = p;
333.     }
334.     else
335.     {
336.         x = p->right;
337.         while (x->left != NULL)
338.         {
339.             x = x->left;
340.         }
341.     }
342.     //y保存需要删除节点x的子节点
343.     if (NULL == x->left)
344.     {
345.         y = x->right;
346.     }
347.     else
348.     {
349.         y = x->left;
350.     }
351.     //删除的节点不是根节点
352.     if (x != root)
353.     {
354.         if (y != NULL)
355.         {
356.             y->parent = x->parent;
357.         }   
358.         if (x == x->parent->left)
359.         {
360.             x->parent->left = y;
361.         }
362.         else
363.         {
364.             x->parent->right = y;
365.         }
366.         
367.         if (BLACK == x->color)
368.         {
369.             if (y != NULL)
370.             {
371.                 DeleteFixup(y);
372.             }
373.             else
374.             {
375.                 DeleteFixup(x->parent);
376.             }           
377.         }   
378.     }
379.     //删除的节点是根节点
380.     else
381.     {
382.         root = y;
383.         if (y != NULL)
384.         {
385.             y->color = BLACK;
386.         }       
387.     }
388.     //用"实际被删除节点"的值取代"表面上删除节点"的值
389.     if ( x != p)
390.     {
391.         p->key = x->key;
392.         p->value = x->value;
393.     }
394.     
395.     delete x;
396.     return RBT_STATUS_OK;
397. }
399. //删除节点修正函数(有bug,但不知怎样修正: 当x没有兄弟节点时即silbing为空时。)
400. void RBTree::DeleteFixup(RBTreeNode *x)
401. {
402.     
403.     RBTreeNode *sibling = NULL;//节点x的兄弟节点
404.     //一直循环，直到x是根节点或x节点为红色，这时直接将x设为黑色即可
405.     while ((x != root) && (x->color == BLACK))
406.     {
407.         //节点x在其父亲的左子树上
408.         if (x == x->parent->left)
409.         {
410.             sibling = x->parent->right;
411.             //兄弟颜色为红色，转换为兄弟为黑色的情况
412.             if (RED == sibling->color)
413.             {
414.                 x->parent->color = RED;
415.                 sibling->color = BLACK;
416.                 RotateLeft(x->parent);
417.                 sibling = x->parent->right;
418.             }
419.             //兄弟颜色为黑色
420.             
421.             //兄弟的两个子树均为黑色, 空节点算黑节点
422.             if ((NULL == sibling->left || BLACK == sibling->left->color) && /
423.                 (NULL == sibling->right || BLACK == sibling->right->color))
424.             {
425.                 sibling->color = RED;
426.                 x = x->parent;
427.             }               
428.             else
429.             {
430.                 //兄弟的两个子树中左红右黑，将其转换为右子树为红色
431.                 if ((NULL == sibling->right) || (BLACK == sibling->right->color))
432.                 {
433.                     sibling->color = RED;
434.                     sibling->left->color = BLACK;
435.                     RotateRight(sibling);
436.                     sibling = x->parent->right;
437.                 }   
438.                 //兄弟的右子树为红
439.                 sibling->color = x->parent->color;
440.                 x->parent->color = BLACK;   
441.                 sibling->right->color = BLACK;
442.                 RotateLeft(x->parent);  
443.                 break;
444.             }
445.             
446.         }
447.         //节点x在其父亲的右子树上, 算法与上面相同，只是旋转方向需要改变
448.         else
449.         {
450.             sibling = x->parent->left;
451.             if (RED == sibling->color)
452.             {
453.                 x->parent->color = RED;
454.                 sibling->color = BLACK;
455.                 RotateRight(x->parent);
456.                 sibling = x->parent->left;
457.             }
458.             
459.             if ((NULL == sibling->left || BLACK == sibling->left->color) && /
460.                 (NULL == sibling->right || BLACK == sibling->right->color))
461.             {
462.                 sibling->color = RED;
463.                 x = x->parent;
464.             }
465.             else 
466.             {
467.                 if ((NULL == sibling->left) || (BLACK == sibling->left->color))
468.                 {
469.                     sibling->color = RED;
470.                     sibling->right->color = BLACK;
471.                     RotateLeft(sibling);
472.                     sibling = x->parent->left;
473.                 }                       
474.                 sibling->color = x->parent->color;
475.                 x->parent->color = BLACK;   
476.                 sibling->left->color = BLACK;
477.                 RotateRight(x->parent); 
478.                 break;
479.             }
480.             
481.         }
482.     }   
483.     x->color = BLACK;   
484. }
486. //显示每个节点的键和值
487. void RBTree::Display(RBTreeNode *x)
488. {
489.     cout << x->key << "--" << x->value << endl;
490. }
492. //中序遍历红黑树内部函数
493. void RBTree::InOrder(RBTreeNode *y, void (RBTree::*callback)(RBTreeNode*))
494. {
495.     if (NULL == y)
496.     {
497.         return;
498.     }
499.     InOrder(y->left, callback);
500.     Display(y);
501.     InOrder(y->right, callback);
502. }
504. //中序遍历红黑树
505. void RBTree::InOrder()
506. {
507.     InOrder(root, RBTree::Display);
508. }