JAVA集合：TreeMap红黑树深度解析
- 上篇中介绍了jdk1.7和jdk1.8中的HashMap【 JAVA集合：HashMap深度解析（版本对比）】1.8中的HashMap引入了红黑树的结构，补充一下对红黑树的理解，这里以TreeMap中的红黑树结构为例，HashMap中的红黑树结构稍微复杂一点，由于涉及到链表和红黑树结构的相互转换（如下源码来自jdk1.8）
红黑树是一种特殊的平衡二叉树，不追求严格的平衡，能够在O(log n)时间内作查找、插入和删除，插入节点最多只须要两次旋转便可达到平衡，效率很高。node
规则：
- 每一个节点都有颜色（红或黑）；
- 根节点必须是黑色的；
- 叶子节点（null节点）是黑的，即每一个节点都有两个子节点（其中一个或者两个多是null节点）；
- 相连节点不能都是红色（红色节点的父节点和子节点必须为黑色）；
- 任意节点到它全部的叶子节点的路径都含有相同的黑色节点的数量。
结构
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; //默认黑色
｝
复制代码
【引伸规则：根据规则4和5，若是一个节点只有一个子节点，那么这个子节点确定是红色的而且没有子节点。（如上图的22节点和65节点）】
基本方法
- 获取节点颜色，叶子节点（null节点）的颜色是黑色
private static <K,V> boolean colorOf(Entry<K,V> p) {
return (p == null ? BLACK : p.color);
}
复制代码
变化
为了保证规则5成立，插入节点的颜色老是红色的，但这时候可能会形成规则4不成立，就须要进行调整，红黑树有两种调整操做：算法
- 变色（改变节点的颜色）
- 旋转（左旋转和右旋转）
- 左旋转示意图（对节点E左旋转，图片来自互联网）
private void rotateLeft(Entry<K,V> p) {
if (p != null) {
Entry<K,V> r = p.right;
//把右孩子的左孩子节点置为当前节点的右孩子节点(上图中的betweenEandS节点变化)
p.right = r.left;
if (r.left != null)
r.left.parent = p;
//把右孩子节点放到当前节点位置(上图中S节点换到E节点位置)
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;
//当前节点变成右孩子节点的左孩子节点(E节点变成S节点的左孩子)
r.left = p;
p.parent = r;
}
}
复制代码
- 右旋转示意图（对节点S右旋转，图片来自互联网）
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;
}
}
复制代码
put方法
public V put(K key, V value) {
Entry<K,V> t = root;
if (t == null) { //若是根节点是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) { //若是实现了comparator就用comparator比较大小，不然用通用的Comparable比较大小
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;
fixAfterInsertion(e); //插入以后可能违反了红黑树的规则，须要进行调整
size++;
modCount++;
return null;
}
复制代码
fixAfterInsertion插入新节点以后的调整函数（重点）
private void fixAfterInsertion(Entry<K,V> x) {
x.color = RED; //新插入的节点都是红色的
while (x != null && x != root && x.parent.color == RED) { //若是父节点也是红色，违反了规则4，就须要调整。
if (parentOf(x) == leftOf(parentOf(parentOf(x)))) { //若是x的父节点是x的祖父节点的左孩子，
Entry<K,V> y = rightOf(parentOf(parentOf(x))); //y表示x的叔父节点（x的父节点的兄弟节点）
/**
* 状况1：若是x的父节点和叔父节点都是红色的
* 则祖父节点确定是黑色的
* 把祖父节点变成红色的，父亲节点和叔父节点变成黑色的
* （保证从祖父节点到其全部叶子节点的黑色节点数量保持不变）
* 此时祖父节点从黑色变成红色，可能违反了规则4，while循环继续对祖父节点进行调整
*/
if (colorOf(y) == RED) {
setColor(parentOf(x), BLACK); //父亲节点红变黑
setColor(y, BLACK); //叔父节点红变黑
setColor(parentOf(parentOf(x)), RED); //祖父节点黑变红
x = parentOf(parentOf(x)); //while循环继续对祖父进行调整
} else {
/**
* 状况2：x的叔父节点是黑色的（咱们用p表明x的父节点，pp表明x的祖父节点，pr表明x的叔父节点）
* x和p是红色，pr和pp是黑色，不能直接变色，这种状况下咱们把p变黑，pp变红，
* 而后对pp右旋转，左右分支的黑色节点数量不变
* 可是右旋转会使p的右孩子变成pp的左孩子，pp如今是红色，若是x是p的右孩子（红色），旋转过去就会冲突。
* 因此须要提早判断x若是是p的右孩子，对x的父节点进行左旋转（参照上面的左旋转）
* x变成父节点，p变成左孩子，把红色节点移到左分支，x的右孩子是黑色，保证下面的祖父节点右旋转不会发生冲突
* 右旋转以后新祖父节点到各个子孙节点的黑色节点数量仍然保持不变，而且是黑色的，不会再和它的父节点冲突，调整到此结束。
* 即插入操做最多旋转操做两次就能够解决冲突
*/
if (x == rightOf(parentOf(x))) {
x = parentOf(x); //x指向父亲节点
rotateLeft(x); //对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)));
}
}
}
/**
* 保证根节点是黑色
* 假设x的父节点和叔父节点都是红色，祖父节点是黑色而且是根节点
* 符合状况1，那么把父节点叔父节点变黑，祖父节点变红，冲突解决
* x = parentOf(parentOf(x));此时x是根节点不会再调整，可是此时x是红色的，不知足规则2，因此把根节点置黑。
*/
root.color = BLACK;
}
复制代码
示例
如下图红黑树为例 bash
如今咱们要增长一个节点50，放在节点47的右子树上。
新增节点和父节点冲突，叔父节点是红色的，进行变色操做，把父亲节点和叔父节点都变成黑色，祖父节点变成红色，而后再对祖父节点进行调整。
if (colorOf(y) == RED) {
setColor(parentOf(x), BLACK);
setColor(y, BLACK);
setColor(parentOf(parentOf(x)), RED);
x = parentOf(parentOf(x));
}
复制代码
叔父节点y是黑色的，而且x是右孩子，先进行左旋转，把红色节点转移到左分支。
if (x == rightOf(parentOf(x))) {
x = parentOf(x);
rotateLeft(x);
}
复制代码
再把x的父节点变黑，祖父节点变红，而后把祖父节点右旋转。
setColor(parentOf(x), BLACK);
setColor(parentOf(parentOf(x)), RED);
rotateRight(parentOf(parentOf(x)));
复制代码
最多两次旋转便可解决冲突。
delete方法
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); //successor函数查找继承者s，而后把key和value赋值给当前删除的节点，继承者s变成须要删除的节点 p.key = s.key; p.value = s.value; p = s; } // p has 2 children /** * 继承节点没有左孩子节点，因此此时p只有一个孩子节点或者没有孩子节点 */ // Start fixup at replacement node, if it exists. Entry<K,V> replacement = (p.left != null ? p.left : p.right); /** * 若是有一个孩子节点，用这个孩子节点replacement替换掉须要删除的节点p * 根据上面的引伸规则，replacement节点确定是红色的，而且没有子节点 */ 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和其余节点的连接 p.left = p.right = p.parent = null; /** * 若是删除的节点p是红色的，直接删除，不须要更多的处理 * 若是是黑色的，就须要replacement节点进行调整 * 由于replacement节点是红色的，因此fixAfterDeletion方法也只是把replacement节点变黑 if (p.color == BLACK) fixAfterDeletion(replacement); } else if (p.parent == null) { // p没有孩子节点，而且没有父亲节点，则p是根节点，直接删除 root = null; } else { // p没有孩子节点，而且不是根节点，若是是红色，直接删除，若是是黑色，则须要进行调整 if (p.color == BLACK) fixAfterDeletion(p); if (p.parent != null) { //调整完以后把p删除 if (p == p.parent.left) p.parent.left = null; else if (p == p.parent.right) p.parent.right = null; p.parent = null; } } } 复制代码
successor方法（查找继承者）
- 当须要删除的节点有两个孩子节点时才调用此方法。即右孩子节点 != null
static <K,V> TreeMap.Entry<K,V> successor(Entry<K,V> t) {
if (t == null)
return null;
/**
* 右孩子节点不为null，查找右子树中最左边的节点，这个节点的值大于节点t
* 而且是右子树中最小的节点，用来看成继承者替换节点t
*/
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;
}
}
复制代码
fixAfterDeletion删除节点的调整函数（重点）
算法思想：咱们要删除一个黑色节点，这会破坏规则5，调整有3种情景：函数
- 若是兄弟节点是红色的，通过变色旋转，在x节点上面增长一个红色的父亲节点，而且不破坏其余分支的黑色节点数量。
- 兄弟节点是黑色的，若是兄弟节点的子节点都是黑色的，直接把黑色节点变红，即减小兄弟分支的黑色节点数量，而后对其父节点进行调整；
- 兄弟节点是黑色的，但其有红色的孩子节点，不能直接变红。若是左孩子是红色节点，通过变色和右旋转把红色节点移到右边。此时再通过变色，并对x的父节点进行左旋转，在x节点的上面增长一个黑色节点，而且不破坏其余分支的黑色节点数量，调整结束。
private void fixAfterDeletion(Entry<K,V> x) {
while (x != root && colorOf(x) == BLACK) { //节点x不是根节点而且是黑色才进行处理
if (x == leftOf(parentOf(x))) { //x是其父节点的左孩子
Entry<K,V> sib = rightOf(parentOf(x)); //sib表示x的兄弟节点
/**
* 若是兄弟节点是红色的，那么父节点确定是黑色的
* 把兄弟节点变黑，父节点变红，而后对父节点左旋转
* 兄弟节点变成父节点，而且到右子树的黑色节点数量不变（由1黑1红变成1黑）
*
* 即情景1，在x节点上增长一个父节点（红色）。
*/
if (colorOf(sib) == RED) {
setColor(sib, BLACK);
setColor(parentOf(x), RED);
rotateLeft(parentOf(x));
sib = rightOf(parentOf(x)); //旋转以后从新赋值兄弟节点sib，原sib变成x的祖父节点（见左旋转动图）
}
/**
* 进行上一步的判断处理后，此时兄弟节点确定是黑色的。
* 若是兄弟节点的孩子节点都是黑色的，咱们就能够把兄弟节点变红。
* 而后while循环继续调整其父节点，即情景2。
*/
if (colorOf(leftOf(sib)) == BLACK &&
colorOf(rightOf(sib)) == BLACK) {
setColor(sib, RED);
x = parentOf(x);
} else { //兄弟节点不能直接变红的状况下，即情景3
/**
* 若是兄弟节点的左孩子是红色，右孩子是黑色
* 兄弟节点的左孩子变黑，兄弟节点变红，对兄弟节点右旋转，把红色节点转移到右分支
*/
if (colorOf(rightOf(sib)) == BLACK) {
setColor(leftOf(sib), BLACK);
setColor(sib, RED);
rotateRight(sib);
sib = rightOf(parentOf(x)); //从新赋值兄弟节点
}
/**
* 通过上一步判断处理，兄弟节点是黑色，兄弟节点的左孩子是黑色，兄弟节点的右孩子是红色，
* 把兄弟节点变成父节点的颜色，兄弟节点的右孩子变成黑色（不破坏右分支的规则），父节点变成黑色，对父亲节点左旋转，
* 主要就在x节点的上面增长了一个黑色的父节点，即情景3，调整结束。
*/
setColor(sib, colorOf(parentOf(x)));
setColor(parentOf(x), BLACK);
setColor(rightOf(sib), BLACK);
rotateLeft(parentOf(x));
x = root;
}
} else { // x节点是其父节点的右孩子，调整方法和上面的对称。
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);
}
复制代码
示例
- 删除的节点只有一个子节点（删除390），根据上面的引伸规则，这个节点确定是黑色，子节点是红色
- 删除红色的节点而且没有子节点（删除833）
- 删除黑色的节点而且没有子节点（删除22）
- 兄弟节点是红色的状况
变色+旋转，给x节点增长一个红色的父亲节点
if (colorOf(sib) == RED) {
setColor(sib, BLACK);
setColor(parentOf(x), RED);
rotateLeft(parentOf(x));
sib = rightOf(parentOf(x));
}
复制代码
此时x的新兄弟节点是黑色，而且孩子节点全是黑色（叶子节点是黑色的），把兄弟节点变色，而后x指向父节点，while循环继续调整。
if (colorOf(leftOf(sib)) == BLACK &&
colorOf(rightOf(sib)) == BLACK) {
setColor(sib, RED);
x = parentOf(x);
复制代码
节点是红色，跳出循环。循环外把该节点变黑。
while (x != root && colorOf(x) == BLACK) {}
setColor(x, BLACK);
复制代码
方法返回后，deleteEntry方法把22节点删除，整个过程结束。
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;
}
复制代码
- 兄弟节点是黑色的状况
上面是旋转变化过程当中其实已经碰见了这种状况，而且兄弟节点的孩子节点全是黑色，能够直接变色处理，下面来看一下，兄弟节点是黑色，而且有孩子节点是红色的状况post
继续上面的红黑树，下面删除65节点 ui
兄弟节点是黑色，而且有红色的孩子节点，针对x是左孩子的状况下，若是红色节点是左孩子，须要经过旋转操做移到右边
if (colorOf(rightOf(sib)) == BLACK) {
setColor(leftOf(sib), BLACK);
setColor(sib, RED);
rotateRight(sib);
sib = rightOf(parentOf(x));
}
复制代码
而后再进行变色旋转操做，给x节点增长一个黑色的父节点。x = root结束循环。
setColor(sib, colorOf(parentOf(x)));
setColor(parentOf(x), BLACK);
setColor(rightOf(sib), BLACK);
rotateLeft(parentOf(x));
x = root;
复制代码
方法返回，deleteEntry方法把65节点删除，整个过程结束。
- 删除节点有两个孩子节点的状况。
删除节点55，该节点有两个孩子节点，deleteEntry方法中会查找继承者节点，即图中的65节点，把65节点的key和value赋值给55节点，而后转化为删除65节点。
if (p.left != null && p.right != null) {
Entry<K,V> s = successor(p);
p.key = s.key;
p.value = s.value;
p = s;
}
复制代码
由于继承者节点没有左孩子节点，因此这个问题又变成了删除一个孩子节点或者无孩子节点的问题。（参照上面）
相关文章
- 1. JAVA集合：TreeMap红黑树深度解析
- 2. 死磕 java集合之TreeMap源码分析（二）——红黑树全解析
- 3. 死磕 java集合之TreeMap源码分析（一）——红黑树全解析
- 4. 死磕 java集合之TreeMap源码分析（三）——红黑树全解析
- 5. 死磕 java集合之TreeMap源码分析（四）——红黑树全解析
- 6. 红黑树、TreeMap、TreeSet
- 7. Java集合（3）一 红黑树、TreeMap与TreeSet（上）
- 8. Java集合（4）一 红黑树、TreeMap与TreeSet（下）
- 9. 结合 TreeMap 源码分析红黑树在 java 中的实现
- 10. TreeMap（红黑树）源码分析
- 更多相关文章...
- • XML DOM 解析器 - XML DOM 教程
- • TCP滑动窗口机制深度剖析 - TCP/IP教程
- • 算法总结-深度优先算法
- • ☆技术问答集锦（13）Java Instrument原理
相关标签/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
欢迎关注本站公众号,获取更多信息
相关文章
- 1. JAVA集合：TreeMap红黑树深度解析
- 2. 死磕 java集合之TreeMap源码分析（二）——红黑树全解析
- 3. 死磕 java集合之TreeMap源码分析（一）——红黑树全解析
- 4. 死磕 java集合之TreeMap源码分析（三）——红黑树全解析
- 5. 死磕 java集合之TreeMap源码分析（四）——红黑树全解析
- 6. 红黑树、TreeMap、TreeSet
- 7. Java集合（3）一 红黑树、TreeMap与TreeSet（上）
- 8. Java集合（4）一 红黑树、TreeMap与TreeSet（下）
- 9. 结合 TreeMap 源码分析红黑树在 java 中的实现
- 10. TreeMap（红黑树）源码分析