紅黑樹

// http://www.cnblogs.com/Anker/archive/2013/01/30/2882773.html

// http://blog.chinaunix.net/uid-26575352-id-3061918.html

摘要：

　　紅黑樹是一種二叉查找樹，但在每個結點上增加了一個存儲位表示結點的顏色，可以是RED或者BLACK。通過對任何一條從根到葉子的路徑上各個着色方式的限制，紅黑樹確保沒有一條路徑會比其他路徑長出兩倍，因而是接近平衡的。本章主要介紹了紅黑樹的性質、左右旋轉、插入和刪除。重點分析了在紅黑樹中插入和刪除元素的過程，分情況進行詳細討論。一棵高度爲h的二叉查找樹可以實現任何一種基本的動態集合操作，如SEARCH、PREDECESSOR、SUCCESSOR、MIMMUM、MAXMUM、INSERT、DELETE等。當二叉查找樹的高度較低時，這些操作執行的比較快，但是當樹的高度較高時，這些操作的性能可能不比用鏈表好。紅黑樹（red-black tree）是一種平衡的二叉查找樹，它能保證在最壞情況下，基本的動態操作集合運行時間爲O(lgn)。本章內容有些複雜，看了兩天，才大概清楚其插入和刪除過程，日後需要經常回顧，爭取完全消化掉。紅黑樹的用途非常廣泛，例如STL中的map就是採用紅黑樹實現的，效率非常之高，有機會可以研究一下STL的源代碼。

1、紅黑樹的性質

　　紅黑樹中的每個結點包含五個域：color、key、left、right和parent。如果某結點沒有一個子結點或父結點，則該結點相應的指針parent域包含值爲NIL（NIL並是是空指針，此處有些迷惑，一會解釋）。把NIL視爲指向紅黑樹的外結點（葉子）的指針，而把帶關鍵字的結點視爲紅黑樹的內結點。紅黑樹結點結構如下所示：

 1 #define RED  0
 2 #define BLACK 1
 3 struct RedBlackTreeNode
 4 { 
 5     T key;
 6     struct RedBlackTreeNode * parent;
 7     struct RedBlackTreeNode * left;
 8     struct RedBlackTreeNode * right;
 9     int color;
10 };

紅黑樹的性質如下：

（1）每個結點或是紅色，或是黑色。

（2）根結點是黑色。

（3）每個葉子結點（NIL）是黑色。

（4）如果有一個結點是紅色，則它的兩個兒子都是黑色。

（5）對每個結點，從該結點到其孫子結點的所有路徑上包含相同數目的黑色結點。

如下圖是一棵紅黑樹：

從圖可以看出NIL不是空指針，而是一個葉子結點。實際操作的時候可以將NIL視爲哨兵，這樣便於對黑紅色進行操作。紅黑樹的操作主要是對內部結點操作，因爲內部結點存儲了關鍵字的值。書中爲了便於討論，忽略了葉子結點的，如是上圖紅黑樹變成如下圖所示：

　　書中給出了黑高度的概念：從某個結點x出發（不包含該結點）到達一個葉子結點的任意一條路徑上，黑色結點的個數稱爲該結點的黑高度。由紅黑樹的性質（5）可知，從該結點出發的所有下降路徑都有相同的黑色結點個數。紅黑樹的黑高度定義爲其根結點的黑高度。

　　書中給出了一個引理來說明爲什麼紅黑樹是一種好的查找樹，並對引理進行了證明（採用歸納法進行證明的，需要很強的歸納推理知識，正是我的不足之處，看書的痛苦在於此）。

引理：一棵有n個內結點的紅黑樹的高度之多爲2lg(n+1)。

2、旋轉

　　在紅黑樹上進行結點插入和刪除操作時，會改變樹的結構形狀，導致結果可能不滿足了紅黑樹的某些性質，爲了保證每次插入和刪除操作後，仍然能報維持紅黑樹的性質，需要改變樹中某些結點的顏色和指針結構。其中的指針結構的改變通過旋轉完成的。書中給出了兩種旋轉：左旋轉和右旋轉。如下圖是旋轉過程：

