先来讲讲什么是二叉搜索树，二叉搜索树有如下特点：他是以一颗二叉树（最多有两个子结点）来组织的，对于树中的某个节点，其左子树的所有元素均小于该节点，其右子树的元素均大于该节点。我们知道一颗有N个节点的二叉树的高度至少为lgN，然后在树上的操作都与其高度有关，因此限制树的高度就显得非常有必要。当一个二叉搜索树的高度是lgN时，在该树上的插入删除搜索等操作均为O（lgN）的时间复杂度，但当二叉搜索树不小心插入成了链表，高度为N的时候，在树上的操作就变为O（N）了。因此我们有许多种平衡二叉树通过特定的方法来限制树的高度，红黑树就是其中的一种。红黑树（Red Black Tree） 是一种自平衡二叉查找树，是在计算机科学中用到的一种数据结构，它在每个节点上增加了一个存储位来表示节点的颜色，可以为红色或黑色。通过对任何一条从根到叶子的简单路径上各个节点的颜色进行约束，红黑树确保没有一条路径会比其他路径长出2倍，因此是近似于平衡的。

一颗红黑树是满足以下红黑性质的二叉搜索树：

1. 每个节点是红色或黑色
2. 根是黑色
3. 叶节点（null）是黑色的
4. 红色的节点的两个子结点均为黑色
5. 对于每个节点，从该节点到其所有后代的简单路径上，均包含相同数目的黑色节点（我们把到叶节点的黑色节点数称为黑高）

1. // 颜色枚举
2. enum RBColor {
3. RED, BLACK;
4. }
5. // 树节点类
6. class RBTreeNode {
7. RBTreeNode p = nullNode;    // 父节点
8. RBTreeNode left = nullNode; // 左子节点
9. RBTreeNode right = nullNode;    // 右子节点
10. int val;    // 值
11. RBColor color;  // 颜色
12. public RBTreeNode() {};
13. RBTreeNode(int val) {
14. this.val = val;
15. }
16. @Override
17. public String toString() {
18. return " (" + val + " " +  color + ") ";
19. }
20. // 用于表示空叶节点的静态变量
21. public static RBTreeNode nullNode = new RBTreeNode() {
22. {
23. color = RBColor.BLACK; // 叶结点为黑色
24. }
25. @Override
26. public String toString() {
27. return " (null " +  color + ") ";
28. }
29. };
30. }

3.旋转

4.插入

终于来到红黑树的第一个关键步骤了：插入操作。

对与插入操作我们利用如下思想解决：我们先把红黑树看成一个普通的二叉搜索树，对其进行插入操作，插入完成后，我们把新加入的节点染成红色，此时红黑树的红黑性质被破坏，然后再通过特定的方法来维护红黑树的性质。

插入的Java代码如下：

1. /**
2. * 红黑树插入操作
3. * @param root 根结点引用
4. * @param insertNode 要插入的新节点
5. * @return 根节点
6. */
7. public static RBTreeNode rbInsert(RBTreeNode root, RBTreeNode insertNode) {
8. RBTreeNode position = root, parent = RBTreeNode.nullNode; // position为插入位置，parent为该位置的父节点
9. while (position != RBTreeNode.nullNode) {
10. parent = position;
11. if (insertNode.val < position.val) // 比该节点元素小的节点应该插入其左子树
12. position = position.left;
13. else // 比该节点元素大的节点应该插入其右子树
14. position = position.right;
15. }
16. insertNode.p = parent;
17. if (parent == RBTreeNode.nullNode) // 没有父节点的节点为根结点
18. root = insertNode;
19. else if (insertNode.val < parent.val) // 插入为左节点
20. parent.left = insertNode;
21. else // 插入为右节点
22. parent.right = insertNode;
23. insertNode.color = RBColor.RED; // 把新插入的节点染成红色
24. return rbInsertFixup(root, insertNode); // 修复插入时红黑树性质
25. }

好，终于来到重点了，红黑树的插入操作前半部分与一般二叉搜索树别无二致，区别在于最后把新加入的节点染成红色和恢复红黑树性质的部分。我们先来思考一下往红黑树插入一个红节点会破坏红黑树的什么性质？首先性质1、3、5是不会受影响的，那么当我们插入的节点是红黑树的根结点时会影响性质2，根节点变成了红色，此时我们把根节点染成黑色即可。当我们插入节点的父节点是红色时会影响性质4，红色节点有一个为红色的子结点。对于以上这些影响我们分为3种情况来处理：

