红黑树及其实例JDK中的TreeMap
红黑树是一种自平衡二叉查找树(binary search tree,BST),红黑树是一种比较复杂的数据结构,红黑树查找、插入、删除元素的时间复杂度为O(log n),n是树中元素的数目.文章的要讲的知识点如下：
二叉查找树(binary search tree,BST,也称排序二叉树)虽然可以快速检索，但在最坏的情况下：如果插入的节点集本身就是有序的，要么是由小到大排列，要么是由大到小排列，那么最后得到的二叉查找树将变成链表：所有节点只有左节点（如果插入节点集本身是大到小排列）；或所有节点只有右节点（如果插入节点集本身是小到大排列）。在这种情况下，二叉查找树就变成了普通链表，其检索效率就会下降为O(n)。
为了改变二叉查找树存在的不足，Rudolf Bayer 与 1972 年发明了另一种改进后的二叉查找树：红黑树。红黑树是一颗自平衡二叉查找树,它有以下特点:
- 节点是红色或黑色
- 根节点是黑色
- 所有空节点(NIL节点)都是黑色
- 如果一个节点是红色的,则它的子节点都是黑的.(从每个叶子到根的所有路径上不能有两个连续的红色节点)
- 对每个节点来说,从它到他的所有子孙叶子节点的路径上的黑色节点数目相同(节点的黑色高度相同)
红黑树实例：
红黑树的性质确保了红黑树的关键特性: 从根到叶子的最长的可能路径不多于最短的可能路径的两倍长。这就保证了红黑树大致上是平衡的。因为操作比如插入、删除和查找某个值的最坏情况时间都要求与树的高度成比例，这个在高度上的理论上限允许红黑树在最坏情况下都是高效的，而不同于普通的二叉查找树。
简而言之:二叉搜索树只限定了节点的大小顺序,红黑树不只限定了节点的大小,还对节点颜色做了限制,并用此来保证红黑树的平衡性.红黑树中插入有序序列并不会像二叉搜索树那样变为链表结构，如下图:
上面我们已经说明了红黑树的概念以及其特性,接下来我们分析红黑树的常见操作:搜索节点、插入节点、删除节点.红黑树是一颗自平衡二叉树,对红黑树操作需要继续保持红黑树的特性。红黑树的搜索操作和排序二叉树一样,不一样的地方在于插入和删除节点可能会破坏红黑树的性质,所以在插入和删除节点后需要维护红黑树的性质.1,2,3条性质比较简单,维护4,5性质比较复杂,实际上红黑树的平衡也就是通过性质4,5来维护的.
红黑树插入节点和删除节点的操作比较复杂,如果对红黑树不太熟悉,可以先进行实际操作下,这里提供一个很形象的红黑树动画教程:http://www.bbniu.com/matrix/ShowApplication.aspx?id=149.(要安装Silverlight),遇到难以理解的地方,可以对照着操作,多操作几次,有助于理解.
介绍插入和删除操作前,先介绍维护红黑树性质的两种方式:节点变色和旋转.
1.变色:实际就是通过改变节点的颜色来维护红黑树性质
2.旋转:改变父子节点的位置
这两个操作不了解没关系,后面用到的时候自然就懂了.
首先,按照二叉查找树(BST)的方式插入新的节点.然后修复二叉树,保持红黑树的性质.
insert(N)：
- 按照BST插入方式插入新节点
不同的地方：
- N节点的两个子节点都指向NIL节点(空节点,黑色)
- N节点为红色
- 处理不符合红黑树性质的部分
怎么去处理呢?首先我们分析下插入操作会破坏哪些性质.
- 每个节点不是黑就是红
- root是黑色的
- 每个空节点(nil节点)都是黑色的
- 如果一个节点是红色的,则它的子节点都是黑色的
- 对每个节点来说,从它到它的所有子孙叶子节点的路径上含有一样数目的黑色节点.
因为新增的节点N是红色的,N节点取代一个nil节点,而N的两个子节点都是nil节点.所以新增节点N不会破坏性质5;
如果破坏性质2,说明新增节点就是root节点,整棵树只有N节点,此时把N节点变为黑色节点就可以.很容易处理;
如果破坏性质4,说明N节点的父节点P节点是一个红色节点.
为了便于分析问题,对G,P,U,N节点进行约定:
N节点：新增节点
P节点：N节点的父节点
U节点：N节点的叔父节点
G节点：P节点的父节点,N节点的爷爷节点.
根据约定,G,P,U,N节点存在如下关系图:
我们针对破坏性质4的情况进行分析.也就是P节点为红节点,G节点为黑节点,新增节点N为红节点的情况.此时,有如下三种情形:
① U节点为红色节点
② U节点为黑色节点,N节点为P节点的右子节点
③ U节点为黑色节点,N节点为P节点的左子节点
我们依次对上面三种情形进行分析:
case 1： U节点为红色节点,N为P的左子节点或者右子节点
针对case1我们的处理方式是：将P,U节点变成黑色,G节点变成红色.此时,需要继续对G节点进行分析:
- 如果G节点的父节点为黑色节点,则ok.
- 如果G节点的父节点为红节点,同样破坏了性质4,这时我们把G节点当成新增节点,进行递归处理.
case 2：U节点为黑色节点或nil节点,N节点为P节点的右子节点
case2最终会转换成case3.
case 3:U节点为黑色节点或nil节点,N节点为P节点的左子节点.
上面就是红黑树插入节点后的修复操作.如果理解起来不太顺畅,请对着情形多操作几次动画教程.实际操作能加深理解!
红黑树插入性能分析：
插入时间:原本正常的二叉搜索树要花O(log n)的时间,因为树的高度最高为2log(n+1)。
花费在调整上的时间：在最槽糕的状况下,case1一直重复发生,也就是N节点每次都需要往上移两层,执行时间与树的高度成正比,也是O(log n).在case3的情况下,只需要一次调整就能满足红黑树的性质,也就是O(1).另外,在case2情况下,最多只需要调整两次(不会发生第二次case2)
红黑树删除节点
按照二叉查找树删除节点的方式删除节点,然后修复红黑树,保持红黑树的性质.
delete(z)
删除节点z首先要找到z节点.接下来有三种情形:
- 如果z是叶子节点,直接删除
- 如果z节点有一个孩子节点,将z节点唯一的子节点放到z节点的位置.
- 如果z节点有两个子节点,找左子树中最大的节点（或者右子树中最小的节点）x,用x节点的值替换z节点的值,x节点的颜色改变成z的颜色,然后删除x节点.
现在我们分析,删除节点在什么情形下会破坏红黑树的规则。
当要删除的节点z为红色节点时:
- 因为z节点是红色节点,black height不会改变--->性质5不会破坏
- 会不会造成连续两个红色节点?--->性质4
如果z是被删掉的,因为z是红色节点,所有z的上下层都是黑色节点,所以不会产生连续的红色节点
3. z如果是红色,则z节点不可能为root节点,所以也不会破坏性质2
so,只有当z为黑色节点才会破坏红黑树的性质,需要在删除节点后修复操作.
当z节点是黑色节点,可能违反规则的有如下情况:
- z是root节点,z删除以后,它的红色子节点变成了root节点
- z原本上下两层都是红色节点,删除以后造成两个红色节点相邻
- z删掉后,造成black height不一致(因为z是黑色节点)
我们假设z节点为删除节点,x节点为z节点的子孙节点,x节点的兄弟节点为w,会有以下四种情形:
case 1: w是红色节点
case 2: w是黑色节点,w的孩子都是黑色的
case 3: w是黑色节点,w的左孩子是红色的,w的右孩子是黑色节点
case 4: w是黑色节点,w的右孩子是红色的
下面,我们依次分析这四种情形.
case 1: w是红色节点
ps:+1表示该节点需要一个黑色节点来维持红黑树的性质.case1最终会转换到下面的三种情形之一.
case 2:w是黑色节点,w的所有儿子都是黑色的.
这种情况下,递归对x进行删除处理以保持红黑树的性质.
case 3： w是黑色的,w的左孩子是红色的,右孩子是黑色的.
case 4: w是黑色节点,w的右孩子是红色的.
删除算法性能分析：
查找节点的时间复杂度：O(log n).
修复红黑树需要的时间:
最槽糕的情形是case2一直重复发生,需要O(log n)
case 1,case3,case4都是O(1).最多需要三次旋转.
前面讲了红黑树,现在我们来看一个红黑树应用实例: jdk中基于红黑树实现的TreeMap.
在TreeMap中,每一个Entry代表一个节点,TreeMap就是用红黑树存储Entry的集合.下面是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; Entry(K key, V value, Entry<K,V> parent) { this.key = key; this.value = value; this.parent = parent; } public K getKey() { return key; } public V getValue() { return value; } 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; } }
TreeMap搜索节点
public V get(Object key) { Entry<K,V> p = getEntry(key); return (p==null ? null : p.value); } final Entry<K,V> getEntry(Object key) { //comparator!=null说明程序采用定制排序,调用getEntryUsingComparator()处理 if (comparator != null) return getEntryUsingComparator(key); if (key == null) throw new NullPointerException(); // 将key强转为Comparable实例 Comparable<? super K> k = (Comparable<? super K>) key; // 从root节点开始查找 Entry<K,V> p = root; while (p != null) { // key与当前节点的key进行比较 int cmp = k.compareTo(p.key); // 如果key小于当前节点的key,去”左子树”搜索 if (cmp < 0) p = p.left; // 如果key大于当前节点的key,去”右子树”搜索 else if (cmp > 0) p = p.right; else // 相等则返回当前节点 return p; } return null; }
上面的getEntry(Object key)方法就是利用排序二叉树的特征来搜索目标Entry,程序从root节点开始,如果key大于root.key,则向右子树搜索,如果小于,就向左子树搜索,如果相等,则返回当前节点.
getEntryUsingComparator()方法与getEntry()方法的思路完全类似,前者采用的是定制排序,后者采用的是Entry.key的自然排序(此时,key对象必须实现Comparable接口,重写compareTo方法).
TreeMap插入节点
插入节点思路:
- 确定节点的插入位置
2.查找新增节点的parent
3. 如果新增节点比parent大,则做为parent的右子节点,如果较小,则做为parent的左子节点,如果相等,则替换
4.检查是否破坏红黑树性质,如果破坏,修复.未破坏--->ok.
我们看TreeMap中的put(k,v):
public V put(K key, V value) { Entry<K,V> t = root; if (t == null) { // 空树,以Entry做为root节点创建红黑树 root = new Entry<K,V>(key, value, null); size = 1; modCount++; return null; } int cmp; Entry<K,V> parent; Comparator<? super K> cpr = comparator; // 获取插入节点的parent节点,与搜索节点类似 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); } // 创建新节点,父节点为parent Entry<K,V> e = new Entry<K,V>(key, value, parent); if (cmp < 0)//如果新节点比parent小,则左子节点 parent.left = e; else parent.right = e; // 修复红黑树 fixAfterInsertion(e); size++; modCount++; return null; }
上面就是红黑树的插入过程,我们接下来看TreeMap是如何修复红黑树的.
private void fixAfterInsertion(Entry<K,V> x) { // 新增节点为红色 x.color = RED; // 如果x节点不为空,也不是root节点,并且x的父节点不是红色节点 while (x != null && x != root && x.parent.color == RED) { // x的父节点是x的爷爷节点的左子节点 if (parentOf(x) == leftOf(parentOf(parentOf(x)))) { // 获取x节点的叔父节点 Entry<K,V> y = rightOf(parentOf(parentOf(x))); // 叔父节点为红色,对应红黑树修复中的case1 if (colorOf(y) == RED) { //把x的父节点,叔父节点变成黑色,x的爷爷节点变成红色,x的爷爷节点变成红色后,可能造成两个红色节点连续,所以需要对x的爷爷节点进行递归处理 setColor(parentOf(x), BLACK); setColor(y, BLACK); setColor(parentOf(parentOf(x)), RED); x = parentOf(parentOf(x)); } else {//叔父节点为黑色,case2、3 //x为右子节点,对应case2 if (x == rightOf(parentOf(x))) { //x指向x的父节点, 对x的父节点进行左旋转,改成rotateLeft(parentOf(x))更容易理解 x = parentOf(x); rotateLeft(x); } // case3,x为左子节点,x节点的父节点变成黑色,爷爷节点变成红色,然后对爷爷节点进行右旋转 setColor(parentOf(x), BLACK); setColor(parentOf(parentOf(x)), RED); rotateRight(parentOf(parentOf(x))); } } else {//x的父节点是x爷爷节点的右子节点,思路与上面一样 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节点为黑色 root.color = BLACK; }
不能理解的地方可以回头再看下红黑树插入的那一段.修复方法和红黑树插入那一节的case1,case2,case3都是对应的.
TreeMap删除节点
删除节点的思路：
- 首先,使用排序二叉树中删除节点的方法来删除节点
- 检查是否破坏红黑树性质,如果有破坏,进行修复
private void deleteEntry(Entry<K,V> p) { modCount++; size--; //如果节点有左右子节点 if (p.left != null && p.right != null) { //使用p节点的中序后继节点(p左子树中的最大节点)代替p节点 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); // 如果p有子节点 if (replacement != null) { //replacement替换父节点p的位置,根据p节点在p节点的位置,决定replace在p节点父节点的位置 replacement.parent = p.parent; //如果p没有父节点,replacement为root节点 if (p.parent == null) root = replacement; else if (p == p.parent.left) // 如果p是其父节点的左子节点,replacement就成为p节点的父节点的左子节点 p.parent.left = replacement; else //replacement成为p节点的父节点的右子节点 p.parent.right = replacement; //删除p节点 p.left = p.right = p.parent = null; // 如果删除的是黑色节点,需要修复红黑树 if (p.color == BLACK) fixAfterDeletion(replacement); } else if (p.parent == null) { //如果p节点就是root节点,直接删除 root = null; } else { // 如果p节点为叶子节点 // 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; } } }
上面就是红黑树删除节点的过程,只有当删除或移动的节点是黑色节点的时候,才可能会破坏红黑树的性质,此时需要修复红黑树,下面我们看红黑树删除节点以后的修复方法.
private void fixAfterDeletion(Entry<K,V> x) { // x非root节点,且为黑色节点 while (x != root && colorOf(x) == BLACK) { if (x == leftOf(parentOf(x))) {// x为左子节点 // 获取x的兄弟节点 Entry<K,V> sib = rightOf(parentOf(x)); // 如果x的兄弟节点为红色,对应红黑树删除的case1 if (colorOf(sib) == RED) { //兄弟节点变成黑色,父节点变成红色,左旋转父节点 setColor(sib, BLACK); setColor(parentOf(x), RED); rotateLeft(parentOf(x)); sib = rightOf(parentOf(x)); } // case2:兄弟节点的子节点都是黑色,设置兄弟节点为红色,递归处理 if (colorOf(leftOf(sib)) == BLACK && colorOf(rightOf(sib)) == BLACK) { setColor(sib, RED); x = parentOf(x); } else { // case3：转成case4处理 if (colorOf(rightOf(sib)) == BLACK) { setColor(leftOf(sib), BLACK); setColor(sib, RED); rotateRight(sib); sib = rightOf(parentOf(x)); } // case4:兄弟节点变成与父节点一样的颜色 setColor(sib, colorOf(parentOf(x))); //设置父节点,兄弟节点的右子节点为黑色,x的父节点左旋转 setColor(parentOf(x), BLACK); setColor(rightOf(sib), BLACK); rotateLeft(parentOf(x)); x = root;//终止循环 } } else { // x为右子节点,与上面的处理思路一样 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; } } } // 设置root节点为黑色 setColor(x, BLACK); }
红黑树的删除节点修复算法比较复杂,可以参照前面红黑树删除那一节的内容来理解.
