红黑树-TreeMap

1.原理

排序二叉树

排序二叉树是一种特殊结构的二叉树，可以非常方便地对树中所有节点进行排序和检索。

排序二叉树要么是一棵空二叉树，要么是具有下列性质的二叉树：

• 若它的左子树不空，则左子树上所有节点的值均小于它的根节点的值；
• 若它的右子树不空，则右子树上所有节点的值均大于它的根节点的值；
• 它的左、右子树也分别为排序二叉树。

平衡二叉树

平衡二叉树（Balanced Binary Tree）是二叉查找树的一个进化体，也是第一个引入平衡概念的二叉树。1962年，G.M. Adelson-Velsky 和 E.M. Landis发明了这棵树，所以它又叫AVL树。

平衡二叉树要求对于每一个节点来说，它的左右子树的高度之差不能超过1，如果插入或者删除一个节点使得高度之差大于1，就要进行节点之间的旋转，将二叉树重新维持在一个平衡状态。

这个方案很好的解决了二叉查找树退化成链表的问题，把插入，查找，删除的时间复杂度最好情况和最坏情况都维持在O(logN)。但是频繁旋转会使插入和删除牺牲掉O(logN)左右的时间。

红黑树

 红黑树顾名思义就是节点是红色或者黑色的平衡二叉树，它通过颜色的约束来维持着二叉树的平衡。对于一棵有效的红黑树二叉树而言我们必须增加如下规则：

       1、每个节点都只能是红色或者黑色

       2、根节点是黑色

       3、每个叶节点（NIL节点，空节点）是黑色的。

       4、如果一个结点是红的，则它两个子节点都是黑的。也就是说在一条路径上不能出现相邻的两个红色结点。

       5、从任一节点到其每个叶子的所有路径都包含相同数目的黑色节点。

排序二叉树的深度直接影响了检索的性能，正如前面指出，当插入节点本身就是由小到大排列时，排序二叉树将变成一个链表，这种排序二叉树的检索性能最低：N 个节点的二叉树深度就是 N-1。

红黑树通过上面这种限制来保证它大致是平衡的——因为红黑树的高度不会无限增高，这样保证红黑树在最坏情况下都是高效的，不会出现普通排序二叉树的情况。

由于红黑树只是一个特殊的排序二叉树，因此对红黑树上的只读操作与普通排序二叉树上的只读操作完全相同，只是红黑树保持了大致平衡，因此检索性能比排序二叉树要好很多。

但在红黑树上进行插入操作和删除操作会导致树不再符合红黑树的特征，因此插入操作和删除操作都需要进行一定的维护，以保证插入节点、删除节点后的树依然是红黑树。

2.数据结构模型

 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
  * {@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;
  }
  }

3.Put

1. 以根节点当前节点开始搜索。
2. 拿新节点的值和当前节点的值比较。
3. 如果新节点的值更大，则以当前节点的右子节点作为新的当前节点；如果新节点的值更小，则以当前节点的左子节点作为新的当前节点。
4. 重复 2、3 两个步骤，直到搜索到合适的叶子节点为止。
5. 将新节点添加为第 4 步找到的叶子节点的子节点；如果新节点更大，则添加为右子节点；否则添加为左子节点。
6. 修复红黑树

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();
  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;
  }

4.Get

1. 以根节点当前节点开始搜索。
2. 拿新节点的值和当前节点的值比较。
3. 如果新节点的值更大，则以当前节点的右子节点作为新的当前节点；如果新节点的值更小，则以当前节点的左子节点作为新的当前节点。如果相等则返回改Entry
4. 重复 2、3 两个步骤，直到搜索到合适的叶子节点为止。

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;
  }

5.Remove

当程序从排序二叉树中删除一个节点之后，为了让它依然保持为排序二叉树，程序必须对该排序二叉树进行维护。维护可分为如下几种情况：

（1）被删除的节点是叶子节点，则只需将它从其父节点中删除即可。

（2）被删除节点 p 只有左子树，将 p 的左子树 pL 添加成 p 的父节点的左子树即可；被删除节点 p 只有右子树，将 p 的右子树 pR 添加成 p 的父节点的右子树即可。

（3）若被删除节点 p 的左、右子树均非空，找P的替代节点。规则是右分支最左边，或者 左分支最右边的节点

（4）修复红黑树

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++; //修改次数 +1
  size--; //元素个数 -1

  /*
  * 被删除节点的左子树和右子树都不为空，那么就用 p节点的中序后继节点代替 p 节点
  * successor(P)方法为寻找P的替代节点。规则是右分支最左边，或者 左分支最右边的节点
  * ---------------------（1）
  */
  if (p.left != null && p.right != null) {
  Entry<K,V> s = successor(p);
  p.key = s.key;
  p.value = s.value;
  p = s;
  }

  //replacement为替代节点，如果P的左子树存在那么就用左子树替代，否则用右子树替代
  Entry<K,V> replacement = (p.left != null ? p.left : p.right);

  /*
  * 删除节点，分为上面提到的三种情况
  * -----------------------（2）
  */
  //如果替代节点不为空
  if (replacement != null) {
  replacement.parent = p.parent;
  /*
  *replacement来替代P节点
  */
  //若P没有父节点，则跟节点直接变成replacement
  if (p.parent == null)
  root = replacement;
  //如果P为左节点，则用replacement来替代为左节点
  else if (p == p.parent.left)
  p.parent.left = replacement;
  //如果P为右节点，则用replacement来替代为右节点
  else
  p.parent.right = replacement;

  //同时将P节点从这棵树中剔除掉
  p.left = p.right = p.parent = null;

  /*
  * 若P为红色直接删除，红黑树保持平衡
  * 但是若P为黑色，则需要调整红黑树使其保持平衡
  */
  if (p.color == BLACK)
  fixAfterDeletion(replacement);
  } else if (p.parent == null) { //p没有父节点，表示为P根节点，直接删除即可
  root = null;
  } else { //P节点不存在子节点，直接删除即可
  if (p.color == BLACK) //如果P节点的颜色为黑色，对红黑树进行调整
  fixAfterDeletion(p);

  //删除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;
  }
  }
  }

6.左旋(rotateLeft())、右旋（rotateRight()）

/** 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;
  }
  }

8.总结

1.Treemap是基于红黑树的数据模式，是一颗排序二叉树。红黑树不追求完全平衡，对比AVL，降低了对旋转的要求，从而提高了性能。

2、TreeMap的查询、插入、删除效率均没有HashMap高(o(logn):o(1))，一般只有要对key排序时才使用TreeMap。但TreeMap的空间利用率要高于HashMap。

3、TreeMap的key不能为null，而HashMap的key可以为null。

参考文献

http://blog.csdn.net/chenssy/article/details/26668941

http://www.ibm.com/developerworks/cn/java/j-lo-tree/