编程练习——红黑树（RedBlackTree）

   在网上搜索了很多红黑树的资源，发现自己看代码的能力还是有些欠缺。很多都看不懂，后来找到一篇英文红黑树文献，终于弄明白了红黑树的删除插入是怎么做的。但是那片文献好像还有些漏洞，其中有一种删除情况，他并没有考虑到。如果大家想看的话可以搜索下 "red-black trees" ,由 prof. Lyn Turbak所写。因为时间关系，插入算法只是实现了非CLR算法。删除算法我也不知道叫什么名字(文献里没有讲)。但是删除结果依旧符合红黑树。

  建立红黑树节点的时候，考虑到因为经常要和一个节点的父亲节点打交道，所以采用了在节点里添加父亲节点的指针的方法。这样即方便也提高效率。另外也好调试。如果一味采用递归..估计人会看疯掉的。插入的时候，采用的是先插入删除的时候红色节点，然后在判断是否违反红红条件。违反的话就左旋右旋进行调整。否则就插入成功。删除的时候先删除节点，这个过程和删除二叉查找树节点一致。删除时要看真正要删除的节点是否是根节点，是否是黑色节点。因为红色节点和根节点删除不会调整树形。如果删除的是黑色节点，那么要看替换他的节点（这里的替换一定是左子树树根，因为如果有右子树，那么被删除的也不会是这个节点，记住二叉查找树的删除过程）是否是黑色节点（这里如果左子树为空，那他也是黑色节点）。如果是黑色节点，那么一定要调整树的结构，否则就直接染色。调整树结构时要考虑的情况就非常多了。一共有9种情况需要考虑。

 

  下面是代码部分，删除时如何调整在代码注释中。至于insert操作，看看文献就应该会做了。

 

1. /*
2. * create RBNode class for construction RBTree
3. * create by chico chen
4. * date: 2008/09/04
5. * 如需转载注明出处
6. */
8. template<class T>
9. #define RED 0
10. #define BLACK 1
11. class RBNode
12. {
13. public:
15.     T data;
16.     RBNode<T>* left;
17.     RBNode<T>* right;
18.     RBNode<T>* parent;
19.     int color;
21.     RBNode(T& data)
22.     {
23.         this->data = data;
24.         left = NULL;
25.         right = NULL;
26.         parent = NULL;
27.         color = RED; 
28.     }
29.     RBNode(T& data, RBNode<T>* left, RBNode<T>* right, RBNode<T>* parent)
30.     {
31.         this->data = data;
32.         this->left = left;
33.         this->right = right;
34.         this->parent = parent;
35.         color = RED;
36.     }
38.     ~RBNode()
39.     {
40.         this->left = this->right = this->parent = NULL;
41.         color = RED;
42.     }
43. };

 

 

下面是红黑树代码

 

