根据红黑树的算法来分析TreeMap的实现

布满荆棘的人生 2022-09-26 14:58 149阅读 0赞

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

个人站点：[http://cmsblogs.com][http_cmsblogs.com]

—————————————————————————————————————————————————————————-

TreeMap的实现是红黑树[算法][Link 1]的实现，所以要了解TreeMap就必须对红黑树有一定的了解,其实这篇博文的名字叫做：根据红黑树的算法来分析TreeMap的实现，但是为了与[Java][]提高篇系列博文保持一致还是叫做TreeMap比较好。通过这篇博文你可以获得如下知识点：

1、红黑树的基本概念。

2、红黑树增加节点、删除节点的实现过程。

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

4、Java 中TreeMap是如何通过put、deleteEntry两个来实现红黑树增加、删除节点的。

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

#        一、红黑树简介 #

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

我们知道一颗基本的二叉树他们都需要满足一个基本性质–即树中的任何节点的值大于它的左子节点，且小于它的右子节点。按照这个基本性质使得树的检索效率大大提高。我们知道在生成二叉树的过程是非常容易失衡的，最坏的情况就是一边倒（只有右/左子树），这样势必会导致二叉树的检索效率大大降低（O(n)），所以为了维持二叉树的平衡，大牛们提出了各种实现的算法，如：[AVL][]，[SBT][]，[伸展树][Link 2]，[TREAP][] ，[红黑树][Link 3]等等。

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

![SouthEast][]

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

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

**       2、根节点是黑色**

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

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

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

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

![SouthEast 1][]

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

![SouthEast 2][]![SouthEast 3][]

左旋                                   右旋

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

--------------------

**      ** 本节参考文献：[http://baike.baidu.com/view/133754.htm?fr=aladdin][http_baike.baidu.com_view_133754.htm_fr_aladdin]—–百度百科

**       注：**由于本文主要是讲解Java中TreeMap，所以并没有对红黑树进行非常深入的了解和研究，如果诸位想对其进行更加深入的研究Lz提供几篇较好的博文：

**       1、[红黑树系列集锦][Link 4]**

**       2、**[**红黑树数据结构剖析**][Link 5]

**       3、**[**红黑树**  
][Link 6]

[  
][Link 6]

# **      ** 二、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（[更多][Link 7]）则意味着它支持一系列的导航方法，具备针对给定搜索目标返回最接近匹配项的导航方法 。

**      ** 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()方法。通过这两个方法我们会了解红黑树增加、删除节点的核心算法。

# **      ** 三、TreeMap put()方法 #

**      ** 在了解TreeMap的put()方法之前，我们先了解红黑树增加节点的算法。

## **      ** 红黑树增加节点 ##

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

![SouthEast 4][]

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

**      ** 1、插入新节点总是红色节点 。

**      ** 2、如果插入节点的父节点是黑色, 能维持性质 。

**      ** 3、如果插入节点的父节点是红色, 破坏了性质. 故插入算法就是通过重新着色或旋转, 来维持性质 。

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

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

**2、根节点是黑色**

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

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

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

*    
    
 *  **       一、为跟节点**
 *  **      ** 若新插入的节点N没有父节点，则直接当做根据节点插入即可，同时将颜色设置为黑色。（如图一（1））
    
    **       二、父节点为黑色**
    
    **      ** 这种情况新节点N同样是直接插入，同时颜色为红色，由于根据规则四它会存在两个黑色的叶子节点，值为null。同时由于新增节点N为红色，所以通过它的子节点的路径依然会保存着相同的黑色节点数，同样满足规则5。（如图一（2））
    
    ![SouthEast 5][]  
    
    
    （图一）
    
    **       三、若父节点P和P的兄弟节点U都为红色**
    
    **      ** 对于这种情况若直接插入肯定会出现不平衡现象。怎么处理？P、U节点变黑、G节点变红。这时由于经过节点P、U的路径都必须经过G所以在这些路径上面的黑节点数目还是相同的。但是经过上面的处理，可能G节点的父节点也是红色，这个时候我们需要将G节点当做新增节点递归处理。
    
    ![SouthEast 6][]  
    
    
    ### **      ** 四、若父节点P为红色，叔父节点U为黑色或者缺少，且新增节点N为P节点的右孩子 ###
    
    **      ** 对于这种情况我们对新增节点N、P进行一次左旋转。这里所产生的结果其实并没有完成，还不是平衡的（违反了规则四），这是我们需要进行情况5的操作。
    
    ![SouthEast 7][]  
    
 *  **      ** 五、父节点P为红色，叔父节点U为黑色或者缺少，新增节点N为父节点P左孩子
 *    
    
 *  **      ** 这种情况有可能是由于情况四而产生的，也有可能不是。对于这种情况先已P节点为中心进行右旋转，在旋转后产生的树中，节点P是节点N、G的父节点。但是这棵树并不规范，它违反了规则4，所以我们将P、G节点的颜色进行交换，使之其满足规范。开始时所有的路径都需要经过G其他们的黑色节点数一样，但是现在所有的路径改为经过P，且P为整棵树的唯一黑色节点，所以调整后的树同样满足规范5。
 *   *  ![SouthEast 8][]  
        
 *  **      ** 上面展示了红黑树新增节点的五种情况，这五种情况涵盖了所有的新增可能，不管这棵红黑树多么复杂，都可以根据这五种情况来进行生成。下面就来分析Java中的TreeMap是如何来实现红黑树的。
 *    
    
    
    ## **      ** TreeMap put()方法实现分析 ##
    
    **      ** 在TreeMap的put()的实现方法中主要分为两个步骤，第一：构建排序二叉树，第二：平衡二叉树。
 *  **      ** 对于排序二叉树的创建，其添加节点的过程如下：
 *  **      ** 1、以根节点为初始节点进行检索。
 *  **      ** 2、与当前节点进行比对，若新增节点值较大，则以当前节点的右子节点作为新的当前节点。否则以当前节点的左子节点作为新的当前节点。
 *  **      ** 3、循环递归2步骤知道检索出合适的叶子节点为止。
 *  **      ** 4、将新增节点与3步骤中找到的节点进行比对，如果新增节点较大，则添加为右子节点；否则添加为左子节点。
 *  **      ** 按照这个步骤我们就可以将一个新增节点添加到排序二叉树中合适的位置。如下：
 *    
    
    
    **\[html\]** view plain copy
    
    print ? [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]
    
    1.  public V put(K key, V value) \{  
    2.             //用t表示二叉树的当前节点  
    3.              Entry<K,V> t = root;  
    4.              //t为null表示一个空树，即TreeMap中没有任何元素，直接插入  
    5.              if (t == null) \{  
    6.                  //比较key值，个人觉得这句代码没有任何意义，空树还需要比较、排序？  
    7.                  compare(key, key); // type (and possibly null) check  
    8.                  //将新的key-value键值对创建为一个Entry节点，并将该节点赋予给root  
    9.                  root = new Entry<>(key, value, null);  
    10.                 //容器的size = 1，表示TreeMap集合中存在一个元素  
    11.                 size = 1;  
    12.                 //修改次数 + 1  
    13.                 modCount++;  
    14.                 return null;  
    15.             \}  
    16.             int cmp;     //cmp表示key排序的返回结果  
    17.             Entry<K,V> parent;   //父节点  
    18.             // split comparator and comparable paths  
    19.             Comparator<? super K> cpr = comparator;    //指定的排序算法  
    20.             //如果cpr不为空，则采用既定的排序算法进行创建TreeMap集合  
    21.             if (cpr != null) \{  
    22.                 do \{  
    23.                     parent = t;      //parent指向上次循环后的t  
    24.                     //比较新增节点的key和当前节点key的大小  
    25.                     cmp = cpr.compare(key, t.key);  
    26.                     //cmp返回值小于0，表示新增节点的key小于当前节点的key，则以当前节点的左子节点作为新的当前节点  
    27.                     if (cmp < 0)  
    28.                         t = t.left;  
    29.                     //cmp返回值大于0，表示新增节点的key大于当前节点的key，则以当前节点的右子节点作为新的当前节点  
    30.                     else if (cmp > 0)  
    31.                         t = t.right;  
    32.                     //cmp返回值等于0，表示两个key值相等，则新值覆盖旧值，并返回新值  
    33.                     else  
    34.                         return t.setValue(value);  
    35.                 \} while (t != null);  
    36.             \}  
    37.             //如果cpr为空，则采用默认的排序算法进行创建TreeMap集合  
    38.             else \{  
    39.                 if (key == null)     //key值为空抛出异常  
    40.                     throw new NullPointerException();  
    41.                 /\* 下面处理过程和上面一样 \*/  
    42.                 Comparable<? super K> k = (Comparable<? super K>) key;  
    43.                 do \{  
    44.                     parent = t;  
    45.                     cmp = k.compareTo(t.key);  
    46.                     if (cmp < 0)  
    47.                         t = t.left;  
    48.                     else if (cmp > 0)  
    49.                         t = t.right;  
    50.                     else  
    51.                         return t.setValue(value);  
    52.                 \} while (t != null);  
    53.             \}  
    54.             //将新增节点当做parent的子节点  
    55.             Entry<K,V> e = new Entry<>(key, value, parent);  
    56.             //如果新增节点的key小于parent的key，则当做左子节点  
    57.             if (cmp < 0)  
    58.                 parent.left = e;  
    59.           //如果新增节点的key大于parent的key，则当做右子节点  
    60.             else  
    61.                 parent.right = e;  
    62.             /\*  
    63.              \*  上面已经完成了排序二叉树的的构建，将新增节点插入该树中的合适位置  
    64.              \*  下面fixAfterInsertion()方法就是对这棵树进行调整、平衡，具体过程参考上面的五种情况  
    65.              \*/  
    66.             fixAfterInsertion(e);  
    67.             //TreeMap元素数量 + 1  
    68.             size++;  
    69.             //TreeMap容器修改次数 + 1  
    70.             modCount++;  
    71.             return null;  
    72.         \}  
    
    ![save_snippets.png][]
    
        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); 调整的过程务必会涉及到红黑树的左旋、右旋、着色三个基本操作。代码如下：
 *  **\[java\]** view plain copy
    
    print ? [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]
    
    1.  /\*\* 
    2.       \* 新增节点后的修复操作 
    3.       \* x 表示新增节点 
    4.       \*/  
    5.       private void fixAfterInsertion(Entry<K,V> x) \{  
    6.              x.color = RED;    //新增节点的颜色为红色  
    7.    
    8.              //循环 直到 x不是根节点，且x的父节点不为红色  
    9.              while (x != null && x != root && x.parent.color == RED) \{  
    10.                 //如果X的父节点（P）是其父节点的父节点（G）的左节点  
    11.                 if (parentOf(x) == leftOf(parentOf(parentOf(x)))) \{  
    12.                     //获取X的叔节点(U)  
    13.                     Entry<K,V> y = rightOf(parentOf(parentOf(x)));  
    14.                     //如果X的叔节点（U） 为红色（情况三）  
    15.                     if (colorOf(y) == RED) \{       
    16.                         //将X的父节点（P）设置为黑色  
    17.                         setColor(parentOf(x), BLACK);  
    18.                         //将X的叔节点（U）设置为黑色  
    19.                         setColor(y, BLACK);  
    20.                         //将X的父节点的父节点（G）设置红色  
    21.                         setColor(parentOf(parentOf(x)), RED);  
    22.                         x = parentOf(parentOf(x));  
    23.                     \}  
    24.                     //如果X的叔节点（U为黑色）；这里会存在两种情况（情况四、情况五）  
    25.                     else \{     
    26.                         //如果X节点为其父节点（P）的右子树，则进行左旋转（情况四）  
    27.                         if (x == rightOf(parentOf(x))) \{  
    28.                             //将X的父节点作为X  
    29.                             x = parentOf(x);  
    30.                             //右旋转  
    31.                             rotateLeft(x);  
    32.                         \}  
    33.                         //（情况五）  
    34.                         //将X的父节点（P）设置为黑色  
    35.                         setColor(parentOf(x), BLACK);  
    36.                         //将X的父节点的父节点（G）设置红色  
    37.                         setColor(parentOf(parentOf(x)), RED);  
    38.                         //以X的父节点的父节点（G）为中心右旋转  
    39.                         rotateRight(parentOf(parentOf(x)));  
    40.                     \}  
    41.                 \}  
    42.                 //如果X的父节点（P）是其父节点的父节点（G）的右节点  
    43.                 else \{  
    44.                     //获取X的叔节点（U）  
    45.                     Entry<K,V> y = leftOf(parentOf(parentOf(x)));  
    46.                   //如果X的叔节点（U） 为红色（情况三）  
    47.                     if (colorOf(y) == RED) \{  
    48.                         //将X的父节点（P）设置为黑色  
    49.                         setColor(parentOf(x), BLACK);  
    50.                         //将X的叔节点（U）设置为黑色  
    51.                         setColor(y, BLACK);  
    52.                         //将X的父节点的父节点（G）设置红色  
    53.                         setColor(parentOf(parentOf(x)), RED);  
    54.                         x = parentOf(parentOf(x));  
    55.                     \}  
    56.                   //如果X的叔节点（U为黑色）；这里会存在两种情况（情况四、情况五）  
    57.                     else \{  
    58.                         //如果X节点为其父节点（P）的右子树，则进行左旋转（情况四）  
    59.                         if (x == leftOf(parentOf(x))) \{  
    60.                             //将X的父节点作为X  
    61.                             x = parentOf(x);  
    62.                            //右旋转  
    63.                             rotateRight(x);  
    64.                         \}  
    65.                         //（情况五）  
    66.                         //将X的父节点（P）设置为黑色  
    67.                         setColor(parentOf(x), BLACK);  
    68.                         //将X的父节点的父节点（G）设置红色  
    69.                         setColor(parentOf(parentOf(x)), RED);  
    70.                         //以X的父节点的父节点（G）为中心右旋转  
    71.                         rotateLeft(parentOf(parentOf(x)));  
    72.                     \}  
    73.                 \}  
    74.             \}  
    75.             //将根节点G强制设置为黑色  
    76.             root.color = BLACK;  
    77.         \}  
    
    ![save_snippets.png][]
    
        /**
             * 新增节点后的修复操作
             * 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为黑色）；这里会存在两种情况（情况四、情况五）
                            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为黑色）；这里会存在两种情况（情况四、情况五）
                            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()
 *  **\[java\]** view plain copy
    
    print ? [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]
    
    1.  private void rotateLeft(Entry<K,V> p) \{  
    2.          if (p != null) \{  
    3.              //获取P的右子节点，其实这里就相当于新增节点N（情况四而言）  
    4.              Entry<K,V> r = p.right;  
    5.              //将R的左子树设置为P的右子树  
    6.              p.right = r.left;  
    7.              //若R的左子树不为空，则将P设置为R左子树的父亲  
    8.              if (r.left != null)  
    9.                  r.left.parent = p;  
    10.             //将P的父亲设置R的父亲  
    11.             r.parent = p.parent;  
    12.             //如果P的父亲为空，则将R设置为跟节点  
    13.             if (p.parent == null)  
    14.                 root = r;  
    15.             //如果P为其父节点（G）的左子树，则将R设置为P父节点(G)左子树  
    16.             else if (p.parent.left == p)  
    17.                 p.parent.left = r;  
    18.             //否则R设置为P的父节点（G）的右子树  
    19.             else  
    20.                 p.parent.right = r;  
    21.             //将P设置为R的左子树  
    22.             r.left = p;  
    23.             //将R设置为P的父节点  
    24.             p.parent = r;  
    25.         \}  
    26.     \}  
    
    ![save_snippets.png][]
    
        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。
 *  **\[java\]** view plain copy
    
    print ? [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]
    
    1.  private void rotateRight(Entry<K,V> p) \{  
    2.          if (p != null) \{  
    3.              //将L设置为P的左子树  
    4.              Entry<K,V> l = p.left;  
    5.              //将L的右子树设置为P的左子树  
    6.              p.left = l.right;  
    7.              //若L的右子树不为空，则将P设置L的右子树的父节点  
    8.              if (l.right != null)   
    9.                  l.right.parent = p;  
    10.             //将P的父节点设置为L的父节点  
    11.             l.parent = p.parent;  
    12.             //如果P的父节点为空，则将L设置根节点  
    13.             if (p.parent == null)  
    14.                 root = l;  
    15.             //若P为其父节点的右子树，则将L设置为P的父节点的右子树  
    16.             else if (p.parent.right == p)  
    17.                 p.parent.right = l;  
    18.             //否则将L设置为P的父节点的左子树  
    19.             else   
    20.                 p.parent.left = l;  
    21.             //将P设置为L的右子树  
    22.             l.right = p;  
    23.             //将L设置为P的父节点  
    24.             p.parent = l;  
    25.         \}  
    26.     \}  
    
    ![save_snippets.png][]
    
        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;
                }
            }
 *  **      ** 左旋、右旋的示意图如下：
 *    
    
    
    ![SouthEast 9][]![SouthEast 10][]
    
    （左旋）                                         （右旋）
    
    （图片来自：[http://www.cnblogs.com/yangecnu/p/Introduce-Red-Black-Tree.html][http_www.cnblogs.com_yangecnu_p_Introduce-Red-Black-Tree.html]）
    
    **      ** 着色：setColor()
    
    **      ** 着色就是改变该节点的颜色，在红黑树中，它是依靠节点的颜色来维持平衡的。
 *  **\[java\]** view plain copy
    
    print ? [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]
    
    1.  private static <K,V> void setColor(Entry<K,V> p, boolean c) \{  
    2.          if (p != null)  
    3.              p.color = c;  
    4.      \}  
    
    ![save_snippets.png][]
    
        private static <K,V> void setColor(Entry<K,V> p, boolean c) {
                if (p != null)
                    p.color = c;
            }
    
      
    
 *  # **      ** 四、TreeMap delete()方法 #
    
    ## **      ** 红黑树删除节点 ##
    
    **      ** 针对于红黑树的增加节点而言，删除显得更加复杂，使原本就复杂的红黑树变得更加复杂。同时删除节点和增加节点一样，同样是找到删除的节点，删除之后调整红黑树。但是这里的删除节点并不是直接删除，而是通过走了“弯路”通过一种捷径来删除的：**找到被删除的节点D的子节点C，用C来替代D，不是直接删除D，因为D被C替代了，直接删除C即可。**所以这里就将删除父节点D的事情转变为了删除子节点C的事情，这样处理就将复杂的删除事件简单化了。**子节点C的规则是：右分支最左边，或者 左分支最右边的。**
 *   *  **![SouthEast 11][]**  
        
 *  **      ** 红-黑二叉树删除节点，最大的麻烦是要保持 各分支黑色节点数目相等。 因为是删除，所以不用担心存在颜色冲突问题——插入才会引起颜色冲突。
    
    **      ** 红黑树删除节点同样会分成几种情况，这里是按照待删除节点有几个儿子的情况来进行分类：
    
    **      ** 1、没有儿子，即为叶结点。直接把父结点的对应儿子指针设为NULL，删除儿子结点就OK了。
    
    **      ** 2、只有一个儿子。那么把父结点的相应儿子指针指向儿子的独生子，删除儿子结点也OK了。
    
    **      ** 3、有两个儿子。这种情况比较复杂，但还是比较简单。上面提到过用子节点C替代代替待删除节点D，然后删除子节点C即可。
    
    **      ** 下面就论各种删除情况来进行图例讲解，但是在讲解之前请允许我再次啰嗦一句，**请时刻牢记红黑树的5点规定：**
    
    **       1、每个节点都只能是红色或者黑色**
    
    **       2、根节点是黑色**
    
    **       3、每个叶节点（NIL节点，空节点）是黑色的。**
    
    **       4、如果一个结点是红的，则它两个子节点都是黑的。也就是说在一条路径上不能出现相邻的两个红色结点。**
    
    **       5、从任一节点到其每个叶子的所有路径都包含相同数目的黑色节点。**
    
    **       （注：已经讲三遍了，再不记住我就怀疑你是否适合搞IT了 O(∩\_∩)O~）**
    
    **      ** 诚然，既然删除节点比较复杂，那么在这里我们就约定一下规则：
    
    **      ** 1、下面要讲解的删除节点一定是实际要删除节点的后继节点（N），如前面提到的C。
    
    **      ** 2、下面提到的删除节点的树都是如下结构，该结构所选取的节点是待删除节点的右树的最左边子节点。这里我们规定真实删除节点为N、父节点为P、兄弟节点为W兄弟节点的两个子节点为X1、X2。如下图（2.1）。
 *   *  ![SouthEast 12][]  
        
 *  **      ** 现在我们就上面提到的三种情况进行分析、处理。
    
    **       情况一、无子节点（红色节点）**
    
    **      ** 这种情况对该节点直接删除即可，不会影响树的结构。因为该节点为叶子节点它不可能存在子节点—–如子节点为黑，则违反黑节点数原则（规定5），为红，则违反“颜色”原则（规定4）。 如上图（2.2）。
    
    **       情况二、有一个子节点**
    
    **      ** 这种情况处理也是非常简单的，用子节点替代待删除节点，然后删除子节点即可。如上图（2.3）
    
    **       情况三、有两个子节点**
    
    **      ** 这种情况可能会稍微有点儿复杂。它需要找到一个替代待删除节点（N）来替代它，然后删除N即可。它主要分为四种情况。
    
    **      ** 1、N的兄弟节点W为红色
    
    **      ** 2、N的兄弟w是黑色的，且w的俩个孩子都是黑色的。
    
    **      ** 3、N的兄弟w是黑色的，w的左孩子是红色，w的右孩子是黑色。
    
    **      ** 4、N的兄弟w是黑色的，且w的右孩子时红色的。
    
    **       情况3.1、N的兄弟节点W为红色**
    
    **      ** W为红色，那么其子节点X1、X2必定全部为黑色，父节点P也为黑色。处理策略是：改变W、P的颜色，然后进行一次左旋转。这样处理就可以使得红黑性质得以继续保持。N的新兄弟new w是旋转之前w的某个孩子，为黑色。这样处理后将情况3.1、转变为3.2、3.3、3.4中的一种。如下：
    
    ![SouthEast 13][]  
    
 *  **       情况3.2、N的兄弟w是黑色的，且w的俩个孩子都是黑色的。**
 *  **      ** 这种情况其父节点可红可黑，由于W为黑色，这样导致N子树相对于其兄弟W子树少一个黑色节点，这时我们可以将W置为红色。这样，N子树与W子树黑色节点一致，保持了平衡。如下
 *   *  ![SouthEast 14][]  
        
 *  **      ** 将W由黑转变为红，这样就会导致新节点new N相对于它的兄弟节点会少一个黑色节点。但是如果new x为红色，我们直接将new x转变为黑色，保持整棵树的平衡。否则情况3.2 会转变为情况3.1、3.3、3.4中的一种。
 *  **       情况3.3、N的兄弟w是黑色的，w的左孩子是红色，w的右孩子是黑色。**
 *  **      ** 针对这种情况是将节点W和其左子节点进行颜色交换，然后对W进行右旋转处理。
 *   *  ![SouthEast 15][]  
        
 *  **      ** 此时N的新兄弟X1(new w)是一个有红色右孩子的黑结点，于是将情况3转化为情况4.
 *  **       情况3.4、N的兄弟w是黑色的，且w的右孩子时红色的。**
 *  **      ** 交换W和父节点P的颜色，同时对P进行左旋转操作。这样就把左边缺失的黑色节点给补回来了。同时将W的右子节点X2置黑。这样左右都达到了平衡。
 *   *  ![SouthEast 16][]  
        
 *    
    
 *  **       总结**
 *  **      ** 个人认为这四种情况比较难理解，首先他们都不是单一的某种情况，他们之间是可以进行互转的。相对于其他的几种情况，情况3.2比较好理解，仅仅只是一个颜色的转变，通过减少右子树的一个黑色节点使之保持平衡，同时将不平衡点上移至N与W的父节点，然后进行下一轮迭代。情况3.1，是将W旋转将其转成情况2、3、4情况进行处理。而情况3.3通过转变后可以化成情况3.4来进行处理，从这里可以看出情况3.4应该最终结。情况3.4、右子节点为红色节点，那么将缺失的黑色节点交由给右子节点，通过旋转达到平衡。
 *  **      ** 通过上面的分析，我们已经初步了解了红黑树的删除节点情况，相对于增加节点而言它确实是选的较为复杂。下面我将看到在[Java ][Java 1]TreeMap中是如何实现红黑树删除的。
 *  ## **      ** TreeMap deleteEntry()方法实现分析 ##
 *  **      ** 通过上面的分析我们确认删除节点的步骤是：找到一个替代子节点C来替代P，然后直接删除C，最后调整这棵红黑树。下面代码是寻找替代节点、删除替代节点。
 *  **\[java\]** view plain copy
    
    print ? [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]
    
    1.  private void deleteEntry(Entry<K,V> p) \{  
    2.          modCount++;      //修改次数 +1  
    3.          size–;          //元素个数 -1  
    4.    
    5.          /\* 
    6.           \* 被删除节点的左子树和右子树都不为空，那么就用 p节点的中序后继节点代替 p 节点 
    7.           \* successor(P)方法为寻找P的替代节点。规则是右分支最左边，或者 左分支最右边的节点 
    8.           \* ———————（1） 
    9.           \*/  
    10.         if (p.left != null && p.right != null) \{    
    11.             Entry<K,V> s = successor(p);  
    12.             p.key = s.key;  
    13.             p.value = s.value;  
    14.             p = s;  
    15.         \}  
    16.   
    17.         //replacement为替代节点，如果P的左子树存在那么就用左子树替代，否则用右子树替代  
    18.         Entry<K,V> replacement = (p.left != null ? p.left : p.right);  
    19.   
    20.         /\* 
    21.          \* 删除节点，分为上面提到的三种情况 
    22.          \* ———————–（2） 
    23.          \*/  
    24.         //如果替代节点不为空  
    25.         if (replacement != null) \{  
    26.             replacement.parent = p.parent;  
    27.             /\* 
    28.              \*replacement来替代P节点 
    29.              \*/  
    30.             //若P没有父节点，则跟节点直接变成replacement  
    31.             if (p.parent == null)  
    32.                 root = replacement;  
    33.             //如果P为左节点，则用replacement来替代为左节点  
    34.             else if (p == p.parent.left)  
    35.                 p.parent.left  = replacement;  
    36.           //如果P为右节点，则用replacement来替代为右节点  
    37.             else  
    38.                 p.parent.right = replacement;  
    39.   
    40.             //同时将P节点从这棵树中剔除掉  
    41.             p.left = p.right = p.parent = null;  
    42.   
    43.             /\* 
    44.              \* 若P为红色直接删除，红黑树保持平衡 
    45.              \* 但是若P为黑色，则需要调整红黑树使其保持平衡 
    46.              \*/  
    47.             if (p.color == BLACK)  
    48.                 fixAfterDeletion(replacement);  
    49.         \} else if (p.parent == null) \{     //p没有父节点，表示为P根节点，直接删除即可  
    50.             root = null;  
    51.         \} else \{      //P节点不存在子节点，直接删除即可  
    52.             if (p.color == BLACK)         //如果P节点的颜色为黑色，对红黑树进行调整  
    53.                 fixAfterDeletion(p);  
    54.   
    55.             //删除P节点  
    56.             if (p.parent != null) \{  
    57.                 if (p == p.parent.left)  
    58.                     p.parent.left = null;  
    59.                 else if (p == p.parent.right)  
    60.                     p.parent.right = null;  
    61.                 p.parent = null;  
    62.             \}  
    63.         \}  
    64.     \}  
    
    ![save_snippets.png][]
    
        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()。如下：
    
    **\[java\]** view plain copy
    
    print ? [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]
    
    1.  static <K,V> TreeMap.Entry<K,V> successor(Entry<K,V> t) \{  
    2.          if (t == null)  
    3.              return null;  
    4.          /\* 
    5.           \* 寻找右子树的最左子树 
    6.           \*/  
    7.          else if (t.right != null) \{  
    8.              Entry<K,V> p = t.right;  
    9.              while (p.left != null)  
    10.                 p = p.left;  
    11.             return p;  
    12.         \}   
    13.         /\* 
    14.          \* 选择左子树的最右子树 
    15.          \*/  
    16.         else \{  
    17.             Entry<K,V> p = t.parent;  
    18.             Entry<K,V> ch = t;  
    19.             while (p != null && ch == p.right) \{  
    20.                 ch = p;  
    21.                 p = p.parent;  
    22.             \}  
    23.             return p;  
    24.         \}  
    25.     \}  
    
    ![save_snippets.png][]
    
        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一一对应 。如下：
    
    **      ** 1、有两个儿子。这种情况比较复杂，但还是比较简单。上面提到过用子节点C替代代替待删除节点D，然后删除子节点C即可。
    
    **      ** 2、没有儿子，即为叶结点。直接把父结点的对应儿子指针设为NULL，删除儿子结点就OK了。
    
    **      ** 3、只有一个儿子。那么把父结点的相应儿子指针指向儿子的独生子，删除儿子结点也OK了。
    
    **      ** 删除完节点后，就要根据情况来对红黑树进行复杂的调整：fixAfterDeletion()。
    
    **\[java\]** view plain copy
    
    print ? [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]
    
    1.  private void fixAfterDeletion(Entry<K,V> x) \{  
    2.          // 删除节点需要一直迭代，知道 直到 x 不是根节点，且 x 的颜色是黑色  
    3.          while (x != root && colorOf(x) == BLACK) \{  
    4.              if (x == leftOf(parentOf(x))) \{      //若X节点为左节点  
    5.                  //获取其兄弟节点  
    6.                  Entry<K,V> sib = rightOf(parentOf(x));  
    7.    
    8.                  /\* 
    9.                   \* 如果兄弟节点为红色—-（情况3.1） 
    10.                  \* 策略：改变W、P的颜色，然后进行一次左旋转 
    11.                  \*/  
    12.                 if (colorOf(sib) == RED) \{       
    13.                     setColor(sib, BLACK);       
    14.                     setColor(parentOf(x), RED);    
    15.                     rotateLeft(parentOf(x));  
    16.                     sib = rightOf(parentOf(x));  
    17.                 \}  
    18.   
    19.                 /\* 
    20.                  \* 若兄弟节点的两个子节点都为黑色—-（情况3.2） 
    21.                  \* 策略：将兄弟节点编程红色 
    22.                  \*/  
    23.                 if (colorOf(leftOf(sib))  == BLACK &&  
    24.                     colorOf(rightOf(sib)) == BLACK) \{  
    25.                     setColor(sib, RED);  
    26.                     x = parentOf(x);  
    27.                 \}   
    28.                 else \{  
    29.                     /\* 
    30.                      \* 如果兄弟节点只有右子树为黑色—-（情况3.3） 
    31.                      \* 策略：将兄弟节点与其左子树进行颜色互换然后进行右转 
    32.                      \* 这时情况会转变为3.4 
    33.                      \*/  
    34.                     if (colorOf(rightOf(sib)) == BLACK) \{  
    35.                         setColor(leftOf(sib), BLACK);  
    36.                         setColor(sib, RED);  
    37.                         rotateRight(sib);  
    38.                         sib = rightOf(parentOf(x));  
    39.                     \}  
    40.                     /\* 
    41.                      \*—-情况3.4 
    42.                      \*策略：交换兄弟节点和父节点的颜色， 
    43.                      \*同时将兄弟节点右子树设置为黑色，最后左旋转 
    44.                      \*/  
    45.                     setColor(sib, colorOf(parentOf(x)));  
    46.                     setColor(parentOf(x), BLACK);  
    47.                     setColor(rightOf(sib), BLACK);  
    48.                     rotateLeft(parentOf(x));  
    49.                     x = root;  
    50.                 \}  
    51.             \}   
    52.               
    53.             /\*\* 
    54.              \* X节点为右节点与其为做节点处理过程差不多，这里就不在累述了 
    55.              \*/  
    56.             else \{  
    57.                 Entry<K,V> sib = leftOf(parentOf(x));  
    58.   
    59.                 if (colorOf(sib) == RED) \{  
    60.                     setColor(sib, BLACK);  
    61.                     setColor(parentOf(x), RED);  
    62.                     rotateRight(parentOf(x));  
    63.                     sib = leftOf(parentOf(x));  
    64.                 \}  
    65.   
    66.                 if (colorOf(rightOf(sib)) == BLACK &&  
    67.                     colorOf(leftOf(sib)) == BLACK) \{  
    68.                     setColor(sib, RED);  
    69.                     x = parentOf(x);  
    70.                 \} else \{  
    71.                     if (colorOf(leftOf(sib)) == BLACK) \{  
    72.                         setColor(rightOf(sib), BLACK);  
    73.                         setColor(sib, RED);  
    74.                         rotateLeft(sib);  
    75.                         sib = leftOf(parentOf(x));  
    76.                     \}  
    77.                     setColor(sib, colorOf(parentOf(x)));  
    78.                     setColor(parentOf(x), BLACK);  
    79.                     setColor(leftOf(sib), BLACK);  
    80.                     rotateRight(parentOf(x));  
    81.                     x = root;  
    82.                 \}  
    83.             \}  
    84.         \}  
    85.   
    86.         setColor(x, BLACK);  
    87.     \}  
    
    ![save_snippets.png][]
    
        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);
            }
    
    **      ** 这是红黑树在删除节点后，对树的平衡性进行调整的过程，其实现过程与上面四种复杂的情况一一对应，所以在这个源码的时候一定要对着上面提到的四种情况看。
 *  # **      ** 五、写在最后 #
 *  **      ** 这篇博文确实是有点儿长，在这里非常感谢各位看客能够静下心来读完，我想你通过读完这篇博文一定收获不小。同时这篇博文很大篇幅都在阐述红黑树的实现过程，对Java 的TreeMap聊的比较少，但是我认为如果理解了红黑树的实现过程，对TreeMap那是手到擒来，小菜一碟。
    
    **      ** 同时这篇博文我写了四天，看了、参考了大量的博文。同时不免会有些地方存在借鉴之处，在这里对其表示感谢。LZ大二开始学习[数据结构][Link 1]，自认为学的不错，现在发现数据结构我还有太多的地方需要学习了，同时也再一次体味了算法的魅力！！！！
    
    --------------------
    
    参考资料：
    
    **1、红黑树数据结构剖析：**[**http://www.cnblogs.com/fanzhidongyzby/p/3187912.html**][Link 5]
    
    **2、红黑二叉树详解及理论分析 ：**[**http://blog.csdn.net/kartorz/article/details/8865997**][http_blog.csdn.net_kartorz_article_details_8865997]
    
    **3、**[**教你透彻了解红黑树** ][Link 8]**：****blog.csdn.net/v\_july\_v/article/details/6105630**
    
    **4、经典算法研究系列：五、红黑树算法的实现与剖析 ：**[**http://blog.csdn.net/v\_JULY\_v/article/details/6109153**][http_blog.csdn.net_v_JULY_v_article_details_6109153]
    
    **5、示例，红黑树插入和删除过程：**[**http://saturnman.blog.163.com/blog/static/557611201097221570/**][http_saturnman.blog.163.com_blog_static_557611201097221570]
    
    **6、红黑二叉树详解及理论分析 ：**[**http://blog.csdn.net/kartorz/article/details/8865997**][http_blog.csdn.net_kartorz_article_details_8865997]
    
    [**—————————————————————————————————————————————————————————-**  
    ][http_blog.csdn.net_kartorz_article_details_8865997]

[http_cmsblogs.com_p_1013]: http://cmsblogs.com/?p=1013
[http_cmsblogs.com]: http://cmsblogs.com
[Link 1]: http://lib.csdn.net/base/datastructure
[Java]: http://lib.csdn.net/base/javase
[AVL]: http://baike.baidu.com/view/414610.htm
[SBT]: http://baike.baidu.com/view/2957252.htm
[Link 2]: http://baike.baidu.com/view/1118088.htm
[TREAP]: http://baike.baidu.com/view/956602.htm
[Link 3]: http://baike.baidu.com/view/133754.htm?fr=aladdin#1_1
[SouthEast]: /images/20220708/cf5f26a9fb7c474ab8f054eea6cad733.png
[SouthEast 1]: /images/20220708/3776091807d743448bf9e8f18872ee0f.png
[SouthEast 2]: https://img-blog.csdn.net/20140523092135453?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvY2hlbnNzeQ==/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/SouthEast
[SouthEast 3]: /images/20220708/a61ee93399fc4c1b9341bdf8bd92584b.png
[http_www.cnblogs.com_yangecnu_p_Introduce-Red-Black-Tree.html]: http://www.cnblogs.com/yangecnu/p/Introduce-Red-Black-Tree.html
[http_baike.baidu.com_view_133754.htm_fr_aladdin]: http://baike.baidu.com/view/133754.htm?fr=aladdin
[Link 4]: http://blog.csdn.net/v_JULY_v/article/category/774945
[Link 5]: http://www.cnblogs.com/fanzhidongyzby/p/3187912.html
[Link 6]: http://blog.csdn.net/eric491179912/article/details/6179908
[Link 7]: http://docs.oracle.com/javase/7/docs/api/java/util/NavigableMap.html
[SouthEast 4]: /images/20220708/98ef399e95a54d0db6d1b4ece0a1d4d1.png
[SouthEast 5]: /images/20220708/6fa7b3d443e34f89af1fb1495c22ffed.png
[SouthEast 6]: /images/20220708/4cdaf337225a4545b11deb56fb0bb543.png
[SouthEast 7]: /images/20220708/7d345fc1f90e4b86a80f1b4ed41a7d18.png
[SouthEast 8]: /images/20220708/8333bee18a5e4d8683129682f18d7fc1.png
[CODE]: https://code.csdn.net/assets/CODE_ico.png
[CODE_CODE]: https://code.csdn.net/snippets/359419
[ico_fork.svg]: https://code.csdn.net/assets/ico_fork.svg
[ico_fork.svg 1]: https://code.csdn.net/snippets/359419/fork
[save_snippets.png]: /images/20220708/7bffa76ceea74a248eff7c08f8b72bf9.png
[SouthEast 9]: https://img-blog.csdn.net/20140523091739328?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvY2hlbnNzeQ==/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/SouthEast
[SouthEast 10]: /images/20220708/c09b1207450543a4aae8d736fa332bd4.png
[SouthEast 11]: /images/20220708/70687669c84542afb7a593888f55abb3.png
[SouthEast 12]: /images/20220708/2fd56ddfbb2147bc8ff2b1306eb6104b.png
[SouthEast 13]: /images/20220708/16ab9f80258c4db98671b57eef931614.png
[SouthEast 14]: /images/20220708/99813e3e24884b9eb744171dbd5007c0.png
[SouthEast 15]: /images/20220708/11d4c9a08fc7415f81d26f90e0e841b6.png
[SouthEast 16]: /images/20220708/0ae5bb8fadcf42aeadddec0cbbed174b.png
[Java 1]: http://lib.csdn.net/base/java
[http_blog.csdn.net_kartorz_article_details_8865997]: http://blog.csdn.net/kartorz/article/details/8865997
[Link 8]: http://blog.csdn.net/v_july_v/article/details/6105630
[http_blog.csdn.net_v_JULY_v_article_details_6109153]: http://blog.csdn.net/v_JULY_v/article/details/6109153
[http_saturnman.blog.163.com_blog_static_557611201097221570]: http://saturnman.blog.163.com/blog/static/557611201097221570/