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 }