关键词：叔节点

情况1：插入节点z的叔节点y为红色

情况2：插入节点z的叔节点y是黑色的，且z是一个右孩子

情况3：插入节点z的叔节点y是黑色的，且z是一个左孩子

左上角为情况2，此时叔节点w为黑色，且插入节点z为父节点x的右孩子，此时我们对父节点x进行一次左旋，然后交换x和z的引用，即可转换为右上角的情况3.

右上角为情况3，此时叔节点w为黑色，且插入节点z为父节点x的左孩子，此时我们进行如下操作即可恢复红黑树的性质：

1. 交换父节点x和祖父节点w的颜色
2. 对祖父节点w进行右旋

下面给出红黑树插入时性质修复的Java代码：

1. /**
2. * 修復插入時违反的红黑树性质
3. * @param root 根节点引用
4. * @param node 修复节点
5. * @return 根节点
6. */
7. public static RBTreeNode rbInsertFixup(RBTreeNode root, RBTreeNode node) {
8. // 修复节点不是根节点且为红色时
9. RBTreeNode parent = node.p, grandParent, parentBorther;
10. while(parent != RBTreeNode.nullNode && parent.color == RBColor.RED) {
11. grandParent = parent.p;
12. if (grandParent.left == parent) { // 父节点为左节点
13. parentBorther = grandParent.right; // 叔节点为右节点
14. if (parentBorther != RBTreeNode.nullNode && parentBorther.color == RBColor.RED) { // case 1
15. grandParent.color = RBColor.RED; // 祖父节点改为红色
16. parent.color = RBColor.BLACK; // 父节点和叔节点改为黑色
17. parentBorther.color = RBColor.BLACK;
18. node = grandParent; // 对祖父节点继续遍历
19. } else {
20. if (parent.right == node) { // case 2
21. root = leftRotate(root, parent); // 对父节点左旋
22. // 交换node和parent的引用
23. RBTreeNode temp = node;
24. node = parent;
25. parent = temp;
26. }
27. // case 3
28. grandParent.color = RBColor.RED; // 祖父染成红色
29. parent.color = RBColor.BLACK; // 父节点染成黑色
30. root = rightRotate(root, grandParent); // 对祖父右旋
31. node = root; // 把节点置为根节点退出修复
32. }
33. } else { // 父节点为右节点，镜像处理
34. parentBorther = grandParent.left;
35. if (parentBorther != RBTreeNode.nullNode && parentBorther.color == RBColor.RED) { // case 1
36. grandParent.color = RBColor.RED;
37. parent.color = RBColor.BLACK;
38. parentBorther.color = RBColor.BLACK;
39. node = grandParent;
40. } else {
41. if (parent.left == node) { // case 2
42. root = rightRotate(root, parent);
43. RBTreeNode temp = node;
44. node = parent;
45. parent = temp;
46. }
47. // case 3
48. grandParent.color = RBColor.RED;
49. parent.color = RBColor.BLACK;
50. root = leftRotate(root, grandParent);
51. node = root;
52. }
53. }
54. parent = node.p;
55. }
56. // 根节点染为黑色
57. root.color = RBColor.BLACK;
58. return root;
59. }

5.删除

讲完插入，我们来讲讲删除操作。与插入类似，再删除前我们先把红黑树当成是一颗普通的二叉搜索树来处理删除节点的操作。但在把节点删除过后，由于删除节点会带走一种颜色，因此我们需要记录下被删除的颜色和删除颜色的位置，最后我们再考虑如何修复树的红黑性质。二叉搜索树删除节点分为三种情况，这里简单提一下：

1. 删除节点没有子节点：直接把删除节点的位置置空即可
2. 删除节点有一个子节点：用该子节点顶替删除节点的位置
3. 删除节点有两个子节点：这是比较复杂的情况，此时我们要从删除节点的两边子树中寻找一个节点来顶替其位置，我们可以找右子树的最小节点或左子树的最大节点，本文给出的代码为寻找右子树的最小节点。同时在代码中我们把删除节点的颜色赋给顶替节点，从而使实际删除颜色的节点为顶替节点。

