首先需要理清一个概念，二叉树，平衡二叉树（AVL），二叉搜索树 （BST）：数据结构中常见的树（BST二叉搜索树、AVL平衡二叉树、RBT红黑树、B-树、B+树、B*树）
红黑树基于平衡二叉树，它是一个自平衡的二叉搜索树
为了能以较快的时间O(logN)来搜索一棵树，需要保证树总是平衡的（或者至少大部分是平衡的），这就是说对树中的每个节点在它左边的后代数目和在它右边的后代数目应该大致相等。红-黑树的就是这样的一棵平衡树，对一个要插入的数据项，插入例程要检查会不会破坏树的特征，如果破坏了，程序就会进行纠正，根据需要改变树的结构，从而保持树的平衡。那么红-黑树都有哪些特征呢？
1.红-黑树的特征
它主要有两个特征：1.节点都有颜色；2.在插入和删除的过程中，要遵循保持这些颜色的不同排列的规则。首先第一个特征很好解决，在节点类中店家一个数据字段，例如boolean型变量，以此来表示节点的颜色信息。第二个特征比较复杂，红-黑树有它的几个规则，如果遵循这些规则，那么树就是平衡的。红-黑树的主要规则如下：
1.每个节点不是红色就是黑色的；
2.根节点总是黑色的；
3.如果节点是红色的，则它的子节点必须是黑色的（反之不一定）；
4.从根节点到叶节点或空子节点的每条路径，必须包含相同数目的黑色节点（即相同的黑色高度）。
（注意：有些资料说每个叶节点（NIL节点，空节点）是黑色的，这里说的叶节点其实指的是NIL节点和空节点，而对于一个Node节点来说是可以为红色的）
在红-黑树中插入的节点都是红色的，这不是偶然的，因为插入一个红色节点比插入一个黑色节点违背红-黑规则的可能性更小。原因是：插入黑色节点总会改变黑色高度（违背规则4），但是插入红色节点只有一半的机会会违背规则3。另外违背规则3比违背规则4要更容易修正。当插入一个新的节点时，可能会破坏这种平衡性，那么红-黑树是如何修正的呢？
2.平衡性的修正
红-黑树主要通过三种方式对平衡进行修正，改变节点颜色、左旋和右旋。这看起来有点抽象，我们分别来介绍它们。
1.变色
改变节点颜色比较容易理解，因为它违背了规则3。假设现在有个节点E，然后插入节点A和节点S，节点A在左子节点，S在右子节点，目前是平衡的。如果此时再插一个节点，那么就出现了不平衡了，因为红色节点的子节点必须为黑色，但是新插的节点是红色的。所以这时候就必须改变节点颜色了。所以我们将根的两个子节点从红色变为黑色（至于为什么都要变，下面插入的时候会详细介绍），将父节点会从黑色变成红色。可以用如下示意图表示一下：
2.左旋
通常左旋操作用于将一个向右倾斜的红色链接旋转为向左链接。示意图如下：
左旋有个很萌萌哒的动态示意图，可以方便理解：
3.右旋
右旋可左旋刚好相反，这里不再赘述，直接看示意图：
当然咯，右旋也有个萌萌的动态图：
3.红-黑树的操作
红-黑树的基本操作是添加、删除和旋转。对红-黑树进行添加或删除后，可能会破坏其平衡性，会用到哪种旋转方式去修正呢？我们首先对红-黑树的节点做一介绍，然后分别对左旋和右旋的具体实现做一分析，最后我们探讨下红-黑树的具体操作。
1.红-黑树的节点
红-黑树是对二叉搜索树的改进，所以其节点与二叉搜索树是差不多的，只不过在它基础上增加了一个boolean型变量来表示节点的颜色，具体看RBNode<T>类：
public class Node<T extends Comparable<T>> {
boolean color;//颜色
T key;//每个节点的值
Node<T> left;//左节点
Node<T> right;//右节点
Node<T> parent;//父节点
public Node(boolean color, T key, Node<T> left, Node<T> right,
Node<T> parent) {
this.color = color;
this.key = key;
this.left = left;
this.right = right;
this.parent = parent;
}
}
2.左旋具体实现
上面对左旋的概念已经有了感性的认识了，这里就不再赘述了，我们从下面的代码中结合上面的示意图，探讨一下左旋的具体实现：
3.右旋具体实现
上面对右旋的概念已经有了感性的认识了，这里也不再赘述了，我们从下面的代码中结合上面的示意图，探讨一下右旋的具体实现：
4.插入操作
分析完了红-黑树中主要的旋转操作，接下来我们开始分析常见的插入、删除等操作了。这里先分析插入操作。 由于红-黑树是二叉搜索树的改进，所以插入操作的前半工作时相同的，即先找到待插入的位置，再将节点插入，先来看看插入的前半段代码：
public void insert(T key) {
Node<T> node = new Node<T>(RED, key, null, null, null);
// 如果插入第一个节点，为根节点
if (root == null) {
root = node;
root.color = BLACK;
return;
}
Node<T> nodeParent = null;// 插入的node的父节点
Node<T> x = root;
// 1. 找出插入结点node的父节点
while (x != null) {
nodeParent = x;
int cmp = node.key.compareTo(x.key);
// 如果插入的节点值小于当前位置节点的值
if (cmp < 0)
x = x.left;
else
x = x.right;
}
node.parent = nodeParent;
// 2. 接下来判断是插入到父节点的左边还是右边
int cmp = node.key.compareTo(nodeParent.key);
if (cmp < 0)
nodeParent.left = node;
else
nodeParent.right = node;
// 3. 重新修正为红黑树
insertFixUp(node);
}这与二叉搜索树中实现的思路一模一样，这里不再赘述，主要看看方法里面最后一步insertFixUp操作。因为插入后可能会导致树的不平衡，insertFixUp方法里主要是分情况讨论，分析何时变色，何时左旋，何时右旋。我们先从理论上分析具体的情况，然后再看insertFixUp方法的具体实现。
如果是第一次插入，由于原树为空，所以只会违反红-黑树的规则2，所以只要把根节点涂黑即可；
如果插入节点的父节点是黑色的，那不会违背红-黑树的规则，什么也不需要做；
但是遇到如下三种情况时，我们就要开始变色和旋转了：
1. 插入节点的父节点和其叔叔节点（祖父节点的另一个子节点）均为红色的；
2. 插入节点的父节点是红色，叔叔节点是黑色，且插入节点是其父节点的右子节点；
3. 插入节点的父节点是红色，叔叔节点是黑色，且插入节点是其父节点的左子节点。
下面我们先挨个分析这三种情况都需要如何操作，然后再给出实现代码。（N是当前节点）
对于情况1：插入节点的父节点和其叔叔节点（祖父节点的另一个子节点）均为红色的。（违反规则3）此时，肯定存在祖父节点，但是不知道父节点是其左子节点还是右子节点，但是由于对称性，我们只要讨论出一边的情况，另一种情况自然也与之对应。这里考虑父节点是祖父节点的左子节点的情况，如下左图所示：
对于这种情况，我们要做的操作有：将当前节点(4)的父节点(5)和叔叔节点(8)涂黑，将祖父节点(7)涂红，变成上右图所示的情况。再将当前节点指向其祖父节点，再次从新的当前节点开始算法（具体等下看下面的程序）。这样上右图就变成了情况2了。
对于情况2：插入节点的父节点是红色，叔叔节点是黑色，且插入节点是其父节点的右子节点。我们要做的操作有：将当前节点(7)的父节点(2)作为新的节点，以新的当前节点为支点做左旋操作。完成后如左下图所示，这样左下图就变成情况3了。 
对于情况3：插入节点的父节点是红色，叔叔节点是黑色，且插入节点是其父节点的左子节点。我们要做的操作有：将当前节点的父节点(7)涂黑，将祖父节点(11)涂红，在祖父节点为支点做右旋操作。最后把根节点涂黑，整个红-黑树重新恢复了平衡，如右上图所示。至此，插入操作完成！
我们可以看出，如果是从情况1开始发生的，必然会走完情况2和3，也就是说这是一整个流程，当然咯，实际中可能不一定会从情况1发生，如果从情况2开始发生，那再走个情况3即可完成调整，如果直接只要调整情况3，那么前两种情况均不需要调整了。故变色和旋转之间的先后关系可以表示为：变色->左旋->右旋。
至此，我们完成了全部的插入操作。下面我们看看insertFixUp方法中的具体实现（可以结合上面的分析图，更加利与理解）
public void insertFixUp(Node<T> node) {
Node<T> parent, gParent;
while ((parent = node.parent) != null && parent.color == RED) {
gParent = parent.parent;
// 如果插入结点的父节点位于祖父节点的左边
if (parent == gParent.left) {
Node<T> uncle = gParent.right;
// 1. 如果插入结点的叔叔节点也为红
if (uncle != null && uncle.color == RED) {
parent.color = BLACK;
uncle.color = BLACK;
gParent.color = RED;
// 把插入节点指向祖父节点，从而变成情况2
node = gParent;
continue;//继续while，重新判断
}
// 2. 如果插入节点的父节点是红色，叔叔节点是黑色，且插入节点是其父节点的右子节点
if (node == parent.right) {
leftRotate(parent);
// 并把当前节点指向父节点，为第3种情况做准备
Node<T> tmp = parent; // 然后将父节点和自己调换一下，为下面右旋做准备
parent = node;
node = tmp;
}
// 3. 叔叔节点是黑色，且当前节点是左子节点
parent.color = BLACK;
gParent.color = RED;
rightRotate(gParent);
} else {// 如果插入结点的父节点位于祖父节点的右边
Node<T> uncle = gParent.left;
// 1. 如果插入结点的叔叔节点也为红
if (uncle != null && uncle.color == RED) {
parent.color = BLACK;
uncle.color = BLACK;
gParent.color = RED;
// 把插入节点指向祖父节点，从而变成情况2
node = gParent;
continue;
}
// 2. 如果插入节点的父节点是红色，叔叔节点是黑色，且插入节点是其父节点的左子节点
if (node == parent.left) {
rightRotate(parent);
Node<T> tmp = parent;
parent = node;
node = tmp;
}
// 3. 叔叔节点是黑色的，且当前节点是右子节点
parent.color = BLACK;
gParent.color = RED;
leftRotate(gParent);
}
}
// 将根节点设为黑色
root.color = BLACK;
}
5.删除操作
上面探讨完了红-黑树的插入操作，接下来讨论删除，红-黑树的删除和二叉查找树的删除是一样的，只不过删除后多了个平衡的修复而已。我们先来回忆一下二叉搜索树的删除（也可以直接阅读这篇博客：二叉搜索树）：
1. 如果待删除节点没有子节点，那么直接删掉即可；
2. 如果待删除节点只有一个子节点，那么直接删掉，并用其子节点去顶替它；（如果待删除的节点是黑色的，删除该节点会影响高度，所以用子节点顶替时要把子节点颜色改为黑色；如果待删除节点时红色的，则可以直接顶替）
3. 如果待删除节点有两个子节点，这种情况比较复杂：首选找出它的后继节点，然后处理“后继节点”和“被删除节点的父节点”之间的关系，最后处理“后继节点的子节点”和“被删除节点的子节点”之间的关系。每一步中也会有不同的情况，我们结合下面代码的分析就能弄清楚，当然了，如果已经弄懂了二叉搜索树，那自然自然都能明白，这里就不赘述了。
我们来看一下删除操作的代码及注释：
public void remove(T key) {
Node<T> node = search(root, key);//查询到key对应的节点
if (node != null) {
Node<T> child, parent;
boolean color;
if (node.left != null && node.right != null) {// 1. 删除节点有两个子节点时
// 第一步：首先找到删除节点的后继结点
Node<T> replace = node;
replace = replace.right;
while (replace.left != null) {
replace = replace.left;
}
// 第二步：用后继结点替换掉删除节点
if (node.parent != null) {
if (node.parent.left == node) {
node.parent.left = replace;
} else {
node.parent.right = replace;
}
} else {
root = replace;
}
// 第三步： 处理“后继节点的子节点”和“被删除节点的子节点”之间的关系
child = replace.right; // 后继结点的子节点，后继结点肯定没有左节点
parent = replace.parent;
color = replace.color;
if (parent == node) {// 如果删除节点的右节点，没有左子节点，也即右节点为删除节点的后继结点
parent = replace;
} else {
if (child != null)
child.parent = parent;
parent.left = child;
replace.right = node.right;
node.right.parent = replace;
}
// 第四步：处理 删除节点的左子节点和后继节点的关系
replace.parent = node.parent;
replace.color = node.color;
replace.left = node.left;
node.left.parent = replace;
// 由于用后继结点来填补了删除节点的颜色，那么会影响平衡得就是后继结点的颜色了
if (color == BLACK) {
removeFixUp(child, parent);// 将后继节点的child和parent传进去
}
} else if (node.left == null && node.right == null) {// 2.如果删除节点是叶子节点，直接删除
if (node.parent.left == node)
node.parent.left = null;
else {
node.parent.right = null;
}
} else { //3. 如果删除节点只有一个子节点，要注意变色
Node<T> parentNode = node.parent;// 删除节点的
Node<T> childNode;// 删除节点的子节点
if (node.left == null) {//3.1 如果只有右子节点
childNode = node.right;
}else {//3.2 如果只有左子节点
childNode = node.left;
}
if(node == parentNode.left)
parentNode.left = childNode;
else
parentNode.right = childNode;
childNode.parent = parentNode;
//如果删除的是黑色，则补上去的子节点也要变成黑色，不然会红红相接，如果是红色，则直接接上去
if (node.color == BLACK) {
childNode.color = BLACK;
}
}
node = null;
}
}从上面的代码中可以看出，删除某个节点后，会用它的后继节点来填上，并且后继节点会设置为和删除节点同样的颜色，所以删除节点的那个位置是不会破坏平衡的。可能破坏平衡的是后继节点原来的位置，因为后继节点拿走了，原来的位置结构改变了，这就会导致不平衡的出现。所以removeFixUp方法中传入的参数也是后继节点的子节点和父节点。
为了方便下文的叙述，我们现在约定：后继节点的子节点称为“当前节点”。
删除操作后（此时的当前节点已经指向了后继节点的父节点了，所以会有兄弟节点），如果当前节点是黑色的根节点，那么不用任何操作，因为并没有破坏树的平衡性，即没有违背红-黑树的规则，这很好理解。如果当前节点是红色的，说明刚刚移走的后继节点是黑色的，那么不管后继节点的父节点是啥颜色，我们只要将当前节点涂黑就可以了，红-黑树的平衡性就可以恢复。但是如果遇到以下四种情况，我们就需要通过变色或旋转来恢复红-黑树的平衡了。
1. 当前节点是黑色的，且兄弟节点是红色的（那么父节点和兄弟节点的子节点肯定是黑色的）；
2. 当前节点是黑色的，且兄弟节点是黑色的，且兄弟节点的两个子节点均为黑色的；
3. 当前节点是黑色的，且兄弟节点是黑色的，且兄弟节点的左子节点是红色，右子节点时黑色的；
4. 当前节点是黑色的，且兄弟节点是黑色的，且兄弟节点的右子节点是红色，左子节点任意颜色。
以上四种情况中，我们可以看出2,3,4其实是“当前节点是黑色的，且兄弟节点是黑色的”的三种子集，等会在程序中可以体现出来。现在我们假设当前节点是左子节点（当然也可能是右子节点，跟左子节点相反即可，我们讨论一边就可以了），分别解决上面四种情况：
对于情况1：当前节点是黑色的，且兄弟节点是红色的（那么父节点和兄弟节点的子节点肯定是黑色的）。如左下图所示：A节点表示当前节点。针对这种情况，我们要做的操作有：将父节点（B）涂红，将兄弟节点（D）涂黑，然后将当前节点（A）的父节点（B）作为支点左旋，然后当前节点的兄弟节点就变成黑色的情况了（自然就转换成情况2，3,4的公有特征了），如右下图所示：
对于情况2：当前节点是黑色的，且兄弟节点是黑色的，且兄弟节点的两个子节点均为黑色的。如左下图所示，A表示当前节点。针对这种情况，我们要做的操作有：将兄弟节点（D）涂红，将当前节点指向其父节点（B），将其父节点指向当前节点的祖父节点，继续新的算法（具体见下面的程序），不需要旋转。这样变成了右下图所示的情况：
对于情况3：当前节点是黑色的，且兄弟节点是黑色的，且兄弟节点的左子节点是红色，右子节点时黑色的。如左下图所示，A是当前节点。针对这种情况，我们要做的操作有：把当前节点的兄弟节点（D）涂红，把兄弟节点的左子节点（C）涂黑，然后以兄弟节点作为支点做右旋操作。然后兄弟节点就变成黑色的，且兄弟节点的右子节点变成红色的情况（情况4）了。如右下图：
对于情况4：当前节点是黑色的，且兄弟节点是黑色的，且兄弟节点的右子节点是红色，左子节点任意颜色。如左下图所示：A为当前节点，针对这种情况，我们要做的操作有：把兄弟节点（D）涂成父节点的颜色，再把父节点（B）涂黑，把兄弟节点的右子节点（E）涂黑，然后以当前节点的父节点为支点做左旋操作。至此，删除修复算法就结束了，最后将根节点涂黑即可。
我们可以看出，如果是从情况1开始发生的，可能情况2，3，4中的一种：如果是情况2，就不可能再出现3和4；如果是情况3，必然会导致情况4的出现；如果2和3都不是，那必然是4。当然咯，实际中可能不一定会从情况1发生，这要看具体情况了。
至此，我们完成了全部的删除操作。下面我们看看removeFixUp方法中的具体实现（可以结合上面的分析图，更加利与理解）：
（这里的代码只给出了当待删除节点有两个子节点的情况，没有给出没有子节点和 只有一个子节点的情况，后面我的完整代码会给出）
public void removeFixUp(Node<T> child, Node<T> parent) {
Node<T> bro;
/**
* 1. 如果child为空，不用管 2. 如果child为红色，在最后把child涂黑 3.
* 如果child不为空，child为黑色，并且child不是root，则需要进行4种情况的处理 1).
* 当前节点(child)是黑色的，且兄弟节点是红色的（那么父节点和兄弟节点的子节点肯定是黑色的）； 2).
* 当前节点是黑色的，且兄弟节点是黑色的，且兄弟节点的两个子节点均为黑色的； 3).
* 当前节点是黑色的，且兄弟节点是黑色的，且兄弟节点的左子节点是红色，右子节点时黑色的； 4).
* 当前节点是黑色的，且兄弟节点是黑色的，且兄弟节点的右子节点是红色，左子节点任意颜色。
*/
while ((child == null || child.color == BLACK) && child != root) {
// 分两种情况，child在左和在右边
if (child == parent.left) {
bro = parent.right;
// 1). 当前节点(child)是黑色的，且兄弟节点是红色的（那么父节点和兄弟节点的子节点肯定是黑色的）
if (bro != null && bro.color == RED) {
parent.color = RED;
bro.color = BLACK;
leftRotate(parent);
// 左旋后重新定位child的兄弟节点，情况1后必定发生2,3，4的一种
bro = parent.right;
}
/**
* 2). child的兄弟节点bro是黑色的，且bro的两个子节点也都是黑色的
* 将兄弟节点涂红，将当前节点指向其父节点，将其父节点指向当前节点的祖父节点 情况2出现，不在可能出现3,4种情况
*/
if ((bro.left == null || bro.left.color == BLACK)
&& (bro.right == null || bro.right.color == BLACK)) {
bro.color = RED;
child = parent;// 将当前节点指向其父节点
parent = child.parent;// 将其父节点指向当前节点的祖父节点
} else {
/**
* 3: child的兄弟节点bro是黑色的，且bro的左子节点是红色，右子节点是黑色
* 把当前节点的兄弟节点涂红，把兄弟节点的左子节点涂黑，然后以兄弟节点作为支点做右旋操作 第3种发生，必定会发生第4种
*/
if (bro.right == null || bro.right.color == BLACK) {
bro.color = RED;
bro.left.color = BLACK;
rightRotate(bro);
// 右旋后重新定位兄弟节点的位置
bro = parent.right;
// 变成第4种情况
}
/**
* 4：child的兄弟节点bro是黑色的，且bro的右子节点是红色，左子节点任意颜色
* 把兄弟节点涂成父节点的颜色，再把父节点涂黑，把兄弟节点的右子节点涂黑，然后以当前节点的父节点为支点做左旋操作
* 发生了情况4，必定结束
*/
bro.color = parent.color;
parent.color = BLACK;
bro.right.color = BLACK;
leftRotate(parent);
child = root;
break;
}
} else {// 右边的时候,反过来
bro = parent.left;
if (bro.color == RED) {
// Case 1: node的兄弟bro是红色的
bro.color = BLACK;
parent.color = BLACK;
rightRotate(parent);
bro = parent.left;
}
if ((bro.left == null || bro.left.color == BLACK)
&& (bro.right == null || bro.right.color == BLACK)) {
// Case 2: child的兄弟bro是黑色，且bro的俩个子节点都是黑色的
bro.color = RED;
child = parent;
parent = child.parent;
} else {
if (bro.left == null || bro.left.color == BLACK) {
// Case 3: node的兄弟bro是黑色的，并且bro的左子节点是红色，右子节点为黑色。
bro.right.color = BLACK;
bro.color = RED;
leftRotate(bro);
bro = parent.left;
}
// Case 4: node的兄弟bro是黑色的；并且bro的左子节点是红色的，右子节点任意颜色
bro.color = parent.color;
parent.color = BLACK;
bro.left.color = BLACK;
rightRotate(parent);
child = this.root;
break;
}
}
}
if (child != null) {
child.color = BLACK;
}
} 4.红-黑树的复杂度
前面也说了，当数据以升序或降序插入时，二叉搜索树的性能就会下降到最低，但是红-黑树的自我修复功能保证了即使在最坏的情况下，也能保证时间复杂度在O(logN)的级别上。
5.完整源码
public class RBTree2<T extends Comparable<T>> {
private Node<T> root; // 根节点
private static final boolean RED = false; // 定义红黑树标志
private static final boolean BLACK = true;
/************* 对红黑树节点x进行左旋操作 ******************/
/*
* 左旋示意图：对节点x进行左旋 p p / / x y / \ / \ lx y -----> x ry / \ / \ ly ry lx ly
* 左旋做了三件事： 1. 将y的左子节点赋给x的右子节点,并将x赋给y左子节点的父节点(y左子节点非空时) 2.
* 将x的父节点p(非空时)赋给y的父节点，同时更新p的子节点为y(左或右) 3. 将y的左子节点设为x，将x的父节点设为y
*/
public void leftRotate(Node<T> x) {
// 1
Node<T> y = x.right;
x.right = y.left;
if (y.left != null)
y.left.parent = x;
// 2
Node<T> parent = x.parent;
y.parent = parent;
if (parent == null) {
this.root = y;
} else {
if (x == parent.left)
parent.left = y;
else
parent.right = y;
}
// 3
y.left = x;
x.parent = y;
}
/************* 对红黑树节点y进行右旋操作 ******************/
/*
* 左旋示意图：对节点y进行右旋 p p / / y x / \ / \ x ry -----> lx y / \ / \ lx rx rx ry
* 右旋做了三件事： 1. 将x的右子节点赋给y的左子节点,并将y赋给x右子节点的父节点(x右子节点非空时) 2.
* 将y的父节点p(非空时)赋给x的父节点，同时更新p的子节点为x(左或右) 3. 将x的右子节点设为y，将y的父节点设为x
*/
public void rightRotate(Node<T> y) {
// 1
Node<T> x = y.left;
y.left = x.right;
if (x.right != null)
x.right.parent = y;
// 2
Node<T> parent = y.parent;
x.parent = parent;
if (parent == null) {
root = x;
} else {
if (y == parent.left)
parent.left = x;
else
parent.right = x;
}
x.right = y;
y.parent = x;
}
public void insert(T key) {
Node<T> node = new Node<T>(RED, key, null, null, null);
// 如果插入第一个节点，为根节点
if (root == null) {
root = node;
root.color = BLACK;
return;
}
Node<T> nodeParent = null;// 插入的node的父节点
Node<T> x = root;
// 1. 找出插入结点node的父节点
while (x != null) {
nodeParent = x;
int cmp = node.key.compareTo(x.key);
// 如果插入的节点值小于当前位置节点的值
if (cmp < 0)
x = x.left;
else
x = x.right;
}
node.parent = nodeParent;
// 2. 接下来判断是插入到父节点的左边还是右边
int cmp = node.key.compareTo(nodeParent.key);
if (cmp < 0)
nodeParent.left = node;
else
nodeParent.right = node;
// 3. 重新修正为红黑树
insertFixUp(node);
}
public void insertFixUp(Node<T> node) {
Node<T> parent, gParent;
while ((parent = node.parent) != null && parent.color == RED) {
gParent = parent.parent;
// 如果插入结点的父节点位于祖父节点的左边
if (parent == gParent.left) {
Node<T> uncle = gParent.right;
// 1. 如果插入结点的叔叔节点也为红
if (uncle != null && uncle.color == RED) {
parent.color = BLACK;
uncle.color = BLACK;
gParent.color = RED;
// 把插入节点指向祖父节点，从而变成情况2
node = gParent;
continue;//继续while，重新判断
}
// 2. 如果插入节点的父节点是红色，叔叔节点是黑色，且插入节点是其父节点的右子节点
if (node == parent.right) {
leftRotate(parent);
// 并把当前节点指向父节点，为第3种情况做准备
Node<T> tmp = parent; // 然后将父节点和自己调换一下，为下面右旋做准备
parent = node;
node = tmp;
}
// 3. 叔叔节点是黑色，且当前节点是左子节点
parent.color = BLACK;
gParent.color = RED;
rightRotate(gParent);
} else {// 如果插入结点的父节点位于祖父节点的右边
Node<T> uncle = gParent.left;
// 1. 如果插入结点的叔叔节点也为红
if (uncle != null && uncle.color == RED) {
parent.color = BLACK;
uncle.color = BLACK;
gParent.color = RED;
// 把插入节点指向祖父节点，从而变成情况2
node = gParent;
continue;
}
// 2. 如果插入节点的父节点是红色，叔叔节点是黑色，且插入节点是其父节点的左子节点
if (node == parent.left) {
rightRotate(parent);
Node<T> tmp = parent;
parent = node;
node = tmp;
}
// 3. 叔叔节点是黑色的，且当前节点是右子节点
parent.color = BLACK;
gParent.color = RED;
leftRotate(gParent);
}
}
// 将根节点设为黑色
root.color = BLACK;
}
public Node<T> search(Node<T> begin, T key) {
while (begin != null) {
int cmp = begin.key.compareTo(key);
if (cmp > 0)
begin = begin.left;
else if (cmp < 0)
begin = begin.right;
else
return begin;
}
return begin;
}
public void remove(T key) {
Node<T> node = search(root, key);//查询到key对应的节点
if (node != null) {
Node<T> child, parent;
boolean color;
if (node.left != null && node.right != null) {// 1. 删除节点有两个子节点时
// 第一步：首先找到删除节点的后继结点
Node<T> replace = node;
replace = replace.right;
while (replace.left != null) {
replace = replace.left;
}
// 第二步：用后继结点替换掉删除节点
if (node.parent != null) {
if (node.parent.left == node) {
node.parent.left = replace;
} else {
node.parent.right = replace;
}
} else {
root = replace;
}
// 第三步： 处理“后继节点的子节点”和“被删除节点的子节点”之间的关系
child = replace.right; // 后继结点的子节点，后继结点肯定没有左节点
parent = replace.parent;
color = replace.color;
if (parent == node) {// 如果删除节点的右节点，没有左子节点，也即右节点为删除节点的后继结点
parent = replace;
} else {
if (child != null)
child.parent = parent;
parent.left = child;
replace.right = node.right;
node.right.parent = replace;
}
// 第四步：处理 删除节点的左子节点和后继节点的关系
replace.parent = node.parent;
replace.color = node.color;
replace.left = node.left;
node.left.parent = replace;
// 由于用后继结点来填补了删除节点的颜色，那么会影响平衡得就是后继结点的颜色了
if (color == BLACK) {
removeFixUp(child, parent);// 将后继节点的child和parent传进去
}
} else if (node.left == null && node.right == null) {// 2.如果删除节点是叶子节点，直接删除
if (node.parent.left == node)
node.parent.left = null;
else {
node.parent.right = null;
}
} else { //3. 如果删除节点只有一个子节点，要注意变色
Node<T> parentNode = node.parent;// 删除节点的
Node<T> childNode;// 删除节点的子节点
if (node.left == null) {//3.1 如果只有右子节点
childNode = node.right;
}else {//3.2 如果只有左子节点
childNode = node.left;
}
if(node == parentNode.left)
parentNode.left = childNode;
else
parentNode.right = childNode;
childNode.parent = parentNode;
//如果删除的是黑色，则补上去的子节点也要变成黑色，不然会红红相接，如果是红色，则直接接上去
if (node.color == BLACK) {
childNode.color = BLACK;
}
}
node = null;
}
}
public void removeFixUp(Node<T> child, Node<T> parent) {
Node<T> bro;
/**
* 1. 如果child为空，不用管 2. 如果child为红色，在最后把child涂黑 3.
* 如果child不为空，child为黑色，并且child不是root，则需要进行4种情况的处理 1).
* 当前节点(child)是黑色的，且兄弟节点是红色的（那么父节点和兄弟节点的子节点肯定是黑色的）； 2).
* 当前节点是黑色的，且兄弟节点是黑色的，且兄弟节点的两个子节点均为黑色的； 3).
* 当前节点是黑色的，且兄弟节点是黑色的，且兄弟节点的左子节点是红色，右子节点时黑色的； 4).
* 当前节点是黑色的，且兄弟节点是黑色的，且兄弟节点的右子节点是红色，左子节点任意颜色。
*/
while ((child == null || child.color == BLACK) && child != root) {
// 分两种情况，child在左和在右边
if (child == parent.left) {
bro = parent.right;
// 1). 当前节点(child)是黑色的，且兄弟节点是红色的（那么父节点和兄弟节点的子节点肯定是黑色的）
if (bro != null && bro.color == RED) {
parent.color = RED;
bro.color = BLACK;
leftRotate(parent);
// 左旋后重新定位child的兄弟节点，情况1后必定发生2,3，4的一种
bro = parent.right;
}
/**
* 2). child的兄弟节点bro是黑色的，且bro的两个子节点也都是黑色的
* 将兄弟节点涂红，将当前节点指向其父节点，将其父节点指向当前节点的祖父节点 情况2出现，不在可能出现3,4种情况
*/
if ((bro.left == null || bro.left.color == BLACK)
&& (bro.right == null || bro.right.color == BLACK)) {
bro.color = RED;
child = parent;// 将当前节点指向其父节点
parent = child.parent;// 将其父节点指向当前节点的祖父节点
} else {
/**
* 3: child的兄弟节点bro是黑色的，且bro的左子节点是红色，右子节点是黑色
* 把当前节点的兄弟节点涂红，把兄弟节点的左子节点涂黑，然后以兄弟节点作为支点做右旋操作 第3种发生，必定会发生第4种
*/
if (bro.right == null || bro.right.color == BLACK) {
bro.color = RED;
bro.left.color = BLACK;
rightRotate(bro);
// 右旋后重新定位兄弟节点的位置
bro = parent.right;
// 变成第4种情况
}
/**
* 4：child的兄弟节点bro是黑色的，且bro的右子节点是红色，左子节点任意颜色
* 把兄弟节点涂成父节点的颜色，再把父节点涂黑，把兄弟节点的右子节点涂黑，然后以当前节点的父节点为支点做左旋操作
* 发生了情况4，必定结束
*/
bro.color = parent.color;
parent.color = BLACK;
bro.right.color = BLACK;
leftRotate(parent);
child = root;
break;
}
} else {// 右边的时候,反过来
bro = parent.left;
if (bro.color == RED) {
// Case 1: node的兄弟bro是红色的
bro.color = BLACK;
parent.color = BLACK;
rightRotate(parent);
bro = parent.left;
}
if ((bro.left == null || bro.left.color == BLACK)
&& (bro.right == null || bro.right.color == BLACK)) {
// Case 2: child的兄弟bro是黑色，且bro的俩个子节点都是黑色的
bro.color = RED;
child = parent;
parent = child.parent;
} else {
if (bro.left == null || bro.left.color == BLACK) {
// Case 3: node的兄弟bro是黑色的，并且bro的左子节点是红色，右子节点为黑色。
bro.right.color = BLACK;
bro.color = RED;
leftRotate(bro);
bro = parent.left;
}
// Case 4: node的兄弟bro是黑色的；并且bro的左子节点是红色的，右子节点任意颜色
bro.color = parent.color;
parent.color = BLACK;
bro.left.color = BLACK;
rightRotate(parent);
child = this.root;
break;
}
}
}
if (child != null) {
child.color = BLACK;
}
}
// 从根节点遍历红黑树
public void order() {
order(root);
}
public void order(Node<T> node) {
if (node != null) {
System.out.println("值：" + node.key + " 颜色："
+ transferColor(node.color));
order(node.left);
order(node.right);
}
}
public String transferColor(boolean color) {
if (color == true) {
return "Black";
} else {
return "Red";
}
}
public static void main(String[] args) {
RBTree2<Integer> tree = new RBTree2<>();
int a[] = { 11, 2, 14, 7, 1, 15, 5, 4, 8 };
for (int i = 0; i < a.length; i++) {
tree.insert(a[i]);
}
System.out.println("root : " + tree.root.key + " "
+ tree.transferColor(tree.root.color));
tree.order();
System.out.println("删除：14");
tree.remove(14);
System.out.println("root : " + tree.root.key + " "
+ tree.transferColor(tree.root.color));
tree.order();
}
}
扫一扫
580
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
