紅黑樹的c++完整實現源碼

轉載:http://blog.csdn.net/v_JULY_v/article/details/6285620

前言:
    本人的原創作品紅黑樹系列文章,至此,已經寫到第5篇了。雖然第三篇文章:紅黑樹的c源碼實現與剖析,用c語言完整實現過紅黑樹,但個人感覺,代碼還是不夠清晰。特此,再奉獻出一份c++的完整實現源碼,以饗讀者。

    此份c++實現源碼,代碼緊湊了許多,也清晰了不少,同時採取c++類實現的方式,代碼也更容易維護以及重用。ok,有任何問題,歡迎指正。


第一部分、紅黑樹的c++完整實現源碼

    本文包含紅黑樹c++實現的完整源碼,所有的解釋都含在註釋中,所有的有關紅黑樹的原理及各種插入、刪除操作的情況,都已在本人的紅黑樹系列的前4篇文章中,一一闡述。且在此紅黑樹系列第五篇文章中:紅黑樹從頭至尾插入和刪除結點的全程演示圖,把所有的插入、刪除情況都一一展示盡了。
    因此,有關紅黑樹的全部原理,請參考其它文章,重點可參考此文:紅黑樹算法的實現與剖析。因此,相關原理,本文不再贅述。

    ok,以下,即是紅黑樹c++實現的全部源碼,先是RBTree.h,然後是RBTree.cpp。

