红黑树及其实例JDK中的TreeMap

　　红黑树是一种自平衡二叉查找树(binary search tree,BST),红黑树是一种比较复杂的数据结构,红黑树查找、插入、删除元素的时间复杂度为O(log n),n是树中元素的数目.文章的要讲的知识点如下：

　　一、红黑树的基本介绍

　　　　红黑树插入节点

　　　　红黑树删除节点

　　二、红黑树应用实例：Jdk中的TreeMap

一、红黑树的基本介绍

　　　二叉查找树(binary search tree,BST,也称排序二叉树)虽然可以快速检索，但在最坏的情况下：如果插入的节点集本身就是有序的，要么是由小到大排列，要么是由大到小排列，那么最后得到的二叉查找树将变成链表：所有节点只有左节点（如果插入节点集本身是大到小排列）；或所有节点只有右节点（如果插入节点集本身是小到大排列）。在这种情况下，二叉查找树就变成了普通链表，其检索效率就会下降为O(n)。

　　为了改变二叉查找树存在的不足，Rudolf Bayer 与 1972 年发明了另一种改进后的二叉查找树：红黑树。红黑树是一颗自平衡二叉查找树,它有以下特点:

1. 节点是红色或黑色
2. 根节点是黑色
3. 所有空节点(NIL节点)都是黑色
4. 如果一个节点是红色的,则它的子节点都是黑的.(从每个叶子到根的所有路径上不能有两个连续的红色节点)
5. 对每个节点来说,从它到他的所有子孙叶子节点的路径上的黑色节点数目相同(节点的黑色高度相同)

红黑树实例：

　　　　　　　　

　　红黑树的性质确保了红黑树的关键特性: 从根到叶子的最长的可能路径不多于最短的可能路径的两倍长。这就保证了红黑树大致上是平衡的。因为操作比如插入、删除和查找某个值的最坏情况时间都要求与树的高度成比例，这个在高度上的理论上限允许红黑树在最坏情况下都是高效的，而不同于普通的二叉查找树。

简而言之:二叉搜索树只限定了节点的大小顺序,红黑树不只限定了节点的大小,还对节点颜色做了限制,并用此来保证红黑树的平衡性.红黑树中插入有序序列并不会像二叉搜索树那样变为链表结构，如下图:

　　　　　　　　　　　　　　

　　上面我们已经说明了红黑树的概念以及其特性,接下来我们分析红黑树的常见操作:搜索节点、插入节点、删除节点.红黑树是一颗自平衡二叉树,对红黑树操作需要继续保持红黑树的特性。红黑树的搜索操作和排序二叉树一样,不一样的地方在于插入和删除节点可能会破坏红黑树的性质,所以在插入和删除节点后需要维护红黑树的性质.1,2,3条性质比较简单,维护4,5性质比较复杂,实际上红黑树的平衡也就是通过性质4,5来维护的.

　　红黑树插入节点和删除节点的操作比较复杂,如果对红黑树不太熟悉,可以先进行实际操作下,这里提供一个很形象的红黑树动画教程:http://www.bbniu.com/matrix/ShowApplication.aspx?id=149.(要安装Silverlight),遇到难以理解的地方,可以对照着操作,多操作几次,有助于理解.

　　介绍插入和删除操作前,先介绍维护红黑树性质的两种方式:节点变色和旋转.

　　　　1.变色:实际就是通过改变节点的颜色来维护红黑树性质

 　　　　

　　　　2.旋转:改变父子节点的位置

　　　　

　　　　这两个操作不了解没关系,后面用到的时候自然就懂了.

红黑树插入节点

　　首先,按照二叉查找树(BST)的方式插入新的节点.然后修复二叉树,保持红黑树的性质.

　　insert(N)：

1. 1. 按照BST插入方式插入新节点

　　不同的地方：

1. 1. N节点的两个子节点都指向NIL节点(空节点,黑色)
   2. N节点为红色
   3. 处理不符合红黑树性质的部分

　　怎么去处理呢?首先我们分析下插入操作会破坏哪些性质.

1.   每个节点不是黑就是红
2. root是黑色的
3.  每个空节点(nil节点)都是黑色的
4. 如果一个节点是红色的,则它的子节点都是黑色的
5. 对每个节点来说,从它到它的所有子孙叶子节点的路径上含有一样数目的黑色节点.

     因为新增的节点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为红色节点时:

1. 因为z节点是红色节点,black height不会改变--->性质5不会破坏
2. 会不会造成连续两个红色节点?--->性质4

　　　　如果z是被删掉的,因为z是红色节点,所有z的上下层都是黑色节点,所以不会产生连续的红色节点

　　3. z如果是红色,则z节点不可能为root节点,所以也不会破坏性质2

so,只有当z为黑色节点才会破坏红黑树的性质,需要在删除节点后修复操作.

当z节点是黑色节点,可能违反规则的有如下情况:

1. z是root节点,z删除以后,它的红色子节点变成了root节点
2. z原本上下两层都是红色节点,删除以后造成两个红色节点相邻
3. 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).最多需要三次旋转.

红黑树实例: Java TreeMap

 　　前面讲了红黑树,现在我们来看一个红黑树应用实例: 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插入节点

　　插入节点思路:

1. 确定节点的插入位置

　　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删除节点

删除节点的思路：

1. 首先,使用排序二叉树中删除节点的方法来删除节点
2. 检查是否破坏红黑树性质,如果有破坏,进行修复

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

红黑树的删除节点修复算法比较复杂,可以参照前面红黑树删除那一节的内容来理解.