Java提升篇（二七）-----TreeMap

时间 2019-12-05

标签 java 提升二七 treemap 栏目 Java 繁體版

原文原文链接

原文出自：http://cmsblogs.com/?p=1013。尊重做者的成果，转载请注明出处！ html

---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- 算法

TreeMap的实现是红黑树算法的实现，因此要了解TreeMap就必须对红黑树有必定的了解,其实这篇博文的名字叫作：根据红黑树的算法来分析TreeMap的实现，可是为了与Java提升篇系列博文保持一致仍是叫作TreeMap比较好。经过这篇博文你能够得到以下知识点：编程

一、红黑树的基本概念。api

二、红黑树增长节点、删除节点的实现过程。数据结构

三、红黑树左旋转、右旋转的复杂过程。oracle

四、Java 中TreeMap是如何经过put、deleteEntry两个来实现红黑树增长、删除节点的。学习

我想经过这篇博文你对TreeMap必定有了更深的认识。好了，下面先简单普及红黑树知识。spa

1、红黑树简介

红黑树又称红-黑二叉树，它首先是一颗二叉树，它具体二叉树全部的特性。同时红黑树更是一颗自平衡的排序二叉树。.net

咱们知道一颗基本的二叉树他们都须要知足一个基本性质--即树中的任何节点的值大于它的左子节点，且小于它的右子节点。按照这个基本性质使得树的检索效率大大提升。咱们知道在生成二叉树的过程是很是容易失衡的，最坏的状况就是一边倒（只有右/左子树），这样势必会致使二叉树的检索效率大大下降（O(n)），因此为了维持二叉树的平衡，大牛们提出了各类实现的算法，如：AVL，SBT，伸展树，TREAP ，红黑树等等。

平衡二叉树必须具有以下特性：它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，而且左右两个子树都是一棵平衡二叉树。也就是说该二叉树的任何一个等等子节点，其左右子树的高度都相近。

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

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

二、根节点是黑色

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

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

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

这些约束强制了红黑树的关键性质: 从根到叶子的最长的可能路径很少于最短的可能路径的两倍长。结果是这棵树大体上是平衡的。由于操做好比插入、删除和查找某个值的最坏状况时间都要求与树的高度成比例，这个在高度上的理论上限容许红黑树在最坏状况下都是高效的，而不一样于普通的二叉查找树。因此红黑树它是复杂而高效的，其检索效率O(log n)。下图为一颗典型的红黑二叉树。

对于红黑二叉树而言它主要包括三大基本操做：左旋、右旋、着色。

左旋右旋

（图片来自：http://www.cnblogs.com/yangecnu/p/Introduce-Red-Black-Tree.html）

本节参考文献：http://baike.baidu.com/view/133754.htm?fr=aladdin-----百度百科

注：因为本文主要是讲解Java中TreeMap，因此并无对红黑树进行很是深刻的了解和研究，若是诸位想对其进行更加深刻的研究Lz提供几篇较好的博文：

一、红黑树系列集锦

二、红黑树数据结构剖析

三、红黑树

2、TreeMap数据结构

>>>>>>回归主角：TreeMap<<<<<<

TreeMap的定义以下：

public class TreeMap<K,V>
    extends AbstractMap<K,V>
    implements NavigableMap<K,V>, Cloneable, java.io.Serializable

TreeMap继承AbstractMap，实现NavigableMap、Cloneable、Serializable三个接口。其中AbstractMap代表TreeMap为一个Map即支持key-value的集合， NavigableMap（更多）则意味着它支持一系列的导航方法，具有针对给定搜索目标返回最接近匹配项的导航方法。

TreeMap中同时也包含了以下几个重要的属性：

//比较器，由于TreeMap是有序的，经过comparator接口咱们能够对TreeMap的内部排序进行精密的控制
        private final Comparator<? super K> comparator;
        //TreeMap红-黑节点，为TreeMap的内部类
        private transient Entry<K,V> root = null;
        //容器大小
        private transient int size = 0;
        //TreeMap修改次数
        private transient int modCount = 0;
        //红黑树的节点颜色--红色
        private static final boolean RED = false;
        //红黑树的节点颜色--黑色
        private static final boolean BLACK = true;