RBTree.h

  1. //file RBTree.h  
  2. //written by saturnman,20101008。  
  3. //updated by July,20110329。  
  4. /*----------------------------------------------- 
  5. 版權聲明: 
  6. July和saturnman對此份紅黑樹的c++實現代碼享有全部的版權, 
  7. 謝絕轉載,侵權必究。 
  8. ------------------------------------------------*/  
  9. #ifndef _RB_TREE_H_  
  10. #define _RB_TREE_H_  
  11. #include<iostream>  
  12. #include<string>  
  13. #include<sstream>  
  14. #include<fstream>  
  15. using namespace std;  
  16.   
  17. template<class KEY,class U>  
  18. class RB_Tree  
  19. {  
  20.     private:  
  21.         RB_Tree(const RB_Tree& input){}  
  22.         const RB_Tree& operator=(const RB_Tree& input){}  
  23.     private:  
  24.         enum COLOR{RED,BLACK};  
  25.         class RB_Node  
  26.         {  
  27.         public:  
  28.             RB_Node()  
  29.             {  
  30.                 //RB_COLOR = BLACK;  
  31.                 right = NULL;  
  32.                 left = NULL;  
  33.                 parent = NULL;  
  34.             }  
  35.             COLOR RB_COLOR;  
  36.             RB_Node* right;  
  37.             RB_Node* left;  
  38.             RB_Node* parent;  
  39.             KEY key;  
  40.             U data;  
  41.         };  
  42.         public:  
  43.             RB_Tree()  
  44.             {  
  45.                 this->m_nullNode = new RB_Node();  
  46.                 this->m_root = m_nullNode;  
  47.                 this->m_nullNode->right = this->m_root;  
  48.                 this->m_nullNode->left = this->m_root;  
  49.                 this->m_nullNode->parent = this->m_root;  
  50.                 this->m_nullNode->RB_COLOR = BLACK;  
  51.             }  
  52.               
  53.             bool Empty()  
  54.             {  
  55.                 if(this->m_root == this->m_nullNode)  
  56.                 {  
  57.                     return true;  
  58.                 }  
  59.                 else  
  60.                 {  
  61.                     return false;  
  62.                 }  
  63.             }  
  64.               
  65.             //查找key  
  66.             RB_Node* find(KEY key)  
  67.             {  
  68.                 RB_Node* index = m_root;  
  69.                 while(index != m_nullNode)  
  70.                 {  
  71.                     if(key<index->key)     
  72.                     {  
  73.                         index  = index->left;  //比當前的小,往左  
  74.                     }  
  75.                     else if(key>index->key)  
  76.                     {  
  77.                         index = index->right;  //比當前的大,往右  
  78.                     }  
  79.                     else  
  80.                     {  
  81.                         break;  
  82.                     }  
  83.                 }  
  84.                 return index;  
  85.             }  
  86.               
  87.             //--------------------------插入結點總操作----------------------------------  
  88.             //全部的工作,都在下述僞代碼中:  
  89.             /*RB-INSERT(T, z)    
  90.             1  y ← nil[T]                 // y 始終指向 x 的父結點。 
  91.             2  x ← root[T]              // x 指向當前樹的根結點, 
  92.             3  while x ≠ nil[T] 
  93.             4      do y ← x 
  94.             5         if key[z] < key[x]           //向左,向右.. 
  95.             6            then x ← left[x] 
  96.             7            else x ← right[x]   //爲了找到合適的插入點,x探路跟蹤路徑,直到x成爲NIL 爲止。 
  97.             8  p[z] ← y         //y置爲 插入結點z 的父結點。 
  98.             9  if y = nil[T] 
  99.             10     then root[T] ← z 
  100.             11     else if key[z] < key[y] 
  101.             12             then left[y] ← z 
  102.             13             else right[y] ← z     //此 8-13行,置z 相關的指針。 
  103.             14  left[z] ← nil[T] 
  104.             15  right[z] ← nil[T]            //設爲空, 
  105.             16  color[z] ← RED             //將新插入的結點z作爲紅色 
  106.             17  RB-INSERT-FIXUP(T, z)    
  107.             */  
  108.             //因爲將z着爲紅色,可能會違反某一紅黑性質,  
  109.             //所以需要調用下面的RB-INSERT-FIXUP(T, z)來保持紅黑性質。  
  110.             bool Insert(KEY key,U data)  
  111.             {  
  112.                 RB_Node* insert_point = m_nullNode;  
  113.                 RB_Node* index = m_root;  
  114.                 while(index!=m_nullNode)  
  115.                 {  
  116.                     insert_point = index;  
  117.                     if(key<index->key)  
  118.                     {  
  119.                         index = index->left;  
  120.                     }  
  121.                     else if(key>index->key)  
  122.                     {  
  123.                         index = index->right;  
  124.                     }  
  125.                     else  
  126.                     {  
  127.                         return false;  
  128.                     }  
  129.                 }  
  130.                 RB_Node* insert_node = new RB_Node();  
  131.                 insert_node->key = key;  
  132.                 insert_node->data = data;  
  133.                 insert_node->RB_COLOR = RED;  
  134.                 insert_node->right = m_nullNode;  
  135.                 insert_node->left = m_nullNode;  
  136.                 if(insert_point==m_nullNode) //如果插入的是一顆空樹  
  137.                 {  
  138.                     m_root = insert_node;  
  139.                     m_root->parent = m_nullNode;  
  140.                     m_nullNode->left = m_root;  
  141.                     m_nullNode->right = m_root;  
  142.                     m_nullNode->parent = m_root;  
  143.                 }  
  144.                 else  
  145.                 {  
  146.                     if(key<insert_point->key)  
  147.                     {  
  148.                         insert_point->left = insert_node;  
  149.                     }  
  150.                     else  
  151.                     {  
  152.                         insert_point->right = insert_node;  
  153.                     }  
  154.                     insert_node->parent = insert_point;  
  155.                 }  
  156.                 InsertFixUp(insert_node);    //調用InsertFixUp修復紅黑樹性質。  
  157.             }  
  158.               
  159.             //---------------------插入結點性質修復--------------------------------  
  160.             //3種插入情況,都在下面的僞代碼中(未涉及到所有全部的插入情況)。  
  161.             /* 
  162.             RB-INSERT-FIXUP(T, z) 
  163.             1 while color[p[z]] = RED 
  164.             2     do if p[z] = left[p[p[z]]] 
  165.             3           then y ← right[p[p[z]]] 
  166.             4                if color[y] = RED 
  167.             5                   then color[p[z]] ← BLACK                    ? Case 1 
  168.             6                        color[y] ← BLACK                       ? Case 1 
  169.             7                        color[p[p[z]]] ← RED                   ? Case 1 
  170.             8                        z ← p[p[z]]                            ? Case 1 
  171.             9                   else if z = right[p[z]] 
  172.             10                           then z ← p[z]                       ? Case 2 
  173.             11                                LEFT-ROTATE(T, z)              ? Case 2 
  174.             12                           color[p[z]] ← BLACK                 ? Case 3 
  175.             13                           color[p[p[z]]] ← RED                ? Case 3 
  176.             14                           RIGHT-ROTATE(T, p[p[z]])            ? Case 3 
  177.             15           else (same as then clause with "right" and "left" exchanged) 
  178.             16 color[root[T]] ← BLACK 
  179.             */  
  180.             //然後的工作,就非常簡單了,即把上述僞代碼改寫爲下述的c++代碼:  
  181.             void InsertFixUp(RB_Node* node)  
  182.             {  
  183.                 while(node->parent->RB_COLOR==RED)  
  184.                 {  
  185.                     if(node->parent==node->parent->parent->left)   //  
  186.                     {  
  187.                         RB_Node* uncle = node->parent->parent->right;  
  188.                         if(uncle->RB_COLOR == RED)   //插入情況1,z的叔叔y是紅色的。  
  189.                         {  
  190.                             node->parent->RB_COLOR = BLACK;  
  191.                             uncle->RB_COLOR = BLACK;  
  192.                             node->parent->parent->RB_COLOR = RED;  
  193.                             node = node->parent->parent;  
  194.                         }  
  195.                         else if(uncle->RB_COLOR == BLACK )  //插入情況2:z的叔叔y是黑色的,。  
  196.                         {  
  197.                             if(node == node->parent->right) //且z是右孩子  
  198.                             {  
  199.                                 node = node->parent;  
  200.                                 RotateLeft(node);  
  201.                             }  
  202.                             else                 //插入情況3:z的叔叔y是黑色的,但z是左孩子。  
  203.                             {  
  204.                                 node->parent->RB_COLOR = BLACK;  
  205.                                 node->parent->parent->RB_COLOR = RED;  
  206.                                 RotateRight(node->parent->parent);  
  207.                             }  
  208.                         }  
  209.                     }  
  210.                     else //這部分是針對爲插入情況1中,z的父親現在作爲祖父的右孩子了的情況,而寫的。  
  211.                         //15 else (same as then clause with "right" and "left" exchanged)  
  212.                     {  
  213.                         RB_Node* uncle = node->parent->parent->left;  
  214.                         if(uncle->RB_COLOR == RED)  
  215.                         {  
  216.                             node->parent->RB_COLOR = BLACK;  
  217.                             uncle->RB_COLOR = BLACK;  
  218.                             uncle->parent->RB_COLOR = RED;  
  219.                             node = node->parent->parent;  
  220.                         }  
  221.                         else if(uncle->RB_COLOR == BLACK)  
  222.                         {  
  223.                             if(node == node->parent->left)  
  224.                             {  
  225.                                 node = node->parent;  
  226.                                 RotateRight(node);     //與上述代碼相比,左旋改爲右旋  
  227.                             }  
  228.                             else  
  229.                             {  
  230.                                 node->parent->RB_COLOR = BLACK;  
  231.                                 node->parent->parent->RB_COLOR = RED;  
  232.                                 RotateLeft(node->parent->parent);   //右旋改爲左旋,即可。  
  233.                             }  
  234.                         }  
  235.                     }  
  236.                 }  
  237.                 m_root->RB_COLOR = BLACK;  
  238.             }  
  239.               
  240.             //左旋代碼實現  
  241.             bool RotateLeft(RB_Node* node)  
  242.             {  
  243.                 if(node==m_nullNode || node->right==m_nullNode)  
  244.                 {  
  245.                     return false;//can't rotate  
  246.                 }  
  247.                 RB_Node* lower_right = node->right;  
  248.                 lower_right->parent =  node->parent;  
  249.                 node->right=lower_right->left;  
  250.                 if(lower_right->left!=m_nullNode)  
  251.                 {  
  252.                     lower_right->left->parent = node;  
  253.                 }  
  254.                 if(node->parent==m_nullNode) //rotate node is root  
  255.                 {  
  256.                     m_root = lower_right;  
  257.                     m_nullNode->left = m_root;  
  258.                     m_nullNode->right= m_root;  
  259.                     //m_nullNode->parent = m_root;  
  260.                 }  
  261.                 else  
  262.                 {  
  263.                     if(node == node->parent->left)  
  264.                     {  
  265.                         node->parent->left = lower_right;  
  266.                     }  
  267.                     else  
  268.                     {  
  269.                         node->parent->right = lower_right;  
  270.                     }  
  271.                 }  
  272.                 node->parent = lower_right;  
  273.                 lower_right->left = node;  
  274.             }  
  275.               
  276.             //右旋代碼實現  
  277.             bool RotateRight(RB_Node* node)  
  278.             {  
  279.                 if(node==m_nullNode || node->left==m_nullNode)  
  280.                 {  
  281.                     return false;//can't rotate  
  282.                 }  
  283.                 RB_Node* lower_left = node->left;  
  284.                 node->left = lower_left->right;  
  285.                 lower_left->parent = node->parent;  
  286.                 if(lower_left->right!=m_nullNode)  
  287.                 {  
  288.                     lower_left->right->parent = node;  
  289.                 }  
  290.                 if(node->parent == m_nullNode) //node is root  
  291.                 {  
  292.                     m_root = lower_left;  
  293.                     m_nullNode->left = m_root;  
  294.                     m_nullNode->right = m_root;  
  295.                     //m_nullNode->parent = m_root;  
  296.                 }  
  297.                 else  
  298.                 {  
  299.                     if(node==node->parent->right)  
  300.                     {  
  301.                         node->parent->right = lower_left;  
  302.                     }  
  303.                     else  
  304.                     {  
  305.                         node->parent->left = lower_left;  
  306.                     }  
  307.                 }  
  308.                 node->parent = lower_left;  
  309.                 lower_left->right = node;  
  310.             }  
  311.               
  312.             //--------------------------刪除結點總操作----------------------------------  
  313.             //僞代碼,不再貼出,詳情,請參考此紅黑樹系列第二篇文章:  
  314.             //經典算法研究系列:五、紅黑樹算法的實現與剖析:  
  315.             //http://blog.csdn.net/v_JULY_v/archive/2010/12/31/6109153.aspx。  
  316.             bool Delete(KEY key)  
  317.             {  
  318.                 RB_Node* delete_point = find(key);  
  319.                 if(delete_point == m_nullNode)  
  320.                 {  
  321.                     return false;  
  322.                 }  
  323.                 if(delete_point->left!=m_nullNode && delete_point->right!=m_nullNode)  
  324.                 {  
  325.                     RB_Node* successor = InOrderSuccessor(delete_point);  
  326.                     delete_point->data = successor->data;  
  327.                     delete_point->key = successor->key;  
  328.                     delete_point = successor;  
  329.                 }  
  330.                 RB_Node* delete_point_child;  
  331.                 if(delete_point->right!=m_nullNode)  
  332.                 {  
  333.                     delete_point_child = delete_point->right;  
  334.                 }  
  335.                 else if(delete_point->left!=m_nullNode)  
  336.                 {  
  337.                     delete_point_child = delete_point->left;  
  338.                 }  
  339.                 else  
  340.                 {  
  341.                     delete_point_child = m_nullNode;  
  342.                 }  
  343.                 delete_point_child->parent = delete_point->parent;  
  344.                 if(delete_point->parent==m_nullNode)//delete root node  
  345.                 {  
  346.                     m_root = delete_point_child;  
  347.                     m_nullNode->parent = m_root;  
  348.                     m_nullNode->left = m_root;  
  349.                     m_nullNode->right = m_root;  
  350.                 }  
  351.                 else if(delete_point == delete_point->parent->right)  
  352.                 {  
  353.                     delete_point->parent->right = delete_point_child;  
  354.                 }  
  355.                 else  
  356.                 {  
  357.                     delete_point->parent->left = delete_point_child;  
  358.                 }  
  359.                 if(delete_point->RB_COLOR==BLACK && !(delete_point_child==m_nullNode && delete_point_child->parent==m_nullNode))  
  360.                 {  
  361.                     DeleteFixUp(delete_point_child);  
  362.                 }  
  363.                 delete delete_point;  
  364.                 return true;  
  365.             }  
  366.               
  367.             //---------------------刪除結點性質修復-----------------------------------  
  368.             //所有的工作,都在下述23行僞代碼中:  
  369.             /* 
  370.             RB-DELETE-FIXUP(T, x) 
  371.             1 while x ≠ root[T] and color[x] = BLACK 
  372.             2     do if x = left[p[x]] 
  373.             3           then w ← right[p[x]] 
  374.             4                if color[w] = RED 
  375.             5                   then color[w] ← BLACK                        ?  Case 1 
  376.             6                        color[p[x]] ← RED                       ?  Case 1 
  377.             7                        LEFT-ROTATE(T, p[x])                    ?  Case 1 
  378.             8                        w ← right[p[x]]                         ?  Case 1 
  379.             9                if color[left[w]] = BLACK and color[right[w]] = BLACK 
  380.             10                   then color[w] ← RED                          ?  Case 2 
  381.             11                        x p[x]                                  ?  Case 2 
  382.             12                   else if color[right[w]] = BLACK 
  383.             13                           then color[left[w]] ← BLACK          ?  Case 3 
  384.             14                                color[w] ← RED                  ?  Case 3 
  385.             15                                RIGHT-ROTATE(T, w)              ?  Case 3 
  386.             16                                w ← right[p[x]]                 ?  Case 3 
  387.             17                         color[w] ← color[p[x]]                 ?  Case 4 
  388.             18                         color[p[x]] ← BLACK                    ?  Case 4 
  389.             19                         color[right[w]] ← BLACK                ?  Case 4 
  390.             20                         LEFT-ROTATE(T, p[x])                   ?  Case 4 
  391.             21                         x ← root[T]                            ?  Case 4 
  392.             22        else (same as then clause with "right" and "left" exchanged) 
  393.             23 color[x] ← BLACK  
  394.             */  
  395.             //接下來的工作,很簡單,即把上述僞代碼改寫成c++代碼即可。  
  396.             void DeleteFixUp(RB_Node* node)  
  397.             {  
  398.                 while(node!=m_root && node->RB_COLOR==BLACK)  
  399.                 {  
  400.                     if(node == node->parent->left)  
  401.                     {  
  402.                         RB_Node* brother = node->parent->right;  
  403.                         if(brother->RB_COLOR==RED)   //情況1:x的兄弟w是紅色的。  
  404.                         {  
  405.                             brother->RB_COLOR = BLACK;  
  406.                             node->parent->RB_COLOR = RED;  
  407.                             RotateLeft(node->parent);  
  408.                         }  
  409.                         else     //情況2:x的兄弟w是黑色的,  
  410.                         {  
  411.                             if(brother->left->RB_COLOR == BLACK && brother->right->RB_COLOR == BLACK)  
  412.                                 //且w的倆個孩子都是黑色的。  
  413.                             {  
  414.                                 brother->RB_COLOR = RED;  
  415.                                 node = node->parent;  
  416.                             }  
  417.                             else if(brother->right->RB_COLOR == BLACK)  
  418.                                 //情況3:x的兄弟w是黑色的,w的右孩子是黑色(w的左孩子是紅色)。  
  419.                             {  
  420.                                 brother->RB_COLOR = RED;  
  421.                                 brother->left->RB_COLOR = BLACK;  
  422.                                 RotateRight(brother);  
  423.                             }  
  424.                             else if(brother->right->RB_COLOR == RED)  
  425.                                 //情況4:x的兄弟w是黑色的,且w的右孩子時紅色的。  
  426.                             {  
  427.                                 brother->RB_COLOR = node->parent->RB_COLOR;  
  428.                                 node->parent->RB_COLOR = BLACK;  
  429.                                 brother->right->RB_COLOR = BLACK;  
  430.                                 RotateLeft(node->parent);  
  431.                                 node = m_root;  
  432.                             }  
  433.                         }  
  434.                     }  
  435.                     else  //下述情況針對上面的情況1中,node作爲右孩子而闡述的。  
  436.                         //22        else (same as then clause with "right" and "left" exchanged)  
  437.                         //同樣,原理一致,只是遇到左旋改爲右旋,遇到右旋改爲左旋,即可。其它代碼不變。  
  438.                     {  
  439.                         RB_Node* brother = node->parent->left;  
  440.                         if(brother->RB_COLOR == RED)  
  441.                         {  
  442.                             brother->RB_COLOR = BLACK;  
  443.                             node->parent->RB_COLOR = RED;  
  444.                             RotateRight(node->parent);  
  445.                         }  
  446.                         else  
  447.                         {  
  448.                             if(brother->left->RB_COLOR==BLACK && brother->right->RB_COLOR == BLACK)  
  449.                             {  
  450.                                 brother->RB_COLOR = RED;  
  451.                                 node = node->parent;  
  452.                             }  
  453.                             else if(brother->left->RB_COLOR==BLACK)  
  454.                             {  
  455.                                 brother->RB_COLOR = RED;  
  456.                                 brother->right->RB_COLOR = BLACK;  
  457.                                 RotateLeft(brother);  
  458.                             }  
  459.                             else if(brother->left->RB_COLOR==RED)  
  460.                             {  
  461.                                 brother->RB_COLOR = node->parent->RB_COLOR;  
  462.                                 node->parent->RB_COLOR = BLACK;  
  463.                                 brother->left->RB_COLOR = BLACK;  
  464.                                 RotateRight(node->parent);  
  465.                                 node = m_root;  
  466.                             }  
  467.                         }  
  468.                     }  
  469.                 }  
  470.                 m_nullNode->parent = m_root;   //最後將node置爲根結點,  
  471.                 node->RB_COLOR = BLACK;    //並改爲黑色。  
  472.             }  
  473.               
  474.             //  
  475.             inline RB_Node* InOrderPredecessor(RB_Node* node)  
  476.             {  
  477.                 if(node==m_nullNode)       //null node has no predecessor  
  478.                 {  
  479.                     return m_nullNode;  
  480.                 }  
  481.                 RB_Node* result = node->left;     //get node's left child  
  482.                 while(result!=m_nullNode)         //try to find node's left subtree's right most node  
  483.                 {  
  484.                     if(result->right!=m_nullNode)       
  485.                     {  
  486.                         result = result->right;  
  487.                     }  
  488.                     else  
  489.                     {  
  490.                         break;  
  491.                     }  
  492.                 }            //after while loop result==null or result's right child is null  
  493.                 if(result==m_nullNode)  
  494.                 {  
  495.                     RB_Node* index = node->parent;  
  496.                     result = node;  
  497.                     while(index!=m_nullNode && result == index->left)  
  498.                     {  
  499.                         result = index;  
  500.                         index = index->parent;  
  501.                     }  
  502.                     result = index;         // first right parent or null  
  503.                 }  
  504.                 return result;  
  505.             }  
  506.               
  507.             //  
  508.             inline RB_Node* InOrderSuccessor(RB_Node* node)  
  509.             {  
  510.                 if(node==m_nullNode)       //null node has no successor  
  511.                 {  
  512.                     return m_nullNode;  
  513.                 }  
  514.                 RB_Node* result = node->right;   //get node's right node  
  515.                 while(result!=m_nullNode)        //try to find node's right subtree's left most node  
  516.                 {  
  517.                     if(result->left!=m_nullNode)       
  518.                     {  
  519.                         result = result->left;  
  520.                     }  
  521.                     else  
  522.                     {  
  523.                         break;  
  524.                     }  
  525.                 }                              //after while loop result==null or result's left child is null  
  526.                 if(result == m_nullNode)  
  527.                 {  
  528.                     RB_Node* index = node->parent;  
  529.                     result = node;  
  530.                     while(index!=m_nullNode && result == index->right)  
  531.                     {  
  532.                         result = index;  
  533.                         index = index->parent;  
  534.                     }  
  535.                     result = index;         //first parent's left or null  
  536.                 }  
  537.                 return result;  
  538.             }  
  539.               
  540.             //debug  
  541.             void InOrderTraverse()  
  542.             {  
  543.                 InOrderTraverse(m_root);  
  544.             }  
  545.             void CreateGraph(string filename)  
  546.             {  
  547.                 //delete  
  548.             }  
  549.             void InOrderCreate(ofstream& file,RB_Node* node)  
  550.             {  
  551.                 //delete  
  552.             }  
  553.             void InOrderTraverse(RB_Node* node)  
  554.             {  
  555.                 if(node==m_nullNode)  
  556.                 {  
  557.                     return;  
  558.                 }  
  559.                 else  
  560.                 {  
  561.                     InOrderTraverse(node->left);  
  562.                     cout<<node->key<<endl;  
  563.                     InOrderTraverse(node->right);  
  564.                 }  
  565.             }  
  566.             ~RB_Tree()  
  567.             {  
  568.                 clear(m_root);  
  569.                 delete m_nullNode;  
  570.             }  
  571.     private:  
  572.         // utility function for destructor to destruct object;  
  573.         void clear(RB_Node* node)  
  574.         {  
  575.             if(node==m_nullNode)  
  576.             {  
  577.                 return ;  
  578.             }  
  579.             else  
  580.             {  
  581.                 clear(node->left);  
  582.                 clear(node->right);  
  583.                 delete node;  
  584.             }  
  585.         }  
  586.     private:  
  587.         RB_Node *m_nullNode;  
  588.         RB_Node *m_root;  
  589. };  
  590. #endif /*_RB_TREE_H_*/  

 

 RBTree.cpp

  1. //file RBTree.cpp  
  2. //written by saturnman,20101008。  
  3. //updated by July,20110329。  
  4.   
  5. //所有的頭文件都已補齊,現在您可以直接複製此份源碼上機驗證了(版權所有,侵權必究)。  
  6. //July、updated,2011.05.06。  
  7. #include<iostream>  
  8. #include<algorithm>  
  9. #include<iterator>  
  10. #include<vector>  
  11. #include<sstream>  
  12. #include"RBTree.h"    //如果.h文件,和cpp文件放在一個文件裏,此句去掉  
  13. using namespace std;  
  14.   
  15. int main()  
  16. {  
  17.     RB_Tree<int,int> tree;  
  18.     vector<int> v;  
  19.       
  20.     for(int i=0;i<20;++i)  
  21.     {  
  22.         v.push_back(i);  
  23.     }  
  24.     random_shuffle(v.begin(),v.end());  
  25.     copy(v.begin(),v.end(),ostream_iterator<int>(cout," "));  
  26.     cout<<endl;  
  27.     stringstream sstr;  
  28.     for(i=0;i<v.size();++i)  
  29.     {  
  30.         tree.Insert(v[i],i);  
  31.         cout<<"insert:"<<v[i]<<endl;   //添加結點  
  32.     }  
  33.     for(i=0;i<v.size();++i)  
  34.     {  
  35.         cout<<"Delete:"<<v[i]<<endl;  
  36.         tree.Delete(v[i]);             //刪除結點  
  37.         tree.InOrderTraverse();  
  38.     }  
  39.     cout<<endl;  
  40.     tree.InOrderTraverse();  
  41.     return 0;  
  42. }  
 

