1 import java.util.Random;
2
3
4 public class RBTree
5 {
6
7 private Node root;
8
9
10 public RBTree(int[] array)
11 {
12 for (int i : array) insert(i);
13 }
14
15 private Node search(int key, Node node)
16 {
17 if (node == null) return null;
18 int compare = compare(key, node.key);
19
20 if (compare == 0) return node;
21 if (compare > 0)
22 return search(key, node.right);
23 else
24 return search (key, node.left);
25 }
26
27 /*
28 * 插入节点
29 */
30 public boolean insert(int key)
31 {
32 Node node = new Node(key);
33 node.color = 'R';
34
35 Node parent = null, current = root;
36 int compare = 0;
37
38 /*
39 * 寻找插入节点的父节点
40 */
41 while (current != null) {
42 parent = current;
43 compare = compare(key, current.key);
44
45 if (compare == 0) return false;
46
47 if (compare == 1)
48 current = current.right;
49 else
50 current = current.left;
51 }
52
53 // 添加新节点
54 if (parent == null) {
55 root = node;
56 }
57 else {
58 node.parent = parent;
59 if (compare == 1) {
60 parent.right = node;
61 }
62 else {
63 parent.left = node;
64 }
65 }
66
67 insertFixup(node);
68 return true;
69 }
70
71 private void insertFixup(Node node)
72 {
73 while (node != root && node.parent.color == 'R') {
74 // 父节点为祖父节点的左节点
75 if (node.parent == node.parent.parent.left) {
76 Node uncle = node.parent.parent.right;
77 /*
78 * 父节点与叔叔节点都是红色
79 * 将父节点与叔叔节点变成黑色
80 * 将祖父节点变成红色
81 * 当前节点指向组父节点
82 */
83 if (uncle != null && uncle.color == 'R') {
84 node.parent.color = 'B';
85 uncle.color = 'B';
86 uncle.parent.color = 'R';
87 node = node.parent.parent;
88 }
89 else {
90 /*
91 * 叔叔节点是黑色且node为右孩子
92 * 当前结点指向父节点
93 * 以当前结点为中心左旋
94 */
95 if (node == node.parent.right) {
96 node = node.parent;
97 leftRotate(node);
98 }
99
100 /*
101 * 叔叔节点是黑色且node为左孩子
102 * 父节点变为黑色，组父节点变为红色
103 * 以祖父节点为中心右旋
104 */
105 node.parent.color = 'B';
106 node.parent.parent.color = 'R';
107 rightRotate(node.parent.parent);
108 }
109 }
110 else {
111 // 父节点为祖父节点的右节点
112 Node uncle = node.parent.parent.left;
113
114 // 操作与上面相反
115 if (uncle != null && uncle.color == 'R') {
116 node.parent.color = 'B';
117 uncle.color = 'B';
118 uncle.parent.color = 'R';
119 node = node.parent.parent;
120 }
121 else {
122 if (node == node.parent.left) {
123 node = node.parent;
124 rightRotate(node);
125 }
126 node.parent.color = 'B';
127 node.parent.parent.color = 'R';
128 leftRotate(node.parent.parent);
129 }
130 }
131 }
132 root.color = 'B';
133 }
134
135 private void deleteFixup(Node node)
136 {
137 if (node == null) return;
138
139 while (node != root && node.color == 'B') {
140 // node为父节点的左子节点
141 if (node == node.parent.left) {
142 Node sibling = node.parent.right;
143
144 /*
145 * 当前结点为黑色且兄弟节点为红色
146 * 将父节点染成红色,兄弟节点染成黑色
147 * 针对父节点最一次左旋
148 */
149 if (sibling.color == 'R') {
150 sibling.color = 'B';
151 sibling.parent.color = 'R';
152 leftRotate(node.parent);
153 sibling = node.parent.right;
154 }
155
156 /*
157 * 当前结点和兄弟节点为黑色,兄弟节点的子节点都为黑色
158 * 将当前节点和兄弟节点抽出一重黑色加到父节点上
159 * 把父节点当成新的节点继续计算
160 */
161 if (sibling.left.color == 'B'
162 && sibling.right.color == 'B')
163 {
164 sibling.color = 'R';
165 node = node.parent;
166 }
167 else {
168 /*
169 * 当前节点和兄弟节点为黑色,兄弟的左子节点为红色
170 * 把兄弟节点染红,兄弟左子节点染黑
171 * 以兄弟节点位置点右旋
172 */
173 if (sibling.right.color == 'B') {
174 sibling.left.color = 'B';
175 sibling.color = 'R';
176 rightRotate(sibling);
177 sibling = node.parent.right;
178 }
179
180 /*
181 * 当前结点和兄弟节点为黑色,兄弟右子节点为红色
182 * 把兄弟节点染成当前结点的父节点的颜色
183 * 将当前节点的父节点染成黑色
184 * 兄弟节点有子节点染成黑色
185 * 以当前节点的父节点为支点左旋
186 */
187 sibling.color = node.parent.color;
188 node.parent.color = 'B';
189 sibling.right.color = 'B';
190 leftRotate(node.parent);
191 node = root;
192 }
193 }
194 // node为父节点的右子节点
195 else {
196 Node sibling = node.parent.left;
197
198 /*
199 * 当前结点为黑色，兄弟节点为红色
200 * 将兄弟节点染成黑色
201 * 当前结点的父节点染成红色
202 * 以当前节点的父节点进行右旋
203 */
204 if (sibling.color == 'R') {
205 sibling.color = 'B';
206 sibling.parent.color = 'R';
207 rightRotate(node.parent);
208 sibling = node.parent.left;
209 }
210
211 /*
212 * 当前结点和兄弟节点为黑色
213 * 把当前结点和兄弟节点抽取一重黑色到父节点上
214 * 把当前节点当作新的节点重新计算
215 */
216 if (sibling.left.color == 'B' && sibling.right.color == 'B') {
217 sibling.color = 'R';
218 sibling.parent.color = 'B';
219 node = node.parent;
220 }
221 else {
222 /*
223 * 当前结点和兄弟节点为黑色,兄弟的右子节点为红色
224 * 把兄弟节点染红,兄弟的左子节点染黑
225 * 以兄弟节点为支点左旋
226 */
227 if (sibling.left.color == 'B') {
228 sibling.color = 'R';
229 sibling.right.color = 'B';
230 leftRotate(sibling);
231 sibling = node.parent.left;
232 }
233
234 /*
235 * 当前结点和兄弟节点为黑色,兄弟的右子节点为黑色
236 * 将兄弟节点染成当前结点的父节点的颜色
237 * 当前节点的父节点染黑
238 * 以当前结点的父节点为支点进行右旋
239 */
240 sibling.color = node.parent.color;
241 node.parent.color = 'B';
242 sibling.left.color = 'B';
243 rightRotate(node.parent);
244 node = root;
245 }
246 }
247 }
248 node.color = 'B';
249 }
250
251 /*
252 * 删除节点
253 * 只会在只有一个子节点的节点上进行
254 */
255 public void delete(int key)
256 {
257 Node node = search(key, root);
258 if (node == null) return;
259
260 Node delete, child = null;
261
262 // 如果有两个子节点则删除是其节点后继节点
263 if (node.left == null || node.right == null) {
264 delete = node;
265 }
266 else {
267 delete = interval(node);
268 }
269
270 // 如国有子节点则判断是那个子节点
271 if (delete.left != null || delete.right != null) {
272 if (delete.left != null)
273 child = delete.left;
274 else
275 child = delete.right;
276
277 child.parent = delete.parent;
278 }
279
280 // 清除删除节点的引用
281 if (delete.parent == null) {
282 root = child;
283 }
284 else {
285 if (delete == delete.parent.left)
286 delete.parent.left = child;
287 else
288 delete.parent.right = child;
289 }
290
291 // 如果删除的是后继节点则将当前其值赋给当前结点
292 if (delete != node) {
293 node.key = delete.key;
294 }
295
296 // 调整红黑树平衡
297 if (delete.color == 'B')
298 deleteFixup(child);
299 }
300
301 private void leftRotate(Node node)
302 {
303 /*
304 * 左旋
305 * P P
306 * / \ / \
307 * @ d y d
308 * / \ --> / \
309 * a y @ c
310 * / \ / \
311 * b c a b
312 */
313
314 Node right = node.right;
315 node.right = right.left;
316
317 if (node.right != null) {
318 node.right.parent = node;
319 }
320
321 right.parent = node.parent;
322 if (right.parent == null) {
323 root = right;
324 }
325 else {
326 if (node == node.parent.left)
327 node.parent.left = right;
328 else
329 node.parent.right = right;
330 }
331
332 right.left = node;
333 node.parent = right;
334 }
335
336 private void rightRotate(Node node)
337 {
338 /*
339 * 右旋
340 * P P
341 * / \ / \
342 * d @ d y
343 * / \ --> / \
344 * y a b @
345 * / \ / \
346 * b c c a
347 */
348
349 Node left = node.left;
350 node.left = left.right;
351
352 if (node.left != null) {
353 node.left.parent = node;
354 }
355
356 left.parent = node.parent;
357 if (left.parent == null) {
358 root = left;
359 }
360 else {
361 if (node == node.parent.left)
362 node.parent.left = left;
363 else
364 node.parent.right = left;
365 }
366
367 left.right = node;
368 node.parent = left;
369 }
370
371 /*
372 * 最小值想做遍历寻找
373 */
374 private Node min(Node node)
375 {
376 while (node.left != null) {
377 node = node.left;
378 }
379 return node;
380 }
381
382 /*
383 * 最大值向右遍历寻找
384 */
385 private Node max(Node node)
386 {
387 while (node.right != null) {
388 node = node.right;
389 }
390 return node;
391 }
392
393 /*
394 * 查找直接后继节点
395 */
396 private Node interval(Node node)
397 {
398 /*
399 * 如果有右子节点则在右子节点中寻找
400 * 否则查找父节点为左子节点的节点作为后继节点
401 */
402 if (node.right != null)
403 return min(node.right);
404 else {
405 Node parent = node.parent;
406 while (parent != null && node == parent.right) {
407 node = parent;
408 parent = node.parent;
409 }
410 return parent;
411 }
412 }
413
414 /*
415 * 比较大小
416 */
417 private int compare(int a, int b)
418 {
419 return a > b ? 1 : a < b ? -1 : 0;
420 }
421
422 /*
423 * 前序遍历
424 */
425 public void preOrder()
426 {
427 preOrder(root);
428 }
429
430 private void preOrder(Node node)
431 {
432 if (node == null) return;
433
434 System.out.println(node.key + " " + node.color);
435 preOrder(node.left);
436 preOrder(node.right);
437 }
438
439 /*
440 * 后续遍历
441 */
442 public void postOrder()
443 {
444 postOrder(root);
445 }
446
447 private void postOrder(Node node)
448 {
449 if (node == null) return;
450
451 postOrder(node.left);
452 postOrder(node.right);
453 System.out.println(node.key + " " + node.color);
454 }
455
456 /*
457 * 中序遍历
458 */
459 public void inOrder()
460 {
461 inOrder(root);
462 }
463
464 private void inOrder(Node node)
465 {
466 if (node == null) return;
467
468 inOrder(node.left);
469 System.out.println(node.key + " " + node.color);
470 inOrder(node.right);
471 }
472
473 static class Node
474 {
475 Node parent;
476 Node left;
477 Node right;
478 char color = 'B';
479 int key;
480
481 public Node(int key)
482 {
483 this.key = key;
484 }
485
486 public Node(char color)
487 {
488 this.color = color;
489 this.key = -Integer.MIN_VALUE;
490 }
491 }
492
493 public static void main(String[] args)
494 {
495 int[] array = new int[20];
496
497 Random rond = new Random();
498 for (int i = 0; i < array.length; i++) {
499 array[i] = Math.abs(rond.nextInt()) % 40;
500 }
501
502 RBTree tree = new RBTree(array);
503 //tree.preOrder();
504 tree.inOrder();
505
506 System.out.println();
507 System.out.println("delete " + array[6]);
508 System.out.println();
509
510 tree.delete(array[6]);
511 //tree.preOrder();
512 tree.inOrder();
513 }
514 }
浙公网安备 33010602011771号