1. /*
2. * this is red-black-tree code
3. * this code is not efficent in inserting
4. *
5. * create by chico chen
6. * date: 2008/09/04
7. * 如需转载注明出处
8. */
10. #include "RBNode.h"
12. template<class T>
13. class RBTree
14. {
16. private:
17.     RBNode<T>* root;
18. public:
19.     RBTree()
20.     {
21.         this->root = NULL;
22.     }
23.     ~RBTree()
24.     {
25.         clearTree(this->root);
26.     }
30.     void print()
31.     {
32.         print(this->root,0);
33.     }
34.     
39.     void insert(T& data)
40.     {
42.         RBNode<T>* node = new RBNode<T>(data);
43.         insertNode(node);
44.     }
46.     void deleteKey(T& data)
47.     {
48.         deleteNode(data);
49.     }
52.     bool RBTreeTest()
53.     {
54.         try
55.         {
56.             getBlackNum(this->root);
58.         }
59.         catch(...)
60.         {
61.             return false;
62.         }
63.         return true;
64.     }
66. private:
69.     void print(RBNode<T>* subRoot, int num)
70.     {
71.         if(subRoot != NULL)
72.         {
73.             print(subRoot->right,num+3);
74.             for(int i = 0; i < num; i++)
75.             {
76.                 cout << " ";
77.             }
78.             cout << subRoot->data<<"("<<subRoot->color<<")"<<endl;
79.             print(subRoot->left,num+3);
80.         }
81.     }
83.     void clearTree(RBNode<T>* subRoot)
84.     {
85.         if(subRoot == NULL)
86.             return;
87.         clearTree(subRoot->left);
88.         clearTree(subRoot->right);
89.         delete subRoot;
90.     }
92.     RBNode<T>* deleteMin(RBNode<T>* subRoot,RBNode<T>** parent)
93.     {
94.         
95.         while(subRoot != NULL)
96.         {
97.             parent = &subRoot;
98.             if(subRoot->right != NULL)
99.             {
100.                 subRoot = subRoot->right;
101.             }
102.             else
103.             {
104.                 break;
105.             }
106.         }
107.         return subRoot;
108.     }
110.     void deleteNode(T& data)
111.     {
112.         if(root == NULL)
113.         {
114.             throw "Empty tree";
115.         }
116.         RBNode<T>* subRoot = root;
117.         while(subRoot != NULL)
118.         {
119.             if(subRoot->data > data)
120.             {
121.                 subRoot = subRoot->left;
122.             }
123.             else if(subRoot->data < data)
124.             {
125.                 subRoot = subRoot->right;
126.             }
127.             else
128.             {
129.                 // find the data
130.                 // use the midOrder last one which is before the data node to replace
131.                 RBNode<T>* inParent = subRoot;
132.                 RBNode<T>* deleteNode = deleteMin(subRoot->left,&inParent);
133.                 RBNode<T>* realDelete = NULL;
134.                 if(deleteNode != NULL)
135.                 {
136.                     subRoot->data = deleteNode->data; // copy
137.                     realDelete = deleteNode;
138.                     //real delete
139.                 }
140.                 else
141.                 {
142.                     realDelete = subRoot;
143.                     //real delete
144.                 }
145.                 if(realDelete->parent == NULL)
146.                 {
147.                     // delete root
148.                     delete realDelete;
149.                 }
150.                 else
151.                 {
152.                     // nothing at realDelete->right
153.                     RBNode<T>* parent = realDelete->parent;
154.                     RBNode<T>* subATree = NULL;
155.                     if(parent->left == realDelete)
156.                     {
157.                         parent->left = realDelete->left;
158.                     }
159.                     else
160.                     {
161.                         parent->right = realDelete->left;
162.                     }
163.                     subATree = realDelete->left;
164.                     if(realDelete->left != NULL)
165.                     {
166.                         realDelete->left->parent = parent;
167.                     }
168.                     int color = realDelete->color;
169.                     delete realDelete;
170.                     if(color == BLACK && 
171.                         (subATree == NULL || subATree->color == BLACK))
172.                     {
173.                         
174.                         
175.                         deleteRebuild(subATree,parent);
176.                     }
177.                     else if(color == BLACK && subATree->color == RED)
178.                     {
179.                         subATree->color = BLACK;
180.                     }
181.                     else
182.                     {
183.                         // do nothing
184.                     }
185.                     break;
186.                 }
188.             }
189.         }
190.     }
193.     /* delete them if you want
194.     *
195.     //     x(r)                c(r)
196.     //     /  /                /  /
197.     //   `a(b) b(b) -->     x(b)   b(b)
198.     //         /            /
199.     //        c(r)         a(b)
200.     // LRL means L-> double black is at left, and rotate is RL
201.     RBNode<T>* LRLCaseA(RBNode<T>* x)
202.     {
203.         RLRotate(x,x->right,x->right->left);
204.         x->color = BLACK;
205.         return x->parent;
206.         
207.     }
210.     //     x(r)                 b(r)
211.     //     /  /                 /  /
212.     //   `a(b) b(b)   -->    x(b)   c(b)
213.     //          /             /
214.     //           c(r)       a(b)
215.     RBNode<T>* LLLCaseA(RBNode<T>* x)
216.     {
217.         RRRotate(x,x->right);
218.         x->color = BLACK;
219.         x->parent->color = RED;
220.         x->parent->right->color = BLACK;
221.         return x->parent;
222.     }
224.     //     x(r)                b(r)
225.     //     /  /                /  /
226.     //   b(b) `a(b)-->       c(b) x(b)
227.     //    /                         /
228.     //  c(r)                        a(b)
229.     RBNode<T>* RLLCaseA(RBNode<T>* x)
230.     {
231.         LLRotate(x,x->left);
232.         x->color = BLACK;
233.         x->parent->color = RED;
234.         x->parent->left->color = BLACK;
235.         return x->parent;
236.     }
239.     //     x(r)                c(r)
240.     //     /  /                /  /
241.     //   b(b) `a(b)-->       b(b) x(b)
242.     //    /                         /
243.     //    c(r)                        a(b)
244.     RBNode<T>* RLRCaseA(RBNode<T>* x)
245.     {
246.         LRRotate(x,x->left,x->left->right);
247.         x->color = BLACK;
248.         
249.         return x->parent;
250.     }
252.     
253.     //     x(r)                     x(b)
254.     //     /  /                     /  /
255.     //   `a(b) c(b)        ->     a(b) c(r)
256.     //         /   /                  /   /
257.     //        d(b)  e(b)            d(b)  e(b)
258.     RBNode<T>* LCaseB(RBNode<T>* x)
259.     {
260.         x->color = BLACK;
261.         x->right->color = RED;
262.     }
264.     //     x(r)                     x(b)
265.     //     /  /                     /  /
266.     //    c(b) `a(b)       ->     c(r) a(b)
267.     //   /   /                   /   /
268.     // d(b)  e(b)              d(b)  e(b)
269.     RBNode<T>* RCaseB(RBNode<T>* x)
270.     {
271.         x->color = BLACK;
272.         x->left->color = RED;
273.     }
275.     //     x(b)                    c(b)
276.     //     /  /                    /  /
277.     //  `a(b)  c(r)      ->     x(r)  e(b)
278.     //        /   /             /  / 
279.     //       d(b)  e(b)      `a(b)  d(b)
280.     RBNode<T>* LCaseC(RBNode<T>* x)
281.     {
282.         RRRotate(x,x->right);
283.         x->color = RED;
284.         x->parent->color = BLACK;
285.         return  x->parent;
286.     }
288.     //     x(b)                    c(b)
289.     //     /  /                    /  /
290.     //   c(r) `a(b)     ->       d(b) x(r)
291.     //   /   /                        /  / 
292.     //  d(b)  e(b)                  e(b) `a(b) 
293.     RBNode<T>* RCaseC(RBNode<T>* x)
294.     {
295.         LLRotate(x,x->left);
296.         x->color = RED;
297.         x->parent->color = BLACK;
298.         return  x->parent;
299.     }
300.     *
301.     */
303.     bool isBlack(RBNode<T>* node)
304.     {
306.         if(node == NULL || node->color == BLACK)
307.             return true;
308.         return false;
309.     }
311.     void rebuild(RBNode<T>* node)
312.     {
313.         if(node->parent->data > node->data)
314.         {
315.             node->parent->left = node;
316.         }
317.         else
318.         {
319.             node->parent->right = node;
320.         }
321.     }
324.     /*
325.     * There are 9 cases we will meet. The cases of the double black node at the right is ignored.
326.     * (b) means black node, (db) means double black node, (r) means red node
327.     * 1.    (b)              2   (b)           3 (b)
328.     *      /   /                 /  /            /  /
329.     *    (db)  (b)             (db)  (b)       (db)  (b)
330.     *          /  /                  / /             / /
331.     *         (b)  (b)             (r)  (b)        (b)  (r)
332.     *
333.     * 4.    (b)              5   (b)           6 (r)
334.     *      /   /                 /  /            /  /
335.     *    (db)  (b)             (db)  (r)       (db)  (b)
336.     *          /  /                  / /             / /
337.     *         (r)  (r)             (b)  (b)        (b)  (b)
338.     *
339.     * 7.    (r)              8   (r)           9 (r)
340.     *      /   /                 /  /            /  /
341.     *    (db)  (b)             (db)  (b)       (db)  (b)
342.     *          /  /                  / /             / /
343.     *         (r)  (b)             (b)  (r)        (r)  (r)
344.     *
345.     * case 1,6: up the black, if the parent is black then call the function again until the 
346.     * double black node is root, else blacken the parent.
347.     * case 2,4,7,9: call the RLRotate, if the parent of the double
348.     * node is black, up the black and call the function again, else 
349.     * blacken the parent.
350.     * case 3,8: call the LLRotate, the same as case 2.
351.     * case 5: call LLRotate, change as    (b)   then end.
352.     *                                    /   / 
353.     *                                  (b)    (b)
354.     *                                  / /
355.     *                                (b)  (r)
356.     * 
357.     */
358.     void deleteRebuild(RBNode<T>* node,RBNode<T>* parent)
359.     {
360.         if(parent == NULL)
361.         {
362.             // root, delete the black
363.             return;
364.         }
365.         if(parent->left == node)
366.         {
367.             RBNode<T>* brother = parent->right;
368.             RBNode<T>* nephewA = brother->left;
369.             RBNode<T>* nephewB = brother->right;
370.             
371.             if(isBlack(nephewA) && isBlack(nephewB) && isBlack(brother))
372.             {
373.                 // case 1,6
374.                 brother->color = RED;
375.                 if(parent->color == BLACK)
376.                 {
377.                     deleteRebuild(parent,parent->parent);
378.                 }
379.                 else
380.                 {
381.                     parent->color = BLACK;
382.                     return;
383.                 }
384.                 
385.             }
386.         
387.             else if(!isBlack(nephewA))
388.             {
389.                 // case 2,4,7,9
390.                 RBNode<T>* tempRoot = RLRotate(parent,brother,nephewA);
391.                 // rebuild
392.                 rebuild(tempRoot);
394.             }
395.             else if(!isBlack(nephewB))
396.             {
397.                 // case 3,8
398.                 RBNode<T>* tempRoot = RRRotate(parent,brother);
399.                 rebuild(tempRoot);
400.                 nephewB->color = BLACK;
401.                 brother->color = RED;
402.             }
403.             else if(!isBlack(brother))
404.             {
405.                 // case 5
406.                 RBNode<T>* tempRoot = RRRotate(parent,brother);
407.                 rebuild(tempRoot);
408.                 brother->color = BLACK;
409.                 nephewA->color = RED;
410.                 return;
411.             }
412.             else
413.             {
414.                 // unknown 
415.                 throw "none excption, about there is no red or black";
416.             }
418.             if(parent->color == BLACK)
419.             {
420.                 // case 2,3,4
421.                 deleteRebuild(parent,parent->parent);
422.             }
423.             else
424.             {
425.                 // case 7,8,9
426.                 parent->color = BLACK;
427.             }
429.         }
430.         else
431.         {
432.             RBNode<T>* brother = parent->left;
433.             RBNode<T>* nephewA = brother->right;
434.             RBNode<T>* nephewB = brother->left;
436.             if(isBlack(nephewA) && isBlack(nephewB) && isBlack(brother))
437.             {
438.                 brother->color = RED;
439.                 if(parent->color == BLACK)
440.                 {
441.                     deleteRebuild(parent,parent->parent);
442.                 }
443.                 else
444.                 {
445.                     parent->color = BLACK;
446.                     return;
447.                 }
448.             }
449.             else if(!isBlack(nephewA))
450.             {
451.                 RBNode<T>* tempRoot = LRRotate(parent,brother,nephewA);
452.                 // rebuild
453.                 rebuild(tempRoot);
455.             }
456.             else if(!isBlack(nephewB))
457.             {
458.                 RBNode<T>* tempRoot = LLRotate(parent,brother);
459.                 rebuild(tempRoot);
460.                 nephewB->color = BLACK;
461.                 brother->color = RED;
462.             }
463.             else if(!isBlack(brother))
464.             {
465.                 RBNode<T>* tempRoot = LLRotate(parent,brother);
466.                 rebuild(tempRoot);
467.                 nephewA->color = RED;
468.                 brother->color = BLACK;
469.                 return;
470.             }
471.             else
472.             {
473.                 throw "none excption, about there is no red or black";
474.             }
476.             if(parent->color == BLACK)
477.             {
478.                 deleteRebuild(parent,parent->parent);
479.             }
480.             else
481.             {
482.                 parent->color = BLACK;
483.             }
485.         }
486.         
487.     }
488.     
489.     
490.     void insertNode(RBNode<T>* node)
491.     {
493.         if(root == NULL)
494.         {
495.             root = node;
496.             node->color = BLACK;
497.             return;
498.         }
499.         RBNode<T>* subRoot = root;
500.         RBNode<T>* insertPoint = NULL;
501.         while(subRoot!=NULL)
502.         {
503.             insertPoint = subRoot;
504.             if(subRoot->data > node->data)
505.             {
506.                 // insert left
507.                 subRoot = subRoot->left;
509.             }
510.             else if(subRoot->data < node->data)
511.             {
512.                 subRoot = subRoot->right;
513.             }
514.             else
515.             {
516.                 throw "same key";
517.             }   
518.         }
519.         
521.         if(insertPoint->data > node->data)
522.         {
523.             insertPoint->left = node;
524.         }
525.         else
526.         {
527.             insertPoint->right = node;
528.         }
529.         node->parent = insertPoint;
530.         
531.         
532.         insertRebuild(node);
533.         
534.     }
536.     // return the subRoot
537.     //        a                   b
538.     //       /                  /   /
539.     //      b        ->        c     a
540.     //     /
541.     //    c
542.     RBNode<T>* LLRotate(RBNode<T>* a, RBNode<T>* b)
543.     {
544.         if(b->right != NULL)
545.         {
546.             b->right->parent = a;
547.             
548.         }
549.         a->left = b->right;
550.         b->right = a;
551.         b->parent = a->parent;
552.         a->parent = b;
553.         return b;
554.     }
556.     // return the subRoot
557.     //        a                      b
558.     //          /                  /   /
559.     //            b        ->     a     c
560.     //              /
561.     //                c
562.     RBNode<T>* RRRotate(RBNode<T>* a, RBNode<T>* b)
563.     {
564.         if(b->left != NULL)
565.         {
566.             b->left->parent = a;
567.             
568.         }
569.         a->right = b->left;
570.         b->left = a;
571.         b->parent = a->parent;
572.         a->parent = b;
575.         return b;
576.     }
579.     // return the subRoot
580.     //        a                      c
581.     //          /                  /   /
582.     //            b        ->     a     b
583.     //           /                 /      
584.     //          c                   d  
585.     //         /
586.     //        d
587.     RBNode<T>* RLRotate(RBNode<T>* a, RBNode<T>* b, RBNode<T>* c)
588.     {
589.         
590.         if(c->right != NULL)
591.         {
592.             c->right->parent = b;       
593.             
594.         }
595.         b->left = c->right;
596.         c->right = b;
597.         b->parent = c;
598.         if(c->left != NULL)
599.         {
600.             c->left->parent = a;        
601.             
602.         }
603.         a->right = c->left;
604.         c->left = a;
605.         c->parent = a->parent;
606.         a->parent = c;
607.         
608.         return c;
609.     }
611.     // return the subRoot
612.     //        a                      c
613.     //       /                     /   /
614.     //      b              ->     b     a
615.     //       /                         /       
616.     //        c                       d   
617.     //         /
618.     //          d
619.     RBNode<T>* LRRotate(RBNode<T>* a, RBNode<T>* b, RBNode<T>* c)
620.     {
621.         if(c->left != NULL)
622.         {
623.             c->left->parent = b;
624.             
625.             
626.         }
627.         b->right = c->left;
628.         c->left = b;
629.         b->parent = c;
630.         if(c->right!= NULL)
631.         {
632.             c->right->parent = a;
633.             
634.         }
635.         a->left = c->right;
636.         c->right = a;
637.         c->parent = a->parent;
638.         a->parent = c;
639.         
640.         return c;
641.     }
643.     // node is not the root
644.     void insertRebuild(RBNode<T>* node)
645.     {
646.         RBNode<T>* parent = NULL;
647.         RBNode<T>* grandParent = NULL;
648.         while(node->parent != NULL)
649.         {
650.             parent = node->parent;
651.             
652.             if(parent->color == RED)// here means there must be a grandparent
653.             {
654.                 grandParent = parent->parent;
655.                 grandParent->color = BLACK;
656.                 
657.                 if(grandParent->left == parent)
658.                 {
659.                     if(parent->left == node)
660.                     {
661.                         //LLRotate
662.                         node->color = BLACK;
663.                         node = LLRotate(grandParent,parent);
664.                         
665.                     }
666.                     else
667.                     {
668.                         //LRRotate
669.                         parent->color = BLACK;
670.                         node = LRRotate(grandParent,parent,node);
671.                         
672.                     }
673.                     
674.                 }
675.                 else
676.                 {
678.                     if(parent->left == node)
679.                     {
680.                         //RLRotate          
681.                         parent->color = BLACK;
682.                         node = RLRotate(grandParent,parent,node);
683.                     }
684.                     else
685.                     {
686.                         //RRRotate
687.                         node->color = BLACK;
688.                         node = RRRotate(grandParent,parent);
689.                     }
690.                 }
691.             }
692.             else
693.             {
694.                 break;
695.             }
696.         }
698.         if(node->parent == NULL)
699.         {
700.             node->color = BLACK;
701.             this->root = node;
702.         }
703.         else
704.         {
705.             rebuild(node);
706.             /*if(node->parent->data > node->data)
707.             {
708.                 node->parent->left = node;
709.             }
710.             else
711.             {
712.                 node->parent->right = node;
713.             }*/
714.         }
715.     }
720.     int getBlackNum(RBNode<T>* subRoot)
721.     {
722.         if(subRoot == NULL)
723.         {
724.             return 1;
725.         }
726.         int left = getBlackNum(subRoot->left);
727.         int right = getBlackNum(subRoot->right);
728.         if(left != right)
729.         {
730.             throw "wrong";
731.         }
732.         if(subRoot->color == BLACK)
733.         {
734.             
735.             return 1+left;
736.         }
737.         else
738.         {
739.             return left;
740.         }
742.     }
743. };