这一章节特别有意思。习题也比较多，但是很容易掌握。主要描述的就是在已知数据结构的基础上，通过增加或修改部分基础操作。来构造更加有效的新数据结构。
14.1 动态数据统计
本节主要介绍如何修改红黑树，使得可以在O(lgn)时间内确定顺序统计量，如何在O(lgn)时间内确定一个元素的秩，即它在集合线性序中的位置。顺序统计树（order-static tree）T只是简单地在每个结点上存储附加信息的一棵红黑树，附加信息是当前子树的size大小。源代码如下：
1 #include <iostream>
2 #include <cstdio>
3 #include <cstring>
4 #include <cstdlib>
5 #include <algorithm>
6 using namespace std;
7
8 #define LOCAL_DEBUG
9 #define RED true
10 #define BLACK false
11
12 typedef struct Node_t {
13 bool color;
14 int key, size;
15 Node_t *p, *left, *right;
16 Node_t() {}
17 Node_t(int kkey) {
18 key = kkey;
19 }
20 } Node_t;
21
22 typedef struct Tree_t {
23 Node_t *NIL;
24 Node_t *root;
25 Tree_t() {
26 NIL = new Node_t();
27 NIL->key = 0;
28 NIL->size = 0;
29 NIL->color = BLACK;
30 NIL->p = NIL->left = NIL->right = NIL;
31 root = NIL;
32 }
33 } Tree_t;
34
35 Tree_t *t;
36
37 void Inorder_RBTree_Walk(Tree_t *t, Node_t *x) {
38 if (x != t->NIL) {
39 Inorder_RBTree_Walk(t, x->left);
40 printf("key: %d, size: %d\n", x->key, x->size);
41 Inorder_RBTree_Walk(t, x->right);
42 }
43 }
44
45 void Preorder_RBTree_Walk(Tree_t *t, Node_t *x) {
46 if (x != t->NIL) {
47 printf("key: %d, size: %d\n", x->key, x->size);
48 Preorder_RBTree_Walk(t, x->left);
49 Preorder_RBTree_Walk(t, x->right);
50 }
51 }
52
53 void Postorder_RBTree_Walk(Tree_t *t, Node_t *x) {
54 if (x != t->NIL) {
55 Postorder_RBTree_Walk(t, x->left);
56 Postorder_RBTree_Walk(t, x->right);
57 printf("key: %d, size: %d\n", x->key, x->size);
58 }
59 }
60
61 void Inorder_RBTree_Walk_WithColor(Tree_t *t, Node_t *x) {
62 if (x != t->NIL) {
63 Inorder_RBTree_Walk_WithColor(t, x->left);
64 printf("key: %d, size: %d, color: %s\n", x->key, x->size, x->color?"Red":"Black");
65 Inorder_RBTree_Walk_WithColor(t, x->right);
66 }
67 }
68
69 void Preorder_RBTree_Walk_WithColor(Tree_t *t, Node_t *x) {
70 if (x != t->NIL) {
71 printf("key: %d, size: %d, color: %s\n", x->key, x->size, x->color?"Red":"Black");
72 Preorder_RBTree_Walk_WithColor(t, x->left);
73 Preorder_RBTree_Walk_WithColor(t, x->right);
74 }
75 }
76
77 void Postorder_RBTree_Walk_WithColor(Tree_t *t, Node_t *x) {
78 if (x != t->NIL) {
79 Postorder_RBTree_Walk_WithColor(t, x->left);
80 Postorder_RBTree_Walk_WithColor(t, x->right);
81 printf("key: %d, size: %d, color: %s\n", x->key, x->size, x->color?"Red":"Black");
82 }
83 }
84
85 Node_t *RBTree_Minimum(Tree_t *t, Node_t *x) {
86 while (x->left != t->NIL)
87 x = x->left;
88 return x;
89 }
90
91 Node_t *RBTree_Maximum(Tree_t *t, Node_t *x) {
92 while (x->right != t->NIL)
93 x = x->right;
94 return x;
95 }
96
97 Node_t *RBTree_Search(Tree_t *t, int key) {
98 Node_t *x = t->root;
99 while (x!=t->NIL && x->key!=key) {
100 if (key < x->key) {
101 x = x->left;
102 } else {
103 x = x->right;
104 }
105 }
106 return x;
107 }
108
109 void Left_Rotate(Tree_t *t, Node_t *x) {
110 Node_t *y = x->right;
111 x->right = y->left;
112 if (y->left != t->NIL)
113 y->left->p = x;
114 y->p = x->p;
115 if (x->p == t->NIL) {
116 // x is root
117 t->root = y;
118 } else if (x == x->p->left) {
119 x->p->left = y;
120 } else {
121 x->p->right = y;
122 }
123 y->left = x;
124 x->p = y;
125 y->size = x->size;
126 x->size = x->left->size + x->right->size + 1;
127 }
128
129 void Right_Rotate(Tree_t *t, Node_t *y) {
130 Node_t *x = y->left;
131 y->left = x->right;
132 if (x->right != t->NIL)
133 x->right->p = y;
134 x->p = y->p;
135 if (y->p == t->NIL) {
136 // y is root
137 t->root = x;
138 } else if (y == y->p->left) {
139 y->p->left = x;
140 } else {
141 y->p->right = x;
142 }
143 x->right = y;
144 y->p = x;
145 x->size = y->size;
146 y->size = y->left->size + y->right->size + 1;
147 }
148
149 void RBTree_Transplant(Tree_t *t, Node_t *u, Node_t *v) {
150 if (u->p == t->NIL) {
151 t->root = v;
152 } else if (u == u->p->left) {
153 u->p->left = v;
154 } else {
155 u->p->right = v;
156 }
157 v->p = u->p;
158 }
159
160 void RBTree_Insert_Fixup(Tree_t *t, Node_t *z) {
161 Node_t *y;
162
163 while (z->p->color == RED) {
164 // means z->p->p->color == BLACK
165 if (z->p == z->p->p->left) {
166 y = z->p->p->right;
167 if (y->color == RED) {
168 z->p->color = BLACK;
169 y->color = BLACK;
170 z->p->p->color = RED;
171 z = z->p->p;
172 } else {
173 // y->color is BLACK
174 if (z == z->p->right) {
175 z = z->p;
176 Left_Rotate(t, z);
177 }
178 z->p->color = BLACK; // break later
179 z->p->p->color = RED;
180 Right_Rotate(t, z->p->p);
181 }
182 } else {
183 y = z->p->p->left;
184 if (y->color == RED) {
185 z->p->color = BLACK;
186 y->color = BLACK;
187 z->p->p->color = RED;
188 z = z->p->p;
189 } else {
190 // y->color is BLACK
191 if (z == z->p->left) {
192 z = z->p;
193 Right_Rotate(t, z);
194 }
195 z->p->color = BLACK; // break later
196 z->p->p->color = RED;
197 Left_Rotate(t, z->p->p);
198 }
199 }
200 }
201 t->root->color = BLACK;
202 }
203
204 void RBTree_Insert(Tree_t *t, Node_t *z) {
205 Node_t *y = t->NIL;
206 Node_t *x = t->root;
207 while (x != t->NIL) {
208 y = x;
209 ++x->size;
210 if (z->key < x->key) {
211 x = x->left;
212 } else {
213 x = x->right;
214 }
215 }
216 z->p = y;
217 if (y == t->NIL) {
218 // tree is empty
219 t->root = z;
220 } else if (z->key < y->key) {
221 y->left = z;
222 } else {
223 y->right = z;
224 }
225 z->left = z->right = t->NIL;
226 z->color = RED;
227 z->size = 1;
228 RBTree_Insert_Fixup(t, z);
229 }
230
231 void RBTree_Delete_Fixup(Tree_t *t, Node_t *x) {
232 Node_t *w;
233
234 while (x!=t->root && x->color==BLACK) {
235 if (x == x->p->left) {
236 w = x->p->right;
237 if (w->color == RED) {
238 w->color = BLACK;
239 x->p->color = RED;
240 Left_Rotate(t, x->p);
241 w = x->p->right;
242 }
243 // means w->color == BLACK
244 if (w->left->color==BLACK && w->right->color==BLACK) {
245 w->color = RED;
246 x = x->p; // fetch the black in w & x and pass it to x->p
247 } else {
248 if (w->right->color == BLACK) {
249 // means w->left->color == RED
250 w->left->color = BLACK;
251 w->color = RED;
252 Right_Rotate(t, w);
253 w = x->p->right;
254 }
255 // means w->right->color == RED && w->left->color == uncertain
256 w->color = x->p->color;
257 x->p->color = BLACK;
258 w->right->color = BLACK;
259 Left_Rotate(t, x->p);
260 x = t->root;
261 }
262 } else {
263 w = x->p->left;
264 if (w->color == RED) {
265 w->color = BLACK;
266 x->p->color = RED;
267 Right_Rotate(t, x->p);
268 w = x->p->left;
269 }
270 // means w->color == BLACK
271 if (w->left->color==BLACK && w->right->color==BLACK) {
272 w->color = RED;
273 x = x->p; // fetch the black in w & x and pass it to x->p
274 } else {
275 if (w->left->color == BLACK) {
276 // means x->right->color == RED
277 w->right->color = BLACK;
278 w->color = RED;
279 Left_Rotate(t, w);
280 w = x->p->left;
281 }
282 // means w->left->color == RED && w->right->color = ANY
283 w->color = x->p->color;
284 x->p->color = BLACK;
285 w->left->color = BLACK;
286 Right_Rotate(t, x->p);
287 x = t->root;
288 }
289 }
290 }
291 x->color = BLACK;
292 }
293
294 void RBTree_Delete(Tree_t *t, Node_t *z) {
295 Node_t *x, *y = z;
296 Node_t *q; // q used to back trace for maintening the [size] of Node_t
297 bool y_original_color = y->color;
298
299 if (z->left == t->NIL) {
300 x = z->right;
301 q = y->p;
302 RBTree_Transplant(t, y, x);
303 } else if (z->right == t->NIL) {
304 x = z->left;
305 RBTree_Transplant(t, y, x);
306 q = y->p;
307 } else {
308 y = RBTree_Minimum(t, z->right);
309 y_original_color = y->color;
310 x = y->right;
311 if (y->p == z) {
312 x->p = y;
313 q = y;
314 } else {
315 RBTree_Transplant(t, y, x);
316 q = y->p;
317 y->right = z->right;
318 y->right->p = y;
319 }
320 RBTree_Transplant(t, z, y);
321 y->left = z->left;
322 y->left->p = y;
323 y->color = z->color;
324 y->size = z->size;
325 }
326
327 // maintence the [size] of Node_t
328 while (q != t->NIL) {
329 --q->size;
330 printf("key=%d,size=%d, --\n", q->key, q->size);
331 q = q->p;
332 }
333
334 if (y_original_color == BLACK)
335 RBTree_Delete_Fixup(t, x); // use x replace y
336 }
337
338 int check_BHeight(Tree_t *t, Node_t *x, bool &f) {
339 if (x == t->NIL)
340 return 1;
341 int lBH = check_BHeight(t, x->left, f);
342 int rBH = check_BHeight(t, x->right, f);
343
344 if (f == false)
345 return 0;
346
347 if (lBH != rBH)
348 f = false;
349 if (x->color == BLACK)
350 return lBH+1;
351 return lBH;
352 }
353
354 bool check_RNode(Tree_t *t, Node_t *x) {
355 if (x == t->NIL)
356 return true;
357 if (x->color==RED && (x->left->color!=BLACK || x->right->color!=BLACK)) {
358 return false;
359 }
360 return check_RNode(t, x->left) && check_RNode(t, x->right);
361 }
362
363 bool check_Size(Tree_t *t, Node_t *x) {
364 if (x == t->NIL) {
365 return x->size == 0;
366 }
367
368 if (x->left->size+x->right->size+1 != x->size) {
369 printf("check_size: key=%d, size=%d, wrong!!!\n", x->key, x->size);
370 printf("x->left: key=%d, size=%d\n", x->left->key, x->left->size);
371 printf("x->right: key=%d, size=%d\n", x->right->key, x->right->size);
372 return false;
373 }
374 return check_Size(t, x->left) && check_Size(t, x->right) && x->left->size+x->right->size+1==x->size;
375 }
376
377 bool check_RBTree(Tree_t *t) {
378 bool ret = true;
379
380 if (t->NIL->color != BLACK)
381 return false;
382 if (t->root == t->NIL)
383 return ret;
384 if (t->root->color != BLACK)
385 return false;
386
387 ret = check_RNode(t, t->root);
388 if (ret == false) {
389 puts("not fit B<-R->B");
390 return false;
391 }
392
393 ret = check_Size(t, t->root);
394 if (ret == false) {
395 puts("size not fit");
396 return false;
397 }
398
399 check_BHeight(t, t->root, ret);
400 if (ret == false)
401 puts("BHeight not fit");
402
403 return ret;
404 }
405
406 Node_t *OS_Select(Tree_t *t, Node_t *x, int i) {
407 int r = x->left->size + 1;
408 if (r == i)
409 return x;
410 else if (r > i)
411 return OS_Select(t, x->left, i);
412 else
413 return OS_Select(t, x->right, i-r);
414 }
415
416 int OS_Rank(Tree_t *t, Node_t *x) {
417 int r = x->left->size + 1;
418 Node_t *y = x;
419 while (y != t->root) {
420 if (y == y->p->right)
421 r += y->p->left->size + 1;
422 y = y->p;
423 }
424 return r;
425 }
426
427 void init() {
428 t = new Tree_t();
429 int a[] = {26, 17, 41, 14, 21, 30, 47, 10, 16, 19, 21, 28, 38, 7, 12, 14, 20, 35, 39, 3};
430 int n = sizeof(a) / sizeof(int);
431 Node_t *p;
432
433 printf("n = %d\n", n);
434 for (int i=0; i<n; ++i) {
435 p = new Node_t(a[i]);
436 RBTree_Insert(t, p);
437 }
438
439 Inorder_RBTree_Walk_WithColor(t, t->root);
440 if (check_RBTree(t))
441 puts("Right");
442 else
443 puts("Wrong");
444 printf("\n");
445 }
446
447 void test_delete() {
448 Tree_t *t = new Tree_t();
449 int a[] = {26, 17, 41, 14, 21, 30, 47, 10, 16, 19, 21, 28, 38, 7, 12, 14, 20, 35, 39, 3};
450 int n = sizeof(a) / sizeof(int);
451 bool visit[30];
452 int i, j, k;
453 Node_t *p;
454
455 printf("n = %d\n", n);
456 for (i=0; i<n; ++i) {
457 p = new Node_t(a[i]);
458 RBTree_Insert(t, p);
459 }
460
461 memset(visit, false, sizeof(visit));
462 for (i=0; i<n; ++i) {
463 while (1) {
464 j = rand()%n;
465 if (visit[j] == false)
466 break;
467 }
468 visit[j] = true;
469 p = RBTree_Search(t, a[j]);
470 printf("delete %d\n", a[j]);
471 RBTree_Delete(t, p);
472 Inorder_RBTree_Walk_WithColor(t, t->root);
473 if (check_RBTree(t))
474 puts("Right");
475 else
476 puts("Wrong");
477 RBTree_Insert(t, p);
478 if (check_RBTree(t))
479 puts("Right");
480 else
481 puts("Wrong");
482 printf("\n\n\n");
483 }
484 }
485
486 int main() {
487
488 #ifdef LOCAL_DEBUG
489 freopen("data.in", "r", stdin);
490 freopen("data.out", "w", stdout);
491 #endif
492
493 //init();
494 test_delete();
495
496 return 0;
497 }
14.1-5
14.1-6
注意在新的秩的定义下, x.size = x.left.size + 1. 因此，相关函数修改为
1 void RBTree_Insert(Tree_t *t, Node_t *z) {
2 ......
3 while (x != t->NIL) {
4 y = x;
5 if (z->key < x->key) {
6 ++x->size;
7 x = x->left;
8 } else {
9 x = x->right;
10 }
11 }
12 ......
13 }
14
15 void Left_Rotate(Tree_t *t, Node_t *x) {
16 ......
17 y->size += x->left->size;
18 }
19
20 void Right_Rotate(Tree_t *t, Node_t *y) {
21 ......
22 y->size -= x->left->size;
23 }
24
25 void RBTree_Delete(Tree_t *t, Node_t *z) {
26 ......
27 while (q != t->NIL) {
28 if (q == q->p->left)
29 --q->size;
30 q = q->p;
31 }
32 }
14.1-7
14.2 如何扩张数据结构
扩张一种数据结构一般分为4个步骤：
1. 选择一种基础数据结构；
2. 确定基础数据结构中要维护的附加信息；
3. 检验基础数据结构上的基本修改操作能否维护附加信息；
4. 设计一些新操作。
这一章节还有一个非常有意思的定理。
定理14.1 设f是n个结点的红黑树T扩张的属性，且假设对任一结点x，f的值仅依赖于结点x、x.left和x.right的信息，还可能包括x.left.f和x.right.f。那么，我们可以再插入或删除操作期间对T的所有结点的f值进行维护，并且不影响这两个操作的渐进时间性能。
这个定理主要说的是x.f如何仅依赖于x,x.left,x.right以及x.left.f,x.right.f，那么就可以在原始时间复杂度的基础上稍作修改维护新的属性f。
该章节后面的大部分习题都以此为基础。
14.2-1
其实就和线索树一样，增加4个指针并进行维护。
14.2-2
可以，可以参考英文参考答案。
14.3 区间树
这里的区间树特别像线段树。区间树是定理14.1的应用。
区间三分律（interval trichotomy）,任何两个区间i和i‘满足下面三条性质之一：
a. i和i‘重叠；
b. i在i‘的左边，即i.high < i‘.low；
c. i在i‘的右边，即i‘.high < i.low；
区间树源代码如下：
1 #include <iostream>
2 #include <cstdio>
3 #include <cstring>
4 #include <cstdlib>
5 #include <algorithm>
6 using namespace std;
7
8 #define LOCAL_DEBUG
9 #define RED true
10 #define BLACK false
11 #define INF 9999999
12
13 typedef struct interval_t {
14 int low, high;
15 interval_t() {}
16 interval_t(int l, int h) {
17 low = l; high = h;
18 }
19 friend bool operator ==(const interval_t &a, const interval_t &b) {
20 return a.low==b.low && a.high==b.high;
21 }
22 } interval_t;
23
24 typedef struct Node_t {
25 bool color;
26 int key, mmax;
27 interval_t intr;
28 Node_t *p, *left, *right;
29 Node_t() {}
30 Node_t(interval_t iintr) {
31 intr = iintr;
32 key = iintr.low;
33 }
34 } Node_t;
35
36 typedef struct Tree_t {
37 Node_t *NIL;
38 Node_t *root;
39 Tree_t() {
40 NIL = new Node_t();
41 NIL->key = 0;
42 NIL->mmax = -INF;
43 NIL->color = BLACK;
44 NIL->p = NIL->left = NIL->right = NIL;
45 root = NIL;
46 }
47 } Tree_t;
48
49 Tree_t *t;
50
51 void Inorder_RBTree_Walk(Tree_t *t, Node_t *x) {
52 if (x != t->NIL) {
53 Inorder_RBTree_Walk(t, x->left);
54 printf("[%d, %d] | %d\n", x->intr.low, x->intr.high, x->mmax);
55 Inorder_RBTree_Walk(t, x->right);
56 }
57 }
58
59 void Preorder_RBTree_Walk(Tree_t *t, Node_t *x) {
60 if (x != t->NIL) {
61 printf("[%d, %d] | %d\n", x->intr.low, x->intr.high, x->mmax);
62 Preorder_RBTree_Walk(t, x->left);
63 Preorder_RBTree_Walk(t, x->right);
64 }
65 }
66
67 void Postorder_RBTree_Walk(Tree_t *t, Node_t *x) {
68 if (x != t->NIL) {
69 Postorder_RBTree_Walk(t, x->left);
70 Postorder_RBTree_Walk(t, x->right);
71 printf("[%d, %d] | %d\n", x->intr.low, x->intr.high, x->mmax);
72 }
73 }
74
75 void Inorder_RBTree_Walk_WithColor(Tree_t *t, Node_t *x) {
76 if (x != t->NIL) {
77 Inorder_RBTree_Walk_WithColor(t, x->left);
78 printf("%s: [%d, %d] | %d\n", x->color?"Red":"Black", x->intr.low, x->intr.high, x->mmax);
79 Inorder_RBTree_Walk_WithColor(t, x->right);
80 }
81 }
82
83 void Preorder_RBTree_Walk_WithColor(Tree_t *t, Node_t *x) {
84 if (x != t->NIL) {
85 printf("%s: [%d, %d] | %d\n", x->color?"Red":"Black", x->intr.low, x->intr.high, x->mmax);
86 Preorder_RBTree_Walk_WithColor(t, x->left);
87 Preorder_RBTree_Walk_WithColor(t, x->right);
88 }
89 }
90
91 void Postorder_RBTree_Walk_WithColor(Tree_t *t, Node_t *x) {
92 if (x != t->NIL) {
93 Postorder_RBTree_Walk_WithColor(t, x->left);
94 Postorder_RBTree_Walk_WithColor(t, x->right);
95 printf("%s: [%d, %d] | %d\n", x->color?"Red":"Black", x->intr.low, x->intr.high, x->mmax);
96 }
97 }
98
99 Node_t *RBTree_Minimum(Tree_t *t, Node_t *x) {
100 while (x->left != t->NIL)
101 x = x->left;
102 return x;
103 }
104
105 Node_t *RBTree_Maximum(Tree_t *t, Node_t *x) {
106 while (x->right != t->NIL)
107 x = x->right;
108 return x;
109 }
110
111 bool overlap(interval_t a, interval_t b) {
112 return b.low<=a.high && a.low<=b.high;
113 }
114
115 Node_t *RBTree_Search(Tree_t *t, interval_t intr) {
116 Node_t *x = t->root;
117 while (x!=t->NIL && !overlap(intr, x->intr)) {
118 if (x->left!=t->NIL && x->left->mmax>=intr.low) {
119 x = x->left;
120 } else {
121 x = x->right;
122 }
123 }
124 return x;
125 }
126
127 void Left_Rotate(Tree_t *t, Node_t *x) {
128 Node_t *y = x->right;
129 x->right = y->left;
130 if (y->left != t->NIL)
131 y->left->p = x;
132 y->p = x->p;
133 if (x->p == t->NIL) {
134 // x is root
135 t->root = y;
136 } else if (x == x->p->left) {
137 x->p->left = y;
138 } else {
139 x->p->right = y;
140 }
141 y->left = x;
142 x->p = y;
143 // maintenance attr mmax
144 x->mmax = max(
145 max(x->left->mmax, x->right->mmax), x->intr.high
146 );
147 y->mmax = max(
148 max(y->left->mmax, y->right->mmax), y->intr.high
149 );
150 }
151
152 void Right_Rotate(Tree_t *t, Node_t *y) {
153 Node_t *x = y->left;
154 y->left = x->right;
155 if (x->right != t->NIL)
156 x->right->p = y;
157 x->p = y->p;
158 if (y->p == t->NIL) {
159 // y is root
160 t->root = x;
161 } else if (y == y->p->left) {
162 y->p->left = x;
163 } else {
164 y->p->right = x;
165 }
166 x->right = y;
167 y->p = x;
168 // maintenance attr mmax
169 y->mmax = max(
170 max(y->left->mmax, y->right->mmax), y->intr.high
171 );
172 x->mmax = max(
173 max(x->left->mmax, x->right->mmax), x->intr.high
174 );
175 }
176
177 void RBTree_Transplant(Tree_t *t, Node_t *u, Node_t *v) {
178 if (u->p == t->NIL) {
179 t->root = v;
180 } else if (u == u->p->left) {
181 u->p->left = v;
182 } else {
183 u->p->right = v;
184 }
185 v->p = u->p;
186 }
187
188 void RBTree_Insert_Fixup(Tree_t *t, Node_t *z) {
189 Node_t *y;
190
191 while (z->p->color == RED) {
192 // means z->p->p->color == BLACK
193 if (z->p == z->p->p->left) {
194 y = z->p->p->right;
195 if (y->color == RED) {
196 z->p->color = BLACK;
197 y->color = BLACK;
198 z->p->p->color = RED;
199 z = z->p->p;
200 } else {
201 // y->color is BLACK
202 if (z == z->p->right) {
203 z = z->p;
204 Left_Rotate(t, z);
205 }
206 z->p->color = BLACK; // break later
207 z->p->p->color = RED;
208 Right_Rotate(t, z->p->p);
209 }
210 } else {
211 y = z->p->p->left;
212 if (y->color == RED) {
213 z->p->color = BLACK;
214 y->color = BLACK;
215 z->p->p->color = RED;
216 z = z->p->p;
217 } else {
218 // y->color is BLACK
219 if (z == z->p->left) {
220 z = z->p;
221 Right_Rotate(t, z);
222 }
223 z->p->color = BLACK; // break later
224 z->p->p->color = RED;
225 Left_Rotate(t, z->p->p);
226 }
227 }
228 }
229 t->root->color = BLACK;
230 }
231
232 void RBTree_Insert(Tree_t *t, Node_t *z) {
233 Node_t *y = t->NIL;
234 Node_t *x = t->root;
235 Node_t *q;
236
237 while (x != t->NIL) {
238 y = x;
239 if (z->key < x->key) {
240 x = x->left;
241 } else {
242 x = x->right;
243 }
244 }
245 z->p = y;
246 if (y == t->NIL) {
247 // tree is empty
248 t->root = z;
249 } else if (z->key < y->key) {
250 y->left = z;
251 } else {
252 y->right = z;
253 }
254 z->left = z->right = t->NIL;
255 z->color = RED;
256 // maintence the [mmax] of tree
257 q = z;
258 while (q != t->NIL) {
259 q->mmax = max(
260 max(q->left->mmax, q->right->mmax), q->intr.high
261 );
262 q = q->p;
263 }
264 RBTree_Insert_Fixup(t, z);
265 }
266
267 void RBTree_Delete_Fixup(Tree_t *t, Node_t *x) {
268 Node_t *w;
269
270 while (x!=t->root && x->color==BLACK) {
271 if (x == x->p->left) {
272 w = x->p->right;
273 if (w->color == RED) {
274 w->color = BLACK;
275 x->p->color = RED;
276 Left_Rotate(t, x->p);
277 w = x->p->right;
278 }
279 // means w->color == BLACK
280 if (w->left->color==BLACK && w->right->color==BLACK) {
281 w->color = RED;
282 x = x->p; // fetch the black in w & x and pass it to x->p
283 } else {
284 if (w->right->color == BLACK) {
285 // means w->left->color == RED
286 w->left->color = BLACK;
287 w->color = RED;
288 Right_Rotate(t, w);
289 w = x->p->right;
290 }
291 // means w->right->color == RED && w->left->color == uncertain
292 w->color = x->p->color;
293 x->p->color = BLACK;
294 w->right->color = BLACK;
295 Left_Rotate(t, x->p);
296 x = t->root;
297 }
298 } else {
299 w = x->p->left;
300 if (w->color == RED) {
301 w->color = BLACK;
302 x->p->color = RED;
303 Right_Rotate(t, x->p);
304 w = x->p->left;
305 }
306 // means w->color == BLACK
307 if (w->left->color==BLACK && w->right->color==BLACK) {
308 w->color = RED;
309 x = x->p; // fetch the black in w & x and pass it to x->p
310 } else {
311 if (w->left->color == BLACK) {
312 // means x->right->color == RED
313 w->right->color = BLACK;
314 w->color = RED;
315 Left_Rotate(t, w);
316 w = x->p->left;
317 }
318 // means w->left->color == RED && w->right->color = ANY
319 w->color = x->p->color;
320 x->p->color = BLACK;
321 w->left->color = BLACK;
322 Right_Rotate(t, x->p);
323 x = t->root;
324 }
325 }
326 }
327 x->color = BLACK;
328 }
329
330 void RBTree_Delete(Tree_t *t, Node_t *z) {
331 Node_t *x, *y = z;
332 Node_t *q; // q used to back trace for maintening the [mmax] of Node_t
333 bool y_original_color = y->color;
334
335 if (z->left == t->NIL) {
336 x = z->right;
337 q = y->p;
338 RBTree_Transplant(t, y, x);
339 } else if (z->right == t->NIL) {
340 x = z->left;
341 RBTree_Transplant(t, y, x);
342 q = y->p;
343 } else {
344 y = RBTree_Minimum(t, z->right);
345 y_original_color = y->color;
346 x = y->right;
347 if (y->p == z) {
348 x->p = y;
349 q = y;
350 } else {
351 RBTree_Transplant(t, y, x);
352 q = y->p;
353 y->right = z->right;
354 y->right->p = y;
355 }
356 RBTree_Transplant(t, z, y);
357 y->left = z->left;
358 y->left->p = y;
359 y->color = z->color;
360 }
361
362 // maintence the [size] of Node_t
363 while (q != t->NIL) {
364 q->mmax = max(
365 max(q->left->mmax, q->right->mmax), q->intr.high
366 );
367 q = q->p;
368 }
369
370 if (y_original_color == BLACK)
371 RBTree_Delete_Fixup(t, x); // use x replace y
372 }
373
374 Node_t *RBTree_Search_Min(Tree_t *t, Node_t *z, interval_t intr) {
375 Node_t *x;
376
377 if (z == t->NIL)
378 return t->NIL;
379
380 if (z->left!=t->NIL && z->left->mmax>=intr.low) {
381 x = RBTree_Search_Min(t, z->left, intr);
382 if (x != t->NIL)
383 return x;
384 }
385
386 if (overlap(intr, z->intr))
387 return z;
388
389 if (z->right != t->NIL)
390 return RBTree_Search_Min(t, z->right, intr);
391
392 return t->NIL;
393 }
394
395 void RBTree_Search_All(Tree_t *t, Node_t *z, interval_t intr) {
396 Node_t *x;
397
398 if (z == t->NIL)
399 return ;
400
401 if (z->left!=t->NIL && z->left->mmax>=intr.low) {
402 RBTree_Search_All(t, z->left, intr);
403 }
404
405 if (overlap(intr, z->intr)) {
406 printf("[%d, %d]\n", z->intr.low, z->intr.high);
407 }
408
409 if (z->right!=t->NIL && z->right->mmax>=intr.low) {
410 RBTree_Search_All(t, z->right, intr);
411 }
412 }
413
414 Node_t *RBTree_Seach_Exactly(Tree_t *t, interval_t intr) {
415 Node_t *x = t->root;
416
417 while (x != t->NIL) {
418 if (overlap(intr, x->intr)) {
419 if (intr == x->intr)
420 break;
421 if (x->left!=t->NIL && intr.low<x->key)
422 x = x->left;
423 else
424 x = x->right;
425 } else {
426 if (x->left!=t->NIL && x->left->mmax>=intr.low)
427 x = x->left;
428 else
429 x = x->right;
430 }
431 }
432 return x;
433 }
434
435 int check_BHeight(Tree_t *t, Node_t *x, bool &f) {
436 if (x == t->NIL)
437 return 1;
438 int lBH = check_BHeight(t, x->left, f);
439 int rBH = check_BHeight(t, x->right, f);
440
441 if (f == false)
442 return 0;
443
444 if (lBH != rBH)
445 f = false;
446 if (x->color == BLACK)
447 return lBH+1;
448 return lBH;
449 }
450
451 bool check_RNode(Tree_t *t, Node_t *x) {
452 if (x == t->NIL)
453 return true;
454 if (x->color==RED && (x->left->color!=BLACK || x->right->color!=BLACK)) {
455 return false;
456 }
457 return check_RNode(t, x->left) && check_RNode(t, x->right);
458 }
459
460 bool check_OthAttr(Tree_t *t, Node_t *x) {
461 if (x == t->NIL)
462 return x->mmax == -INF;
463 if (x->intr.high>x->mmax || x->left->mmax>x->mmax || x->right->mmax>x->mmax) {
464 return false;
465 }
466 return check_OthAttr(t, x->left) && check_OthAttr(t, x->right);
467 }
468
469 bool check_RBTree(Tree_t *t) {
470 bool ret;
471
472 if (t->NIL->color != BLACK) {
473 puts("NIL color is not black.");
474 return false;
475 }
476
477 if (t->root == t->NIL)
478 return true;
479
480 if (t->root->color != BLACK) {
481 puts("root color is not black.");
482 return false;
483 }
484
485 if (check_RNode(t, t->root) == false) {
486 puts("color attr is not right.");
487 return false;
488 }
489
490 ret = true;
491 check_BHeight(t, t->root, ret);
492 if (ret == false) {
493 puts("black height is not right.");
494 return false;
495 }
496
497 if (check_OthAttr(t, t->root) == false) {
498 puts("mmax attr is not right.");
499 return false;
500 }
501
502 return true;
503 }
504
505 void init() {
506 int i, j, k;
507 Tree_t *t = new Tree_t();
508 interval_t intrs[10] = {
509 interval_t(16, 21),
510 interval_t(8 , 9 ),
511 interval_t(25, 30),
512 interval_t(5 , 8 ),
513 interval_t(15, 23),
514 interval_t(17, 19),
515 interval_t(26, 26),
516 interval_t(0 , 3 ),
517 interval_t(6 , 10),
518 interval_t(19, 20)
519 };
520 int n = sizeof(intrs) / sizeof(interval_t);
521 Node_t *p;
522
523 printf("n = %d\n", n);
524 for (i=0; i<n; ++i) {
525 p = new Node_t(intrs[i]);
526 printf("key=%d, intr=[%d, %d]\n", p->key, p->intr.low, p->intr.high);
527 RBTree_Insert(t, p);
528 }
529
530 printf("\n\nInorder the tree with color:\n");
531 Inorder_RBTree_Walk_WithColor(t, t->root);
532 if (check_RBTree(t))
533 puts("\nRight");
534 else
535 puts("\nWrong");
536 printf("\n");
537 }
538
539 void check_delete() {
540 int i, j, k;
541 Tree_t *t = new Tree_t();
542 interval_t intrs[10] = {
543 interval_t(16, 21),
544 interval_t(8 , 9 ),
545 interval_t(25, 30),
546 interval_t(5 , 8 ),
547 interval_t(15, 23),
548 interval_t(17, 19),
549 interval_t(26, 26),
550 interval_t(0 , 3 ),
551 interval_t(6 , 10),
552 interval_t(19, 20)
553 };
554 Node_t *nds[10];
555 bool visit[10];
556 int n = sizeof(intrs) / sizeof(interval_t);
557 Node_t *p;
558
559 printf("n = %d\n", n);
560 for (i=0; i<n; ++i) {
561 p = new Node_t(intrs[i]);
562 nds[i] = p;
563 RBTree_Insert(t, p);
564 }
565
566 memset(visit, false, sizeof(visit));
567 for (i=0; i<n; ++i) {
568 while (1) {
569 j = rand()%n;
570 if (!visit[j])
571 break;
572 }
573 visit[j] = true;
574 RBTree_Delete(t, nds[j]);
575 if (check_RBTree(t))
576 puts("Right");
577 else
578 puts("Wrong");
579 }
580 }
581
582 void check_Search() {
583 int i, j, k;
584 Tree_t *t = new Tree_t();
585 interval_t intrs[10] = {
586 interval_t(16, 21),
587 interval_t(8 , 9 ),
588 interval_t(25, 30),
589 interval_t(5 , 8 ),
590 interval_t(15, 23),
591 interval_t(17, 19),
592 interval_t(26, 26),
593 interval_t(0 , 3 ),
594 interval_t(6 , 10),
595 interval_t(19, 20)
596 };
597 int n = sizeof(intrs) / sizeof(interval_t);
598 Node_t *p;
599
600 printf("n = %d\n", n);
601 for (i=0; i<n; ++i) {
602 p = new Node_t(intrs[i]);
603 RBTree_Insert(t, p);
604 }
605
606 interval_t tmp = interval_t(15, 28);
607 // // test 14.3-3
608 // p = RBTree_Search_Min(t, t->root, tmp);
609 // if (p == t->NIL) {
610 // puts("no overlap interval");
611 // } else {
612 // printf("[%d, %d]\n", p->intr.low, p->intr.high);
613 // }
614
615 // // test 14.3-4
616 // RBTree_Search_All(t, t->root, tmp);
617 // test 14.3-5
618 printf("\n\nInorder the tree with color:\n");
619 Inorder_RBTree_Walk_WithColor(t, t->root);
620 printf("\n\nsearch exactly [%d, %d]\n", tmp.low, tmp.high);
621 p = RBTree_Seach_Exactly(t, tmp);
622 if (p == t->NIL)
623 puts("not found such exactly intr");
624 else
625 puts("found a exactly intr");
626 tmp = interval_t(17, 19);
627 printf("\n\nsearch exactly [%d, %d]\n", tmp.low, tmp.high);
628 p = RBTree_Seach_Exactly(t, tmp);
629 if (p == t->NIL)
630 puts("not found such exactly intr");
631 else
632 puts("found a exactly intr");
633 }
634
635 int main() {
636
637 #ifdef LOCAL_DEBUG
638 freopen("data.in", "r", stdin);
639 freopen("data.out", "w", stdout);
640 #endif
641
642 // init();
643 // check_delete();
644 check_Search();
645
646 return 0;
647 }
14.3-1
见区间树源代码。
14.3-2
1 bool overlap(interval_t a, interval_t b) {
2 return b.low<a.high && a.low<b.high; // <= -> <
3 }
4
5 Node_t *RBTree_Search(Tree_t *t, interval_t intr) {
6 Node_t *x = t->root;
7 while (x!=t->NIL && !overlap(intr, x->intr)) {
8 if (x->left!=t->NIL && x->left->mmax>intr.low) { // >= -> >
9 x = x->left;
10 } else {
11 x = x->right;
12 }
13 }
14 return x;
15 }
14.3-3
见区间树源代码RBTree_Search_Min。
14.3-4
见区间树源代码RBTree_Search_All。
14.3-5
见区间树源代码RBTree_Search_Exactly。
14.3-6
在原始红黑树的基础上增加mmax，mmin属性（最大值，最小值）。源代码如下：
1 #include <iostream>
2 #include <cstdio>
3 #include <cstring>
4 #include <cstdlib>
5 #include <algorithm>
6 using namespace std;
7
8 #define LOCAL_DEBUG
9 #define RED true
10 #define BLACK false
11 #define INF 9999999
12
13 typedef struct Node_t {
14 bool color;
15 int key, mmax, mmin;
16 Node_t *p, *left, *right;
17 Node_t() {}
18 Node_t(int kkey) {
19 key = kkey;
20 }
21 } Node_t;
22
23 typedef struct Tree_t {
24 Node_t *NIL;
25 Node_t *root;
26 Tree_t() {
27 NIL = new Node_t();
28 NIL->key = 0;
29 NIL->mmax = -INF;
30 NIL->mmin = INF;
31 NIL->color = BLACK;
32 NIL->p = NIL->left = NIL->right = NIL;
33 root = NIL;
34 }
35 } Tree_t;
36
37 Tree_t *t;
38
39 void Inorder_RBTree_Walk(Tree_t *t, Node_t *x) {
40 if (x != t->NIL) {
41 Inorder_RBTree_Walk(t, x->left);
42 printf("key=%d, mmin=%d, mmax=%d\n", x->key, x->mmin, x->mmax);
43 Inorder_RBTree_Walk(t, x->right);
44 }
45 }
46
47 void Preorder_RBTree_Walk(Tree_t *t, Node_t *x) {
48 if (x != t->NIL) {
49 printf("key=%d, mmin=%d, mmax=%d\n", x->key, x->mmin, x->mmax);
50 Preorder_RBTree_Walk(t, x->left);
51 Preorder_RBTree_Walk(t, x->right);
52 }
53 }
54
55 void Postorder_RBTree_Walk(Tree_t *t, Node_t *x) {
56 if (x != t->NIL) {
57 Postorder_RBTree_Walk(t, x->left);
58 Postorder_RBTree_Walk(t, x->right);
59 printf("key=%d, mmin=%d, mmax=%d\n", x->key, x->mmin, x->mmax);
60 }
61 }
62
63 void Inorder_RBTree_Walk_WithColor(Tree_t *t, Node_t *x) {
64 if (x != t->NIL) {
65 Inorder_RBTree_Walk_WithColor(t, x->left);
66 printf("%s: key=%d, mmin=%d, mmax=%d\n", x->color?"Red":"Black", x->key, x->mmin, x->mmax);
67 Inorder_RBTree_Walk_WithColor(t, x->right);
68 }
69 }
70
71 void Preorder_RBTree_Walk_WithColor(Tree_t *t, Node_t *x) {
72 if (x != t->NIL) {
73 printf("%s: key=%d, mmin=%d, mmax=%d\n", x->color?"Red":"Black", x->key, x->mmin, x->mmax);
74 Preorder_RBTree_Walk_WithColor(t, x->left);
75 Preorder_RBTree_Walk_WithColor(t, x->right);
76 }
77 }
78
79 void Postorder_RBTree_Walk_WithColor(Tree_t *t, Node_t *x) {
80 if (x != t->NIL) {
81 Postorder_RBTree_Walk_WithColor(t, x->left);
82 Postorder_RBTree_Walk_WithColor(t, x->right);
83 printf("%s: key=%d, mmin=%d, mmax=%d\n", x->color?"Red":"Black", x->key, x->mmin, x->mmax);
84 }
85 }
86
87 Node_t *RBTree_Minimum(Tree_t *t, Node_t *x) {
88 while (x->left != t->NIL)
89 x = x->left;
90 return x;
91 }
92
93 Node_t *RBTree_Maximum(Tree_t *t, Node_t *x) {
94 while (x->right != t->NIL)
95 x = x->right;
96 return x;
97 }
98
99 Node_t *RBTree_Search(Tree_t *t, int key) {
100 Node_t *x = t->root;
101 while (x!=t->NIL && x->key!=key) {
102 if (key < x->key) {
103 x = x->left;
104 } else {
105 x = x->right;
106 }
107 }
108 return x;
109 }
110
111 void Left_Rotate(Tree_t *t, Node_t *x) {
112 Node_t *y = x->right;
113 x->right = y->left;
114 if (y->left != t->NIL)
115 y->left->p = x;
116 y->p = x->p;
117 if (x->p == t->NIL) {
118 // x is root
119 t->root = y;
120 } else if (x == x->p->left) {
121 x->p->left = y;
122 } else {
123 x->p->right = y;
124 }
125 y->left = x;
126 x->p = y;
127 // maintenance attr mmax & mmin
128 y->mmin = x->mmin;
129 x->mmax = max(x->key, x->right->mmax);
130 }
131
132 void Right_Rotate(Tree_t *t, Node_t *y) {
133 Node_t *x = y->left;
134 y->left = x->right;
135 if (x->right != t->NIL)
136 x->right->p = y;
137 x->p = y->p;
138 if (y->p == t->NIL) {
139 // y is root
140 t->root = x;
141 } else if (y == y->p->left) {
142 y->p->left = x;
143 } else {
144 y->p->right = x;
145 }
146 x->right = y;
147 y->p = x;
148 // maintenance attr mmax & mmin
149 x->mmax = y->mmax;
150 y->mmin = min(y->key, y->left->mmin);
151 }
152
153 void RBTree_Transplant(Tree_t *t, Node_t *u, Node_t *v) {
154 if (u->p == t->NIL) {
155 t->root = v;
156 } else if (u == u->p->left) {
157 u->p->left = v;
158 } else {
159 u->p->right = v;
160 }
161 v->p = u->p;
162 }
163
164 void RBTree_Insert_Fixup(Tree_t *t, Node_t *z) {
165 Node_t *y;
166
167 while (z->p->color == RED) {
168 // means z->p->p->color == BLACK
169 if (z->p == z->p->p->left) {
170 y = z->p->p->right;
171 if (y->color == RED) {
172 z->p->color = BLACK;
173 y->color = BLACK;
174 z->p->p->color = RED;
175 z = z->p->p;
176 } else {
177 // y->color is BLACK
178 if (z == z->p->right) {
179 z = z->p;
180 Left_Rotate(t, z);
181 }
182 z->p->color = BLACK; // break later
183 z->p->p->color = RED;
184 Right_Rotate(t, z->p->p);
185 }
186 } else {
187 y = z->p->p->left;
188 if (y->color == RED) {
189 z->p->color = BLACK;
190 y->color = BLACK;
191 z->p->p->color = RED;
192 z = z->p->p;
193 } else {
194 // y->color is BLACK
195 if (z == z->p->left) {
196 z = z->p;
197 Right_Rotate(t, z);
198 }
199 z->p->color = BLACK; // break later
200 z->p->p->color = RED;
201 Left_Rotate(t, z->p->p);
202 }
203 }
204 }
205 t->root->color = BLACK;
206 }
207
208 void RBTree_Insert(Tree_t *t, Node_t *z) {
209 Node_t *y = t->NIL;
210 Node_t *x = t->root;
211 Node_t *q;
212
213 while (x != t->NIL) {
214 y = x;
215 if (z->key < x->key) {
216 x = x->left;
217 } else {
218 x = x->right;
219 }
220 }
221 z->p = y;
222 if (y == t->NIL) {
223 // tree is empty
224 t->root = z;
225 } else if (z->key < y->key) {
226 y->left = z;
227 } else {
228 y->right = z;
229 }
230 z->left = z->right = t->NIL;
231 z->color = RED;
232 // maintence the [mmax] of tree
233 q = z;
234 while (q != t->NIL) {
235 q->mmax = max(q->right->mmax, q->key);
236 q->mmin = min(q->left->mmin, q->key);
237 q = q->p;
238 }
239 RBTree_Insert_Fixup(t, z);
240 }
241
242 void RBTree_Delete_Fixup(Tree_t *t, Node_t *x) {
243 Node_t *w;
244
245 while (x!=t->root && x->color==BLACK) {
246 if (x == x->p->left) {
247 w = x->p->right;
248 if (w->color == RED) {
249 w->color = BLACK;
250 x->p->color = RED;
251 Left_Rotate(t, x->p);
252 w = x->p->right;
253 }
254 // means w->color == BLACK
255 if (w->left->color==BLACK && w->right->color==BLACK) {
256 w->color = RED;
257 x = x->p; // fetch the black in w & x and pass it to x->p
258 } else {
259 if (w->right->color == BLACK) {
260 // means w->left->color == RED
261 w->left->color = BLACK;
262 w->color = RED;
263 Right_Rotate(t, w);
264 w = x->p->right;
265 }
266 // means w->right->color == RED && w->left->color == uncertain
267 w->color = x->p->color;
268 x->p->color = BLACK;
269 w->right->color = BLACK;
270 Left_Rotate(t, x->p);
271 x = t->root;
272 }
273 } else {
274 w = x->p->left;
275 if (w->color == RED) {
276 w->color = BLACK;
277 x->p->color = RED;
278 Right_Rotate(t, x->p);
279 w = x->p->left;
280 }
281 // means w->color == BLACK
282 if (w->left->color==BLACK && w->right->color==BLACK) {
283 w->color = RED;
284 x = x->p; // fetch the black in w & x and pass it to x->p
285 } else {
286 if (w->left->color == BLACK) {
287 // means x->right->color == RED
288 w->right->color = BLACK;
289 w->color = RED;
290 Left_Rotate(t, w);
291 w = x->p->left;
292 }
293 // means w->left->color == RED && w->right->color = ANY
294 w->color = x->p->color;
295 x->p->color = BLACK;
296 w->left->color = BLACK;
297 Right_Rotate(t, x->p);
298 x = t->root;
299 }
300 }
301 }
302 x->color = BLACK;
303 }
304
305 void RBTree_Delete(Tree_t *t, Node_t *z) {
306 Node_t *x, *y = z;
307 Node_t *q; // q used to back trace for maintening the [mmax] of Node_t
308 bool y_original_color = y->color;
309
310 if (z->left == t->NIL) {
311 x = z->right;
312 q = y->p;
313 RBTree_Transplant(t, y, x);
314 } else if (z->right == t->NIL) {
315 x = z->left;
316 RBTree_Transplant(t, y, x);
317 q = y->p;
318 } else {
319 y = RBTree_Minimum(t, z->right);
320 y_original_color = y->color;
321 x = y->right;
322 if (y->p == z) {
323 x->p = y;
324 q = y;
325 } else {
326 RBTree_Transplant(t, y, x);
327 q = y->p;
328 y->right = z->right;
329 y->right->p = y;
330 }
331 RBTree_Transplant(t, z, y);
332 y->left = z->left;
333 y->left->p = y;
334 y->color = z->color;
335 }
336
337 // maintence the [size] of Node_t
338 while (q != t->NIL) {
339 q->mmax = max(q->right->mmax, q->key);
340 q->mmin = min(q->left->mmin, q->key);
341 q = q->p;
342 }
343
344 if (y_original_color == BLACK)
345 RBTree_Delete_Fixup(t, x); // use x replace y
346 }
347
348 int Min_Gap(Tree_t *t, Node_t *x) {
349 if (x == t->NIL)
350 return INF;
351 int lgap = Min_Gap(t, x->left);
352 int rgap = Min_Gap(t, x->right);
353 int gap;
354 if (x->right->mmin == INF)
355 gap = x->key - x->left->mmax;
356 else
357 gap = min(
358 x->key - x->left->mmax, x->right->mmin - x->key
359 );
360 int ret = min(
361 min(lgap, rgap), gap
362 );
363
364 return ret;
365 }
366
367 int check_BHeight(Tree_t *t, Node_t *x, bool &f) {
368 if (x == t->NIL)
369 return 1;
370 int lBH = check_BHeight(t, x->left, f);
371 int rBH = check_BHeight(t, x->right, f);
372
373 if (f == false)
374 return 0;
375
376 if (lBH != rBH)
377 f = false;
378 if (x->color == BLACK)
379 return lBH+1;
380 return lBH;
381 }
382
383 bool check_RNode(Tree_t *t, Node_t *x) {
384 if (x == t->NIL)
385 return true;
386 if (x->color==RED && (x->left->color!=BLACK || x->right->color!=BLACK)) {
387 return false;
388 }
389 return check_RNode(t, x->left) && check_RNode(t, x->right);
390 }
391
392 bool check_OthAttr(Tree_t *t, Node_t *x) {
393 if (x == t->NIL)
394 return x->mmax==-INF && x->mmin==INF;
395 Node_t *p = RBTree_Minimum(t, x);
396 Node_t *q = RBTree_Maximum(t, x);
397
398 return p->key==x->mmin && q->key==x->mmax && check_OthAttr(t, x->left) && check_OthAttr(t, x->right);
399 }
400
401 bool check_RBTree(Tree_t *t) {
402 bool ret;
403
404 if (t->NIL->color != BLACK) {
405 puts("NIL color is not black.");
406 return false;
407 }
408
409 if (t->root == t->NIL)
410 return true;
411
412 if (t->root->color != BLACK) {
413 puts("root color is not black.");
414 return false;
415 }
416
417 if (check_RNode(t, t->root) == false) {
418 puts("color attr is not right.");
419 return false;
420 }
421
422 ret = true;
423 check_BHeight(t, t->root, ret);
424 if (ret == false) {
425 puts("black height is not right.");
426 return false;
427 }
428
429 if (check_OthAttr(t, t->root) == false) {
430 puts("mmax/mmin attr is not right.");
431 return false;
432 }
433
434 return true;
435 }
436
437 void init() {
438 int i, j, k, tmp;
439 int gap;
440 Tree_t *t = new Tree_t();
441 int a[] = {26, 17, 41, 14, 21, 30, 47, 10, 16, 19, 23, 28, 38, 7, 12, 15, 20, 35, 39, 3};
442 int n = sizeof(a) / sizeof(int);
443 Node_t *p;
444
445 printf("n = %d\n", n);
446 for (i=0; i<n; ++i) {
447 p = new Node_t(a[i]);
448 RBTree_Insert(t, p);
449 }
450
451 printf("\n\nInorder the tree with color:\n");
452 Inorder_RBTree_Walk_WithColor(t, t->root);
453 if (check_RBTree(t))
454 puts("\nRight");
455 else
456 puts("\nWrong");
457 printf("\n");
458
459 gap = Min_Gap(t, t->root);
460 sort(a, a+n);
461 k = INF;
462 for (i=1; i<n; ++i) {
463 tmp = a[i] - a[i-1];
464 k = min(tmp, k);
465 }
466 printf("gap = %d, Min_gap = %d\n", k, gap);
467 }
468
469 int cal_Gap(int *a, bool *visit, int n) {
470 int b[30], m = 0;
471 int i, j, k;
472
473 for (i=0; i<n; ++i)
474 if (!visit[i])
475 b[m++] = a[i];
476
477 sort(b, b+m);
478 k = INF;
479 for (i=1; i<m; ++i) {
480 j = b[i] - b[i-1];
481 k = min(j, k);
482 }
483 return k;
484 }
485
486 void check_delete() {
487 int i, j, k, tmp;
488 int gap;
489 Tree_t *t = new Tree_t();
490 int a[] = {26, 17, 41, 14, 21, 30, 47, 10, 16, 19, 23, 28, 38, 7, 12, 15, 20, 35, 39, 3};
491 int n = sizeof(a) / sizeof(int);
492 bool visit[30];
493 Node_t *p;
494
495 printf("n = %d\n", n);
496 for (i=0; i<n; ++i) {
497 p = new Node_t(a[i]);
498 RBTree_Insert(t, p);
499 }
500
501 // Inorder_RBTree_Walk_WithColor(t, t->root);
502 // puts("");
503
504 memset(visit, false, sizeof(visit));
505 for (i=1; i<n; ++i) {
506 while (1) {
507 j = rand()%n;
508 if (!visit[j])
509 break;
510 }
511 visit[j] = true;
512 p = RBTree_Search(t, a[j]);
513 RBTree_Delete(t, p);
514 // Inorder_RBTree_Walk_WithColor(t, t->root);
515 if (check_RBTree(t))
516 puts("Right");
517 else
518 puts("Wrong");
519 gap = Min_Gap(t, t->root);
520 k = cal_Gap(a, visit, n);
521 printf("delete = %d, gap = %d, Min_gap = %d\n\n", a[j], k, gap);
522 }
523 }
524
525 int main() {
526
527 #ifdef LOCAL_DEBUG
528 freopen("data.in", "r", stdin);
529 freopen("data.out", "w", stdout);
530 #endif
531
532 // init();
533 check_delete();
534
535 return 0;
536 }
时间： 2024-10-09 05:23:00