红黑树的代码实现

红黑树满足一下规则

1. 每个节点不是红色就是黑色

2.根节点为黑色

3.如果节点为红，其子节点必须为黑

4.任一节点至nil的任何路径，所包含的黑节点数必须相同。

5.叶子节点nil为黑色

当破坏了平衡时，在调整的时候需要用到左旋和右旋

左旋：

右旋：

代码实现：

 1 void rb_tree::__rb_tree_rotate_left(link_type x) {
 2     link_type y = x->right;
 3     x->right = y->left;
 4     if(y->left != nil) {
 5         y->left->parent = x;
 6     }
 7     y->parent = x->parent;
 8     if(x == root) {
 9         root = y;
10     } else if(x == x->parent->left) {
11         x->parent->left = y;
12     } else {
13         x->parent->right = y;
14     }
15     x->parent = y;
16     y->left = x;
17 }

左旋转

 1 void rb_tree::__rb_tree_rotate_right(link_type x) {
 2     link_type y = x->left;
 3     x->left = y->right;
 4     if(x->left != nil) {
 5         x->left->parent = x;
 6     }
 7     y->parent = x->parent;
 8     if(x == root) {
 9         root = y;
10     } else if(x->parent->left == x) {
11         x->parent->left = y;
12     } else {
13         x->parent->right = y;
14     }
15
16     x->parent = y;
17     y->right = x;
18 }

右旋转

插入节点时，可能会破坏红黑树的结构，如下图，在插入3,8,35,75的时候，就破坏了树的结构：

设定如下用语：新节点为X，其父节点为P，组父节点为G，伯父节点为S，曾祖父节点GG。

根据红黑树规则4，X必为红，若P也为红(这就违反了规则3，必须调整树形)，则G必为黑。于是，根据X的插入位置及外围节点的颜色，有了以下三种考虑。

情况1：S为黑且X为外侧插入。

对此情况，我们先对P，G做一次单旋转，并更改P，G的颜色，即可重新满足红黑树的规则3。

情况2：S为黑且X为内侧插入。

对此情况，我们必须先对P，X做一次单旋转并更改G，X颜色，再将结果对G做一次单旋转，即可重新满足红黑树规则3.

情况3：S为红，不考虑X是否内外测。

对此情况，我们需将P和S设置为黑色，G设置为红色，并将X设置成G继续判断即可。

以下为插入和调整代码

 1 void rb_tree::insert(key_type __x) {
 2     link_type new_node;
 3     link_type new_parent = nil;
 4     link_type pos = root;
 5     while (pos != nil) {
 6         new_parent = pos;
 7         if(__x < pos->key) {
 8             pos = pos->left;
 9         } else if(__x > pos->key) {
10             pos = pos->right;
11         } else {
12             fprintf(stderr, "Error: node %d already in the tree.\n", __x);
13             exit(1);
14         }
15     }
16     new_node = get_node(__x);
17     new_node->parent = new_parent;
18     if(new_parent == nil) {
19         root = new_node;
20     } else if(__x < new_parent->key) {
21         new_parent->left = new_node;
22     } else {
23         new_parent->right = new_node;
24     }
25     __rb_tree_rebalance(new_node);
26     ++ node_count;
27 }

插入

 1 void rb_tree::__rb_tree_rebalance(link_type x) {
 2     while (x != root && x->parent->color == __rb_tree_red) {
 3         if(x->parent == x->parent->parent->left) {
 4             link_type s = x->parent->parent->right;
 5             if(s && s->color == __rb_tree_red) {
 6                 x->parent->color = __rb_tree_black;
 7                 s->color = __rb_tree_black;
 8                 x->parent->parent->color = __rb_tree_red;
 9                 x = x->parent->parent;
10             } else {
11                 if(x == x->parent->right) {
12                     x = x->parent;
13                     __rb_tree_rotate_left(x);
14                 }
15                 x->parent->color = __rb_tree_black;
16                 x->parent->parent->color = __rb_tree_red;
17                 __rb_tree_rotate_right(x->parent->parent);
18             }
19         } else {
20             link_type s = x->parent->parent->left;
21             if(s && s->color == __rb_tree_red) {
22                 s->color = __rb_tree_black;
23                 x->parent->color = __rb_tree_black;
24                 x->parent->parent->color = __rb_tree_red;
25                 x = x->parent->parent;
26             } else {
27                 if(x == x->parent->left) {
28                     x = x->parent;
29                     __rb_tree_rotate_right(x);
30                 }
31                 x->parent->color = __rb_tree_black;
32                 x->parent->parent->color = __rb_tree_red;
33                 __rb_tree_rotate_left(x->parent->parent);
34             }
35         }
36     }
37     root->color = __rb_tree_black;
38 }

