什么是红黑树
红黑树首先是二叉搜索树，** 满足对任何节点x，左子树的关键字最大不超过x.key，右子树的关键字最小不低于x.key。再者，红黑树是一种平衡树，满足最坏情况下插入、删除、查询的时间复杂度为O(lg n)。**
什么情况下用红黑树
红黑树的插入、删除、遍历时间复杂度都为O(lgN)，所以性能上低于哈希表。但是哈希表无法提供键值对的有序输出，红黑树因为是排序插入的，可以按照键的值的大小有序输出。
例如:
public static class Node implements Comparable<Node>{
public Node(int v){
this.value = v;
}
public int value;
@Override
public int compareTo(Node o) {
return this.value-o.value;
}
}
public static void main(String[] args) {
Map<Node,Object> map=new TreeMap<>();
map.put(new Node(6), new Object());
map.put(new Node(3), new Object());
map.put(new Node(5), new Object());
map.put(new Node(4), new Object());
map.put(new Node(1), new Object());
map.put(new Node(11), new Object());
Iterator<Node> iterator = map.keySet().iterator();
while(iterator.hasNext()){
System.out.println(iterator.next().value);
}
}
打印结果:
1
3
4
5
6
11
用TreeMap可以在构造方法传入Comparator对象，或者在键类中实现Comparable接口使之排序。
注意：TreeMap无法像HashMap那样以null为键
红黑树性质
- ** 每个节点非黑即红。**
- ** 根节点是黑色的。**
- ** 每个哨兵节点是黑色的。**
- ** 红节点的两个子节点都是黑色的。**
- ** 每个节点到后代哨兵节点路径上的黑色节点数量是一样多的。**
为什么叫红黑树，因为它利用红黑两种颜色保持二叉树的平衡。红黑树的五个性质也是制约它平衡的必要条件。
TreeMap的实现
节点
static final class Entry<K,V> implements Map.Entry<K,V> {
K key;
V value;
Entry<K,V> left;
Entry<K,V> right;
Entry<K,V> parent;
boolean color = BLACK;
}
红黑树的节点是用Entry类表示的，该类包括两个指向左右两个孩子节点的指针left、right，一个指向父亲节点的指针parent，表示当前颜色的变量color,默认为黑色。K泛型的key表示键，V泛型的value表示值。
插入算法
首先执行二叉搜索树的插入算法，保证左子树的关键字最大不超过x.key，右子树的关键字最小不低于x.key。
Entry<K,V> t = root;
if (t == null) {
@1
compare(key, key); // type (and possibly null) check
root = new Entry<>(key, value, null);
size = 1;
modCount++;
return null;
}
@2
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 @3
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);
}
@4
Entry<K,V> e = new Entry<>(key, value, parent);
if (cmp < 0)
parent.left = e;
else
parent.right = e;
@1 表示根节点为空的情况直接插入到根节点
@2 表示根节点非空，通过传入的Comparator或者key自身实现的Comparable来比较key的值，先从根部节点比较。
@3 如果key的值与比较节点的值相同，直接将value赋给节点返回。
@4 如果key.value < root.value，接下来比较key与root左子树的值；如果key.value > root.value,接下来比较key与root右子树的值。以此循环，直到要比较的节点为空,将新节点插入该位置。
插入后的颜色修复
经过二叉搜索树的插入算法，此时树已满足二叉搜索树的条件，接下来在不破坏二叉搜索树性质的条件下对颜色修复使得该树满足红黑树的性质。
private void fixAfterInsertion(Entry<K,V> x) {
x.color = RED;
while (x != null && x != root && x.parent.color == RED) { @1
if (parentOf(x) == leftOf(parentOf(parentOf(x)))) {
Entry<K,V> y = rightOf(parentOf(parentOf(x)));
if (colorOf(y) == RED) { //情况1
setColor(parentOf(x), BLACK);
setColor(y, BLACK);
setColor(parentOf(parentOf(x)), RED);
x = parentOf(parentOf(x));
} else {
if (x == rightOf(parentOf(x))) { //情况2
x = parentOf(x);
rotateLeft(x);
}
//情况3
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;
}
如果新插入的节点非根节点，并且父亲是红色，因为它自身也是红色，因此违反了性质4，需要调整颜色。
下面以父节点是左孩子的判断分支分析，父节点是右孩子的状况具有对称性，不重复推导。
情况一，叔节点是红色
如果当前节点x的父亲是左节点，并且和叔节点y（父亲的兄弟节点）都是红色，这时候父亲的父亲节点必须是黑色的，否则不满足性质4。将父亲x,p和叔节点y都染成黑色，将父亲的父亲x.p.p节点染成红色。此时插入的节点x、插入节点的父亲节点x.p、叔节点y都满足红黑树性质，但是父亲的父亲节点x.p.p被染成红色后未必还满足红黑树性质，所以将x设置为x.p.p节点，交给下个迭代解决。
情况二，当前的节点是右孩子，叔节点是黑色
如果x是右孩子，将x设置成x.p，对x左旋。
情况三，当前节点是左孩子，叔节点y是黑色
将x的父亲节点x.p染成黑色，再将x节点的父亲的父亲x.p.p染成红色。
将x.p.p右旋。
经过上述步骤的变化现在已经成为一颗符合性质的红黑树。
三种情况针对父亲节点是左孩子的情况，父亲是右孩子的情况可以根据三种情况反推。
插入算法小结
因为一颗有n个节点的红黑树，其高度为lg n，二叉搜索树的插入最多执行O(lg n)的时间。而颜色修复在情况一沿着树上升2层，循环才会重复执行。循环可能执行的总数为O(lg n),一旦进入情况2或3，下面执行的旋转不超过2次，循环就结束了。所以红黑树的插入算法时间是O(lg n)。
删除算法
public V remove(Object key) {
Entry<K,V> p = getEntry(key);
if (p == null)
return null;
V oldValue = p.value;
deleteEntry(p);
return oldValue;
}
首先通过getEntry找到与key对应的节点，然后调用deleteEntry方法删除节点:
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.
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.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;
}
}
}
首先根据二叉搜索树的删除算法删除节点，具体表现为:
- 如果删除的节点没有子树，直接删除，如果它是黑色的，从哨兵节点开始颜色修复。
- 如果删除的节点只有一个子树，用它的孩子节点替换它，如果它是黑色的，从它的孩子开始执行颜色修复。
- 如果删除的节点有双子树，用右子树最小的节点替换它，并对最小节点的右节点执行颜色修复。
删除后的颜色修复
删除节点完毕后，开始执行颜色修复算法,颜色修复只指针替换节点为黑色的，因为路径中少了一个黑色节点破坏了性质5。
下面以修复节点是左孩子分析，如果该节点是右孩子与它是左孩子具有对称性，不再重复分析。
private void fixAfterDeletion(Entry<K,V> x) {
while (x != root && colorOf(x) == BLACK) {
if (x == leftOf(parentOf(x))) {
Entry<K,V> sib = rightOf(parentOf(x));
if (colorOf(sib) == RED) { //情况一
setColor(sib, BLACK);
setColor(parentOf(x), RED);
rotateLeft(parentOf(x));
sib = rightOf(parentOf(x));
}
if (colorOf(leftOf(sib)) == BLACK &&
colorOf(rightOf(sib)) == BLACK) { //情况二
setColor(sib, RED);
x = parentOf(x);
} else {
if (colorOf(rightOf(sib)) == BLACK) {//情况三
setColor(leftOf(sib), BLACK);
setColor(sib, RED);
rotateRight(sib);
sib = rightOf(parentOf(x));
}
setColor(sib, colorOf(parentOf(x))); //情况四
setColor(parentOf(x), BLACK);
setColor(rightOf(sib), BLACK);
rotateLeft(parentOf(x));
x = root;
}
} 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;
}
}
}
setColor(x, BLACK);
}
情况一，兄弟sib是红色节点
将兄弟设置黑色，将x的父亲设置为红色，并将x的父亲左旋，设置新的兄弟节点为sib。将情况1转换成情况2或3或4。
情况二，兄弟节点sib是黑色的，且sib的两个孩子节点也是黑色的
设置兄弟节点sib为红色,将x设置为x的父亲。完成后sib被抹去一层黑色，以此向上循环达到平衡。
情况三，兄弟节点sib是黑色的，sib的左孩子是红色，sib的右孩子是黑色
设置sib的左孩子为黑色，设置sib为红色，将sib右旋，重新设置sib为x的兄弟节点。
情况四，兄弟sib是黑色的，sib的右孩子是红色的
设置sib为父亲的颜色，设置父亲为黑色，设置sib的右孩子为黑色，对父亲左旋，并将x设置为root。这样将情况3转换为情况4。
删除算法小结
因为包含n个节点的红黑树高度为O(lg n),因此执行二叉搜索树的删除算法时间效率为O(lg n)，在执行删除后的颜色调整时，情况1、3、4执行至多三次旋转便能终止。情况2最多循环数的高度O(lg n)，且不会执行旋转。所以红黑树的删除时间为O(lg n)。
