阅读时间:2019.1.18–1.23
一、概述
TreeMap底层为红黑树实现,最大的特点是可排序或者说天生有序。
- 关于排序:排序的方式可以按大小,也可以自定义实现Comparator ,且对于自定义的类(如User类),那么必须自己定义比较机制:
1 、方式一:User类去实现java.lang.Comparable接口,并实现其compareTo()方法。
2、方式二:写一个类(如MyCompatator)去实现java.util.Comparator接口,并实现compare()方法,然后将MyCompatator类实例对象作为TreeMap的构造方法参数进行传参(当然也可以使用匿名内部类),这些比较方法是怎么被调用的将在源码中讲解。 - 关于红黑树:红黑树首先是一颗二叉树,而且它不是完全平衡的(非AVL),相反,它是降低了对平衡性的要求,从而在增删中减少了旋转次数,提升了增删性能的同时,也没有降低查找的速度。他有五大性质:
性质1. 节点是红色或黑色。
性质2. 根节点是黑色。
性质3. 每个叶节点(NIL节点,空节点)是黑色的。
性质4. 每个红色节点的两个子节点都是黑色。(从每个叶子到根的所有路径上不能有两个连续的红色节点)
性质5. 从任一节点到其每个叶子的所有路径都包含相同数目的黑色节点。
二、树节点
可以看到,每个初始化的节点,都是黑色的
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(K key, V value, Entry<K,V> parent) {
this.key = key;
this.value = value;
this.parent = parent;
}
//方法省略
}
三、重要属性
private final Comparator<? super K> comparator;//外部比较器,红黑树有序的基础;若为空则自然有序
private transient Entry<K,V> root;//根节点
private transient int size = 0;//节点总数
private transient int modCount = 0;
private transient EntrySet entrySet;
private transient KeySet<K> navigableKeySet;
private transient NavigableMap<K,V> descendingMap;//倒序的map
四、初始化方法
TreeMap提供四种初始化方式:
如果节点内是自定义类型对象,则必须要么有外部比较器Comparator,要么有内部比较器Comparable
TreeMap():默认比较器
TreeMap(Comparator<? super K> comparator) :需要自定义比较器
TreeMap(Map<? extends K, ? extends V> m):用其他map作为参数,但value必须实现比较器
TreeMap(SortedMap<K, ? extends V> m):用已经排好序的map作为参数
下面分别对其进行分析
//使用自然排序法,key必须可以进行比较,例如int,float,String;或者树节点Entry<K,V>的K实现了Comparable接口
public TreeMap() {
comparator = null;
}
//Entry<K,V>的K可以不实现Comparable,则传参必须实现Comparator
public TreeMap(Comparator<? super K> comparator) {
this.comparator = comparator;
//例如:TreeMap< UserB, Integer> treeMapB = new TreeMap<UserB, Integer>((o1,o2)->(o1.getId()<o2.getId())?-1:1);
}
//接收一个
public TreeMap(SortedMap<K, ? extends V> m) {
comparator = m.comparator();
try {
buildFromSorted(m.size(), m.entrySet().iterator(), null, null);
} catch (java.io.IOException cannotHappen) {
} catch (ClassNotFoundException cannotHappen) {
}
}
下面的初始化方法的参数是map,map的key必须是自然可排序的
public TreeMap(Map<? extends K, ? extends V> m) {
comparator = null;
putAll(m);//把指定map的元素都复制到本map里,是一个建树的过程
}
public void putAll(Map<? extends K, ? extends V> map) {
int mapSize = map.size();
if (size==0 && mapSize!=0 && map instanceof SortedMap) {
Comparator<?> c = ((SortedMap<?,?>)map).comparator();
if (c == comparator || (c != null && c.equals(comparator))) {
++modCount;
try {
//调用下面的入口方法buildFromSorted
buildFromSorted(mapSize, map.entrySet().iterator(),
null, null);
} catch (java.io.IOException cannotHappen) {
} catch (ClassNotFoundException cannotHappen) {
}
return;
}
}
super.putAll(map);
}
下面的初始化方法的参数也是map,他针对的是节点是自定义对象的map,这样的map必须是有序的
public TreeMap(SortedMap<K, ? extends V> m) {
comparator = m.comparator();
try {
buildFromSorted(m.size(), m.entrySet().iterator(), null, null);
} catch (java.io.IOException cannotHappen) {
} catch (ClassNotFoundException cannotHappen) {
}
}
private void buildFromSorted(int size, Iterator<?> it,
java.io.ObjectInputStream str,
V defaultVal)
throws java.io.IOException, ClassNotFoundException {
this.size = size;
root = buildFromSorted(0, 0, size-1, computeRedLevel(size),
it, str, defaultVal);
}
上述两个方法的核心都是buildFromSorted,这个方法是结果就是建立红黑树。我们细致的解读这个方法。
主要思想:(翻译原意)根节点是最中心的节点。为了实现这一目的,我们必须首先递归的构建整个左子树,然后剩下的元素构建成右子树。
参数含义:level:当前所在层次;lo:子树的第一个索引位置;hi:子树的最后一个索引位置
参数定义 | 参数含义 |
---|---|
int level | 当前所在层次 |
int lo | 子树的第一个索引位置 |
int hi | 子树的最后一个索引位置 |
int redLevel | 使用最佳的红节点层级computeRedLevel |
Iterator<?> it | 遍历每个节点的迭代器 |
java.io.ObjectInputStream str | 如果没有迭代器,用readObject 来读取节点也可以,默认用的迭代器 |
V defaultVal | 用默认值填充新节点,若为空,用原map的节点填充 |
红黑树不唯一,红节点越多,树的操作越复杂,红节点最优层的算法如下:
private static int computeRedLevel(int sz) {
int level = 0;
for (int m = sz - 1; m >= 0; m = m / 2 - 1)
level++;
return level;
}
现在我们来解析buildFromSorted这个递归算法:
步骤一:先求出mid=(lo+hi)>>1,左子树即lo < mid的部分,进行逐层递归
buildFromSorted(level+1, lo, mid - 1, redLevel, it, str, defaultVal);直到到达叶节点(lo=mid)
步骤二:创建叶节点Entry<K,V> middle = new Entry<>(key, value, null);
步骤三:染色。如果当前层级==红色所在层级redLevel,涂红
步骤四:挂接左子树
步骤五:构建右子树,然后挂接到右侧
private final Entry<K,V> buildFromSorted(int level, int lo, int hi,
int redLevel,
Iterator<?> it,
java.io.ObjectInputStream str,
V defaultVal)
throws java.io.IOException, ClassNotFoundException {
if (hi < lo) return null;
//步骤一:先求出mid=(lo+hi)>>1,左子树即lo < mid的部分,进行逐层递归
int mid = (lo + hi) >>> 1;
Entry<K,V> left = null;
if (lo < mid)
left = buildFromSorted(level+1, lo, mid - 1, redLevel,it, str, defaultVal);
K key;
V value;
//步骤二:创建叶节点Entry<K,V> middle = new Entry<>(key, value, null);
if (it != null) {
if (defaultVal==null) {
Map.Entry<?,?> entry = (Map.Entry<?,?>)it.next();
key = (K)entry.getKey();
value = (V)entry.getValue();
} else {
key = (K)it.next();
value = defaultVal;
}
} else { // use stream
key = (K) str.readObject();
value = (defaultVal != null ? defaultVal : (V) str.readObject());
}
Entry<K,V> middle = new Entry<>(key, value, null);
//步骤三:染色。如果当前层级==红色所在层级redLevel,涂红
// color nodes in non-full bottommost level red
if (level == redLevel)
middle.color = RED;
//步骤四:挂接左子树
if (left != null) {
middle.left = left;
left.parent = middle;
}
//步骤五:构建右子树,然后挂接到右侧
if (mid < hi) {
Entry<K,V> right = buildFromSorted(level+1, mid+1, hi, redLevel,
it, str, defaultVal);
middle.right = right;
right.parent = middle;
}
return middle;
}
经过buildFromSorted之后得到了一颗红黑树
五、重要public方法
增删操作会影响树的平衡,要进行旋转,所以增删要仔细分析
功能性方法
public int size()//
public boolean containsKey(Object key)
public boolean containsValue(Object value)
public Comparator<? super K> comparator()
public void putAll(Map<? extends K, ? extends V> map)
public Object clone()
“增”类方法
public V put(K key, V value)
“删”类方法
public V remove(Object key)
public void clear()
“改”类方法
public V replace(K key, V value)
public boolean replace(K key, V oldValue, V newValue)
“查”类方法
public V get(Object key)
public K firstKey()
public K lastKey()
public Map.Entry<K,V> firstEntry()
public Map.Entry<K,V> lastEntry()
public Map.Entry<K,V> pollFirstEntry()
public Map.Entry<K,V> pollLastEntry()
public Map.Entry<K,V> lowerEntry(K key)
public Map.Entry<K,V> ceilingEntry(K key)
public Map.Entry<K,V> higherEntry(K key)
public K lowerKey(K key)
public K higherKey(K key)
public K ceilingKey(K key)
public Map.Entry<K,V> floorEntry(K key)
函数式方法
public void forEach(BiConsumer<? super K, ? super V> action)
public void replaceAll(BiFunction<? super K, ? super V, ? extends V> function)
1.功能性方法
1)containsKey:查找map中是否存在key,遍历所有key。如果有外部比较器,使用外部比较器查找;如果没有,用自然序查找该key,小于当前节点,找左子树,大于当前节点,找右子树
public boolean containsKey(Object key) {
return getEntry(key) != null;
}
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;
}
2)containsValue:查找map中是否有对应的value这个for循环很关键。起始是树的最小节点,增加条件是顺序取下一个节点successor(e)按这样的顺序:目前节点是否有右节点?有则指向右节点的最小左节点;如果没有,取上一层(parent)节点。
真正的取value,判断value过程很简单
public boolean containsValue(Object value) {
for (Entry<K,V> e = getFirstEntry(); e != null; e = successor(e))
if (valEquals(value, e.value))
return true;
return false;
}
//取map中最小的节点,即左子树的最下层左节点
final Entry<K,V> getFirstEntry() {
Entry<K,V> p = root;
if (p != null)
while (p.left != null)
p = p.left;
return p;
}
//取下一个节点
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;
}
}
//判断两者是否一致
static final boolean valEquals(Object o1, Object o2) {
return (o1==null ? o2==null : o1.equals(o2));
}
3)putAll已在初始化方法中详尽的分析了
2.“增”类方法
put方法把<key,value>插入到树中,整体分为三步:
第一步:找到应插入的位置。同样的,如果有外部比较器,就用外部比较器进行排序;如果没有外部比较器Comparator,就用内部比较器Comparable。找插入位置时,分以下情况:当遍历树节点t时,如果t.key<key,则往左子树找;若t.key>key,则往右子树找;如果t.key==key,则替换掉原值。前两种情况可能需要进行再平衡,最后一种情况不需要再平衡,直接返回
第二步:插入节点
第三步:再平衡红黑树
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;
// 第一步查找要插入的位置,并没真的插入
Comparator<? super K> cpr = comparator;
if (cpr != null) {//用外部比较器Comparator找插入的位置
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 {//用内部比较器Comparable找插入的位置
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);//如果相等,直接把新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,这里有个地方很有意思。我们知道在创建节点时,我们的节点时黑的boolean color = BLACK;这是因为默认创建的是叶子节点NIL,一定必须是黑的。但是当要进行插入树中时,他变成了节点,先把他染红。实际是可以用黑节点插入的,但它需要旋转的次数会多。所以先染红。对于如何调整红黑树,当三种情况时,需要调整。
三个case都要满足的条件:(x不是叶节点 && x不是根节点 && x的父节点是红的)
此时,违背原则4(不能有两个连续的红节点),且以下假定了X的父节点是左子树,右子树时是一样的
case 1:如果当X的父节点的兄弟节点也为红时,采用以下方法来重新平衡,设父节点的兄弟节点为Y,操作步骤如下:
- 将父节点染黑 setColor(parentOf(x), BLACK);
- 将父亲的兄弟节点染黑 setColor(y, BLACK);
- 将父亲的父亲节点染红 setColor(parentOf(parentOf(x)), RED);
- 此时父亲的父亲节点至根节点可能再次不平衡,所以继续把X指向祖父节点进行再平衡x = parentOf(parentOf(x));
抽出来的代码如下:
private void fixAfterInsertion(Entry<K,V> x) {
while (x != null && x != root && x.parent.color == RED) {//如果当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));
}
//...省略代码
}
case 2:当父节点的兄弟节点是黑色,并且X是父节点的右子节点。操作步骤如下:
- 把X的父节点作为操作节点 x = parentOf(x);
- 左旋转 rotateLeft(x);
- 转化为case 3,再通过case 3进行调整
在case 3中再给出剥离后的代码
case 3:当父节点的兄弟节点是黑色,并且X是父节点的左子节点。操作步骤如下:
- 将父节点染黑 setColor(parentOf(x), BLACK);
- 将父节点的父节点染红 setColor(parentOf(parentOf(x)), RED);
- 以父节点做右旋转 rotateRight(parentOf(parentOf(x)));
抽出来的代码如下:
private void fixAfterInsertion(Entry<K,V> x) {
//...省略代码
if (x == rightOf(parentOf(x))) {//case 2,把case 2转化成 case 3
x = parentOf(x);
rotateLeft(x);
}
setColor(parentOf(x), BLACK); //case 3
setColor(parentOf(parentOf(x)), RED);
rotateRight(parentOf(parentOf(x)));
//...省略代码
}
注:上述三个case是在X的父节点是祖父节点的左子树条件下的,如果是右子树,结论一样,总的代码:
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) { //case 1
setColor(parentOf(x), BLACK);
setColor(y, BLACK);
setColor(parentOf(parentOf(x)), RED);
x = parentOf(parentOf(x));
} else {
if (x == rightOf(parentOf(x))) { //case 2
x = parentOf(x);
rotateLeft(x);
}
setColor(parentOf(x), BLACK); //case 3
setColor(parentOf(parentOf(x)), RED);
rotateRight(parentOf(parentOf(x)));
}
} else {//当前父节点是祖父节点的右子树
Entry<K,V> y = leftOf(parentOf(parentOf(x)));//只在此处有差异
if (colorOf(y) == RED) { //case 1
setColor(parentOf(x), BLACK);
setColor(y, BLACK);
setColor(parentOf(parentOf(x)), RED);
x = parentOf(parentOf(x));
} else {
if (x == leftOf(parentOf(x))) { //case 2
x = parentOf(x);
rotateRight(x);
}
setColor(parentOf(x), BLACK); //case 3
setColor(parentOf(parentOf(x)), RED);
rotateLeft(parentOf(parentOf(x)));
}
}
}
root.color = BLACK;
}
3.“删”类方法
1)、remove
与put方法类似,remove方法也可以分为两个步骤进行:
第一步:将红黑树当作一颗二叉查找树,将节点删除。这和"删除常规二叉查找树中删除节点的方法是一样的"。分3种情况:
- 被删除节点没有儿子,即为叶节点。那么,直接将该节点删除就OK了。
- 被删除节点只有一个儿子。那么,直接删除该节点,并用该节点的唯一子节点顶替它的位置。
- 被删除节点有两个儿子。那么按一下顺序
1)先找出它的后继节点;
2)然后把“它的后继节点的内容”复制给“该节点的内容”;
3)之后,删除“它的后继节点”。
在这里,后继节点相当于替身,在将后继节点的内容复制给"被删除节点"之后,再将后继节点删除。这样就巧妙的将问题转换为"删除后继节点"的情况了,下面就考虑后继节点。 在"被删除节点"有两个非空子节点的情况下,它的后继节点不可能是双子非空。既然"的后继节点"不可能双子都非空,就意味着"该节点的后继节点"要么没有儿子,要么只有一个儿子。若没有儿子,则按"情况① "进行处理;若只有一个儿子,则按"情况② "进行处理。在这里,后继节点相当于替身,在将后继节点的内容复制给"被删除节点"之后,再将后继节点删除。这样就巧妙的将问题转换为"删除后继节点"的情况了,下面就考虑后继节点。 在"被删除节点"有两个非空子节点的情况下,它的后继节点不可能是双子非空。既然"的后继节点"不可能双子都非空,就意味着"该节点的后继节点"要么没有儿子,要么只有一个儿子。若没有儿子,则按"情况① "进行处理;若只有一个儿子,则按"情况② "进行处理。
第二步:通过"旋转和重新着色"等一系列来修正该树,使之重新成为一棵红黑树。
整体代码如下:
public V remove(Object key) {
Entry<K,V> p = getEntry(key); //containKey方法中有介绍
if (p == null)
return null;
V oldValue = p.value;
deleteEntry(p);
return oldValue;
}
private void deleteEntry(Entry<K,V> p) {
modCount++;
size--;
//第一步,将红黑树当作一颗二叉查找树,将节点删除,先预处理有双孩子的节点
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.
//只有单孩子节点(双孩子节点的P已经到达叶子节点,此时的p无孩子,所以不会再次处理双孩子的节点了)
Entry<K,V> replacement = (p.left != null ? p.left : p.right);
if (replacement != null) {//p有一个孩子,用p的孩子替代自己的位置
// Link replacement to parent
replacement.parent = p.parent;//把p的孩子的parent指向p的parent,即删掉p
if (p.parent == null)//删除的p是根节点了,则用p的孩子做根
root = replacement;
else if (p == p.parent.left)
//p不是根节点时,若p是左节点,则把p->parent.left指向p的孩子
p.parent.left = replacement;
else
//p不是根节点时,若p是右节点,则把p->parent.right指向p的孩子
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.
//要删除的是叶子节点,或者要删除的节点p已经和后继节点置换了,直接删除它
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;
}
}
}
再平衡fixAfterDeletion
假设要删除的节点为x,替换他的节点是y(x有双孩子,y是x的后继节点;x有单孩子时,y是x的孩子;x没有孩子,y一个黑色叶子NIL)。则有四种情况需要进行再平衡:
case 1:x是黑的,y是黑的(或者y是叶子节点),并且x的兄弟节点是红的,调整步骤如下:
- 把x的兄弟节点染黑 setColor(sib, BLACK);
- 把x的父节点染红 setColor(parentOf(x), RED);
- 以x的父节点做左旋转 rotateLeft(parentOf(x));
- 重新设置x的兄弟节点 sib = rightOf(parentOf(x));
相应的剥离代码块:
private void fixAfterDeletion(Entry<K,V> x) {
while (x != root && colorOf(x) == BLACK) {
//...省略代码
if (colorOf(sib) == RED) {//case 1
setColor(sib, BLACK);
setColor(parentOf(x), RED);
rotateLeft(parentOf(x));
sib = rightOf(parentOf(x));
}
//...省略代码
}
}
case 2:x是黑的,y也是黑的;并且x的兄弟节点是黑的,并且兄弟节点的两个孩子也是黑的
- 将x的兄弟节点设为“红色”。
- 设置“x的父节点”为“新的x节点”。
相应的剥离代码块:
private void fixAfterDeletion(Entry<K,V> x) {
while (x != root && colorOf(x) == BLACK) {
//...省略代码
if (colorOf(leftOf(sib)) == BLACK && colorOf(rightOf(sib)) == BLACK) {
setColor(sib, RED);
x = parentOf(x);
}
//...省略代码
}
}
case 3:x是黑的,y也是黑的;并且x的兄弟节点是黑的,并且兄弟节点的左孩子是红,右孩子为黑
- 将x兄弟节点的左孩子设为“黑色”。 setColor(leftOf(sib), BLACK);
- 将x兄弟节点设为“红色”。 setColor(sib, RED);
- 对x的兄弟节点进行右旋。 rotateRight(sib);
- 右旋后,重新设置x的兄弟节点。 sib = rightOf(parentOf(x));
最终转化为case 4
与case 4一起剥离代码。
case 4:x是黑色的,y也是黑的;x的兄弟节点是黑色;x的兄弟节点的右孩子是红色的,x的兄弟节点的左孩子任意颜色
- 将x父节点颜色 赋值给 x的兄弟节点。 setColor(sib, colorOf(parentOf(x)));
- 将x父节点设为“黑色”。 setColor(parentOf(x), BLACK);
- 将x兄弟节点的右子节设为“黑色”。 setColor(rightOf(sib), BLACK);
- 对x的父节点进行左旋。 rotateLeft(parentOf(x));
- 设置“x”为“根节点”,把25号节点删掉,红黑树再次平衡。 x = root;
相应的剥离代码块:
private void fixAfterDeletion(Entry<K,V> x) {
while (x != root && colorOf(x) == BLACK) {
//...省略代码
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;
//...省略代码
}
}
完整的fixAfterDeletion如下:
private void fixAfterDeletion(Entry<K,V> x) {
while (x != root && colorOf(x) == BLACK) {//遇到红节点,调整结束
if (x == leftOf(parentOf(x))) {//x是左子树,(x是右子树时是一样的)
Entry<K,V> sib = rightOf(parentOf(x));
if (colorOf(sib) == RED) {//case 1:兄弟节点是红的
setColor(sib, BLACK);
setColor(parentOf(x), RED);
rotateLeft(parentOf(x));
sib = rightOf(parentOf(x));
}
if (colorOf(leftOf(sib)) == BLACK &&
colorOf(rightOf(sib)) == BLACK) {//case 2:兄弟节点两个孩子都是黑色的
setColor(sib, RED);
x = parentOf(x);
} else {
if (colorOf(rightOf(sib)) == BLACK) {//case 3:兄弟节点左孩子红,右孩子黑
//转化成case 4
setColor(leftOf(sib), BLACK);
setColor(sib, RED);
rotateRight(sib);
sib = rightOf(parentOf(x));
}
setColor(sib, colorOf(parentOf(x)));//case 4:兄弟节点右孩子红,左孩子任意
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);
}
2)、clear
clear很简单,把跟置空空,就会逐层瓦解整棵树
public void clear() {
modCount++;
size = 0;
root = null;
}
4.“改”类方法
改类方法(改变V)不会使得红黑树失去平衡(是依据key排序的),所以较简单。有两个方法
V replace(K key, V value):用value替换当前K处的old value;如果old value为空,不能替换。
boolean replace(K key, V oldValue, V newValue):只有树中old value==传入参数的oldvalue时才进行替换,否则返回false
public V replace(K key, V value) {
Entry<K,V> p = getEntry(key);
if (p!=null) {
V oldValue = p.value;
p.value = value;
return oldValue;
}
return null;
}
public boolean replace(K key, V oldValue, V newValue) {
Entry<K,V> p = getEntry(key);
if (p!=null && Objects.equals(oldValue, p.value)) {
p.value = newValue;
return true;
}
return false;
}
5.“查”类方法
get类方法不会影响树的平衡,所以与一般的容器取值没有太大差别。
分为获取key,获取value,和获取entry<k,v>
1)V get(Object key)
直接调用的getEntry
public V get(Object key) {
Entry<K,V> p = getEntry(key);
return (p==null ? null : p.value);
}
2)获取key的方法:都比较简单
public K firstKey():获得最小的key
public K lastKey():获得最大的key
public K lowerKey(K key):获得比参数key上一个小的k
public K higherKey(K key):获得比参数key下一个大的k
public K ceilingKey(K key):获得比该键至少大于或等于的k
public K firstKey() {
return key(getFirstEntry());////一直往左子树里找
}
public K lastKey() {
return key(getLastEntry());//一直往右子树里找
}
public K lowerKey(K key) {
return keyOrNull(getLowerEntry(key));
}
public K higherKey(K key) {
return keyOrNull(getHigherEntry(key));
}
public final K ceilingKey(K key) {
return keyOrNull(getCeilingEntry(key));
}
3)获取entry的方法
public Map.Entry<K,V> firstEntry() :获得K最小的那个entry
public Map.Entry<K,V> lastEntry() :获得K最大的那个entry
public Map.Entry<K,V> pollFirstEntry():获得K最小的那个entry,并把它移除出树
public Map.Entry<K,V> pollLastEntry():获得K最大的那个entry,并把它移除出树
public Map.Entry<K,V> lowerEntry(K key):获得比K小一个的那个entry
public Map.Entry<K,V> ceilingEntry(K key):获得比该K至少大于或等于的entry
public Map.Entry<K,V> higherEntry(K key):获得比K大一个的那个entry
public Map.Entry<K,V> floorEntry(K key):获得比K小一个的那个entry
public Map.Entry<K,V> firstEntry() {
return exportEntry(getFirstEntry());
}
public Map.Entry<K,V> lastEntry() {
return exportEntry(getLastEntry());
}
public Map.Entry<K,V> pollFirstEntry() {
Entry<K,V> p = getFirstEntry();
Map.Entry<K,V> result = exportEntry(p);
if (p != null)
deleteEntry(p);
return result;
}
public Map.Entry<K,V> pollLastEntry() {
Entry<K,V> p = getLastEntry();
Map.Entry<K,V> result = exportEntry(p);
if (p != null)
deleteEntry(p);
return result;
}
public Map.Entry<K,V> higherEntry(K key) {
return exportEntry(getHigherEntry(key));
}
public Map.Entry<K,V> lowerEntry(K key) {
return exportEntry(getLowerEntry(key));
}
public Map.Entry<K,V> ceilingEntry(K key) {
return exportEntry(getCeilingEntry(key));
}
public Map.Entry<K,V> floorEntry(K key) {
return exportEntry(getFloorEntry(key));
}
6.函数式方法
1) forEach(BiConsumer<? super K, ? super V> action)
二元函数,使用方法:treeMapB.forEach((k,v)->System.out.println(" key = " + k.getId() + ", value = " + v));
在HashMap中详尽的解读过,除了遍历的for语句有差别,其他都一样
public void forEach(BiConsumer<? super K, ? super V> action) {
Objects.requireNonNull(action);
int expectedModCount = modCount;
for (Entry<K, V> e = getFirstEntry(); e != null; e = successor(e)) {
action.accept(e.key, e.value);
if (expectedModCount != modCount) {
throw new ConcurrentModificationException();
}
}
}
2) replaceAll(BiFunction<? super K, ? super V, ? extends V> function)
二元函数式,使用方法treeMapB.replaceAll((k,v)->(int)k.getAccount()+v);//把每个key的Account值加目前的value,替换 oldvalue
遍历所有节点,处理function.apply(e.key, e.value);把新值进行赋值
public void replaceAll(BiFunction<? super K, ? super V, ? extends V> function) {
Objects.requireNonNull(function);
int expectedModCount = modCount;
for (Entry<K, V> e = getFirstEntry(); e != null; e = successor(e)) {
e.value = function.apply(e.key, e.value);
if (expectedModCount != modCount) {
throw new ConcurrentModificationException();
}
}
}
六、重要内部类
分为四种:
1.内部容器类:KeySet,Values,EntrySet。注意这三个有区别
- KeySet是有序的set(实现NavigableSet接口)
- Values和EntrySet是无序的,Values是AbstractCollection,EntrySet是AbstractSet。这是因为Values可以有重复的值,所以普通容器就好;但是EntrySet必须不能重复
2.迭代器类:EntryIterator,ValueIterator,KeyIterator均继承于PrivateEntryIterator,具体实现均在后者。另外红黑树还提供了DescendingKeyIterator,倒序的key迭代器,具体实现也是在PrivateEntryIterator中
3.子map以及子map的迭代器类:SubMap,AscendingSubMap(正序),DescendingSubMap(反序)。对应的迭代器:SubMapEntryIterator,DescendingSubMapEntryIterator,SubMapKeyIterator,DescendingSubMapKeyIterator
4.并行遍历迭代器:TreeMapSpliterator,KeySpliterator,DescendingKeySpliterator,ValueSpliterator,EntrySpliterator
每一种类型的实现都比较相似,择一来详读
1、内部容器类
遍历时,经常要用到EntrySet例如:for(Map.Entry<K,V> e: map.entrySet()),此时便会调用EntrySet
public Set<Map.Entry<K,V>> entrySet() {
EntrySet es = entrySet;
return (es != null) ? es : (entrySet = new EntrySet());
}
它有如下方法,只能删除entry,不能插入entry
class EntrySet extends AbstractSet<Map.Entry<K,V>> {
public Iterator<Map.Entry<K,V>> iterator() {
return new EntryIterator(getFirstEntry());
}
public boolean contains(Object o) {
if (!(o instanceof Map.Entry))
return false;
Map.Entry<?,?> entry = (Map.Entry<?,?>) o;
Object value = entry.getValue();
Entry<K,V> p = getEntry(entry.getKey());
return p != null && valEquals(p.getValue(), value);
}
public boolean remove(Object o) {
if (!(o instanceof Map.Entry))
return false;
Map.Entry<?,?> entry = (Map.Entry<?,?>) o;
Object value = entry.getValue();
Entry<K,V> p = getEntry(entry.getKey());
if (p != null && valEquals(p.getValue(), value)) {
deleteEntry(p);
return true;
}
return false;
}
public int size() {
return TreeMap.this.size();
}
public void clear() {
TreeMap.this.clear();
}
public Spliterator<Map.Entry<K,V>> spliterator() {
return new EntrySpliterator<K,V>(TreeMap.this, null, null, 0, -1, 0);
}
}
2、迭代器类
倒序key遍历器DescendingKeyIterator。提供向前遍历方法prevEntry(),向后遍历nextEntry()
倒序的next=正序的prev
final class DescendingKeyIterator extends PrivateEntryIterator<K> {
DescendingKeyIterator(Entry<K,V> first) {
super(first);
}
public K next() {
return prevEntry().key;
}
public void remove() {
if (lastReturned == null)
throw new IllegalStateException();
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
deleteEntry(lastReturned);
lastReturned = null;
expectedModCount = modCount;
}
}
3、子map以及子map的迭代器类
切分有有三种方式,自定义切,切头,切尾,最终都会新建一个AscendingSubMap类
public SortedMap<K,V> subMap(K fromKey, K toKey):
public SortedMap<K,V> headMap(K toKey)
public SortedMap<K,V> tailMap(K fromKey)
//例如:
public SortedMap<K,V> tailMap(K fromKey) {
return tailMap(fromKey, true);
}
public NavigableMap<K,V> tailMap(K fromKey, boolean inclusive) {
return new AscendingSubMap<>(this,
false, fromKey, inclusive,
true, null, true);
}
submap的迭代器的结构与TreeMap的迭代器结构一样。没有与主map共用一套迭代器,我想是为了更模块化,以及减少错误吧。subMap是浅拷贝,对subMap的改动也会影响到TreeMap。
4、并行遍历器类
TreeMap提供5种并行遍历器:
- TreeMapSpliterator:没找到入口在哪?
- KeySpliterator:对Key的遍历器–>使用入口在KeySet.spliterator()
- DescendingKeySpliterator:没找到入口在哪?
- ValueSpliterator :对值的遍历器–>使用入口在Values.spliterator()
- EntrySpliterator:对entry的遍历器–>使用入口在EntrySet.spliterator()
提供的主要方法,和HashMap中的基本一样,以entry为例
public EntrySpliterator<K,V> trySplit()
public void forEachRemaining(Consumer<? super Map.Entry<K, V>> action)
public boolean tryAdvance(Consumer<? super Map.Entry<K,V>> action)
多线程时,每个线程切一小段trySplit(),然后处理forEachRemaining,从而达到并发的效果
七、测试类
测试用用,用于做key,分为实现Comparable接口的UserA,和不实现的UserB
public class UserA implements Comparable<UserA>{
int id;
String name;
long account;
public UserA(int id, String name, long account) {
this.id = id;
this.name = name;
this.account = account;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public long getAccount() {
return account;
}
public void setAccount(long account) {
this.account = account;
}
@Override
public int compareTo(UserA o) {
// TODO Auto-generated method stub
return (this.getId()<o.getId())?-1:1;
}
}
不实现Comparable接口的UserB
public class UserB {
int id;
String name;
long account;
public UserB(int id, String name, long account) {
this.id = id;
this.name = name;
this.account = account;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public long getAccount() {
return account;
}
public void setAccount(long account) {
this.account = account;
}
}
测试用main
public static void main(String[] args) {
//测试组1:使用默认方法创建TreeMap,按Id正序建立
System.out.println("测试组1:使用内部比较器comparable创建TreeMap");
TreeMap< UserA, Integer> treeMapA = new TreeMap<UserA, Integer>();
UserA a = new UserA(1, "userA 1",100);
treeMapA.put(new UserA(1, "userA 1",100), 1);
treeMapA.put(new UserA(3, "userA 3",300), 3);
treeMapA.put(new UserA(2, "userA 2",200), 2);
treeMapA.forEach((k,v)->System.out.println(" key = " + k.getId() + ", value = " + v));
treeMapA = null;//干掉map
//测试组2:使用自定义Comparator方法创建TreeMap,按Id正序建立
System.out.println("测试组2:使用外部比较器Compartor创建TreeMap");
TreeMap< UserB, Integer> treeMapB = new TreeMap<UserB, Integer>((o1,o2)->(o1.getId()<o2.getId())?-1:1);
treeMapB.put(new UserB(1, "userB 1",100), 1);
treeMapB.put(new UserB(3, "userB 3",300), 3);
treeMapB.put(new UserB(2, "userB 2",200), 2);
treeMapB.forEach((k,v)->System.out.println(" key = " + k.getId() + ", value = " + v));
//测试组3:测试lowerEntry,并对其进行修改,可以看到影响到原map
System.out.println("测试组3:测试lowerEntry,并对其进行修改,可以看到影响到原map");
Map.Entry<UserB, Integer> b = treeMapB.lowerEntry(new UserB(5, "userB 1",100));
b.getKey().setId(4);
treeMapB.forEach((k,v)->System.out.println(" key = " + k.getId() + ", value = " + v));
b.getKey().setId(3);
//测试组4:测试replaceAll
System.out.println("测试组4:测试firstKey,并对其进行修改,可以看到不影响到原map");
treeMapB.replaceAll((k,v)->(int)k.getAccount()+v);
treeMapB.forEach((k,v)->System.out.println(" key = " + k.getId() + ", value = " + v));
//测试组5:测试subMap
System.out.println("测试组5:测试subMap");
SortedMap< UserB, Integer> treeMapC = treeMapB.subMap(new UserB(1, "userB 1",100), new UserB(3, "userB 1",100));
System.out.println("分割后的subMap");
treeMapC.forEach((k,v)->System.out.println(" key = " + k.getId() + ", value = " + v));
System.out.println("分割后的主Map");
treeMapB.forEach((k,v)->System.out.println(" key = " + k.getId() + ", value = " + v));
//测试组6:测试Spliterator
System.out.println("测试组6:测试Spliterator");
Set<Map.Entry<UserB, Integer>> entry = treeMapB.entrySet();
Spliterator<Entry<UserB, Integer>> sit = entry.spliterator();
//切割一次,遍历切掉的部分:
System.out.println("切割一次,遍历切剩下的部分:");
sit.trySplit().forEachRemaining(e->System.out.println(" key = " + e.getKey().getId()));
//遍历剩下的部分:
System.out.println("遍历剩下的部分:");
sit.forEachRemaining(e->System.out.println(" key = " + e.getKey().getId()));
}
八、总结
- TreeMap是有序的,实现的原理是Key自然有序(int,long等),或实现Comparable接口,或者提供外部比较器
- TreeMap是实现TreeSet的基础
- 左旋,右旋;put,remove操作
- 待补充