调整结构

删除节点的操作和二叉搜索树的原理一样，只是加了旋转和着色。

1.当删除节点没有子节点树直接删除，用nil代替当前位置，

2.当删除节点只有一个子树时，用子节点代替当前位置，

3.当删除节点有两个字数时，找到它的后继节点，将它们继续更换，那么就变成了删除后继节点，而且后继节点至多有一个字数，这就转换成前两种情况了。

假设删除节点为y，子节点为x。

如果y是红色的，那就不会破坏结构。

如果y是黑色的，x是红色的，那么将x变为黑色就OK了

如果y是黑色的，x是黑色且是根，不会破坏结构。

否则的话就有下面四种情况：

情况1：X为黑色，S为红色。

如果X是P的左孩子，将S设置为黑色，X设置为红色，对P进行左旋装，重新设置S

如果X是P的右孩子，将S设置为黑色，X设置为红色，对P进行右旋转，重新设置S

情况2：X为黑色，S为黑色，并且S的两个孩子都为黑色。

将S设置为红色，设置X为P。

情况3：X为黑色，S为黑色。

如果X是P的左孩子，S的左孩子为红色，右孩子为黑色。

将S的左孩子设置为黑色，S设置为红色，对S进行右旋转，重新设置S。

如果X是P的右孩子，S的右孩子为红色，左孩子为黑色。

将S的右孩子设置为黑色，S设置为红色，对S进行左旋转，重新设置S。

情况4：X为黑色，S为黑色。

如果X是P的左孩子，S的右孩子为红色，左孩子任意。

将P的颜色赋值给S，设置P的颜色为黑色，S的右孩子为黑色，对P进行左旋转，设置X为root

如果X是P的右孩子，S的左孩子为红色，右孩子任意。

将P的颜色赋值给S，设置P的颜色为黑色，S的左孩子为红色，对P进行右旋转，设置X为root

其实X是P的左孩子或者右孩子，它们的操作都是对应的。

以下是删除代码和删除后调整的代码

 1 rb_tree::link_type rb_tree::erase(key_type __x) {
 2     link_type dead = find(__x);
 3     if(dead == nil) {
 4         fprintf(stderr, "Error,node %d does not exist\n", __x);
 5         return nil;
 6     }
 7     link_type x = nil, y = nil;
 8     if(dead->left == nil || dead->right == nil) {
 9         y = dead;
10     } else {
11         y = __get_next_node(dead);
12     }
13     if(y->left == nil) {
14         x = y->right;
15     }else if(y->right == nil) {
16         x = y->left;
17     }
18 //    if(x) {
19         x->parent = y->parent;
20 //    }
21     if(y->parent == nil) {
22         root = x;
23     } else if(y == y->parent->left) {
24         y->parent->left = x;
25     } else if(y == y->parent->right) {
26         y->parent->right = x;
27     }
28
29     if(dead != y) {
30         dead->key = y->key;
31     }
32     if(y->color == __rb_tree_black) {
33         __rb_tree_delete_fixup(x);
34     }
35     return y;
36 }