1. /**
2. * 红黑树删除操作
3. * @param root 根节点引用
4. * @param deleteNode 要删除的节点
5. * @return 根节点
6. */
7. public static RBTreeNode rbDelete(RBTreeNode root, RBTreeNode deleteNode) {
8. RBTreeNode replaceNode, fixNode = RBTreeNode.nullNode; // 顶替删除节点的代替节点、需要修复颜色的节点位置
9. RBTreeNode fixNodeParent = deleteNode.p;
10. RBColor deleteColor = deleteNode.color; // 记录被删除节点的颜色
11. if (deleteNode.left == RBTreeNode.nullNode && deleteNode.right == RBTreeNode.nullNode) // 删除节点没有任何子结点
12. replaceNode = RBTreeNode.nullNode;
13. else if (deleteNode.right == RBTreeNode.nullNode) { // 处理只有左子节点的情况
14. replaceNode = deleteNode.left;
15. fixNode = replaceNode;
16. } else if (deleteNode.left == RBTreeNode.nullNode) { //处理只有右子节点的情况
17. replaceNode = deleteNode.right;
18. fixNode = replaceNode;
19. } else { // 处理有两个子节点的情况
20. replaceNode = deleteNode.right;
21. while (replaceNode.left != RBTreeNode.nullNode) // 找到右子树的最小节点
22. replaceNode = replaceNode.left;
23. fixNode = replaceNode.right; // 修复节点位置变为原顶替节点位置
24. if (replaceNode.p == deleteNode) { // 特殊情况，右子树没有左节点
25. if (fixNode != RBTreeNode.nullNode) // 修复节点不为空
26. fixNode.p = replaceNode;
27. fixNodeParent = replaceNode;
28. } else {
29. replaceNode.p.left = fixNode; // 修复节点顶替该节点的位置
30. if (fixNode != RBTreeNode.nullNode) // 修复节点不为空
31. fixNode.p = replaceNode.p;
32. fixNodeParent = replaceNode.p;
33. replaceNode.right = deleteNode.right;
34. }
35. // 用删除节点的颜色代替顶替节点的颜色，使得被删除颜色的节点实际变为顶替节点
36. deleteColor = replaceNode.color;
37. replaceNode.color = deleteNode.color;
38. replaceNode.left = deleteNode.left;
39. }
40. if (replaceNode != RBTreeNode.nullNode) // 存在顶替节点
41. replaceNode.p = deleteNode.p;
42. if (deleteNode.p == RBTreeNode.nullNode) // 删除节点的父节点为空，是根节点
43. root = replaceNode;
44. else { // 删除节点不是根节点
45. if (deleteNode.p.left == deleteNode)
46. deleteNode.p.left = replaceNode;
47. else
48. deleteNode.p.right = replaceNode;
49. }
50. if (deleteColor == RBColor.BLACK) // 如果删除的颜色是黑色则需要进行修复
51. root = rbDeleteFixup(root, fixNode, fixNodeParent);
52. return root;
53. }

接下来我们来考虑一下一上的删除操作会影响红黑树的什么性质。

首先，如果删除的节点颜色为红色，则不会影响任何红黑性质。但如果删除的颜色是黑色，则可能影响性质2（根节点是黑色的），也可能影响性质4（红色的节点的两个子结点均为黑色），也可能影响性质5（对于每个节点，从该节点到其所有后代的简单路径上，均包含相同数目的黑色节点）。那么当删除的节点颜色为黑色时，对于如何修复删除后的红黑性质，我们采用以下思考方式：

我们假设修复位置的节点具有两种颜色，该节点原来的颜色，以及我们被删除的黑色。那么：

1. 如果该节点原来为红色，那么我们被删除的黑色可以直接覆盖其颜色不影响任何红黑性质
2. 如果该节点是黑色同时他也是根节点，那么我们可以简单的“消除”掉节点上面的一层黑色
3. 如果该节点是黑色，但不是根节点，我们只能通过旋转和重新着色的方法转换修复的位置或退出循环

关键词：兄弟节点

情况1：A的兄弟节点为红色

情况2：A的兄弟节点为黑色，其子节点均为黑色（下图灰色代表未知颜色）

情况3：A的兄弟节点为黑色，兄弟节点的左子节点为红色，右子节点为黑色

情况4：A的兄弟节点为黑色，兄弟节点的右子节点为红色