简介
TreeMap是基于红黑树实现的有序映射表。下面就从红黑树开始讲起，介绍一下TreeMap是如何实现CRUD的。
红黑树
以下是百度百科里的定义，直接照搬之。
红黑树是每个节点都带有颜色属性的二叉查找树，颜色或红色或黑色。在二叉查找树强制一般要求以外，对于任何有效的红黑树我们增加了如下的额外要求:
- 性质1. 节点是红色或黑色。
- 性质2. 根节点是黑色。
- 性质3 每个叶节点（NIL节点，空节点）是黑色的。
- 性质4 每个红色节点的两个子节点都是黑色。(从每个叶子到根的所有路径上不能有两个连续的红色节点)
- 性质5. 从任一节点到其每个叶子的所有路径都包含相同数目的黑色节点
总之，以上五个条件就是红黑树的充分必要条件。我们的TreeMap更改都是基于以上5个条件来调整二叉树。
左旋转
如图所示：对红色模块进行左旋转，红色模块变成原来右子树的左子树，原来红色模块右子树的左子树变成红色模块的右子树。一般情况是，在由子树上添加了一个元素，破坏了红黑树，通过左旋转，来将红树上移。红黑树算法是把红色节点尽量向根节点移动，然后再更改根节点为黑色。伪代码如下所示：
p = current
prev = p.prev
prev.left= p.right
p.right.prev = prev
p.prev = p.right
p.right = p.right.left
p.prev.left = p右旋转
右转和左转相反，红色节点的左子树会会成为红色节点的父节点，而左子树的右子树会成为红色节点左子树。伪代码如下：
prev = p.prev
prev.left = p.left
prev.left.prev=prev
p.prev=p.left
p.left = p.prev.right
p.prev.right = p 红黑树算法
根据被插入节点的父节点的情况，可以将”当节点z被着色为红色节点，并插入二叉树”划分为三种情况来处理。
① 情况说明：被插入的节点是根节点。
处理方法：直接把此节点涂为黑色。
② 情况说明：被插入的节点的父节点是黑色。
处理方法：什么也不需要做。节点被插入后，仍然是红黑树。
③ 情况说明：被插入的节点的父节点是红色。
处理方法：那么，该情况与红黑树的“特性(5)”相冲突。这种情况下，被插入节点是一定存在非空祖父节点的；进一步的讲，被插入节点也一定存在叔叔节点(即使叔叔节点为空，我们也视之为存在，空节点本身就是黑色节点)。理解这点之后，我们依据”叔叔节点的情况”，将这种情况进一步划分为3种情况(Case)。
假设当前节点为n
1. case1: 叔叔节点是红色节点： 处理情况是，直接将父节点和叔叔节点标为黑色，祖父节点标为红色，然后将祖父节点赋值为n，继续对当前节点进行操作。
2. case2: 叔叔节点是黑色，n的父节点是祖父节点的左孩子节点，如果n是父节点的右孩子节点，操作为将父节点赋值为n，进行左旋操作，如果不是，则不旋转，然后将n的父节点设置为黑色，将n的祖父节点设置为红色，然后以n的祖父节点为中心，右旋转
3. case3：叔叔节点是黑色，n的父节点是祖父节点的左孩子节点右孩子节点，如果n是父节点的左孩子节点，操作为将父节点赋值为n，进行右旋操作，否则，不旋转，然后将n的父节点设置为黑色，将n的祖父节点设置为红色，然后以n的祖父节点为中心，左旋转
TreeMap
下面介绍一下TreeMap的源码
TreeMap成员变量
/**
* 比较器，用来维持元素的顺序，
* 如果为null，则使用key元素对象的比较器
*/
private final Comparator<? super K> comparator;
/**
* 根节点
*/
private transient Entry<K,V> root;
/**
* The number of entries in the tree
*/
private transient int size = 0;
/**
* 树结构的变化次数
*/
private transient int modCount = 0;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;
/**
* Make a new cell with given key, value, and parent, and with
* {@code null} child links, and BLACK color.
*/
Entry(K key, V value, Entry<K,V> parent) {
this.key = key;
this.value = value;
this.parent = parent;
}
/**
* Returns the key.
*
* @return the key
*/
public K getKey() {
return key;
}
/**
* Returns the value associated with the key.
*
* @return the value associated with the key
*/
public V getValue() {
return value;
}
/**
* Replaces the value currently associated with the key with the given
* value.
*
* @return the value associated with the key before this method was
* called
*/
public V setValue(V value) {
V oldValue = this.value;
this.value = value;
return oldValue;
}
public boolean equals(Object o) {
if (!(o instanceof Map.Entry))
return false;
Map.Entry<?,?> e = (Map.Entry<?,?>)o;
return valEquals(key,e.getKey()) && valEquals(value,e.getValue());
}
public int hashCode() {
int keyHash = (key==null ? 0 : key.hashCode());
int valueHash = (value==null ? 0 : value.hashCode());
return keyHash ^ valueHash;
}
public String toString() {
return key + "=" + value;
}
}Entry对象包含了指向父节点、左子节点，右子节点还包含了对象的颜色。颜色默认是黑色。
添加元素
/**
* 按顺序插入元素
*/
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;
fixAfterInsertion(e);
size++;
modCount++;
return null;
}
/**
* 维护红黑树的平衡
*/
private void fixAfterInsertion(Entry<K,V> x) {
x.color = RED;
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) {
setColor(parentOf(x), BLACK);
setColor(y, BLACK);
setColor(parentOf(parentOf(x)), RED);
x = parentOf(parentOf(x));
} else {
if (x == rightOf(parentOf(x))) {
x = parentOf(x);
rotateLeft(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 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;
}
}
/** 左旋转算法 */
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;
}
}添加元素时，如果root对象为null，则构建Entry对象，并赋值给root。
设比较对象为t，t的初始值为root
如果key和t的key相等，则将value赋值给t的value，并返回原来的value
如果key大于t的key，如果t的右节点为null，则构建Entry对象a，并将a的parent设置为t，将t的右节点设置为a，否则将t设置为当前节点的右节点，
如果key小于t的key，如果t的左节点为null，则构建Entry对象a，并将a的parent设置为t，将t的左节点设置为a，否则将t设置为当前节点的左节点，
否则继续比较。
平衡算法如下：
将新加入的节点属性设置为红色，这样就不违背红黑树的性质5（见前面），只可能违背了性质4。
1、为了方便说明，将新加入的节点设为n
2、如果n的父节点是黑色或是根节点，直接将节点的颜色设为黑色，然后返回。
3、如果n的叔叔节点是红色，则直接将父节点，叔叔节点，都设为黑色，将祖父节点设置为为红色，将n指向祖父节点，继续从第2步开始比较。
4、如果n是父节点的左节点，则将n指向父节点，然后，以n为中心，右旋转，将n节点的父节点设置为黑色，将n节点的祖父节点设为红色，然后以n节点的祖父节点为中心左旋转，然后从第二步开始比较
5、将n指向父节点，然后，以n为中心左旋转，将n节点的父节点设置为黑色，将n节点的祖父节点设为红色，然后以n节点的祖父节点为中心右旋转，然后从第二步开始比较
操作依据：
3、操作的目的，是将红色节点向root推进，叔叔节点是红色，将父节点设为黑色，则经过n的分支多了一个黑节点，将叔叔节点也设为黑色，祖父节点设为红色，经过祖父节点的分支，黑色节点都没增加。然后在根据祖父节点继续操作。
4、叔叔节点是黑色，祖父节点是黑色，如果父节点是祖父节点的左节点，将父节点设为黑色，祖父节点设为红色，此时，叔叔分支少了一个黑色节点，以祖父节点右旋转，经过叔叔分支的黑色节点就和原来一样了，因为右旋转后，父节点的右子树就变成了祖父节点的左子树，如果n是父节点的右子树，则旋转后，原来的祖父节点和其左子树都是红节点，因此，在选转前，将n指向父节点，然后按n左旋转，这样对祖父节点旋转完就不会出现父子节点都是红色节点的情形
根据key获得数据
public V get(Object key) {
Entry<K,V> p = getEntry(key);
return (p==null ? null : p.value);
}
final Entry<K,V> getEntry(Object key) {
// Offload comparator-based version for sake of performance
if (comparator != null)
return getEntryUsingComparator(key);
if (key == null)
throw new NullPointerException();
@SuppressWarnings("unchecked")
Comparable<? super K> k = (Comparable<? super K>) key;
Entry<K,V> p = root;
while (p != null) {
int cmp = k.compareTo(p.key);
if (cmp < 0)
p = p.left;
else if (cmp > 0)
p = p.right;
else
return p;
}
return null;
}删除元素
public V remove(Object key) {
Entry<K,V> p = getEntry(key);
if (p == null)
return null;
V oldValue = p.value;
deleteEntry(p);
return oldValue;
}
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;
}
}
}
/** From CLR */
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);
}
删除的逻辑为：
case1： x的左右子树不为null，则用x的后继节点的Key,Value赋值给x，然后删除x的后继节点。
case2: x只存在一个子树，用子树节点，替换x即可
case3: x没有子树，直接删除x
对case1和case2来说：
x节点删除后会破坏红黑树的2、4、5特性，为了保持红黑树特性需要对红黑树进行调整，调整策略如下：
为了保持特性5，将替换x节点位置的节点y添加一个x的颜色，例如，x原来为红色，y为黑色，替换后x为：红+黑。为了表示方便，P代表父节点，B代表兄弟节点，BL代表兄弟节点左节点，BR代表兄弟节点右节点
- x为红+黑，直接将x设置为黑色，结束
- x为黑+黑，x为root节点，直接将x设置为黑色，红黑树结构恢复，结束。
- 如果B为红色，将B设置为黑色，将P设置为红色，如果x为P的左子树，则将P左旋转，如果为右子树，则将P右旋转，重新定位B，继续向下执行
- 如果B为黑色，如果BL和BR都为黑色，则将B设置为红色，x指向P，这样P变为红+黑或者黑+黑，重新从1开始执行
- 如果B为黑色，如果x为左子树，并且BR为黑色，将BL设置为黑色，并将B设置为红色，右旋转B，并从新定位B，如果x为右子树，并且BL为黑色，将BR设置为黑色，将B设置为红色，左旋转B，并重新定位B，继续向下执行。
- 将B设置为P的颜色，将P设置为黑色，如果x为左孩子节点，则将BR设置为黑色，并左旋转P，如果x为右孩子节点，则将BL设置为黑色，并右旋转P，将x设置为root，结束。
下面，分析一下，每一步为啥要那么做。
- x为红+黑，设置为黑色后，因为经过x的分支少了一个黑色节点，设置为黑色后，满足条件5
- x为root，设置后并不影响红黑树的特性。
- B为红色，则P一定为黑色，转化后，为形成下面的4，5，6的情况
- 这个情况的处理思想：是将“x中多余的一个黑色属性上移(往根方向移动)”。 x是“黑+黑”节点，我们将x由“黑+黑”节点 变成 “黑”节点，多余的一个“黑”属性移到x的父节点中，即x的父节点多出了一个黑属性(若x的父节点原先是“黑”，则此时变成了“黑+黑”；若x的父节点原先时“红”，则此时变成了“红+黑”)。 此时，需要注意的是：所有经过x的分支中黑节点个数没变化；但是，所有经过x的兄弟节点的分支中黑色节点的个数增加了1(因为x的父节点多了一个黑色属性)！为了解决这个问题，我们需要将“所有经过x的兄弟节点的分支中黑色节点的个数减1”即可，那么就可以通过“将x的兄弟节点由黑色变成红色”来实现。经过上面的步骤(将x的兄弟节点设为红色)，多余的一个颜色属性(黑色)已经跑到x的父节点中。我们需要将x的父节点设为“新的x节点”进行处理。若“新的x节点”是“黑+红”，直接将“新的x节点”设为黑色，即可完全解决该问题；若“新的x节点”是“黑+黑”，则需要对“新的x节点”进行进一步处理。
- 如果x为左孩子，这么做是为了将B的右孩子设置为红色，以便第6步的处理。
- 为了去除x中多余的颜色，将P的颜色赋给B，将P左旋后，经过x中的黑色节点就增加了1个，就可以去除x中的节点，将BR设置为黑色，则经过B分支的黑色节点也不变。
扫一扫
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
