stl map底层之红黑树插入步骤详解与代码实现

本篇文章并没有详细的讲解红黑树各方面的知识，只是以图形的方式对红黑树插入节点需要进行调整的过程进行的解释。

最近在看stl源码剖析，看到map底层红黑树的实现。为了加深对于红黑树的理解就自己动手写了红黑树插入的实现。关于红黑树插入节点后破坏红黑树性质的几种情况，可以在网上搜到很多相关的信息。下面用图说明插入新节点时红黑树所做的调整。插入的序列分别是30，40，50，20，35，10，11。

首先是插入30，由于现在红黑树是一棵空，所以直接将30作为根节点，并将根节点颜色染成黑色即可。

一、插入40，如下图所示。由于此时并没有破坏红黑树的性质，所以此时插入成功。

图1：插入40

二、插入50,插入节点50后，50及其父节点都为红色，由于此时40没有兄弟节点。此时将父节点变黑，祖父节点变红，以祖父节点为根进行左旋。调整后如图2-2所示

                           图2-1：插入节点50                                                                  图2-2：插入节点50调整后

三、插入20，插入节点20后，其父节点30及叔节点50都是红色节点。解决方法是将父节点及叔节点变黑，祖父节点变红。祖父节点变成新的当前节点重新进行算法。由于40是根节点，所以将根节点变黑。调整后如图3-2所示,此时满足红黑树的全部性质。

                                       图3-1：插入节点20                                                                 图3-2：插入节点20调整后

四、插入节点35，如图4所示，由于此时并未破坏红黑树的任何性质。不需要进行调整算法。

                                图4：插入节点35

五、插入节点10，此时10的父节点20及其叔节点35都是红色。将20及35节点变黑，祖父节点30变红。30作为新的当前节点。由于30的父节点40是黑色。所以调整算法结束。调整后如图5-2所示

                                                                                                                      图5-1:插入节点10 

  图5-2：插入节点10调整后

六、插入节点11，如图6-1所示，由于11的父节点10是红色节点，并且11是10的右子节点。所以首先以10节点为根节点进行左旋，旋转后其的红黑树如图6-2所示。此时节点10的父节点11为红色，并且10是11节点的左子节点；此时将父节点11变黑，祖父节点20变红,以祖父节点20为根节点进行右旋。旋转后如图6-3所示。

                                                                                                                   图6-1：插入节点11  

                          

                                                                                            图6-2：10为根节点进行左旋后

图6-3：插入节点调整后的红黑树

下面附上只实现了插入功能的红黑树源码

rbtree.h

[cpp] view plain copy

 