運行效果圖(先是一一插入各結點,然後再刪除所有的結點):

第二部分、程序有bug?

2.1、紅黑樹要求絕對平衡麼?   

    據網友鑫反饋,上述c++源碼雖說從上面的測試結果來看,沒有問題。但程序還是有隱藏的bug,下面,分兩個步驟再來測試下此段源碼:

    1、首先在RBTree.h的最後裏添加下述代碼:

  1. public:  
  2.     void PrintTree()  
  3.     {  
  4.         _printNode(m_root);  
  5.     }  
  6. private:  
  7.     void _printNode(RB_Node *node)  
  8.     {  
  9.         if(node == NULL || node == m_nullNode) return;  
  10.   
  11.         if(node->parent == NULL || node->parent == m_nullNode){  
  12.             printf("root:%d/n", node->data);  
  13.         }else if(node->parent->left == node){  
  14.             printf("left:%d, parent:%d/n", node->data, node->parent->data);  
  15.         }else if(node->parent->right == node){  
  16.             printf("right:%d, parent:%d/n", node->data, node->parent->data);  
  17.         }  
  18.   
  19.         _printNode(node->left);  
  20.         _printNode(node->right);  
  21.     }  

    2、改寫RBTree.cpp文件,如下:

  1. //file RBTree.cpp  
  2. //written by saturnman,20101008。  
  3. //updated by July,20110329。  
  4.   
  5. //所有的頭文件都已補齊,現在您可以直接複製此份源碼上機驗證了(版權所有,侵權必究)。  
  6. //July、updated,2011.05.06。  
  7. #include<iostream>  
  8. #include<algorithm>  
  9. #include<iterator>  
  10. #include<vector>  
  11. #include<sstream>  
  12. //#include"RBTree.h"    //如果.h文件,和cpp文件放在一個文件裏,此句去掉  
  13. using namespace std;  
  14.   
  15. int main()  
  16. {  
  17.     RB_Tree<int,int> tree;  
  18.   
  19.     tree.Insert(12, 12);  
  20.     tree.Insert(1, 1);  
  21.     tree.Insert(9, 9);  
  22.     tree.Insert(2, 2);  
  23.     tree.Insert(0, 0);  
  24.     tree.Insert(11, 11);  
  25.     tree.Insert(7, 7);  
  26.   
  27.   
  28.     tree.Delete(9);  
  29.   
  30.     tree.PrintTree();  
  31.     /*vector<int> v; 
  32.      
  33.     for(int i=0;i<20;++i) 
  34.     { 
  35.         v.push_back(i); 
  36.     } 
  37.     random_shuffle(v.begin(),v.end()); 
  38.     copy(v.begin(),v.end(),ostream_iterator<int>(cout," ")); 
  39.     cout<<endl; 
  40.     stringstream sstr; 
  41.     for(i=0;i<v.size();++i) 
  42.     { 
  43.         tree.Insert(v[i],i); 
  44.         cout<<"insert:"<<v[i]<<endl;   //添加結點 
  45.     } 
  46.     for(i=0;i<v.size();++i) 
  47.     { 
  48.         cout<<"Delete:"<<v[i]<<endl; 
  49.         tree.Delete(v[i]);             //刪除結點 
  50.         tree.InOrderTraverse(); 
  51.     } 
  52.     cout<<endl; 
  53.     tree.InOrderTraverse();*/  
  54.     return 0;  
  55. }  

    後經測試,結果,的確有誤,即依次插入以下節點,12,1,9,0,2,11,7後,紅黑樹變爲如下:

然後刪除根節點9,經過上述程序運行後,運行結果,如下:

即上述運行結果,所對應的紅黑樹的狀態如下(此時,紅黑樹已經不再平衡,存在的問題確實已經很明顯了):

    是的,如你所見,上述程序刪除根節點9之後,正確的紅黑樹的狀態應該爲7代替根節點9,7成爲新的根節點,且節點7着爲黑色,而上述結果則是完全錯誤,紅黑樹已經完全不平衡。至此,終於發現,此c++程序存在隱藏bug了。至於修正,則還得等一段時間。

 

    說明:此程序的bug是經網友鑫指出的,同時,他還發現,網上不少的程序,都存在這個問題,比如這裏:http://sd.csdn.net/a/20110506/297285.html的紅黑樹的flash演示版本,也存在此類的問題。已在原文下發表了以下評論:

很遺憾,經反覆測試,紅黑樹的flash版本有問題(其它的暫還沒發現問題):http://www.cs.usfca.edu/~galles/visualization/flash.html。
如依次往插入這個序列,15,1,9,2,0,12,16,7,11,13,17,14,然後再刪除根節點9,嚴重的錯誤就出來了。上面的版本只是簡單的一個步驟用7代替9,成爲根節點,然後把7節點着爲黑色。樹卻沒有後續調整,完全不平衡。
特此,把問題指出來,希望,這個紅黑樹的錯誤flash版本不致誤導更多的人,同時,問題是朋友鑫提出的)。
我會記住這個問題,如果解決了,再發布在博客裏。
後續:鑫指出:avl樹也有問題。
July、結構之法 算法之道 博主。
2011.05.07。

    但事實是,果真如此麼?請看下文2.1節的修正。