　　從圖可以得出左右旋轉的過程，假設對某個結點x進行左旋轉，y是x的右孩子，則左旋轉過程爲：以x和y之間的鏈爲“支軸”進行的，使得x的右孩子爲y的左孩子，y的父節點爲x的父節點，y的左孩子爲x。書中給出了左旋轉的僞代碼如下：

 1 LEFT_ROTATE(T,x)
 2    y = right[x]   //獲取右孩子
 3    rihgt[x] = left[y]  //設置x的右孩子爲y的左孩子
 4    if left[y] != NIL
 5        then parent[left[x]] = x
 6     parent[y] = parent[x]  //設置y的父節點爲x的父節點
 7     if parent[x] == NIL
 8        then root[T] = y
 9        else if x==left[parent[x]
10               then left[parent[x]] = y
11               else  right[[parent[x]] = y
12     left[y] = x  //設置y的左孩子爲x
13     parent[x] =y
14 
15    

假設對某個結點y進行右旋轉，x是y的左孩子，則左旋轉過程爲：y的左孩子設置爲x的右孩子，將x的父節點設置爲y的父節點，x的右孩子設置爲y。書中並沒有給出右旋轉的僞代碼，參照左旋轉的僞代碼很容易實現：

 1  RIGHT_ROTATE(T,y)
 2      x = left[y]    //獲取左孩子
 3      left[y] = right[x] //設置y的左孩子爲x的右孩子
 4      if right[x] != NIL
 5         then parent[right[x]] = y
 6      parent[x] = parent[y]  //設爲x的父節點爲y的父結點
 7      if parent[y] == NIL
 8          then root = x
 9          else if y== left[parent[y]]
10                then left[parent[y]] = x
11                else  right[parent[y]] = x
12      right[x] = y //設置x的右孩子爲y
13      parent[y] = x

 爲了更好的理解旋轉操作，書中給出了一個左旋轉的例如，如下圖所示：

3、插入

　　紅黑樹插入一個新結點的過程RB_INSERT是在二叉查找樹插入過程的基礎上改進的，先按照二叉排序的插入過程插入到紅黑樹中，然後將新插入的結點標記爲紅色（疑問：爲什麼是紅色，而不是黑色呢？），然後調用一個輔助的過程RB_INSERT_FIXUP來調整結點並重新着色，使得滿足紅黑樹的性質。關於二叉查找樹的插入過程可以參考上一篇日誌：http://www.cnblogs.com/Anker/archive/2013/01/28/2880581.html。書中給出了RB_INSERT的僞代碼：

 1 RB_INSERT(T,z)
 2   y = NIL
 3   x =root(T)
 4   while x != NIL
 5        do y=x
 6            if key[z]<key[x]
 7              then x=left[x]
 8              else  x=right[x]
 9   parent[z] = y
10   if y =NIL
11      then root =z
12      else if key[z] < key[y]
13             then left[y] =z
14             else  right[y] =z
15    left[z] = NIL
16    right[z] =NIL
17    color[z] = RED  //新插入結點標記爲紅色
18    RB_INSERT_FIXUP(T,z)  //進行調整，使得滿足紅黑樹性質

　　紅黑樹的插入過程最主要的是RB_INSERT_FIXUP過程，書中發了很大的篇幅進行介紹。首先分析了當插入一個新的結點後，會破壞紅黑樹的哪些性質，然後針對可能的破壞性質進行分類討論並給出了給出瞭解決辦法。因爲每次插入的新元素標記爲RED，這樣可能性質2（根節點爲黑色）和性質4（一個紅結點的左右孩子都是黑色的）被破壞。例如下圖插入一個新結點，破壞了性質4。

      如果每次插入新的結點z導致紅黑樹性質被破壞，則之多隻有一個性質被破壞，並且不是性質2就是性質4。違反性質2是因爲z是根且爲紅色，違反性質4是因爲z和其父節點parent[z]都是紅色的。

　　如果性質2被違反了，則紅色的根必定是新增的結點z，它是樹中唯一的內結點，由於z的父接點和兩個子女都是NIL（黑色），不違反性質4。違反性質2在整個插入過程中只有這一次。所以對於違反性質2的結點，直接將其結點變成黑色即可。

　　剩下的問題是對於違反性質4的處理，在插入新結點z之前，紅黑樹的性質沒有被破壞。插入結點z後違反性質4，必定是因爲z和其父親結點parent[z]都是紅色的，此時只違反性質4，而沒有違反其他性質。假設新插入結點z，導致紅黑樹性質4被破壞，此時z和其父節點parent[z]都是紅色，由於在插入結點z之前紅黑樹的性質沒有被破壞，parent[z]是紅色，很容易推出z的祖父結點parent[parent[z]]必定是黑色。此時根據parent[z]是parent[parent[z]]的左孩子還是右孩子進行討論。因爲左右之間是對稱的，書中只給出了parent[z]作爲parent[parent[z]]的左孩子進行討論的，然後給出了三種可能的情況。

情況1）：z的叔叔結點y是紅色的

　　此時parent[z]和y都是紅色的，解決辦法是將z的父節點parent[z]和叔叔結點y都着爲黑色，而將z的祖父結點parent[parent[z]]着爲紅色，然後從祖父結點parent[parent[z]]繼續向上判斷是否破壞紅黑樹的性質。處理過程如下圖所示：

情況2）：z的叔叔y是黑色的，而且z是右孩子

情況3）：z的叔叔y是黑色的，而且z是左孩子

　　情況2和情況3中y都是黑色的，通過z是左孩子還是右孩子進行區分的。可以將情況2通過旋轉爲情況3。情況2中z是右孩子，旋轉後成爲情況3，使得z變爲左孩子，可以在parent[z]結點出使用一次左旋轉來完成。無論是間接還是直接的通過情況2進入到情況3，z的叔叔y總是黑色的。在情況3中，將parent[z]着爲黑色，parent[parent[z]]着爲紅色，然後從parent[parent[z]]處進行一次右旋轉。情況2、3修正了對性質4的違反，修正過程不會導致其他的紅黑性質被破壞。修正過程如下圖所示：

　　給一個完整的例子來說明插入過程，如下圖所示：

　　書中給出了RB_INSERT_FIXUP的僞代碼，僞代碼中只給出了z的父節點爲左孩子的情況，爲右孩子的情況與左孩子的情況是對稱的，只需將左孩子中的right換成left即可。

 1 RB_INSERT_FIXUP(T,z)
 2          while color[parent[z]] = RED
 3            do if parent[z] == left[parent[parent[z]]]
 4                   then y = right[parent[parent[z]]]
 5                        if color[y] == RED    //情況1，z的叔叔爲紅色
 6                             then color[parent[z]] = BLACK
 7                                  color[y] = BLACK
 8                                  color[parent[parent[z]]=RED 
9                                   z= parent[parent[z]]
10                                  else if z == right[parent[z]]    //情況2，z的叔叔爲黑色，z爲右孩子
11                                        then z = parent[z]
12                                             LEFT_ROTATE(T,z)
13                                         color[parent[z]]=BLACK    //情況3，z的叔叔爲黑色，z爲左孩子
14                                         color[parent[parent[z]] = RED
15                                         RIGHT_ROTATE(T, parent[parent[z]])
16                  else (same as then clause with “right” and “left” exchanged)
17    color(root(T)) = BLACK; //將根結點設置爲黑色

4、刪除

　　 刪除過程最複雜，看了好多遍才明白個大概，需要反覆看，多想刪除過程中會破壞哪些性質，然後又針對性的去調整。

　　紅黑樹刪除結點過程是在二叉查找樹刪除結點過程的基礎改進的。與二叉查找樹類似，刪除的結點分爲三種情況：<1>無左右孩子、<2>有左孩子或者右孩子、<3>既有樹=左孩子又有右孩子。刪除過程可以參考前一篇日誌：http://www.cnblogs.com/Anker/archive/2013/01/28/2880581.html。紅黑樹在刪除結點後需要檢查是否破壞了紅黑樹的性質。如果刪除的結點y是紅色的，則刪除後的樹仍然是保持紅黑樹的性質，因爲樹中各個結點的黑高度沒有改變，不存在兩個相鄰（父結點和子結點）的紅色結點，y是紅色不可能是根，所有根仍然是黑色。如果刪除的結點z是黑色的，則這個是破壞了紅黑樹的性質，需要調用RB_DELETE_FIXUP進行調整。從刪除結點y的唯一孩子結點x或者是NIL處開始調整。書中給出了RB_DELETE的僞代碼：

 1 RB_DELETE(T,z)
 2      if left[z] ==NIL or right[z] == NIL
 3         then y=z
 4         else  y=TREE_SUCCESSOR(z)
 5     if left[y] != NIL
 6         then x=left[y]
 7         else  x=right[y]
 8     parent[x] = parent[y]
 9     if p[y] ==NIL
10        then root[T] =x
11        else if y = left[[prarnt[y]]
12                    then left[parent[y]] = x
13                    else  right[parent[y]] =x
14      if y!=z
15          then key[z] = key[y]
16                copy y's data into z
17      if color[y] == BLACK    //當被刪除結點爲黑色時候進行調整
18          then RB_DELETE_FIXUP(T,x)
19       return y

　　書中分析了被刪除結點y是黑色會產生的問題：首先，如果y是根，而y的一個紅色孩子變成了新根，則違反了性質2。其次，如果x和parent[y]（此時parent[x] = parent[y]）都是紅色，就違反了性質4。第三，刪除y將會導致先前包含y的任何路徑上黑結點個數減少1，違反了性質5。書中給出瞭解決第三個問題的辦法：將結點x設爲還有額外的一重黑色（此處看的不是很明白，我的理解是是不管是x是什麼顏色，將x增加了額外一重黑色，這樣可以保證黑結點數目增加1個），即將任意包含結點x的路徑上黑結點個數加1，這樣可以保證性質5成立。當將黑色結點y被刪除時，將其黑色“下推”至其子結點，導致問題變成爲結點x可能即不是紅，又不是黑，從而違反性質1。因爲給x增加了一種顏色，即結點x是雙重黑色或者是紅黑色。這樣就分別給包含x的路徑上黑結點個數貢獻2個或1個。但是x的color屬性仍然是RED（如果x是紅黑的）或BLACK（如果x是雙重黑色）。換而言之，一個結點額外的黑色反映在x指向它，而不是它的color屬性。

　　過程RB_DELETE_FIXUP恢復性質1，2，4。對於恢復性質2、4很簡單，因爲x是紅色，所有直接將x結點着爲黑色即可。書中着重介紹瞭如何恢復性質1。此時x是黑色，需要根據x是左孩子還是右孩子兩種情況進行恢復，因爲左右是對稱的，書中只給出了x是左孩子的恢復過程。將x作爲第一個額外的黑色結點，從x結點開始循環，將額外的黑色結點沿着樹向上移，直到：

（1）x指向一個紅黑結點，此時將x單獨着爲黑色。

（2）x指向根，這時可以簡單地消除那個額外的黑色，或者

（3）做必要的旋轉和顏色改變

在循環過程中，x總是指向具有雙重黑色的那個非根結點。設w是x的兄弟結點，因爲x是雙重黑色的，故w不可能是NIL。書中分四種情況討論：

情況1：x的兄弟w是紅色的

          此時因爲x是雙重黑色，貢獻兩個黑色結點，所有w必有黑色孩子。此時將w着爲黑色，parent[x]爲紅色，在對parent[x]做一次左旋轉。此時x的新兄弟w是黑色，這樣將情況1轉換爲情況2、3或4。情況1的處理過程下圖所示：

情況2：x的兄弟w是黑色的，而且w的兩個孩子都是黑色的。

     處理過程是從x和w上去掉一重黑色，即x只有一重黑色而w着爲紅色，給x的父節點parent[x]添加額外黑色。處理過程如下圖所示：

 

情況3：x的兄弟w是黑色的，w的左孩子是紅色的，右孩子是黑色的

       交換w和其左孩子left[w]的顏色，並對w進行右旋轉。旋轉後x的新兄弟w是一個有紅色右孩子的黑結點，轉換成了情況4。處理過程如下圖所示：

情況4：x的兄弟w是黑色的，而且w的右孩子是紅色的。

　　執行過程是將w的顏色設置爲parent[x]的顏色，將parent[x]的顏色設置爲黑色，將w的右孩子着爲黑色，然後在parent[x]做一次右旋，最後將x設置爲根root。處理過程如下圖所示：

書中給出了RB_DELETE_FIXUP的僞代碼：

 1 RB_DELETE_FIXUP(T,x)
 2  　　while x!= root[T] and color[x] ==BLACK
 3          do if x == left[parent[x]]
 4                then w = right[parent[x]]
 5                     if color[w] == RED  //case 1 x的兄弟w是紅色的
 6                        then color[w] = BLACK
 7                             color[parent[x]] = RED
 8                             LEFT_ROTATE(T,PARENT[x])
 9                             w = right[parent[x]]
10                        if color[left[w]] == BLACK and color[right[w]] = BLACK
11                        　　 then color[w] = RED  //case 2
12                             x = parent[x]
13                            else if color[right[w]] =BLACK
14                                   then color[left[w]] = BLACK //case 3
15                                        color[w] = RED
16                                        RIGHT_ROTATE(T,w)
17                                        w = right[parent[x]]
18                                color[w] = color[parent[x]] //case 4
19                                color[parent[x]] = BLACK
20                                color[right[w]] = BLACK
21                                LEFT_ROTATE(T,parent[x])
22                                x=root(T)
23              else(same as then clasue with “right” and “left” exchanged)
24      color[x]=BLACK

5、編程實現

　　這一章看了兩天，宏觀上把握了紅黑樹的插入和刪除操作，中間還有細節問題需要思考。看完後要實現才能消化，於是我採用C++語言設計了簡單的紅黑樹結點和紅黑樹類，設計的類如下所示：

 1 static const int RED = 0;
 2 static const int BLACK = 1;
 3 
 4 template <class T>
 5 class RedBlackTreeNode
 6 {
 7 public:
 8     RedBlackTreeNode():key(T()),parent(NULL),left(NULL),right(NULL),color(BLACK){}
 9     T key;
10     RedBlackTreeNode<T>* parent;
11     RedBlackTreeNode<T>* left;
12     RedBlackTreeNode<T>* right;
13     int color;
14 };
15 
16 template <class T>
17 class RedBlackTree
18 {
19 public:
20     RedBlackTree();
21     int search_element(const T& k) const;
22     int get_minmum(T& retmin)const;
23     int get_maxmum(T& retmax)const;
24     int get_successor(const T& k,T& ret) const;
25     int get_predecessor(const T& k,T& ret) const;
26     int insert_key(const T& k);
27     int delete_key(const T& k);
28     void inorder_tree_walk()const;
29     RedBlackTreeNode<T>* get_root() const;
30     ~RedBlackTree();
31 private:
32     RedBlackTreeNode<T>* root;
33     static  RedBlackTreeNode<T> *NIL;
34     RedBlackTreeNode<T>* get_parent(RedBlackTreeNode<T>* pnode) const;
35     RedBlackTreeNode<T>* get_left(RedBlackTreeNode<T>* pnode) const;
36     RedBlackTreeNode<T>* get_right(RedBlackTreeNode<T>* pnode) const;
37     T get_key(RedBlackTreeNode<T>* pnode) const;
38     int get_color(RedBlackTreeNode<T>* pnode) const;
39     void set_color(RedBlackTreeNode<T>* pnode,int color);
40     void left_rotate(RedBlackTreeNode<T> *pnode);
41     void right_rotate(RedBlackTreeNode<T> *pnode);
42     void rb_insert_fixup(RedBlackTreeNode<T> *pnode);
43     void rb_delete_fixup(RedBlackTreeNode<T> *pnode);
44     RedBlackTreeNode<T>* get_maxmum(RedBlackTreeNode<T> *root) const;
45     RedBlackTreeNode<T>* get_minmum(RedBlackTreeNode<T> *root) const;
46     RedBlackTreeNode<T>* get_successor(RedBlackTreeNode<T> *pnode) const;
47     RedBlackTreeNode<T>* get_predecessor(RedBlackTreeNode<T> *pnode) const;
48     RedBlackTreeNode<T>* search_tree_node(const T& k)const;
49     void make_empty(RedBlackTreeNode<T>* root);
50 };

設計過程中採用了C++的模板類型，這樣可以支持多種數據類型，使得程序具備擴展性，完整的程序實現如下所示：

  1 #include <iostream>
  2 #include <stack>
  3 using namespace std;
  4 
  5 static const int RED = 0;
  6 static const int BLACK = 1;
  7 
  8 template <class T>
  9 class RedBlackTreeNode
 10 {
 11 public:
 12     RedBlackTreeNode():key(T()),parent(NULL),left(NULL),right(NULL),color(BLACK){}
 13     T key;
 14     RedBlackTreeNode<T>* parent;
 15     RedBlackTreeNode<T>* left;
 16     RedBlackTreeNode<T>* right;
 17     int color;
 18 };
 19 
 20 template <class T>
 21 class RedBlackTree
 22 {
 23 public:
 24     RedBlackTree();
 25     int search_element(const T& k) const;
 26     int get_minmum(T& retmin)const;
 27     int get_maxmum(T& retmax)const;
 28     int get_successor(const T& k,T& ret) const;
 29     int get_predecessor(const T& k,T& ret) const;
 30     int insert_key(const T& k);
 31     int delete_key(const T& k);
 32     void inorder_tree_walk()const;
 33     RedBlackTreeNode<T>* get_root() const;
 34     ~RedBlackTree();
 35 private:
 36     RedBlackTreeNode<T>* root;
 37     static  RedBlackTreeNode<T> *NIL;
 38     RedBlackTreeNode<T>* get_parent(RedBlackTreeNode<T>* pnode) const;
 39     RedBlackTreeNode<T>* get_left(RedBlackTreeNode<T>* pnode) const;
 40     RedBlackTreeNode<T>* get_right(RedBlackTreeNode<T>* pnode) const;
 41     T get_key(RedBlackTreeNode<T>* pnode) const;
 42     int get_color(RedBlackTreeNode<T>* pnode) const;
 43     void set_color(RedBlackTreeNode<T>* pnode,int color);
 44     void left_rotate(RedBlackTreeNode<T> *pnode);
 45     void right_rotate(RedBlackTreeNode<T> *pnode);
 46     void rb_insert_fixup(RedBlackTreeNode<T> *pnode);
 47     void rb_delete_fixup(RedBlackTreeNode<T> *pnode);
 48     RedBlackTreeNode<T>* get_maxmum(RedBlackTreeNode<T> *root) const;
 49     RedBlackTreeNode<T>* get_minmum(RedBlackTreeNode<T> *root) const;
 50     RedBlackTreeNode<T>* get_successor(RedBlackTreeNode<T> *pnode) const;
 51     RedBlackTreeNode<T>* get_predecessor(RedBlackTreeNode<T> *pnode) const;
 52     RedBlackTreeNode<T>* search_tree_node(const T& k)const;
 53     void make_empty(RedBlackTreeNode<T>* root);
 54 };
 55 
 56 template <class T>
 57 RedBlackTreeNode<T>* RedBlackTree<T>::NIL = new RedBlackTreeNode<T>;
 58 
 59 template <class T>
 60 RedBlackTree<T>::RedBlackTree()
 61 {
 62     root = NULL;
 63 }
 64 
 65 template <class T>
 66 int RedBlackTree<T>::search_element(const T& k) const
 67 {
 68     return (NIL != search_tree_node(k));
 69 }
 70 
 71 template <class T>
 72 int RedBlackTree<T>::get_minmum(T& retmin)const
 73 {
 74     if(root)
 75     {
 76         retmin = get_minmum(root)->key;
 77         return 0;
 78     }
 79     return -1;
 80 }
 81 
 82 template <class T>
 83 int RedBlackTree<T>::get_maxmum(T& retmax)const
 84 {
 85     if(root)
 86     {
 87         retmax = get_maxmum(root)->key;
 88         return 0;
 89     }
 90     return -1;
 91 }
 92 
 93 template <class T>
 94 int RedBlackTree<T>::get_successor(const T& k,T& ret) const
 95 {
 96     RedBlackTreeNode<T>* pnode = search_tree_node(k);
 97 
 98     if(pnode != NIL)
 99     {
100         pnode = get_successor(pnode);
101         if(pnode != NIL)
102         {
103             ret = pnode->key;
104             return 0;
105         }
106         return -1;
107     }
108     return -1;
109 }
110 template <class T>
111 int RedBlackTree<T>::get_predecessor(const T& k,T& ret) const
112 {
113     RedBlackTreeNode<T>* pnode = search_tree_node(k);
114     if(pnode != NIL)
115     {
116         pnode = get_predecessor(pnode);
117         if(pnode != NIL)
118         {
119             ret = pnode->key;
120             return 0;
121         }
122         return -1;
123     }
124     return -1;
125 }
126 
127 template <class T>
128 int RedBlackTree<T>::insert_key(const T& k)
129 {
130     RedBlackTreeNode<T> *newnode = new RedBlackTreeNode<T>;
131     newnode->key = k;
132     newnode->color = RED;
133     newnode->left = NIL;
134     newnode->right = NIL;
135     newnode->parent = NIL;
136 
137     if(NULL == root)
138         root = newnode;
139     else
140     {
141         RedBlackTreeNode<T>* pnode = root;
142         RedBlackTreeNode<T>* qnode;
143         while(pnode != NIL)
144         {
145             qnode = pnode;
146             if(pnode->key > newnode->key)
147                 pnode = pnode->left;
148             else
149                 pnode = pnode->right;
150         }
151         newnode->parent = qnode;
152         if(qnode->key > newnode->key)
153             qnode->left = newnode;
154         else
155             qnode->right = newnode;
156     }
157     rb_insert_fixup(newnode);
158     return 0;
159 }
160 
161 template <class T>
162 int RedBlackTree<T>::delete_key(const T& k)
163 {
164     RedBlackTreeNode<T>* pnode = search_tree_node(k);
165     if(NIL != pnode)
166     {
167         RedBlackTreeNode<T>* qnode,*tnode;
168         if(get_left(pnode) == NIL || get_right(pnode) == NIL)
169             qnode = pnode;
170         else
171             qnode = get_successor(pnode);
172         if(get_left(qnode) != NIL)
173             tnode = get_left(qnode);
174         else
175             tnode = get_right(qnode);
176         tnode->parent = get_parent(qnode);
177         if(get_parent(qnode) == NIL)
178             root = tnode;
179         else if(qnode == get_left(get_parent(qnode)))
180             qnode->parent->left = tnode;
181         else
182             qnode->parent->right = tnode;
183         if(qnode != pnode)
184              pnode->key = get_key(qnode);
185         if(get_color(qnode) == BLACK)
186             rb_delete_fixup(tnode);
187         delete qnode;
188         return 0;
189     }
190     return -1;
191 }
192 
193 template <class T>
194 RedBlackTree<T>::~RedBlackTree()
195 {
196     make_empty(root);
197 }
198 template <class T>
199 RedBlackTreeNode<T>* RedBlackTree<T>:: get_root() const
200 {
201     return root;
202 }
203 template <class T>
204 RedBlackTreeNode<T>* RedBlackTree<T>::get_parent(RedBlackTreeNode<T>* pnode) const
205 {
206     return pnode->parent;
207 }
208 template <class T>
209 RedBlackTreeNode<T>* RedBlackTree<T>::get_left(RedBlackTreeNode<T>* pnode) const
210 {
211     return pnode->left;
212 }
213 template <class T>
214 RedBlackTreeNode<T>* RedBlackTree<T>::get_right(RedBlackTreeNode<T>* pnode) const
215 {
216     return pnode->right;
217 }
218 template <class T>
219 T RedBlackTree<T>::get_key(RedBlackTreeNode<T>* pnode) const
220 {
221     return pnode->key;
222 }
223 template <class T>
224 int RedBlackTree<T>::get_color(RedBlackTreeNode<T>* pnode) const
225 {
226     return pnode->color;
227 }
228 
229 template <class T>
230 void RedBlackTree<T>::set_color(RedBlackTreeNode<T>* pnode,int color)
231 {
232     pnode->color = color;
233 }
234 
235 template <class T>
236 void RedBlackTree<T>::left_rotate(RedBlackTreeNode<T> *pnode)
237 {
238     RedBlackTreeNode<T>* rightnode = pnode->right;
239     pnode->right = rightnode->left;
240     if(rightnode->left != NIL)
241         rightnode->left->parent = pnode;
242     rightnode->parent = pnode->parent;
243     if(pnode->parent == NIL)
244         root = rightnode;
245     else if(pnode == pnode->parent->left)
246         pnode->parent->left = rightnode;
247     else
248         pnode->parent->right = rightnode;
249     rightnode->left = pnode;
250     pnode->parent = rightnode;
251 }
252 
253 template <class T>
254 void RedBlackTree<T>::right_rotate(RedBlackTreeNode<T> *pnode)
255 {
256     RedBlackTreeNode<T>* leftnode = pnode->left;
257     pnode->left = leftnode->right;
258     if(leftnode->right != NIL)
259         leftnode->right->parent = pnode;
260     leftnode->parent = pnode->parent;
261     if(pnode->parent == NIL)
262         root = leftnode;
263     else if(pnode == pnode->parent->left)
264         pnode->parent->left = leftnode;
265     else
266         pnode->parent->right = leftnode;
267     leftnode->right = pnode;
268     pnode->parent = leftnode;
269 }
270 template <class T>
271 void RedBlackTree<T>::rb_insert_fixup(RedBlackTreeNode<T>*pnode)
272 {
273     RedBlackTreeNode<T> *qnode,*tnode;
274     //當pnode的父節點爲紅色時，破壞性質4
275     while(get_color(get_parent(pnode))== RED)
276     {
277         qnode = get_parent(get_parent(pnode));//祖父結點
278         if(get_parent(pnode) == get_left(qnode))
279         {
280             tnode = get_right(qnode);//pnode的叔叔結點
281             if(get_color(tnode) == RED) //case1 叔叔結點爲紅色
282             {
283                 set_color(get_parent(pnode),BLACK);
284                 set_color(tnode,BLACK);
285                 set_color(qnode,RED);
286                 pnode = qnode;
287             }
288             else  //case 2 or case 3
289             {
290                 if(pnode == get_right(get_parent(pnode)))  //case2 pnode爲右孩子
291                 {
292                     pnode = get_parent(pnode);
293                     left_rotate(pnode);
294                 }
295                 //case3 pnode爲左孩子
296                 set_color(get_parent(pnode),BLACK);
297                 qnode = get_parent(get_parent(pnode));
298                 set_color(qnode,RED);
299                 right_rotate(qnode);
300             }
301         }
302         else
303         {
304             tnode = get_left(qnode);
305             if(get_color(tnode) == RED)
306             {
307                 set_color(get_parent(pnode),BLACK);
308                 set_color(tnode,BLACK);
309                 set_color(qnode,RED);
310                 pnode = qnode;
311             }
312             else
313             {
314                 if(pnode == get_left(get_parent(pnode)))
315                 {
316                     pnode = get_parent(pnode);
317                     right_rotate(pnode);
318                 }
319                 set_color(get_parent(pnode),BLACK);
320                 qnode = get_parent(get_parent(pnode));
321                 set_color(qnode,RED);
322                 left_rotate(qnode);
323             }
324         }
325     }
326     set_color(root,BLACK);
327 }
328 
329 template <class T>
330 void RedBlackTree<T>::rb_delete_fixup(RedBlackTreeNode<T> *pnode)
331 {
332     while(pnode != root && get_color(pnode) == BLACK)
333     {
334         RedBlackTreeNode<T> *qnode,*tnode;
335         if(pnode == get_left(get_parent(pnode)))
336         {
337             qnode = get_right(get_parent(pnode));
338             if(get_color(qnode) == RED)
339             {
340                 set_color(qnode,BLACK);
341                 set_color(get_parent(pnode),RED);
342                 left_rotate(get_parent(pnode));
343                 qnode = get_right(get_parent(pnode));
344             }
345             if(get_color(get_left(qnode)) == BLACK && get_color(get_right(qnode)) == BLACK)
346             {
347                 set_color(qnode,RED);
348                 pnode = get_parent(pnode);
349             }
350             else
351             {
352                 if(get_color(get_right(qnode)) == BLACK)
353                 {
354                     set_color(get_left(qnode),BLACK);
355                     set_color(qnode,RED);
356                     right_rotate(qnode);
357                     qnode = get_right(get_parent(pnode));
358                 }
359                 set_color(qnode,get_color(get_parent(pnode)));
360                 set_color(get_parent(pnode),BLACK);
361                 set_color(get_right(qnode),BLACK);
362                 left_rotate(get_parent(pnode));
363                 pnode = root;
364             }
365         }
366         else
367         {
368             qnode = get_left(get_parent(pnode));
369             if(get_color(qnode) == RED)
370             {
371                 set_color(qnode,BLACK);
372                 set_color(get_parent(pnode),RED);
373                 right_rotate(get_parent(pnode));
374                 qnode = get_left(get_parent(pnode));
375             }
376             if(get_color(get_right(qnode)) == BLACK && get_color(get_left(qnode)) == BLACK)
377             {
378                 set_color(qnode,RED);
379                 pnode = get_parent(pnode);
380             }
381             else
382             {
383                 if(get_color(get_left(qnode)) == BLACK)
384                 {
385                     set_color(get_right(qnode),BLACK);
386                     set_color(qnode,RED);
387                     left_rotate(qnode);
388                     qnode = get_left(get_parent(pnode));
389                 }
390                 set_color(qnode,get_color(get_parent(pnode)));
391                 set_color(get_parent(pnode),BLACK);
392                 set_color(get_left(qnode),BLACK);
393                 right_rotate(get_parent(pnode));
394                 pnode = root;
395             }
396         }
397     }
398     set_color(pnode,BLACK);
399 }
400 
401 template <class T>
402 RedBlackTreeNode<T>* RedBlackTree<T>::get_maxmum(RedBlackTreeNode<T> *root) const
403 {
404     RedBlackTreeNode<T> *pnode = root;
405     while(pnode->right != NIL)
406         pnode = pnode->right;
407     return pnode;
408 }
409 
410 template <class T>
411 RedBlackTreeNode<T>* RedBlackTree<T>::get_minmum(RedBlackTreeNode<T> *root) const
412 {
413     RedBlackTreeNode<T> *pnode = root;
414     while(pnode->left != NIL)
415         pnode = pnode->left;
416     return pnode;
417 }
418 
419 template <class T>
420 RedBlackTreeNode<T>* RedBlackTree<T>:: get_successor(RedBlackTreeNode<T> *pnode) const
421 {
422     if(pnode->right != NIL)
423         return get_minmum(pnode->right);
424     RedBlackTreeNode<T>* parentnode = get_parent(pnode);
425     while(parentnode != NIL && get_right(parentnode) == pnode)
426     {
427             pnode = parentnode;
428             parentnode = get_parent(pnode);
429     }
430     return parentnode;
431 }
432 
433 template <class T>
434 RedBlackTreeNode<T>* RedBlackTree<T>::get_predecessor(RedBlackTreeNode<T> *pnode) const
435 {
436     if(pnode->left != NIL)
437         return get_maxmum(pnode->left);
438     RedBlackTreeNode<T>* parentnode = get_parent(pnode);
439     while(parentnode != NIL && get_left(parentnode) == pnode)
440     {
441         pnode = parentnode;
442         parentnode = get_parent(pnode);
443     }
444     return parentnode;
445 }
446 
447 template <class T>
448 RedBlackTreeNode<T>* RedBlackTree<T>:: search_tree_node(const T& k)const
449 {
450     RedBlackTreeNode<T>* pnode = root;
451     while(pnode != NIL)
452     {
453         if(pnode->key == k)
454             break;
455         else if(pnode->key > k)
456             pnode = pnode->left;
457         else
458             pnode = pnode->right;
459     }
460     return pnode;
461 }
462 
463 template <class T>
464 void RedBlackTree<T>::make_empty(RedBlackTreeNode<T>* root)
465 {
466     if(root)
467     {
468         RedBlackTreeNode<T> *pleft = root->left;
469         RedBlackTreeNode<T>* pright = root->right;
470         delete root;
471         if(pleft != NIL)
472             make_empty(pleft);
473         if(pright != NIL)
474             make_empty(pright);
475     }
476 }
477 template <class T>
478 void RedBlackTree<T>::inorder_tree_walk()const
479 {
480     if(NULL != root)
481      {
482          stack<RedBlackTreeNode<T>* > s;
483          RedBlackTreeNode<T> *ptmpnode;
484          ptmpnode = root;
485          while(NIL != ptmpnode || !s.empty())
486          {
487              if(NIL != ptmpnode)
488              {
489                  s.push(ptmpnode);
490                  ptmpnode = ptmpnode->left;
491              }
492              else
493              {
494                  ptmpnode = s.top();
495                  s.pop();
496                  cout<<ptmpnode->key<<":";
497                  if(ptmpnode->color == BLACK)
498                     cout<<"Black"<<endl;
499                  else
500                     cout<<"Red"<<endl;
501                  ptmpnode = ptmpnode->right;
502              }
503          }
504      }
505 }
506 int main()
507 {
508     RedBlackTree<int> rbtree;
509     int value;
510     rbtree.insert_key(41);
511     rbtree.insert_key(38);
512     rbtree.insert_key(31);
513     rbtree.insert_key(12);
514     rbtree.insert_key(19);
515     rbtree.insert_key(8);
516     cout<<"root is: "<<rbtree.get_root()->key<<endl;
517     cout<<"Inorder walk red black tree:"<<endl;
518     rbtree.inorder_tree_walk();
519     if(rbtree.get_minmum(value) == 0)
520         cout<<"minmum is: "<<value<<endl;
521     if(rbtree.get_maxmum(value) == 0)
522         cout<<"maxmum is: "<<value<<endl;
523     if(rbtree.get_successor(19,value) == 0)
524         cout<<"19 successor is: "<<value<<endl;
525     if(rbtree.get_predecessor(19,value) == 0)
526         cout<<"19 predecessor is: "<<value<<endl;
527     if(rbtree.delete_key(38)==0)
528         cout<<"delete 38 successfully"<<endl;
529      cout<<"root is: "<<rbtree.get_root()->key<<endl;
530     cout<<"Inorder walk red black tree:"<<endl;
531     rbtree.inorder_tree_walk();
532     return 0;
533 }

程序測試結果如下所示：

　　實現過程中感觸非常多，需要很大的耐心去調試程序，關鍵的是insert和delete操作。