二叉树在查询操作中表现出较快的速度，但前提是，它是平衡二叉树，平衡二叉树的左右子树的节点平均分布，这样使得查找时间O(lg n)，平衡二叉树有以下特点：
二叉树是空树，或者它的左右子树的高度差的绝对值不超过1，而且左右子树也是平衡二叉树。
为保证二叉树是平衡二叉树，有各种算法实现，其中java中使用红黑树的算法来实现了平衡二叉树。红黑树有以下性质：
1、每个节点要么是红色，要么是黑色
2、根节点是黑色
3、每个叶子节点（NULL节点，空节点）都是黑色
4、一条路径上，不能出现两个相邻的红色节点，即是，每个红色节点的左右子节点都是黑色
5、对于每个节点到它的叶子节点的路径上所包含的黑色节点数量都是相同的。
在java中，TreeMap是红黑二叉树的实现，下面从源码上来了解红黑树。
TreeMap.Entry是TreeMap保存树节点，如下图。
TreeMap.Entry的源码:
//树的节点，要么红色，要么是黑色
private static final boolean RED = false;
private static final boolean BLACK = true;
/**
* Node in the Tree. Doubles as a means to pass key-value pairs back to
* user (see Map.Entry).
*/
static final class Entry<K,V> implements Map.Entry<K,V> {
K key;
V value;
Entry<K,V> left = null;
Entry<K,V> right = null;
Entry<K,V> parent;
boolean color = BLACK;
/**
* Make a new cell with given key, value, and parent, and with
* <tt>null</tt> child links, and BLACK color.
*/
Entry(K key, V value, Entry<K,V> parent) {
this.key = key;
this.value = value;
this.parent = parent;
}
//其它省略
}
一、添加树的节点
第一次put树的节点时，创建一个TreeMap.Entry对象，即是root节点，root节点的parent、left、right节点都为null
第二次put节点时,从root节点开始遍历。
当前节点t=root，
1.如果Comparator（比较器）不为null:
使用Comparator.compare方法比较key和t.key，
如果key < t.key，则遍历左子树（t = t.left），t变为父节点parent;
如果key > t.key，则遍历右子树（t = t.right），t变为父节点parent；
否则，key和t.key相等，即找到key值相等的节点，用value值替代t.value。
如果遍历到最后节点t，还是找不到key值相等的节点，
则创建一个TreeMap.Entry对象，作为节点t的子节点，
如果key < t.key，则作为节点t的左子节点；
如果key > t.key，则作为节点t的右子节点。
public V put(K key, V value) {
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);
} while (t != null);
}
else {
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);//树中已存在该节点，直接替换节点的value后，返回旧的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;
}
树插入新节点，可能破坏了二叉树的平衡，需要红黑树算法来修复平衡二叉树：
/** From CLR */
private void fixAfterInsertion(ENTRY<K,V> x) {
x.color = RED;//新插入的节点默认是红色节点
while (x != null && x != root && x.parent.color == RED) {//x节点的父节点不是叶子节点
if (parentOf(x) == leftOf(parentOf(parentOf(x)))) {//x节点的父节点是左节点
Entry<K,V> y = rightOf(parentOf(parentOf(x)));//x节点的叔叔节点（既是父节点的同级节点）
if (colorOf(y) == RED) {//叔叔节点是红色
setColor(parentOf(x), BLACK);//x的父节点设黑色
setColor(y, BLACK);//x的叔叔节点设黑色
setColor(parentOf(parentOf(x)), RED);//x的祖父节点设红色
x = parentOf(parentOf(x));//x指向祖父节点
} else {//叔叔节点是黑色
if (x == rightOf(parentOf(x))) {//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));//x指向祖父节点
} else {//叔叔节点是黑色
if (x == leftOf(parentOf(x))) {//x节点是左子树
x = parentOf(x);//x指向父节点
rotateRight(x);//右旋转
}
setColor(parentOf(x), BLACK);//父节点设为黑色
setColor(parentOf(parentOf(x)), RED);//祖父节点设为红色
rotateLeft(parentOf(parentOf(x)));//以祖父节点为支点，左旋转
}
}
}
root.color = BLACK;
}左旋转：
/** 左旋转 */
/** From CLR */
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;
}
}右旋转：
/** From CLR */
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;
}
}
查找节点t的继承者（successor方法）,即找出比节点t大且比其它节点小的节点。
1.寻找节点t的右子树中的最左边的节点l，因为节点l节点t大且比节点t的右子树的其它节点都小。
2.如果节点t没有右子树，即t.right为null，则说明节点t是最大的节点。
寻找节点t的parent节点，且t是parent的右节点。
寻找结果；root节点，或者root的左节点。
public V remove(Object key) {
Entry<K,V> p = getEntry(key);
if (p == null)
return null;
V oldValue = p.value;
deleteEntry(p);
return oldValue;
}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();
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;
}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))) {//x节点是左节点
Entry<K,V> sib = rightOf(parentOf(x));//兄弟节点，即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);
}其中，TreeSet和TreeMap的关系，形同HashSet和HashMap的关系，是的，TreeSet是使用TreeMap来使用元素的，只不过元素当作TreeMap的key来保存，TreeMap都保存相同一份。
408
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