2.1、紅黑樹不要求嚴格平衡

   修正:本程序沒有任何問題。有一點非常之重要,之前就是因爲未意識到而造成上述錯覺,即:紅黑樹並非嚴格意義上的二叉查找樹,它只要滿足它本身的五點性質即可,不要求嚴格平衡。所以,上面的例子中,12,1,9,0,2,11,7,然後刪除根結點9,只要着色適當,同樣不違反紅黑樹的五點性質。所以,結論是,我庸人自擾了,sorry。

   還是這句話,有任何問題,歡迎任何人提出或指正。

 

第三部分、讀者反饋

關於RB_Tree插入刪除操作的討論

July

你好!關於RB_Tree的完整實現代碼,你已經在你的博客中寫出了。但我認爲,你的代碼中有需要改正的地方。

起 因

       我這段時間正好在學習RB_Tree,由於我忽略了RB_Tree的性質(3):每個葉子結點都是黑色的,導致我對RB_Tree的操作糾結了好幾天。在我還沒意識到的時候,偶然間看到你的博客,想從中獲得答案。然後就發現其中有值得商榷的地方。

錯 誤

       下圖是你寫的插入修正函數InsertFixUp的部分截圖:

 你的文章地址:http://blog.csdn.net/v_july_v/article/details/6285620

 

                                                           1

    正如《算法導論》所言,InsertFixUp 中每一次while循環都要面對3種情況:

case 1z的叔叔y是紅色的;

case 2z的叔叔y是黑色的,且z是右孩子;

case 3z的叔叔y是黑色的,且z是左孩子.

並且case 2是落在case 3內的,所以這兩種情況不是相互排斥的!而在你的代碼中,將case 2case 3分別放在ifelse中,導致它們相互獨立。這是不對的。

 

修 正

       所以,在圖1中“標記①”處的else是不能加的,應將其刪除。

       遺憾的是,我認爲你的RB_Tree的刪除修正操作DeleteFixUp也出現了類似的錯誤:對於DeleteFixUp所處理的4種情況也同樣不是相互排斥的,而你用一組if…else if…else if…case 2, 3, 4全部獨立開來。

       以上便是鄙人的一點拙見,如果你認爲有錯誤的地方,歡迎再討論!

                                    楊  

                                                               CSDN ID: crisischaos

                                                               2011.10.06

    考證:非常感謝楊兄來信指導。從算法導論一書原來的插入情況的修復僞代碼來看:

  1. //---------------------插入結點性質修復--------------------------------     
  2. //3種插入情況,都在下面的僞代碼中(未涉及到所有全部的插入情況)。     
  3. /*  
  4. RB-INSERT-FIXUP(T, z)  
  5. 1 while color[p[z]] = RED  
  6. 2     do if p[z] = left[p[p[z]]]  
  7. 3           then y ← right[p[p[z]]]  
  8. 4                if color[y] = RED  
  9. 5                   then color[p[z]] ← BLACK                    ? Case 1  
  10. 6                        color[y] ← BLACK                       ? Case 1  
  11. 7                        color[p[p[z]]] ← RED                   ? Case 1  
  12. 8                        z ← p[p[z]]                            ? Case 1  
  13. 9                   else if z = right[p[z]]  
  14. 10                           then z ← p[z]                       ? Case 2  
  15. 11                                LEFT-ROTATE(T, z)              ? Case 2  
  16. 12                           color[p[z]] ← BLACK                 ? Case 3  
  17. 13                           color[p[p[z]]] ← RED                ? Case 3  
  18. 14                           RIGHT-ROTATE(T, p[p[z]])            ? Case 3  
  19. 15           else (same as then clause with "right" and "left" exchanged)  
  20. 16 color[root[T]] ← BLACK  
  21. */    
  22. //然後的工作,就非常簡單了,即把上述僞代碼改寫爲下述的c++代碼:  ....  

    確實如楊兄所說,理應如此(包括其後的對刪除情況的修復)。日後,再做統一修改,再次謝謝。July、2011.10.06更新。

參考文獻,本人的原創作品紅黑樹系列的前五篇文章:

4、一步一圖一代碼,R-B Tree
1、教你透徹瞭解紅黑樹
5、紅黑樹插入和刪除結點的全程演示
3、紅黑樹的c源碼實現與剖析
2、紅黑樹算法的實現與剖析
6、致謝:http://saturnman.blog.163.com/

完。


 

發表評論
所有評論
還沒有人評論,想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章