linux内核中有个rbtree,stl源码中也有,标准stl中的map和set都只是包装了下rbtree

全部代码:点击打开链接

 

  1 /*************************************************************
  2  * 作者:陈新
  3  * 邮箱:cx2pirate@gmail.com
  4  * 时间:2014.6.1
  5  * 环境:gcc
  6  * 参考:《算法导论》
  7  * ***********************************************************/
  8 
  9 
 10 #ifndef _HEADER_RB_TREE_
 11 #define _HEADER_RB_TREE_
 12 
 13 typedef int Key;                                //键值类型
 14 typedef int Data;                                //其他数据
 15 typedef enum{BLACK,RED} RB_COLOR;            
 16 
 17 struct rb_node{
 18     struct rb_node *parent;
 19     struct rb_node *right;
 20     struct rb_node *left;
 21     RB_COLOR color; 
 22     Key key;                                //键值
 23     Data data;                                //数据域
 24 };
 25 
 26 
 27 struct rb_root{
 28     struct rb_node * rb_node;
 29 };
 30 
 31 extern struct rb_node *RB_NIL;
 32 #define rb_parent(r) ((struct rb_node *)((r) ->parent))
 33 #define RB_ROOT (struct rb_root){RB_NIL}
 34 
 35 //插入和删除节点
 36 int rb_insert(struct rb_node *,struct rb_root*);                    
 37 struct rb_node * rb_delete(struct rb_node *,struct rb_root*);            //只把node从树上卸下来,并没有释放空间
 38 struct rb_node * rb_search(Key key,struct rb_root*);
 39 
 40 /**************************************************************
 41  *和二叉树相同,暂时没有实现,rbtree.c中有几个和下面作用相同的函数
 42  *这里时kernel/include/linux/rbtree.h中的声明...
 43  * ***********************************************************/
 44 
 45 //查找前趋和后继节点
 46 struct rb_node *rb_next(const struct rb_node*);
 47 struct rb_node *rb_prev(const struct rb_node*);
 48 struct rb_node *rb_first(const struct rb_node*);
 49 struct rb_node *rb_last(const struct rb_node*);
 50 
 51 //后续遍历
 52 struct rb_node *rb_first_postorder(const struct rb_root*);
 53 struct rb_node *rb_next_postorder(const struct rb_node*);
 54 
 55 //快速替换某个节点
 56 void rb_replace_node(struct rb_node *victim,struct rb_node *new,struct rb_root *root);
 57 
 58 #endif
 59 
 60 
 61 #include "rbtree.h"
 62 #include <stdio.h>
 63 
 64 struct rb_node *RB_NIL = &(struct rb_node){0,0,0,BLACK,0,0};
 65 
 66 //node为树内任意右孩子不为RB_NIL的节点
 67 void left_rotate(struct rb_node *node,struct rb_root *root)    
 68 {
 69     struct rb_node *rc = node ->right;                //rc为node的right child
 70     node ->right = rc ->left;
 71 
 72     if(rc ->left != RB_NIL){
 73         rc ->left ->parent = node;
 74     }
 75 
 76     rc ->parent = node ->parent;
 77     if(node ->parent == RB_NIL){                    //node为root节点
 78         root ->rb_node = rc;
 79     }
 80     else if(node == node ->parent ->left){
 81         node ->parent ->left = rc;
 82     }
 83     else{
 84         node ->parent ->right = rc;
 85     }
 86 
 87     rc ->left = node;
 88     node ->parent = rc;
 89 }
 90 
 91 //node为树内任意左孩子不为RB_NIL的节点
 92 void right_rotate(struct rb_node *node,struct rb_root *root)    
 93 {
 94     struct rb_node *lc = node ->left;                //lc为node的left child
 95     node ->left = lc ->righ
 96     if(lc ->right != RB_NIL){                    //刚开始直接copy过来,少改了个left,debug long long time...
 97         lc ->right ->parent = node;
 98     }
 99 
100     lc ->parent = node ->parent;
101     if(node ->parent == RB_NIL){                       //node为root节点
102         root ->rb_node = lc;
103     }
104     else if(node == node ->parent ->left){
105         node ->parent ->left = lc;
106     }
107     else{
108         node ->parent ->right = lc;
109     }
110 
111     lc ->right = node;
112     node ->parent = lc;
113 }
114 
115 //非递归版本二叉树查找
116 //node为根节点,k为键值
117 //返回k节点指针,如果不存在返回RB_NIL
118 struct rb_node *rb_search(Key key,struct rb_root *root)
119 {
120     struct rb_node *p = root ->rb_node;
121     
122     while(p != RB_NIL && key != p -> key)
123     {
124         p = key < p ->key ? p ->left : p ->right;
125     }
126 
127     return p == RB_NIL ? NULL : p;
128 }
129 
130 //返回以node为根的子树的最小节点
131 struct rb_node *rb_minimum(struct rb_node *node)
132 {
133     struct rb_node *p = node;
134 
135     while(p ->left != RB_NIL)
136     {
137             p = p ->left;
138     }
139 
140     return p;
141 }
142 
143 //返回以node为根的子树的最大节点
144 struct rb_node *rb_maximum(struct rb_node *node)
145 {
146     struct rb_node *p = node;
147 
148     while(p ->right != RB_NIL)
149     {
150             p = p ->right;
151     }
152 
153     return p;
154 }
155 
156 //返回node的后继节点
157 struct rb_node *tree_successor(struct rb_node *node)
158 {
159     struct rb_node *p = node;
160 
161     if(p ->right != RB_NIL)
162     {
163         return rb_minimum(p ->right);
164     }
165 
166     struct rb_node *parent = p ->parent;
167     while(parent != RB_NIL && p == parent ->right)
168     {
169         p = parent;
170         parent = parent ->parent;
171     }
172 
173     return parent;
174 }
175 
176 //插入节点后红黑树别破坏的性质2和性质4
177 void rb_insert_fixup(struct rb_node *node,struct rb_root *root)
178 {
179     while((rb_parent(node)) ->color == RED){
180         if(rb_parent(node) == rb_parent(rb_parent(node)) ->left){
181             struct rb_node *uc = rb_parent(rb_parent(node)) ->right;
182             if(uc ->color == RED){                            //case1:叔叔的颜色也为红色
183                 uc ->color = BLACK;
184                 rb_parent(node) ->color = BLACK;
185                 rb_parent(rb_parent(node)) ->color = RED;
186                 node = rb_parent(rb_parent(node));
187             }
188             else{
189                 if(node == rb_parent(node) ->right){                //case2:叔叔为黑色,node为parent的右节点
190                     node = rb_parent(node);                    //通过左旋变为case3
191                     left_rotate(node,root);
192                 }
193             
194                 rb_parent(node) ->color = BLACK;
195                 rb_parent(rb_parent(node)) ->color = RED;
196                 right_rotate(rb_parent(rb_parent(node)),root);
197             }
198         }
199         else{
200             struct rb_node *uc = rb_parent(rb_parent(node)) ->left;
201             if(uc ->color == RED){                            //case1:叔叔的颜色也为红色
202                 uc ->color = BLACK;
203                 rb_parent(node) ->color = BLACK;
204                 rb_parent(rb_parent(node)) ->color = RED;
205                 node = rb_parent(rb_parent(node));
206             }
207             else{
208                 if(node == rb_parent(node) ->left){                //case2:叔叔为黑色,node为parent的右节点
209                     node = rb_parent(node);                    //通过左旋变为case3
210                     right_rotate(node,root);
211                 }
212             
213                 rb_parent(node) ->color = BLACK;
214                 rb_parent(rb_parent(node)) ->color = RED;
215                 left_rotate(rb_parent(rb_parent(node)),root);
216             }
217         }
218     }
219     root ->rb_node ->color = BLACK;
220 }
221 
222 //插入一个节点,与二叉树区别不大,最后需要调用rb_insert_fixup修复红黑性质
223 int rb_insert(struct rb_node *node,struct rb_root *root)
224 {
225     struct rb_node *parent = RB_NIL;                        //node在树中的父亲
226     struct rb_node *p = root ->rb_node;
227 
228     while(p != RB_NIL){
229         parent = p;
230         if(node ->key < p ->key){
231             p = p ->left;
232         }
233         else if(node ->key > p ->key){
234             p = p ->right;
235         }
236         else{
237             return 0;
238         }
239     }
240 
241     node ->parent = parent;
242     if(parent == RB_NIL){
243         root ->rb_node = node;
244     }
245     else if(node ->key < parent ->key){
246         parent ->left = node;
247     }
248     else{
249         parent ->right = node;
250     }
251     
252     node ->left = RB_NIL;
253     node ->right = RB_NIL;
254     node ->color = RED;
255 
256     rb_insert_fixup(node,root);
257     return 0;
258 }
259 
260 void rb_delete_fixup(struct rb_node *node,struct rb_root *root)
261 {
262     struct rb_node *sibiling;                                        
263     while(node != root ->rb_node && node ->color == BLACK){    //node has double black attrubute
264         if(node == rb_parent(node) ->left){                        //!note:node could be RB_NIL
265             sibiling = rb_parent(node) ->right;                    //!note:double black node certainly has a brother
266 
267             if(sibiling ->color == RED){                        //case 1:brother's color is red
268                 sibiling ->color = BLACK;                    //and sibiling has two black child
269                 rb_parent(node) ->color = RED;                    //aparenter this,case 1 will be turned to 
270                 left_rotate(rb_parent(node),root);                //case2,case 3 or case 4.
271                 sibiling = rb_parent(node) ->right;
272             }
273 
274             if(sibiling ->left ->color == BLACK && sibiling ->right ->color == BLACK){
275                 sibiling ->color = RED;
276                 node = rb_parent(node);                        //case 2:双重黑色上移到父亲,循环迭代.
277             }
278             else{ 
279                 if(sibiling ->right ->color == BLACK){                //case 3:变为case 4
280                     sibiling ->left ->color = BLACK;
281                     sibiling ->color = RED;
282                     right_rotate(sibiling,root);
283                     sibiling = rb_parent(node) ->right;
284                 }
285 
286                 sibiling ->color = rb_parent(node) ->color;            //case 4:
287                 rb_parent(node) ->color = BLACK;
288                 sibiling ->right ->color = BLACK;
289                 left_rotate(rb_parent(node),root);
290                 node = root ->rb_node;                        //case 4经过此步就结束了
291             }
292         }
293         else{
294             sibiling = rb_parent(node) ->left;                    //double black node certainly has a brother
295 
296             if(sibiling ->color == RED){                        //case 1:brother's color is red
297                 sibiling ->color = BLACK;                    //and sibiling has two black child
298                 rb_parent(node) ->color = RED;                    //aparenter this,case 1 will be turned to 
299                 right_rotate(rb_parent(node),root);                //case2,case 3 or case 4.
300                 sibiling = rb_parent(node) ->left;
301             }
302 
303             if(sibiling ->left ->color == BLACK && sibiling ->right ->color == BLACK){
304                 sibiling ->color = RED;
305                 node = rb_parent(node);                        //case 2:double black move up.
306             }
307             else{
308                 if(sibiling ->left ->color == BLACK){                //case 3:
309                     sibiling ->right ->color = BLACK;
310                     sibiling ->color = RED;
311                     left_rotate(sibiling,root);
312                     sibiling = rb_parent(node) ->left;
313                 }
314 
315                 sibiling ->color = rb_parent(node) ->color;            //case 4:
316                 rb_parent(node) ->color = BLACK;
317                 sibiling ->left ->color = BLACK;
318                 right_rotate(rb_parent(node),root);
319                 node = root ->rb_node;                        //case 4经过此步就结束了
320             }
321         }
322     }
323 
324     node ->color = BLACK;
325 }
326 
327 struct rb_node * rb_delete(struct rb_node *node,struct rb_root *root)
328 {
329     struct rb_node *p,*ps;                                    //p为待删除节点,ps为p的子节点
330     if(node ->left == RB_NIL || node -> right == RB_NIL){
331         p = node;
332     }
333     else{
334         p = tree_successor(node);
335     }
336 
337     ps = p ->left != RB_NIL ? p ->left : p ->right;
338     ps ->parent = p ->parent;                                //different from binary_tree,ps could be NIL
339     
340     if(p ->parent == RB_NIL){
341         root ->rb_node = ps;
342     }
343     else if(p == rb_parent(p) ->left){
344         rb_parent(p) ->left = ps;
345     }
346     else{
347         rb_parent(p) ->right = ps;
348     }
349 
350     if(p != node){                                        //复制key域,如果还有其它数据需要一同复制{
351         node ->key = p ->key;    
352         node ->data = p ->data;
353     }
354 
355     if(p ->color == BLACK){                                    //black node is deleted
356         rb_delete_fixup(ps,root);
357     }
358 
359     return p;
360 }

 

 posted on 2014-06-02 12:37  莫扎特的代码  阅读(305)  评论(0编辑  收藏  举报