红黑树的C++实现--根据《算法导论》中的算法实现

　　红黑树是一种有序的平衡二叉树，STL中的map和set容器的底层实现就是红黑树，在《STL源码剖析》中有另一种实现方式。不过STL中的实现相对来说晦涩难懂，而《算法导论》中的算法则比较清晰易懂。这里的这份实现就是《算法导论》中STL算法的一种C++实现。关于红色树的特性以及规则这里还有这里都有详细描述。下面就是我的实现代码：

  1 #ifndef        __RBTREE_H__
  2 #define        __RBTREE_H__
  3 
  4 #include <iostream>
  5 const int RED = 0;
  6 const int BLACK = 1;
  7 
  8 struct RBTreeNode
  9 {
 10     RBTreeNode* left;
 11     RBTreeNode* right;
 12     RBTreeNode* parent;
 13     int nData;
 14     int color;//RED=0,BLACK=1
 15 };
 16 
 17 class RBTree
 18 {
 19 
 20 public:
 21     RBTree();
 22     ~RBTree();
 23 public:
 24     bool Insert(const int nData);
 25     bool Delete(const int nData);
 26     RBTreeNode* Find(const int nData);
 27     void Display() 
 28     {
 29         PrintTree(root);
 30     }
 31 private:
 32     void RotateLeft(RBTreeNode* pNode);
 33     void RotateRight(RBTreeNode* pNode);
 34     void InsertFixup(RBTreeNode* pNode);
 35     void DeleteFixup(RBTreeNode* pNode);
 36 
 37     RBTreeNode* CreateNode(int nData);
 38     RBTreeNode* DeleteNode(RBTreeNode* pNode);
 39     RBTreeNode* FindNode(const int nData);
 40     RBTreeNode* Maximum(RBTreeNode* pNode);
 41     RBTreeNode* Minimum(RBTreeNode* pNode);
 42     RBTreeNode* Successor(RBTreeNode* pNode);
 43 
 44     void DeleteTree(RBTreeNode* pNode);
 45     void PrintTree(RBTreeNode* pNode) const;
 46 private:
 47     RBTreeNode* root;
 48     RBTreeNode* nil;
 49     int    node_count;
 50 };
 51 
 52 RBTree::RBTree()
 53 {
 54     nil = new RBTreeNode();
 55 
 56     nil->left = NULL;
 57     nil->right = NULL;
 58     nil->parent = NULL;
 59     nil->nData = 0;
 60     nil->color = BLACK;
 61 
 62     root = nil;
 63 }
 64 
 65 RBTree::~RBTree()
 66 {
 67     DeleteTree(root);
 68     delete nil;
 69     root = NULL;
 70     nil = NULL;
 71 }
 72 
 73 RBTreeNode* RBTree::CreateNode(int nData)
 74 {
 75     RBTreeNode* pTempNode = new RBTreeNode();
 76 
 77     pTempNode->left = nil;
 78     pTempNode->right = nil;
 79     pTempNode->parent = nil;
 80     pTempNode->nData = nData;
 81     pTempNode->color = RED;
 82 
 83     return pTempNode;
 84 }
 85 
 86 void RBTree::DeleteTree(RBTreeNode* pNode)
 87 {
 88     if(pNode == nil)
 89         return;
 90 
 91     DeleteTree(pNode->left);
 92     DeleteTree(pNode->right);
 93 
 94     delete pNode;
 95     pNode = NULL;
 96 }
 97 
 98 //左旋转
 99 void RBTree::RotateLeft(RBTreeNode* pNode)