1. #include <iostream>  
2. #include <queue>  
3. using namespace std;  
4. static int _rb_black_node = 0;  
5. static int _rb_red_node   = 1;  
6. template<typename T>  
7. struct RBNode  
8. {  
9.     RBNode():left(NULL),right(NULL),parent(NULL),val(T()),color(_rb_red_node){}  
10.     RBNode(const T &v1):left(NULL),right(NULL),parent(NULL),val(v1),color(_rb_red_node){}  
11.     RBNode  *left;  
12.     RBNode  *right;  
13.     RBNode  *parent;  
14.     int     color;  
15.     T       val;  
16. };  
17.   
18. template<typename T>  
19. class RBTree  
20. {  
21. public:  
22.     RBTree():root(NULL){}  
23.     ~RBTree()  
24.     {  
25.         if(root)  
26.         {  
27.             Destroy(root);  
28.         }  
29.     }  
30.     void    print();  
31.     void    Search(const T &v1, RBNode<T> *&node);  
32.     bool    InsertUnique(const T &v1);  
33.     void    DeleteValue(const T &v1);  
34.     void    Destroy(RBNode<T> *p);  
35.     void    InsertReBalance(RBNode<T> *node);  
36.     RBNode<T>*    _rbtree_rotate_left(RBNode<T> *node);  
37.     RBNode<T>*  _rbtree_rotate_right(RBNode<T> *node);  
38. private:  
39.     RBNode<T> *root;  
40. };  
41.   
42. /* 
43. * 
44. * 打印红黑树的节点信息 
45. * 
46. */  
47. template<typename T>  
48. void RBTree<T>::print()  
49. {  
50.     RBNode<T> *p;  
51.     queue<RBNode<T> *> Q;  
52.     Q.push(root);  
53.     while(!Q.empty())  
54.     {  
55.         p = Q.front();  
56.         Q.pop();  
57.         cout<<"节点: "<<p->val<<" ";  
58.         if(p->left)  
59.         {  
60.             cout<<"left:"<<p->left->val<<"->color:"<<p->left->color<<" ";  
61.             Q.push(p->left);  
62.         }  
63.         if(p->right)  
64.         {  
65.             cout<<"right:"<<p->right->val<<"->color:"<<p->right->color<<" ";  
66.             Q.push(p->right);  
67.         }  
68.         cout<<endl<<endl;  
69.     }  
70. }  
71.   
72. /* 
73. * 
74. * 搜索v1在红黑树中出现的位置，如果v1在红黑树中则node节点为 
75. * 值为v1所在红黑树中的节点。 
76. * 否则node节点为如果将v1插入到红黑树中的父节点 
77. * 
78. */  
79. template<typename T>  
80. void RBTree<T>::Search(const T &v1,RBNode<T> *&node)  
81. {  
82.     RBNode<T> *p = root;  
83.     node = NULL;  
84.     while(p)  
85.     {  
86.         if(p->val == v1)  
87.         {  
88.             node = p;  
89.             break;  
90.         }  
91.         else if(p->val < v1)  
92.         {  
93.             node = p;  
94.             p = p->right;  
95.         }  
96.         else  
97.         {  
98.             node = p;  
99.             p = p->left;  
100.         }  
101.     }  
102. }  
103.   
104. template<typename T>  
105. bool RBTree<T>::InsertUnique(const T &v1)  
106. {  
107.     RBNode<T> *parent = NULL;  
108.     RBNode<T> *newNode = new RBNode<T>(v1);  
109.     Search(v1, parent);  
110.     if(parent == NULL)  
111.     {//红黑树为空，当前插入的节点为根节点。插入后将根颜色变为黑  
112.         root = newNode;  
113.         root->color = _rb_black_node;  
114.         return true;  
115.     }  
116.     if(parent->val == v1)//v1已经存在红黑树中。不再插入  
117.         return false;  
118.       
119.     if(v1 < parent->val)  
120.     {  
121.         parent->left = newNode;  
122.     }  
123.     else  
124.     {  
125.         parent->right = newNode;  
126.     }  
127.     newNode->parent = parent;  
128.     InsertReBalance(newNode);  
129.     return true;  
130. }  
131.   
132. /* 
133. * 
134. * 插入节点后进行调整， 
135. * 使所有节点满足红黑树的性质 
136. * 
137. */  
138. template<typename T>  
139. void RBTree<T>::InsertReBalance(RBNode<T> *node)  
140. {  
141.     RBNode<T> *parent = node->parent;  
142.     RBNode<T> *grandParent = NULL;  
143.     while(parent && parent->color==_rb_red_node)  
144.     {  
145.         grandParent = parent->parent;  
146.         if(parent == grandParent->left)  
147.         {//父节点为祖父节点的左儿子  
148.             RBNode<T> *uncle = grandParent->right;  
149.             if(uncle && uncle->color == _rb_red_node)  
150.             {//情形1 父节点与叔节点都为红  
151.                 //解决方法父与叔变黑，祖父变黑。祖父变为新的当前节点重新进入算法  
152.                 parent->color = _rb_black_node;  
153.                 uncle->color  = _rb_black_node;  
154.                 grandParent->color = _rb_red_node;  
155.                 node = grandParent;  
156.                 parent = grandParent->parent;  
157.             }  
158.             else  
159.             {  
160.                 if(node == parent->right)  
161.                 {//情形2，叔为黑，当前节点为其父节点的右子节点  
162.                     //解决方法：以父节点为根进行左旋  
163.                     //操作后将转换为情形3  
164.                     node = _rbtree_rotate_left(parent);  
165.                     parent = node->parent;  
166.                     grandParent = parent->parent;  
167.                 }  
168.                 //情形3父为红，当前节点为父节点的左子节点  
169.                 //解决方法：父节点变黑，祖父节点变红，以  
170.                 //祖父节点为根节点进行右旋  
171.                 parent->color = _rb_black_node;  
172.                 grandParent->color = _rb_red_node;  
173.                 _rbtree_rotate_right(grandParent);  
174.             }  
175.         }  
176.         else  
177.         {//父节点为祖父节点的右子节点，情况与上面相同  
178.             RBNode<T> *uncle = grandParent->left;  
179.             if(uncle && uncle->color == _rb_red_node)  
180.             {  
181.                 uncle->color = _rb_black_node;  
182.                 parent->color = _rb_black_node;  
183.                 grandParent->color = _rb_red_node;  
184.                 node = grandParent;  
185.                 parent = node->parent;  
186.             }  
187.             else  
188.             {  
189.                 if(node == parent->left)  
190.                 {  
191.                     node = _rbtree_rotate_right(parent);  
192.                     parent = node->parent;  
193.                     grandParent = parent->parent;  
194.                 }  
195.                 parent->color = _rb_black_node;  
196.                 grandParent->color = _rb_red_node;  
197.                 _rbtree_rotate_left(grandParent);  
198.             }  
199.         }  
200.     }  
201.     root->color = _rb_black_node;  
202. }  
203.   
204. /* 
205. * 
206. * 左旋 
207. * 
208. */  
209. template<typename T>  
210. RBNode<T> *RBTree<T>::_rbtree_rotate_left(RBNode<T> *x)  
211. {  
212.     RBNode<T> *y = x->right;  
213.     if(y == NULL)  
214.     {  
215.         return x;  
216.     }  
217.     //x的右节点为y的左节点  
218.     x->right = y->left;  
219.     if(y->left)//如果y的左节点存在，其父节点为y  
220.         y->left->parent = x;  
221.     if(root == x)  
222.     {//x为root，旋转后y为新的root根节点  
223.         root = y;  
224.     }  
225.     else  
226.     {  
227.         if(x == x->parent->left)  
228.         {//如果x为其父节点的左子节点。  
229.             //x的父节点的新左子节点为y  
230.             x->parent->left = y;  
231.         }  
232.         else  
233.         {  
234.             x->parent->right = y;  
235.         }  
236.         //y的父节点为x的父节点  
237.         y->parent = x->parent;  
238.     }  
239.     //y的左子节点为x  
240.     y->left = x;  
241.     //x的父节点为y  
242.     x->parent = y;  
243.     return x;  
244. }  
245.   
246. /* 
247. * 
248. * 右旋 
249. * 分析其逻辑与左旋代码类似 
250. * 
251. */  
252. template<typename T>  
253. RBNode<T>* RBTree<T>::_rbtree_rotate_right(RBNode<T> *x)  
254. {  
255.     RBNode<T> *y = x->left;  
256.     if(y == NULL)  
257.     {  
258.         return x;  
259.     }  
260.     x->left = y->right;  
261.     if(y->right)  
262.         y->right->parent = x;  
263.     if(root == x)  
264.     {  
265.         root = y;  
266.     }  
267.     else  
268.     {  
269.         if(x == x->parent->left)  
270.         {  
271.             x->parent->left = y;  
272.         }  
273.         else  
274.         {  
275.             x->parent->right = y;  
276.         }  
277.         y->parent = x->parent;  
278.     }  
279.     y->right = x;  
280.     x->parent = y;  
281.     return x;  
282. }  
283.   
284. /* 
285. * 
286. * 销毁整棵红黑树 
287. * 
288. */  
289. template<typename T>  
290. void RBTree<T>::Destroy(RBNode<T> *p)  
291. {  
292.     if(p->left)  
293.     {  
294.         Destroy(p->left);  
295.     }  
296.     if(p->right)  
297.     {  
298.         Destroy(p->right);  
299.     }  
300.     delete p;  
301. }  

插入节点的程序：

[cpp] view plain copy

 

1. #include "rbtree.h"  
2. #include <iostream>  
3. using namespace std;  
4.   
5. int main()  
6. {  
7.     RBTree<int> obj;  
8.     obj.InsertUnique(30);  
9.     obj.InsertUnique(40);  
10.     obj.InsertUnique(50);  
11.     obj.InsertUnique(20);  
12.     obj.InsertUnique(35);  
13.     obj.InsertUnique(10);  
14.     obj.InsertUnique(11);  
15.     obj.print();  
16.     return 0;  
17. }