对于叶子节点Entry是TreeMap的内部类，它有几个重要的属性：

//键
        K key;
        //值
        V value;
        //左孩子
        Entry<K,V> left = null;
        //右孩子
        Entry<K,V> right = null;
        //父亲
        Entry<K,V> parent;
        //颜色
        boolean color = BLACK;

注：前面只是开胃菜，下面是本篇博文的重中之重，在下面两节我将重点讲解treeMap的put()、delete()方法。经过这两个方法咱们会了解红黑树增长、删除节点的核心算法。

3、TreeMap put()方法

在了解TreeMap的put()方法以前，咱们先了解红黑树增长节点的算法。

红黑树增长节点

红黑树在新增节点过程当中比较复杂，复杂归复杂它一样必需要依据上面提到的五点规范，同时因为规则一、二、3基本都会知足，下面咱们主要讨论规则四、5。假设咱们这里有一棵最简单的树，咱们规定新增的节点为N、它的父节点为P、P的兄弟节点为U、P的父节点为G。

对于新节点的插入有以下三个关键地方：

一、插入新节点老是红色节点。

二、若是插入节点的父节点是黑色, 能维持性质。

三、若是插入节点的父节点是红色, 破坏了性质. 故插入算法就是经过从新着色或旋转, 来维持性质。

为了保证下面的阐述更加清晰和根据便于参考，我这里将红黑树的五点规定再贴一遍：

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

二、根节点是黑色

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

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

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

1、为跟节点
       若新插入的节点N没有父节点，则直接当作根据节点插入便可，同时将颜色设置为黑色。（如图一（1））

       2、父节点为黑色

       这种状况新节点N一样是直接插入，同时颜色为红色，因为根据规则四它会存在两个黑色的叶子节点，值为null。同时因为新增节点N为红色，因此经过它的子节点的路径依然会保存着相同的黑色节点数，一样知足规则5。（如图一（2））

（图一）

       3、若父节点P和P的兄弟节点U都为红色

       对于这种状况若直接插入确定会出现不平衡现象。怎么处理？P、U节点变黑、G节点变红。这时因为通过节点P、U的路径都必须通过G因此在这些路径上面的黑节点数目仍是相同的。可是通过上面的处理，可能G节点的父节点也是红色，这个时候咱们须要将G节点当作新增节点递归处理。

       4、若父节点P为红色，叔父节点U为黑色或者缺乏，且新增节点N为P节点的右孩子

       对于这种状况咱们对新增节点N、P进行一次左旋转。这里所产生的结果其实并无完成，还不是平衡的（违反了规则四），这是咱们须要进行状况5的操做。
5、父节点P为红色，叔父节点U为黑色或者缺乏，新增节点N为父节点P左孩子
这种状况有多是因为状况四而产生的，也有可能不是。对于这种状况先已P节点为中心进行右旋转，在旋转后产生的树中，节点P是节点N、G的父节点。可是这棵树并不规范，它违反了规则4，因此咱们将P、G节点的颜色进行交换，使之其知足规范。开始时全部的路径都须要通过G其余们的黑色节点数同样，可是如今全部的路径改成通过P，且P为整棵树的惟一黑色节点，因此调整后的树一样知足规范5。

上面展现了红黑树新增节点的五种状况，这五种状况涵盖了全部的新增可能，无论这棵红黑树多么复杂，均可以根据这五种状况来进行生成。下面就来分析Java中的TreeMap是如何来实现红黑树的。
TreeMap put()方法实现分析

在TreeMap的put()的实现方法中主要分为两个步骤，第一：构建排序二叉树，第二：平衡二叉树。

对于排序二叉树的建立，其添加节点的过程以下：