100 {
101     RBTreeNode* pRNode = pNode->right;
102     pNode->right = pRNode->left;
103 
104     if(pRNode->left != nil)
105     {
106         pRNode->left->parent = pNode;
107         pRNode->parent = pNode->parent;
108     }
109 
110     if(pNode->parent == nil)
111     {
112         root = pRNode;
113     }
114     else if(pNode->parent->left == pNode)
115     {
116         pNode->parent->left = pRNode;
117     }
118     else
119     {
120         pNode->parent->right = pRNode;
121     }
122 
123     pRNode->left = pNode;
124     pNode->parent = pRNode;
125 }
126 
127 //右旋转
128 void RBTree::RotateRight(RBTreeNode* pNode)
129 {
130     RBTreeNode* pLNode = pNode->left;
131     pNode->left = pLNode->right;
132 
133     if(pLNode->right != nil)
134     {
135         pLNode->right->parent = pNode;
136         pLNode->parent = pNode->parent;
137     }
138 
139     if(pNode->parent == nil)
140     {
141         root = pLNode;
142     }
143     else if(pNode->parent->left == pNode)
144     {
145         pNode->parent->left = pLNode;
146     }
147     else
148     {
149         pNode->parent->right = pLNode;
150     }
151 
152     pLNode->right = pNode;
153     pNode->parent = pLNode;
154 }
155 
156 RBTreeNode* RBTree::Maximum(RBTreeNode* pNode)
157 {
158     while(pNode->right != nil)
159         pNode = pNode->right;
160 
161     return pNode;
162 }
163 
164 RBTreeNode* RBTree::Minimum(RBTreeNode* pNode)
165 {
166     while(pNode->left != nil)
167         pNode = pNode->left;
168 
169     return pNode;
170 }
171 
172 RBTreeNode* RBTree::Successor(RBTreeNode* pNode)
173 {
174     if(pNode->right != nil)
175         return Minimum(pNode->right);
176     
177     RBTreeNode* pPNode = pNode->parent;
178     while(pPNode != nil && pNode == pPNode->right)
179     {
180         pNode = pPNode;
181         pPNode = pNode->parent;
182     }
183 
184     return pPNode;
185 }
186 
187 bool RBTree::Insert(const int nData)
188 {
189     RBTreeNode* pNewNode = CreateNode(nData);
190     RBTreeNode* pPNewNode = nil;
191     RBTreeNode* pTemp = root;
192 
193     while( pTemp != nil)
194     {
195         pPNewNode = pTemp;
196 
197         if(nData < pTemp->nData)
198             pTemp = pTemp->left;
199         else
200             pTemp = pTemp->right;
201     }
202 
203     pNewNode->parent = pPNewNode;
204 
205     if(pPNewNode == nil)
206         root = pNewNode;
207     else if(nData < pPNewNode->nData)
208         pPNewNode->left = pNewNode;
209     else
210         pPNewNode->right = pNewNode;
211 
212     InsertFixup(pNewNode);
213 
214     return true;
215 }
216 
217 void RBTree::InsertFixup(RBTreeNode* pNode)
218 {
219     while(pNode->parent->color == RED)
220     {
221         if(pNode->parent == pNode->parent->parent->left)
222         {
223             RBTreeNode* pUNode = pNode->parent->parent->right;//pNode的叔父节点
224             
225             if(pUNode->color == RED)//case 1
226             {
227                 pNode->parent->color = BLACK;
228                 pUNode->color = BLACK;
229                 pNode->parent->parent->color = RED;
230 
231                 pNode = pNode->parent->parent;
232             }
233             else if(pNode == pNode->parent->right)//case 2
234             {
235                 pNode = pNode->parent;
236                 RotateLeft(pNode);
237             }
238             else//case 3
239             {
240                 pNode->parent->color = BLACK;
241                 pNode->parent->parent->color = RED;
242                 RotateRight(pNode->parent->parent);
243             }
244         }//pNode的父节点是其父节点的左子节点
245         else
246         {
247             RBTreeNode* pUNode = pNode->parent->parent->left;//pNode的叔父节点
248             
249             if(pUNode->color == RED)//case 1
250             {
251                 pNode->parent->color = BLACK;
252                 pUNode->color = BLACK;
253                 pNode->parent->parent->color = RED;
254 
255                 pNode = pNode->parent->parent;
256             }
257             else if(pNode == pNode->parent->left)//case 2
258             {
259                 pNode = pNode->parent;
260                 RotateRight(pNode);
261             }
262             else//case 3
263             {
264                 pNode->parent->color = BLACK;
265                 pNode->parent->parent->color = RED;
266                 RotateLeft(pNode->parent->parent);
267             }        
268         }//pNode的父节点是其父节点的右子节点
269     }//while(pNode->parent->color == RED)
270 
271     root->color = BLACK;
272 }
273 
274 bool RBTree::Delete(const int nData)
275 {
276     RBTreeNode* pDeleteNode = FindNode(nData);
277 
278     if(pDeleteNode == nil)
279     {
280         std::cout << "no data" << std::endl;
281         return false;
282     }
283 
284     DeleteNode(pDeleteNode);
285 
286     return true;
287 }
288 
289 RBTreeNode* RBTree::FindNode(const int nData)
290 {
291     RBTreeNode* pTemp = root;
292 
293     while(pTemp != nil)
294     {
295         if(nData < pTemp->nData)
296             pTemp = pTemp->left;
297         else if(nData > pTemp->nData)
298             pTemp = pTemp->right;
299         else
300             return pTemp;
301     }
302 
303     return nil;
304 }
305 
306 RBTreeNode* RBTree::DeleteNode(RBTreeNode* pNode)
307 {
308     RBTreeNode* pDeleteNode = nil;//删除节点
309     RBTreeNode* pCDeleteNode = nil;//删除节点的子节点
310 
311     if(pNode->left == nil || pNode->right == nil)
312         pDeleteNode = pNode;
313     else
314         pDeleteNode = Successor(pNode);
315     
316     if(pDeleteNode->left != nil)
317         pCDeleteNode = pDeleteNode->left;
318     else
319         pCDeleteNode = pDeleteNode->right;
320 
321     if(pDeleteNode->parent == nil)
322         root = pCDeleteNode;
323     else if(pDeleteNode == pDeleteNode->parent->left)
324         pDeleteNode->parent->left = pCDeleteNode;
325     else
326         pDeleteNode->parent->right = pCDeleteNode;
327 
328     if(pDeleteNode != pNode)
329         pNode->nData = pDeleteNode->nData;
330 
331     pCDeleteNode->parent = pDeleteNode->parent;
332 
333     if(pDeleteNode->color == BLACK)
334         DeleteFixup(pCDeleteNode);
335 
336     return pDeleteNode;
337 }
338 
339 void RBTree::DeleteFixup(RBTreeNode* pNode)
340 {
341     while(pNode != root && pNode->color == BLACK)
342     {
343         if(pNode == pNode->parent->left)
344         {
345             RBTreeNode* pBNode = pNode->parent->right;//pNode的兄弟节点
346 
347             if(pBNode->color = RED)//case 1
348             {
349                 pBNode->color = BLACK;
350                 pNode->parent->color = RED;
351 
352                 RotateLeft(pNode->parent);
353                 pBNode = pNode->parent->right;
354             }
355 
356             if(pBNode->left->color == BLACK && pBNode->right->color == BLACK)//case 2
357             {
358                 pBNode->color = RED;
359                 pNode = pNode->parent;
360             }
361             else if(pBNode->right->color == BLACK)//case 3
362             {
363                 pBNode->left->color = BLACK;
364                 pBNode->color = RED;
365 
366                 RotateRight(pBNode);
367                 pBNode = pNode->parent->right;
368             }
369             else//case 4
370             {
371                 pBNode->color = pNode->parent->color;
372                 pNode->parent->color = BLACK;
373                 pBNode->right->color = BLACK;
374 
375                 RotateLeft(pNode->parent);
376                 pNode = root;
377             }
378         }
379         else
380         {
381             RBTreeNode* pBNode = pNode->parent->left;//pNode的兄弟节点
382 
383             if(pBNode->color = RED)//case 1
384             {
385                 pBNode->color = BLACK;
386                 pNode->parent->color = RED;
387 
388                 RotateLeft(pNode->parent);
389                 pBNode = pNode->parent->left;
390             }
391 
392             if(pBNode->left->color == BLACK && pBNode->right->color == BLACK)//case 2
393             {
394                 pBNode->color = RED;
395                 pNode = pNode->parent;
396             }
397             else if(pBNode->left->color == BLACK)//case 3
398             {
399                 pBNode->right->color = BLACK;
400                 pBNode->color = RED;
401 
402                 RotateRight(pBNode);
403                 pBNode = pNode->parent->left;
404             }
405             else//case 4
406             {
407                 pBNode->color = pNode->parent->color;
408                 pNode->parent->color = BLACK;
409                 pBNode->left->color = BLACK;
410 
411                 RotateLeft(pNode->parent);
412                 pNode = root;
413             }        
414         }//if(pNode == pNode->parent->left)
415     }//while(pNode != root && pNode->color == BLACK)
416 
417     pNode->color = BLACK;
418 }
419 
420 void RBTree::PrintTree(RBTreeNode* pNode) const
421 {
422     if (NULL == root)
423         return;
424 
425     if (nil == pNode)
426     {
427         return;
428     }
429 
430     static int n = 0;
431     
432     if(pNode == root)
433     {
434         std::cout << "[" << ++n << "]nData = " << pNode->nData << ",nParentData= 0 ,";
435 
436         if(pNode->left)
437             std::cout << "nLeftData= " << pNode->left->nData << " ,";
438         if(pNode->right)
439             std::cout << "nRightData= " << pNode->right->nData << " ,";
440 
441         std::cout << "color = " << pNode->color << std::endl;
442     }
443     else
444     {
445         std::cout << "[" << ++n << "]nData = " << pNode->nData << ",nParentData= " << pNode->parent->nData << " ,";
446 
447         if(pNode->left)
448             std::cout << "nLeftData= " << pNode->left->nData << " ,";
449         if(pNode->right)
450             std::cout << "nRightData= " << pNode->right->nData << " ,";
451 
452         std::cout << "color = " << pNode->color << std::endl;
453     }
454     PrintTree(pNode->left);
455     PrintTree(pNode->right);
456 }
457 
458 #endif        //__RBTREE_H__

