红黑树的知识也是在读HashMap源码的时候所学到的，而TreeMap的实现则很好的体现了红黑树的性质和操作，所以反倒是先看了TreeMap大致明白了红黑树才去整HashMap。关于红黑树的性质和操作会在借读TreeMap的时候写出解读。
在学红黑树之前最好能了解二叉查找树和AVL树，如果看过实现的代码更好，不然红黑树读起来巨费力，反正我有些费力。
红黑树的插入操作
对应的是TreeMap的put方法，先来看源码
public V put(K key, V value) {
Entry<K,V> t = root;
if (t == null) {//如果该树中一个节点也没有，那么设该节点为根节点
compare(key, key); // type (and possibly null) check
root = new Entry<>(key, value, null);
size = 1;
modCount++;
return null;
}
int cmp;
Entry<K,V> parent;
// split comparator and comparable paths
Comparator<? super K> cpr = comparator;
if (cpr != null) {
do {
parent = t;
cmp = cpr.compare(key, t.key);
if (cmp < 0)
t = t.left;
else if (cmp > 0)
t = t.right;
else
return t.setValue(value);
} while (t != null);
}
else {
if (key == null)
throw new NullPointerException();
@SuppressWarnings("unchecked")
Comparable<? super K> k = (Comparable<? super K>) key;
do {
parent = t;
cmp = k.compareTo(t.key);
if (cmp < 0)
t = t.left;
else if (cmp > 0)
t = t.right;
else
return t.setValue(value);
} while (t != null);
}
Entry<K,V> e = new Entry<>(key, value, parent);
if (cmp < 0)
parent.left = e;
else
parent.right = e;//以上这些代码都是关于二叉查找树BST的插入操作
fixAfterInsertion(e);
size++;
modCount++;
return null;
}
在fixAfterInsertion(e);之前都是二叉查找树的插入操作，网上有很多。
也就是插入后再进行调整，使得满足红黑树性质，5性质如下：
性质1. 节点是红色或黑色。
性质2. 根节点是黑色。
性质3 每个叶节点是黑色的。
性质4 每个红色节点的两个子节点都是黑色。(从每个叶子到根的所有路径上不能有两个连续的红色节点)
性质5. 从任一节点到其每个叶子的所有路径都包含相同数目的黑色节点。（黑色节点个数称黑高）
下面来看如何调整
首先，插入的节点必然染红，否则插入黑色节点后导致插入的路径那边黑高就增加了，导致不满足性质5
如果只有一个节点那么是根节点，直接染黑。
如果插入的节点父节点是黑色的，那么插入红色不影响，所以不做调整。
如果父节点是红色的，那么违反了性质4，需要调整，分以下三种情况。
记当前操作的节点点是x，这里考虑父亲是爷爷的左孩子情况
需要关注的节点是叔叔节点
case 1:如果叔叔节点也是红色（意味着爷爷是黑色） -> 父亲染黑，叔叔染黑，爷爷染红，x指针指向爷爷，继续调整(可能爷爷的爸爸也是红色的)
case 2:如果叔叔节点是黑色
case 2.1:x是爸爸的右孩子 -> x指向父亲，进行左旋，此时情况变成了 case 2.2
case 2.2:x是爸爸的左孩子 -> 父亲染黑，爷爷染红，在爷爷处进行右旋
对照着解释，图片来看源码，里面给出了具体的注释
private void fixAfterInsertion(Entry<K,V> x) {
//插入的节点必然是红色，否则必然违反性质5
x.color = RED;
//如果是null或者是根节点或者是父节点演示是BLACK，不做调整
while (x != null && x != root && x.parent.color == RED) {
//父节点是左孩子的情况 能知道 父节点是红色->爷爷节点是黑色的
if (parentOf(x) == leftOf(parentOf(parentOf(x)))) {
Entry<K,V> y = rightOf(parentOf(parentOf(x)));//获取叔叔节点
if (colorOf(y) == RED) {//case1:叔叔节点是红色,x可以是左或者右节点
setColor(parentOf(x), BLACK);//父亲 染黑
setColor(y, BLACK);//叔叔染黑
setColor(parentOf(parentOf(x)), RED);//爷爷染红
x = parentOf(parentOf(x));//指针指向爷爷 回溯了
} else {
//case2:叔叔节点是黑色且 x是父节点的右节点 -->转case3
if (x == rightOf(parentOf(x))) {
x = parentOf(x);//x指向父节点p
rotateLeft(x);//进行左旋操作
}
//case3：叔叔节点是黑色且 x是父节点的左节点
setColor(parentOf(x), BLACK);//父亲染黑
setColor(parentOf(parentOf(x)), RED);//爷爷染红
rotateRight(parentOf(parentOf(x)));//在爷爷节点处右旋
}
} else {//父节点是右孩子的情况，与上面对称（旋转）
Entry<K,V> y = leftOf(parentOf(parentOf(x)));
if (colorOf(y) == RED) {
setColor(parentOf(x), BLACK);
setColor(y, BLACK);
setColor(parentOf(parentOf(x)), RED);
x = parentOf(parentOf(x));
} else {
if (x == leftOf(parentOf(x))) {
x = parentOf(x);
rotateRight(x);
}
setColor(parentOf(x), BLACK);
setColor(parentOf(parentOf(x)), RED);
rotateLeft(parentOf(parentOf(x)));
}
}
}
//最后父节点必须是黑色
root.color = BLACK;
}
关于左旋右旋，如果不对照图我也旋不来，下面给了左右旋的代码，以及一个容易左旋的图
private void rotateLeft(Entry<K,V> p) {
if (p != null) {
Entry<K,V> r = p.right;
p.right = r.left;
if (r.left != null)
r.left.parent = p;
r.parent = p.parent;
if (p.parent == null)
root = r;
else if (p.parent.left == p)
p.parent.left = r;
else
p.parent.right = r;
r.left = p;
p.parent = r;
}
}
/** From CLR */
private void rotateRight(Entry<K,V> p) {
if (p != null) {
Entry<K,V> l = p.left;
p.left = l.right;
if (l.right != null) l.right.parent = p;
l.parent = p.parent;
if (p.parent == null)
root = l;
else if (p.parent.right == p)
p.parent.right = l;
else p.parent.left = l;
l.right = p;
p.parent = l;
}
}
红黑树的删除
红黑树的删除和二叉查找树一样是最麻烦的，主要情况多，对应的TreeMap的操作是remove
public V remove(Object key) {
Entry<K,V> p = getEntry(key);
if (p == null)
return null;
V oldValue = p.value;
deleteEntry(p);
return oldValue;
}
删除逻辑在deleteEntry(p);
private void deleteEntry(Entry<K,V> p) {
modCount++;
size--;
// If strictly internal, copy successor's element to p and then make p
// point to successor.
//有两个孩子的时候，将p节点的key和value设置为右节点中最小节点的key和value
//同时将p指向右子树的最小节点
if (p.left != null && p.right != null) {
Entry<K,V> s = successor(p);
p.key = s.key;
p.value = s.value;
p = s;
} // p has 2 children
// Start fixup at replacement node, if it exists.
Entry<K,V> replacement = (p.left != null ? p.left : p.right);
if (replacement != null) {//有一个孩子的时候
// Link replacement to parent
replacement.parent = p.parent;
if (p.parent == null)
root = replacement;
else if (p == p.parent.left)//先调整指向替代的节点，接下来再删除p节点
p.parent.left = replacement;
else
p.parent.right = replacement;
// Null out links so they are OK to use by fixAfterDeletion.
p.left = p.right = p.parent = null;
// Fix replacement
if (p.color == BLACK)//先删除再调整 这个对应视频上的图
fixAfterDeletion(replacement);
} else if (p.parent == null) { // return if we are the only node.
root = null;
} else { // No children. Use self as phantom replacement and unlink.
if (p.color == BLACK)//先调整再删除
fixAfterDeletion(p);
if (p.parent != null) {
if (p == p.parent.left)
p.parent.left = null;
else if (p == p.parent.right)
p.parent.right = null;
p.parent = null;
}
/*对于上面的情况，由于是叶子节点，不管怎么旋转也没有转到中间节点，所以第二个if可以在
最后对该节点进行删除*/
}
}
//下面的跟BST一样,找到要替换的节点（后继节点，用来替换要删除的节点）
static <K,V> TreeMap.Entry<K,V> successor(Entry<K,V> t) {
if (t == null)
return null;
else if (t.right != null) {
Entry<K,V> p = t.right;
while (p.left != null)
p = p.left;
return p;
} else {
Entry<K,V> p = t.parent;
Entry<K,V> ch = t;
while (p != null && ch == p.right) {
ch = p;
p = p.parent;
}
return p;
}
}
现在我们照着这句代码来调整
p.left = p.right = p.parent = null;//删除
if (p.color == BLACK)
fixAfterDeletion(replacement);
如果删除的节点是红色，那么不影响，所以不做调整
如果删除的是黑色即：if (p.color == BLACK)成立，那么性质5就被影响了，需要调整(调整的是replacement)。
如果最开始就是红色，或者几遍循环后是红色，那么设置成黑色即可，因为原本删除了黑色，补上就好
或者x指向了根节点那么就设置为黑色,这是比较简单的情况，加入x节点是黑色，考虑下面4种情况。
我们要考虑的是兄弟节点（sib）和兄弟节点的两个孩子（L和R）
case 1: 兄弟节点是红色（意味着父亲是黑色） -> 兄弟节点染黑，父亲染红，父亲处左旋，兄弟指针指向右孩子R，但此时R出的黑高比x的要高，继续调整（继续while循环）
case 2: 兄弟节点是黑色，两个孩子也是黑色 -> 将兄弟节点染红，x指针指向父亲。但此时整体的黑高减一了，继续调整。
case 3: 兄弟节点是黑色，左孩子L是红色，右孩子是黑色 -> 将兄弟节点染红，左孩子染黑，兄弟节点处右旋，兄弟节点指针sib指向左孩子sib，但是此时x的黑高然后比sib小，情况转成了 case 4。
case 4: 兄弟节点是黑色，右孩子是红色，左孩子随意 -> 兄弟节点染成跟父亲相同颜色，父亲和右孩子R染黑色，父亲处左旋。此时满足条件，x指向根节点。
/** From CLR */
private void fixAfterDeletion(Entry<K,V> x) {
//如果最开始就是红色，或者几遍循环后是红色，或者x指向了根节点那么就设置为黑色
//方法最后一句设置了。所以x只能是黑色的，由于删除了所以导致了x这边的黑高减一
while (x != root && colorOf(x) == BLACK) {
//x是父节点的左节点
if (x == leftOf(parentOf(x))) {
Entry<K,V> sib = rightOf(parentOf(x));//获取兄弟节点
//case1 兄弟节点是RED
if (colorOf(sib) == RED) {
setColor(sib, BLACK);//case1 兄弟节点设置为BLACK
setColor(parentOf(x), RED);//case1 父亲节点设为RED
rotateLeft(parentOf(x));//case1 左旋
sib = rightOf(parentOf(x));//case1 兄弟指针指向右儿子
}//case1得到的结果不满足性质5 会转为以下的case2,3,4
//case2 兄弟是BLACK（通过case1如果是红也已经染黑了）
//同时兄弟节点左右孩子是BLACK
if (colorOf(leftOf(sib)) == BLACK &&
colorOf(rightOf(sib)) == BLACK) {
setColor(sib, RED);//兄弟染红,父亲的黑高-1，需要继续调整
x = parentOf(x);//x指向父节点p
} else {
//case3 左孩子是RED,右孩子是BLACK
if (colorOf(rightOf(sib)) == BLACK) {
setColor(leftOf(sib), BLACK);//兄弟的左孩子染黑
setColor(sib, RED);//兄弟染红
rotateRight(sib);//右旋
sib = rightOf(parentOf(x));//兄弟节点指针指向了左孩子
}//此时x节点的黑高仍然比兄弟节点的左节点的黑高小，继续调整转为case4
//case4 右孩子是RED,左孩子任意
setColor(sib, colorOf(parentOf(x)));//兄弟节点染成父节点颜色
setColor(parentOf(x), BLACK);//父节点染黑
setColor(rightOf(sib), BLACK);//兄弟的右孩子染黑
rotateLeft(parentOf(x));//父节点左旋
x = root;//到这里调整后是满足条件的，x指向根节点，准备结束了
}
} else { // symmetric
Entry<K,V> sib = leftOf(parentOf(x));
if (colorOf(sib) == RED) {
setColor(sib, BLACK);
setColor(parentOf(x), RED);
rotateRight(parentOf(x));
sib = leftOf(parentOf(x));
}
if (colorOf(rightOf(sib)) == BLACK &&
colorOf(leftOf(sib)) == BLACK) {
setColor(sib, RED);
x = parentOf(x);
} else {
if (colorOf(leftOf(sib)) == BLACK) {
setColor(rightOf(sib), BLACK);
setColor(sib, RED);
rotateLeft(sib);
sib = leftOf(parentOf(x));
}
setColor(sib, colorOf(parentOf(x)));
setColor(parentOf(x), BLACK);
setColor(leftOf(sib), BLACK);
rotateRight(parentOf(x));
x = root;
}
}
}
//最后x设置为黑色
setColor(x, BLACK);
}