TreeMap
非线程安全的不可重复元素的可排序键值对
继承AbstractMap，为Map的骨架实现；
实现了Cloneable，实现浅克隆；
实现了序列化接口，并自定义了readObject、writeObject方法
实现了NavigableMap接口（继承SortedMap），提供了双向查询遍历的相关方法，提供了取得正序及倒序的keySet方法
采用红黑树的数据结构，该数据结构是一颗自平衡二叉查找树（高度log2N），每个节点标注了红或黑的颜色。
红黑树的5个性质如下：
1、节点是红色或黑色
2、根节点是黑色
3、所有的叶子（NIL空节点）是黑色的
4、每个红色节点的两个儿子均为黑色，即不可能有连续的两个红色节点
5、从任一节点到其叶子（NIL空节点）的路径都包含相同数目的黑节点
该性质为平衡的关键，需要注意理解是到NIL空节点的路径
与性质4一起，可推得一个红色节点如果有孩子必然只能有两个黑孩子
TreeMap对红黑树的实现的分析
红黑树的插入
算法时间复杂度约为O(log2N)，并且其与普通查找二叉树比较，插入的旋转次数很少
JDK1.6与JDK1.8基本类似，下面列出JDK1.6的代码：
public V put(K key, V value) {//插入或设置元素，返回原始value值（如果插入返回null）
Entry<K,V> t = root;
if (t == null) {//根元素为空时直接建立根元素
// TBD:
// 5045147: (coll) Adding null to an empty TreeSet should
// throw NullPointerException
//
// compare(key, key); // type check
root = new Entry<K,V>(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);//相等直接进行value设置
} while (t != null);
}
else {//不存在比较器，按compareTo方法查找
if (key == null)
throw new NullPointerException();
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<K,V>(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));//x设置为父元素的父元素，继续进行判定
} else {//叔节点不可能为黑色，故下面为无叔节点情况，必然需要进行旋转
if (x == rightOf(parentOf(x))) {//如果当前元素为其父的右节点
x = parentOf(x);//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));//x设置为父元素的父元素，继续进行判定
} else {//叔节点不可能为黑色，故下面为无叔节点情况，必然需要进行旋转
if (x == leftOf(parentOf(x))) {//如果当前元素为其父的左节点
x = parentOf(x);//x设置为父元素，继续进行判定
rotateRight(x);//进行右旋操作
}
setColor(parentOf(x), BLACK);
setColor(parentOf(parentOf(x)), RED);
rotateLeft(parentOf(parentOf(x)));//进行左旋操作
}
}
}
root.color = BLACK;//根节点设置为黑色
}
插入节点必定是末端节点，插入节点总是红色的（保证不会破坏性质5）
情况1 黑父
插入节点后可维持红黑树性质
情况2 红父
插入节点后不能维持红黑树性质4，故可能需要进行着色或旋转操作
该情况下，红父肯定没有孩子（红父只可能有两个黑孩子）
下面假设父亲为左节点进行分析（右节点的情况类似，只是旋转方向相反）
情况2.1 红父、红叔
根据红黑树的性质5可推得，红叔肯定没有孩子
插入新节点只破坏了颜色的性质，故进行重新着色再按祖向上继续判断即可
情况2.2 红父、黑叔
由于红父没有孩子，根据红黑树的性质5可推得，该情况的黑叔实际只可能为空的NIL节点
插入新节点不仅破坏了颜色的性质，还破坏了平衡，故需要进行重新着色和旋转
此时新节点的左右位置影响具体的旋转方式
情况2.2.1 红父、无叔、插入左节点
重新着色并按祖右旋
情况2.2.2 红父、无叔、插入右节点
按父左旋，并指向父继续判断（即接着按情况2.2.1处理）
红黑树的查询
由于红黑树为有序的二叉查找树，故可以按照二叉查找树的查找方法进行查找操作；算法时间复杂度约为O(log2N)
1、按照key值查找
public V get(Object key) {//根据key值查找value
Entry<K,V> p = getEntry(key);
return (p==null ? null : p.value);
} final Entry<K,V> getEntry(Object key) {//根据key值查找元素方法；final方法不允许被子类重写
// Offload comparator-based version for sake of performance
if (comparator != null)//存在比较器，按比较器进行比较查找
return getEntryUsingComparator(key);
if (key == null)//key值为null抛空指针异常
throw new NullPointerException();
Comparable<? super K> k = (Comparable<? super K>) key;
Entry<K,V> p = root;
while (p != null) {//从root开始循环查找，一直到叶子节点
int cmp = k.compareTo(p.key);//采用key的compareTo方法进行比较
if (cmp < 0)//小于继续查找左边
p = p.left;
else if (cmp > 0)//大于继续查找右边
p = p.right;
else
return p;//等于返回当前元素
}
return null;
} final Entry<K,V> getEntryUsingComparator(Object key) {//比较器查找元素方法
K k = (K) key;
Comparator<? super K> cpr = comparator;
if (cpr != null) {
Entry<K,V> p = root;
while (p != null) {
int cmp = cpr.compare(k, p.key);//采用比较器进行比较
if (cmp < 0)
p = p.left;
else if (cmp > 0)
p = p.right;
else
return p;
}
}
return null;
}2、遍历方法：正序遍历
final Entry<K,V> getFirstEntry() {//取首元素
Entry<K,V> p = root;
if (p != null)
while (p.left != null)//循环查找最左端元素
p = p.left;
return p;
} final Entry<K,V> nextEntry() {
Entry<K,V> e = next;
if (e == null)
throw new NoSuchElementException();
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
next = successor(e);
lastReturned = e;
return e;
}
static <K,V> TreeMap.Entry<K,V> successor(Entry<K,V> t) {//查找下一个元素
if (t == null)
return null;//空元素返回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;//返回父元素
}
}3、遍历方法：倒序遍历
final Entry<K,V> getLastEntry() {//取末元素
Entry<K,V> p = root;
if (p != null)
while (p.right != null)//循环查找最右端元素
p = p.right;
return p;
} static <K,V> Entry<K,V> predecessor(Entry<K,V> t) {//查找上一个元素
if (t == null)
return null;//空元素返回null
else if (t.left != null) {//先查找左边
Entry<K,V> p = t.left;
while (p.right != null)//循环查找该子树的最右元素
p = p.right;
return p;
} else {//右边为空
Entry<K,V> p = t.parent;//父元素
Entry<K,V> ch = t;//当前元素
while (p != null && ch == p.left) {//循环查找父节点（到顶层节点或当前元素为父亲的右节点时停下）
ch = p;
p = p.parent;
}
return p;//返回父元素
}
}
红黑树的删除
由于红黑树为有序的二叉查找树，它的删除也与二叉查找树类似，先找到真正删除点，再进行实际的替换及删除；算法时间复杂度约为O(log2N)
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的数据替换为该元素数据
p = s;//将p指向该元素，作为原始元素（被删除元素）
} // 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;
}
}
}
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);//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);//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);//将x置为黑色
}
真正删除的节点并不一定是传入节点，当其有两个孩子时，会查找下一个节点作为真正的删除点
由遍历方法可知，该节点一定是没有孩子或只有一个孩子
再按红黑树的性质推断：
1、该节点如果为红色，必然为叶子节点
2、该节点如果为黑色，只可能有一个红色孩子或无孩子
那么删除该节点就有下面的几种情况
情况1 该节点为红
删除无孩子的红色不破坏红黑树性质，直接删除即可
情况2 该节点为黑色，并且有一个红色孩子
将红色孩子放置到该节点位置，并着色为黑，即满足了红黑树性质
情况3 该节点为黑色，并且没有孩子
下面假设删除节点为左节点进行分析（右节点的情况类似，只是旋转方向相反）
情况3.1 黑色 红兄
此情况红兄必然有两个孩子，删除后同时影响平衡及颜色性质，故需要重新着色及旋转操作
图片中侄下面的情况未标注，可能有零至数个红色孩子
情况3.2 黑色 黑兄
此情况删除后也同时影响平衡及颜色性质，故需要重新着色及旋转操作
情况3.2.1 黑色 黑兄-无孩子
该情况重新着色即可
情况3.2.2 黑色 黑兄-左孩子
该情况需要重新着色及旋转
情况3.2.3 黑色 黑兄-右孩子
该情况需要重新着色及旋转
其他要点
1、作为一个可排序的结构，提供了可传入的比较器以及直接使用Object.compareTo两种模式进行选择
2、与其他的集合类相同，均提供了拷贝构造器
3、提供了正序、倒序的keySet；提供了KeyIterator、DescendingKeyIterator；EntryIterator；ValueIterator
扫一扫
1883
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