　　将上面的代码复制粘贴到同一个文件中，文件名RBTree.h。下面是测试程序复制到文件Test.cpp中。

 1 #include "RBTree.h"
 2 #include <iostream>
 3 #include <exception>
 4 
 5 int main()
 6 {
 7     try
 8     {
 9         RBTree rbt;
10         for(int i = 1; i < 10; i++)
11         {
12             rbt.Insert(i);
13         }
14         rbt.Delete(4);
15         rbt.Display();
16     }
17     catch (std::exception& e)
18     {
19         std::cout << e.what() << std::endl;
20     }
21 }

　　然后用g++ -o Test Test.cpp该命令进行编译。执行结果如下：

 1 [kiven@localhost Test]$ g++ -o Test Test.cpp
 2 [kiven@localhost Test]$ ls
 3 RBTree.h  Test  Test.cpp
 4 [kiven@localhost Test]$ ./Test
 5 [1]nData = 2,nParentData= 0 ,nLeftData= 1 ,nRightData= 5 ,color = 1
 6 [2]nData = 1,nParentData= 2 ,nLeftData= 0 ,nRightData= 0 ,color = 1
 7 [3]nData = 5,nParentData= 3 ,nLeftData= 3 ,nRightData= 6 ,color = 0
 8 [4]nData = 3,nParentData= 5 ,nLeftData= 0 ,nRightData= 0 ,color = 1
 9 [5]nData = 6,nParentData= 8 ,nLeftData= 0 ,nRightData= 7 ,color = 1
10 [6]nData = 7,nParentData= 6 ,nLeftData= 0 ,nRightData= 0 ,color = 0
11 [kiven@localhost Test]$

　　上面的实现也仅仅是实现了数据结构本身，所以整个都比较粗糙，节点中的数据也用最简单的整形来代替，但是基本功能不缺。

posted @ 2013-02-28 11:48  kiven.li  阅读(2499)  评论(6)  编辑  收藏  举报