一、以根节点为初始节点进行检索。
二、与当前节点进行比对，若新增节点值较大，则以当前节点的右子节点做为新的当前节点。不然以当前节点的左子节点做为新的当前节点。
三、循环递归2步骤知道检索出合适的叶子节点为止。
四、将新增节点与3步骤中找到的节点进行比对，若是新增节点较大，则添加为右子节点；不然添加为左子节点。
按照这个步骤咱们就能够将一个新增节点添加到排序二叉树中合适的位置。以下：

public V put(K key, V value) {
           //用t表示二叉树的当前节点
            Entry<K,V> t = root;
            //t为null表示一个空树，即TreeMap中没有任何元素，直接插入
            if (t == null) {
                //比较key值，我的以为这句代码没有任何意义，空树还须要比较、排序？
                compare(key, key); // type (and possibly null) check
                //将新的key-value键值对建立为一个Entry节点，并将该节点赋予给root
                root = new Entry<>(key, value, null);
                //容器的size = 1，表示TreeMap集合中存在一个元素
                size = 1;
                //修改次数 + 1
                modCount++;
                return null;
            }
            int cmp;     //cmp表示key排序的返回结果
            Entry<K,V> parent;   //父节点
            // split comparator and comparable paths
            Comparator<? super K> cpr = comparator;    //指定的排序算法
            //若是cpr不为空，则采用既定的排序算法进行建立TreeMap集合
            if (cpr != null) {
                do {
                    parent = t;      //parent指向上次循环后的t
                    //比较新增节点的key和当前节点key的大小
                    cmp = cpr.compare(key, t.key);
                    //cmp返回值小于0，表示新增节点的key小于当前节点的key，则以当前节点的左子节点做为新的当前节点
                    if (cmp < 0)
                        t = t.left;
                    //cmp返回值大于0，表示新增节点的key大于当前节点的key，则以当前节点的右子节点做为新的当前节点
                    else if (cmp > 0)
                        t = t.right;
                    //cmp返回值等于0，表示两个key值相等，则新值覆盖旧值，并返回新值
                    else
                        return t.setValue(value);
                } while (t != null);
            }
            //若是cpr为空，则采用默认的排序算法进行建立TreeMap集合
            else {
                if (key == null)     //key值为空抛出异常
                    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<>(key, value, parent);
            //若是新增节点的key小于parent的key，则当作左子节点
            if (cmp < 0)
                parent.left = e;
          //若是新增节点的key大于parent的key，则当作右子节点
            else
                parent.right = e;
            /*
             *  上面已经完成了排序二叉树的的构建，将新增节点插入该树中的合适位置
             *  下面fixAfterInsertion()方法就是对这棵树进行调整、平衡，具体过程参考上面的五种状况
             */
            fixAfterInsertion(e);
            //TreeMap元素数量 + 1
            size++;
            //TreeMap容器修改次数 + 1
            modCount++;
            return null;
        }

上面代码中do{}代码块是实现排序二叉树的核心算法，经过该算法咱们能够确认新增节点在该树的正确位置。找到正确位置后将插入便可，这样作了其实尚未完成，由于我知道TreeMap的底层实现是红黑树，红黑树是一棵平衡排序二叉树，普通的排序二叉树可能会出现失衡的状况，因此下一步就是要进行调整。fixAfterInsertion(e); 调整的过程务必会涉及到红黑树的左旋、右旋、着色三个基本操做。代码以下：

/**
     * 新增节点后的修复操做
     * x 表示新增节点
     */
     private void fixAfterInsertion(Entry<K,V> x) {
            x.color = RED;    //新增节点的颜色为红色

            //循环 直到 x不是根节点，且x的父节点不为红色
            while (x != null && x != root && x.parent.color == RED) {
                //若是X的父节点（P）是其父节点的父节点（G）的左节点
                if (parentOf(x) == leftOf(parentOf(parentOf(x)))) {
                    //获取X的叔节点(U)
                    Entry<K,V> y = rightOf(parentOf(parentOf(x)));
                    //若是X的叔节点（U） 为红色（状况三）
                    if (colorOf(y) == RED) {     
                        //将X的父节点（P）设置为黑色
                        setColor(parentOf(x), BLACK);
                        //将X的叔节点（U）设置为黑色
                        setColor(y, BLACK);
                        //将X的父节点的父节点（G）设置红色
                        setColor(parentOf(parentOf(x)), RED);
                        x = parentOf(parentOf(x));
                    }
                    //若是X的叔节点（U为黑色）；这里会存在两种状况（状况4、状况五）
                    else {   
                        //若是X节点为其父节点（P）的右子树，则进行左旋转（状况四）
                        if (x == rightOf(parentOf(x))) {
                            //将X的父节点做为X
                            x = parentOf(x);
                            //右旋转
                            rotateLeft(x);
                        }
                        //（状况五）
                        //将X的父节点（P）设置为黑色
                        setColor(parentOf(x), BLACK);
                        //将X的父节点的父节点（G）设置红色
                        setColor(parentOf(parentOf(x)), RED);
                        //以X的父节点的父节点（G）为中心右旋转
                        rotateRight(parentOf(parentOf(x)));
                    }
                }
                //若是X的父节点（P）是其父节点的父节点（G）的右节点
                else {
                    //获取X的叔节点（U）
                    Entry<K,V> y = leftOf(parentOf(parentOf(x)));
                  //若是X的叔节点（U） 为红色（状况三）
                    if (colorOf(y) == RED) {
                        //将X的父节点（P）设置为黑色
                        setColor(parentOf(x), BLACK);
                        //将X的叔节点（U）设置为黑色
                        setColor(y, BLACK);
                        //将X的父节点的父节点（G）设置红色
                        setColor(parentOf(parentOf(x)), RED);
                        x = parentOf(parentOf(x));
                    }
                  //若是X的叔节点（U为黑色）；这里会存在两种状况（状况4、状况五）
                    else {
                        //若是X节点为其父节点（P）的右子树，则进行左旋转（状况四）
                        if (x == leftOf(parentOf(x))) {
                            //将X的父节点做为X
                            x = parentOf(x);
                           //右旋转
                            rotateRight(x);
                        }
                        //（状况五）
                        //将X的父节点（P）设置为黑色
                        setColor(parentOf(x), BLACK);
                        //将X的父节点的父节点（G）设置红色
                        setColor(parentOf(parentOf(x)), RED);
                        //以X的父节点的父节点（G）为中心右旋转
                        rotateLeft(parentOf(parentOf(x)));
                    }
                }
            }
            //将根节点G强制设置为黑色
            root.color = BLACK;
        }

对这段代码的研究咱们发现,其处理过程彻底符合红黑树新增节点的处理过程。因此在看这段代码的过程必定要对红黑树的新增节点过程有了解。在这个代码中还包含几个重要的操做。左旋(rotateLeft())、右旋（rotateRight()）、着色（setColor()）。

左旋：rotateLeft()
所谓左旋转，就是将新增节点（N）当作其父节点（P），将其父节点P当作新增节点（N）的左子节点。即：G.left ---> N ,N.left ---> P。
右旋：rotateRight()

private void rotateLeft(Entry<K,V> p) {
        if (p != null) {
            //获取P的右子节点，其实这里就至关于新增节点N（状况四而言）
            Entry<K,V> r = p.right;
            //将R的左子树设置为P的右子树
            p.right = r.left;
            //若R的左子树不为空，则将P设置为R左子树的父亲
            if (r.left != null)
                r.left.parent = p;
            //将P的父亲设置R的父亲
            r.parent = p.parent;
            //若是P的父亲为空，则将R设置为跟节点
            if (p.parent == null)
                root = r;
            //若是P为其父节点（G）的左子树，则将R设置为P父节点(G)左子树
            else if (p.parent.left == p)
                p.parent.left = r;
            //不然R设置为P的父节点（G）的右子树
            else
                p.parent.right = r;
            //将P设置为R的左子树
            r.left = p;
            //将R设置为P的父节点
            p.parent = r;
        }
    }

所谓右旋转即，P.right ---> G、G.parent ---> P。

private void rotateRight(Entry<K,V> p) {
        if (p != null) {
            //将L设置为P的左子树
            Entry<K,V> l = p.left;
            //将L的右子树设置为P的左子树
            p.left = l.right;
            //若L的右子树不为空，则将P设置L的右子树的父节点
            if (l.right != null) 
                l.right.parent = p;
            //将P的父节点设置为L的父节点
            l.parent = p.parent;
            //若是P的父节点为空，则将L设置根节点
            if (p.parent == null)
                root = l;
            //若P为其父节点的右子树，则将L设置为P的父节点的右子树
            else if (p.parent.right == p)
                p.parent.right = l;
            //不然将L设置为P的父节点的左子树
            else 
                p.parent.left = l;
            //将P设置为L的右子树
            l.right = p;
            //将L设置为P的父节点
            p.parent = l;
        }
    }

左旋、右旋的示意图以下：
（左旋）                                         （右旋）

（图片来自：http://www.cnblogs.com/yangecnu/p/Introduce-Red-Black-Tree.html）

       着色：setColor()

       着色就是改变该节点的颜色，在红黑树中，它是依靠节点的颜色来维持平衡的。

private static <K,V> void setColor(Entry<K,V> p, boolean c) {
        if (p != null)
            p.color = c;
    }

       4、TreeMap delete()方法

       红黑树删除节点

       针对于红黑树的增长节点而言，删除显得更加复杂，使本来就复杂的红黑树变得更加复杂。同时删除节点和增长节点同样，一样是找到删除的节点，删除以后调整红黑树。可是这里的删除节点并非直接删除，而是经过走了“弯路”经过一种捷径来删除的：找到被删除的节点D的子节点C，用C来替代D，不是直接删除D，由于D被C替代了，直接删除C便可。因此这里就将删除父节点D的事情转变为了删除子节点C的事情，这样处理就将复杂的删除事件简单化了。子节点C的规则是：右分支最左边，或者左分支最右边的。

       红-黑二叉树删除节点，最大的麻烦是要保持各分支黑色节点数目相等。由于是删除，因此不用担忧存在颜色冲突问题——插入才会引发颜色冲突。

       红黑树删除节点一样会分红几种状况，这里是按照待删除节点有几个儿子的状况来进行分类：

       一、没有儿子，即为叶结点。直接把父结点的对应儿子指针设为NULL，删除儿子结点就OK了。

       二、只有一个儿子。那么把父结点的相应儿子指针指向儿子的独生子，删除儿子结点也OK了。

       三、有两个儿子。这种状况比较复杂，但仍是比较简单。上面提到过用子节点C替代代替待删除节点D，而后删除子节点C便可。

       下面就论各类删除状况来进行图例讲解，可是在讲解以前请容许我再次啰嗦一句，请时刻牢记红黑树的5点规定：

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

       二、根节点是黑色

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

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

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

       （注：已经讲三遍了，再不记住我就怀疑你是否适合搞IT了 O(∩_∩)O~）

       诚然，既然删除节点比较复杂，那么在这里咱们就约定一下规则：

       一、下面要讲解的删除节点必定是实际要删除节点的后继节点（N），如前面提到的C。

       二、下面提到的删除节点的树都是以下结构，该结构所选取的节点是待删除节点的右树的最左边子节点。这里咱们规定真实删除节点为N、父节点为P、兄弟节点为W兄弟节点的两个子节点为X一、X2。以下图（2.1）。

       如今咱们就上面提到的三种状况进行分析、处理。

       状况1、无子节点（红色节点）

       这种状况对该节点直接删除便可，不会影响树的结构。由于该节点为叶子节点它不可能存在子节点-----如子节点为黑，则违反黑节点数原则（规定5），为红，则违反“颜色”原则（规定4）。如上图（2.2）。

       状况2、有一个子节点

       这种状况处理也是很是简单的，用子节点替代待删除节点，而后删除子节点便可。如上图（2.3）

       状况3、有两个子节点

       这种状况可能会稍微有点儿复杂。它须要找到一个替代待删除节点（N）来替代它，而后删除N便可。它主要分为四种状况。

       一、N的兄弟节点W为红色

       二、N的兄弟w是黑色的，且w的俩个孩子都是黑色的。

       三、N的兄弟w是黑色的，w的左孩子是红色，w的右孩子是黑色。

       四、N的兄弟w是黑色的，且w的右孩子时红色的。

       状况3.一、N的兄弟节点W为红色

       W为红色，那么其子节点X一、X2一定所有为黑色，父节点P也为黑色。处理策略是：改变W、P的颜色，而后进行一次左旋转。这样处理就可使得红黑性质得以继续保持。N的新兄弟new w是旋转以前w的某个孩子，为黑色。这样处理后将状况3.一、转变为3.二、3.三、3.4中的一种。以下：
状况3.二、N的兄弟w是黑色的，且w的俩个孩子都是黑色的。
这种状况其父节点可红可黑，因为W为黑色，这样致使N子树相对于其兄弟W子树少一个黑色节点，这时咱们能够将W置为红色。这样，N子树与W子树黑色节点一致，保持了平衡。以下

将W由黑转变为红，这样就会致使新节点new N相对于它的兄弟节点会少一个黑色节点。可是若是new x为红色，咱们直接将new x转变为黑色，保持整棵树的平衡。不然状况3.2 会转变为状况3.一、3.三、3.4中的一种。
状况3.三、N的兄弟w是黑色的，w的左孩子是红色，w的右孩子是黑色。
针对这种状况是将节点W和其左子节点进行颜色交换，而后对W进行右旋转处理。

此时N的新兄弟X1(new w)是一个有红色右孩子的黑结点，因而将状况3转化为状况4.
状况3.四、N的兄弟w是黑色的，且w的右孩子时红色的。
交换W和父节点P的颜色，同时对P进行左旋转操做。这样就把左边缺失的黑色节点给补回来了。同时将W的右子节点X2置黑。这样左右都达到了平衡。

总结
我的认为这四种状况比较难理解，首先他们都不是单一的某种状况，他们之间是能够进行互转的。相对于其余的几种状况，状况3.2比较好理解，仅仅只是一个颜色的转变，经过减小右子树的一个黑色节点使之保持平衡，同时将不平衡点上移至N与W的父节点，而后进行下一轮迭代。状况3.1，是将W旋转将其转成状况二、三、4状况进行处理。而状况3.3经过转变后能够化成状况3.4来进行处理，从这里能够看出状况3.4应该最终结。状况3.四、右子节点为红色节点，那么将缺失的黑色节点交由给右子节点，经过旋转达到平衡。
经过上面的分析，咱们已经初步了解了红黑树的删除节点状况，相对于增长节点而言它确实是选的较为复杂。下面我将看到在Java TreeMap中是如何实现红黑树删除的。
TreeMap deleteEntry()方法实现分析
经过上面的分析咱们确认删除节点的步骤是：找到一个替代子节点C来替代P，而后直接删除C，最后调整这棵红黑树。下面代码是寻找替代节点、删除替代节点。

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

（1）除是寻找替代节点replacement，其实现方法为successor()。以下：

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

（2）处是删除该节点过程。它主要分为上面提到的三种状况，它与上面的if…else if… else一一对应。以下：

一、有两个儿子。这种状况比较复杂，但仍是比较简单。上面提到过用子节点C替代代替待删除节点D，而后删除子节点C便可。

二、没有儿子，即为叶结点。直接把父结点的对应儿子指针设为NULL，删除儿子结点就OK了。

三、只有一个儿子。那么把父结点的相应儿子指针指向儿子的独生子，删除儿子结点也OK了。

删除完节点后，就要根据状况来对红黑树进行复杂的调整：fixAfterDeletion()。

private void fixAfterDeletion(Entry<K,V> x) {
        // 删除节点须要一直迭代，知道 直到 x 不是根节点，且 x 的颜色是黑色
        while (x != root && colorOf(x) == BLACK) {
            if (x == leftOf(parentOf(x))) {      //若X节点为左节点
                //获取其兄弟节点
                Entry<K,V> sib = rightOf(parentOf(x));

                /*
                 * 若是兄弟节点为红色----（状况3.1）
                 * 策略：改变W、P的颜色，而后进行一次左旋转
                 */
                if (colorOf(sib) == RED) {     
                    setColor(sib, BLACK);     
                    setColor(parentOf(x), RED);  
                    rotateLeft(parentOf(x));
                    sib = rightOf(parentOf(x));
                }

                /*
                 * 若兄弟节点的两个子节点都为黑色----（状况3.2）
                 * 策略：将兄弟节点编程红色
                 */
                if (colorOf(leftOf(sib))  == BLACK &&
                    colorOf(rightOf(sib)) == BLACK) {
                    setColor(sib, RED);
                    x = parentOf(x);
                } 
                else {
                    /*
                     * 若是兄弟节点只有右子树为黑色----（状况3.3）
                     * 策略：将兄弟节点与其左子树进行颜色互换而后进行右转
                     * 这时状况会转变为3.4
                     */
                    if (colorOf(rightOf(sib)) == BLACK) {
                        setColor(leftOf(sib), BLACK);
                        setColor(sib, RED);
                        rotateRight(sib);
                        sib = rightOf(parentOf(x));
                    }
                    /*
                     *----状况3.4
                     *策略：交换兄弟节点和父节点的颜色，
                     *同时将兄弟节点右子树设置为黑色，最后左旋转
                     */
                    setColor(sib, colorOf(parentOf(x)));
                    setColor(parentOf(x), BLACK);
                    setColor(rightOf(sib), BLACK);
                    rotateLeft(parentOf(x));
                    x = root;
                }
            } 
            
            /**
             * X节点为右节点与其为作节点处理过程差很少，这里就不在累述了
             */
            else {
                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);
    }

这是红黑树在删除节点后，对树的平衡性进行调整的过程，其实现过程与上面四种复杂的状况一一对应，因此在这个源码的时候必定要对着上面提到的四种状况看。

5、写在最后

这篇博文确实是有点儿长，在这里很是感谢各位看客可以静下心来读完，我想你经过读完这篇博文必定收获不小。同时这篇博文很大篇幅都在阐述红黑树的实现过程，对Java 的TreeMap聊的比较少，可是我认为若是理解了红黑树的实现过程，对TreeMap那是手到擒来，小菜一碟。

同时这篇博文我写了四天，看了、参考了大量的博文。同时难免会有些地方存在借鉴之处，在这里对其表示感谢。LZ大二开始学习数据结构，自认为学的不错，如今发现数据结构我还有太多的地方须要学习了，同时也再一次体味了算法的魅力！！！！

参考资料：

一、红黑树数据结构剖析：http://www.cnblogs.com/fanzhidongyzby/p/3187912.html

二、红黑二叉树详解及理论分析：http://blog.csdn.net/kartorz/article/details/8865997

三、教你透彻了解红黑树 ：blog.csdn.net/v_july_v/article/details/6105630

四、经典算法研究系列：5、红黑树算法的实现与剖析：http://blog.csdn.net/v_JULY_v/article/details/6109153

五、示例，红黑树插入和删除过程：http://saturnman.blog.163.com/blog/static/557611201097221570/

六、红黑二叉树详解及理论分析：http://blog.csdn.net/kartorz/article/details/8865997

Java提升篇（二七）-----TreeMap

1、红黑树简介

2、TreeMap数据结构

3、TreeMap put()方法

红黑树增长节点

4、若父节点P为红色，叔父节点U为黑色或者缺乏，且新增节点N为P节点的右孩子

TreeMap put()方法实现分析

4、TreeMap delete()方法

红黑树删除节点

TreeMap deleteEntry()方法实现分析

5、写在最后