删除

 1 void rb_tree::__rb_tree_delete_fixup(link_type x) {
 2 //    printf("nil:%d\n", x==nil);
 3     while (x != root && x->color == __rb_tree_black) {
 4         if(x == x->parent->left) {
 5             link_type s = x->parent->right;
 6             if(s->color == __rb_tree_red) {
 7                 s->color = __rb_tree_black;
 8                 x->parent->color = __rb_tree_red;
 9                 __rb_tree_rotate_left(x->parent);
10                 s = x->parent->right;
11             }
12
13             if(s->left->color == __rb_tree_black && s->right->color == __rb_tree_black) {
14                 s->color = __rb_tree_red;
15                 x = x->parent;
16             } else {
17                 if(s->right->color == __rb_tree_black) {
18                     s->left->color = __rb_tree_black;
19                     s->color = __rb_tree_red;
20                     __rb_tree_rotate_right(s);
21                     s = x->parent->right;
22                 }
23
24                 s->color = x->parent->color;
25                 x->parent->color = __rb_tree_black;
26                 s->right->color = __rb_tree_black;
27                 __rb_tree_rotate_left(x->parent);
28                 x = root;
29             }
30         } else {
31             link_type s = x->parent->left;
32             if(s->color == __rb_tree_red) {
33                 s->color = __rb_tree_black;
34                 x->parent->color = __rb_tree_red;
35                 __rb_tree_rotate_right(x->parent);
36                 s = x->parent->left;
37             }
38
39             if(s->left->color == __rb_tree_black && s->right->color == __rb_tree_black) {
40                 s->color = __rb_tree_red;
41                 x = x->parent;
42             } else {
43                 if(s->left->color == __rb_tree_black) {
44                     s->right->color = __rb_tree_black;
45                     s->color = __rb_tree_red;
46                     __rb_tree_rotate_left(s);
47                     s = x->parent->left;
48                 }
49
50                 s->color = x->parent->color;
51                 x->parent->color = __rb_tree_black;
52                 s->left->color = __rb_tree_black;
53                 __rb_tree_rotate_right(x->parent);
54                 x = root;
55             }
56         }
57     }
58     x->color = __rb_tree_black;
59 }

调整代码

以下是两个完整的代码，只需 #include "rb_tree.h"即可使用。

 1 //
 2 // Created by starry on 2019/8/24.
 3 //
 4
 5 #ifndef TREE_PTR_H
 6 #define TREE_PTR_H
 7
 8 #include <stdio.h>
 9 //#define nil NULL
10
11 typedef bool __rb_tree_color_type;
12 const __rb_tree_color_type __rb_tree_red = false;
13 const __rb_tree_color_type __rb_tree_black = true;
14
15 struct __rb_tree_node{
16     typedef __rb_tree_color_type color_type;
17     typedef __rb_tree_node* rb_node_ptr;
18     typedef int key_type;
19
20     key_type key;
21     color_type color;
22     rb_node_ptr parent;
23     rb_node_ptr left, right;
24 };
25
26 class rb_tree{
27 public:
28     typedef __rb_tree_node rb_tree_node;
29     typedef __rb_tree_color_type color_type;
30
31     typedef rb_tree_node* link_type;
32     typedef size_t size_type;
33     typedef void* void_pointer;
34     typedef int key_type;
35
36 public:
37     rb_tree();
38
39     bool empty() const { return node_count == 0;}
40     size_type size() const { return node_count;}
41
42     void clear();
43     void insert(key_type __x);
44     link_type erase(key_type __x);
45     link_type find(key_type __x);
46     void draw();
47     int rb_height(link_type x);
48
49 private:
50
51     link_type get_node(key_type __x);
52     void __rb_tree_rebalance(link_type x);
53     void __rb_tree_rotate_left(link_type x);
54     void __rb_tree_rotate_right(link_type x);
55     void __rb_tree_delete_fixup(link_type x);
56     void __serialize(link_type x);
57     void __delete(link_type x);
58     link_type __get_next_node(link_type x);
59
60     size_type node_count;
61     link_type root;
62     link_type nil;
63 };
64
65
66 #endif //TREE_PTR_H

rb_tree.h

  1 //
  2 // Created by starry on 2019/8/24.
  3 //
  4
  5 #include "rb_tree.h"
  6 #include <stdlib.h>
  7 #include <stdio.h>
  8
  9 void rb_tree::draw() {
 10     __serialize(root);
 11     printf("\n");
 12 }
 13
 14 int rb_tree::rb_height(link_type x) {
 15     if(x == nil)
 16         return 0;
 17     int l = rb_height(x->left);
 18     int r = rb_height(x->right);
 19     return 1 + (l>r?l:r);
 20 }
 21
 22 rb_tree::rb_tree() {
 23     nil = (link_type)malloc(sizeof(rb_tree_node));
 24     nil->left = nil->right = nil->parent = nil;
 25     nil->color = __rb_tree_black;
 26     root = nil;
 27     node_count = 0;
 28 }
 29
 30 void rb_tree::clear() {
 31     __delete(root);
 32     root = nil;
 33     node_count = 0;
 34 }
 35
 36 void rb_tree::__delete(link_type x) {
 37     if(x == nil) return;
 38     __delete(x->left);
 39     __delete(x->right);
 40     free(x);
 41 }
 42
 43 rb_tree::link_type rb_tree::find(key_type __x) {
 44     link_type pos = root;
 45     while (pos != nil) {
 46         if(pos->key == __x) return pos;
 47         else if(pos->key > __x) pos = pos->left;
 48         else if(pos->key < __x) pos = pos->right;
 49     }
 50     return pos;
 51 }
 52
 53 void rb_tree::insert(key_type __x) {
 54     link_type new_node;
 55     link_type new_parent = nil;
 56     link_type pos = root;
 57     while (pos != nil) {
 58         new_parent = pos;
 59         if(__x < pos->key) {
 60             pos = pos->left;
 61         } else if(__x > pos->key) {
 62             pos = pos->right;
 63         } else {
 64             fprintf(stderr, "Error: node %d already in the tree.\n", __x);
 65             exit(1);
 66         }
 67     }
 68     new_node = get_node(__x);
 69     new_node->parent = new_parent;
 70     if(new_parent == nil) {
 71         root = new_node;
 72     } else if(__x < new_parent->key) {
 73         new_parent->left = new_node;
 74     } else {
 75         new_parent->right = new_node;
 76     }
 77     __rb_tree_rebalance(new_node);
 78     ++ node_count;
 79 }
 80
 81 rb_tree::link_type rb_tree::erase(key_type __x) {
 82     link_type dead = find(__x);
 83     if(dead == nil) {
 84         fprintf(stderr, "Error,node %d does not exist\n", __x);
 85         return nil;
 86     }
 87     link_type x = nil, y = nil;
 88     if(dead->left == nil || dead->right == nil) {
 89         y = dead;
 90     } else {
 91         y = __get_next_node(dead);
 92     }
 93     if(y->left == nil) {
 94         x = y->right;
 95     }else if(y->right == nil) {
 96         x = y->left;
 97     }
 98 //    if(x) {
 99     x->parent = y->parent;
100 //    }
101     if(y->parent == nil) {
102         root = x;
103     } else if(y == y->parent->left) {
104         y->parent->left = x;
105     } else if(y == y->parent->right) {
106         y->parent->right = x;
107     }
108
109     if(dead != y) {
110         dead->key = y->key;
111     }
112     if(y->color == __rb_tree_black) {
113         __rb_tree_delete_fixup(x);
114     }
115     return y;
116 }
117
118 void rb_tree::__rb_tree_delete_fixup(link_type x) {
119     while (x != root && x->color == __rb_tree_black) {
120         if(x == x->parent->left) {
121             link_type s = x->parent->right;
122             if(s->color == __rb_tree_red) {
123                 s->color = __rb_tree_black;
124                 x->parent->color = __rb_tree_red;
125                 __rb_tree_rotate_left(x->parent);
126                 s = x->parent->right;
127             }
128
129             if(s->left->color == __rb_tree_black && s->right->color == __rb_tree_black) {
130                 s->color = __rb_tree_red;
131                 x = x->parent;
132             } else {
133                 if(s->right->color == __rb_tree_black) {
134                     s->left->color = __rb_tree_black;
135                     s->color = __rb_tree_red;
136                     __rb_tree_rotate_right(s);
137                     s = x->parent->right;
138                 }
139
140                 s->color = x->parent->color;
141                 x->parent->color = __rb_tree_black;
142                 s->right->color = __rb_tree_black;
143                 __rb_tree_rotate_left(x->parent);
144                 x = root;
145             }
146         } else {
147             link_type s = x->parent->left;
148             if(s->color == __rb_tree_red) {
149                 s->color = __rb_tree_black;
150                 x->parent->color = __rb_tree_red;
151                 __rb_tree_rotate_right(x->parent);
152                 s = x->parent->left;
153             }
154
155             if(s->left->color == __rb_tree_black && s->right->color == __rb_tree_black) {
156                 s->color = __rb_tree_red;
157                 x = x->parent;
158             } else {
159                 if(s->left->color == __rb_tree_black) {
160                     s->right->color = __rb_tree_black;
161                     s->color = __rb_tree_red;
162                     __rb_tree_rotate_left(s);
163                     s = x->parent->left;
164                 }
165
166                 s->color = x->parent->color;
167                 x->parent->color = __rb_tree_black;
168                 s->left->color = __rb_tree_black;
169                 __rb_tree_rotate_right(x->parent);
170                 x = root;
171             }
172         }
173     }
174     x->color = __rb_tree_black;
175 }
176
177 rb_tree::link_type rb_tree::__get_next_node(link_type x) {
178     if(x == nil) return nil;
179     link_type next = nil;
180     if(x->right != nil) {
181         x = x->right;
182         while(x->left != nil) x = x->left;
183         next = x;
184     } else {
185         link_type y = x->parent;
186         while (y && x == y->right) {
187             x = y;
188             y = y->parent;
189         }
190         next = y;
191     }
192     return next;
193 }
194
195 void rb_tree::__serialize(link_type x) {
196     if(x == nil) {
197         printf("#$");
198         return;
199     }
200     printf("(%d,%d)",x->key,x->color);
201     __serialize(x->left);
202     __serialize(x->right);
203 }
204
205 rb_tree::link_type rb_tree::get_node(key_type __x) {
206     link_type ret;
207     if((ret = (link_type)malloc(sizeof(rb_tree_node))) == NULL) {
208         fprintf(stderr, "Error: out of memory.\n");
209         exit(1);
210     }
211     ret->left = nil;
212     ret->right = nil;
213     ret->parent = nil;
214     ret->color = __rb_tree_red;
215     ret->key = __x;
216     return ret;
217 }
218
219 void rb_tree::__rb_tree_rebalance(link_type x) {
220     while (x != root && x->parent->color == __rb_tree_red) {
221         if(x->parent == x->parent->parent->left) {
222             link_type s = x->parent->parent->right;
223             if(s && s->color == __rb_tree_red) {
224                 x->parent->color = __rb_tree_black;
225                 s->color = __rb_tree_black;
226                 x->parent->parent->color = __rb_tree_red;
227                 x = x->parent->parent;
228             } else {
229                 if(x == x->parent->right) {
230                     x = x->parent;
231                     __rb_tree_rotate_left(x);
232                 }
233                 x->parent->color = __rb_tree_black;
234                 x->parent->parent->color = __rb_tree_red;
235                 __rb_tree_rotate_right(x->parent->parent);
236             }
237         } else {
238             link_type s = x->parent->parent->left;
239             if(s && s->color == __rb_tree_red) {
240                 s->color = __rb_tree_black;
241                 x->parent->color = __rb_tree_black;
242                 x->parent->parent->color = __rb_tree_red;
243                 x = x->parent->parent;
244             } else {
245                 if(x == x->parent->left) {
246                     x = x->parent;
247                     __rb_tree_rotate_right(x);
248                 }
249                 x->parent->color = __rb_tree_black;
250                 x->parent->parent->color = __rb_tree_red;
251                 __rb_tree_rotate_left(x->parent->parent);
252             }
253         }
254     }
255     root->color = __rb_tree_black;
256 }
257
258 void rb_tree::__rb_tree_rotate_left(link_type x) {
259     link_type y = x->right;
260     x->right = y->left;
261     if(y->left != nil) {
262         y->left->parent = x;
263     }
264     y->parent = x->parent;
265     if(x == root) {
266         root = y;
267     } else if(x == x->parent->left) {
268         x->parent->left = y;
269     } else {
270         x->parent->right = y;
271     }
272     x->parent = y;
273     y->left = x;
274 }
275
276 void rb_tree::__rb_tree_rotate_right(link_type x) {
277     link_type y = x->left;
278     x->left = y->right;
279     if(x->left != nil) {
280         x->left->parent = x;
281     }
282     y->parent = x->parent;
283     if(x == root) {
284         root = y;
285     } else if(x->parent->left == x) {
286         x->parent->left = y;
287     } else {
288         x->parent->right = y;
289     }
290
291     x->parent = y;
292     y->right = x;
293 }

rb_tree.cpp

原文地址：https://www.cnblogs.com/xingkongyihao/p/11411144.html