一, 红黑树所处数据结构的位置

在JDK源码中, 有treeMap和JDK8的HashMap都用到了红黑树去存储

红黑树可以看成B树的一种:

从二叉树看,红黑树是一颗相对平衡的二叉树

二叉树-->搜索二叉树-->平衡搜索二叉树--> 红黑树

从N阶树看,红黑树就是一颗 2-3-4树

N阶树-->B(B-)树

故我提取出了红黑树部分的源码,去说明红黑树的理解

看之前,理解红黑树的几个特性,后面的操作都是为了让树符合红黑树的这几个特性,从而满足对查找效率的O(logn)

二,红黑树特性,以及保持的手段

1,根和叶子节点都是黑色的

2,不能有有连续两个红色的节点

3, 从任一节点到它所能到达得叶子节点的所有简单路径都包含相同数目的黑色节点

这几个特效,个人理解就是规定了红黑树是一颗2-3-4的B树了,从而满足了O(logn)查找效率

保持特性的手段,通过下面这些手段,让红黑树满足红黑树的特性,如果要尝试理解,可以从2-3-4树的向上增长,后面有详细介绍

当然,这些改变也都是在O(logn)内完成的,主要改变方式有

1, 改变颜色

2, 左旋

3, 右旋

三,从JDK源码来理解

主要看我的注释,逻辑的理解

先看TreeMap

//对treeMap的红黑树理解注解. 2017.02.16 by 何锦彬  JDK,1.7.51<br>  <br>/** From CLR */
    private void fixAfterInsertion(Entry<K, V> x) {

        //新加入红黑树的默认节点就是红色
        x.color = RED;
        /**
         * 1. 如为根节点直接跳出
         */
        while (x != null && x != root && x.parent.color == RED) {

            if (parentOf(x) == leftOf(parentOf(parentOf(x)))) {

                //如果X的父节点(P)是其父节点的父节点(G)的左节点
                //即 下面这种情况
                /**
                 *                         G
                 *               P(RED)              U
                 */
                //获取其叔(U)节点
                Entry<K, V> y = rightOf(parentOf(parentOf(x)));
                if (colorOf(y) == RED) {
                    // 这种情况,对应下面 图:情况一
                    /**
                     *                         G
                     *               P(RED)              U(RED)
                     *          X
                     */
                    //如果叔节点是红色的(父节点有判断是红色). 即是双红色,比较好办,通过改变颜色就行. 把P和U都设置成黑色然后,X加到P节点。 G节点当作新加入节点继续迭代
                    setColor(parentOf(x), BLACK);
                    setColor(y, BLACK);
                    setColor(parentOf(parentOf(x)), RED);
                    x = parentOf(parentOf(x));
                } else {
                    //处理红父,黑叔的情况
                    if (x == rightOf(parentOf(x))) {
                        // 这种情况,对应下面 图:情况二
                        /**
                         *                           G
                         *            P(RED)                        U(BLACK)
                         *                     X
                         */
                        //如果X是右边节点
                        x = parentOf(x);
                        // 进行左旋
                        rotateLeft(x);
                    }
                    //左旋后,是这种情况了,对应下面 图:情况三
                    /**
                     *                           G
                     *            P(RED)                        U(BLACK)
                     *      X
                     */

                    // 到这,X只能是左节点了,而且P是红色,U是黑色的情况
                    //把P改成黑色,G改成红色,以G为节点进行右旋
                    setColor(parentOf(x), BLACK);
                    setColor(parentOf(parentOf(x)), RED);
                    rotateRight(parentOf(parentOf(x)));
                }
            } else {
                //父节点在右边的
                /**
                 *                         G
                 *                 U               P(RED)
                 */
                //获取U
                Entry<K, V> y = leftOf(parentOf(parentOf(x)));

                if (colorOf(y) == RED) {
                    //红父红叔的情况
                    /**
                     *                          G
                     *             U(RED)               P(RED)
                     */
                    setColor(parentOf(x), BLACK);
                    setColor(y, BLACK);
                    setColor(parentOf(parentOf(x)), RED);
                    //把G当作新插入的节点继续进行迭代
                    x = parentOf(parentOf(x));
                } else {
                    //红父黑叔,并且是右父的情况
                    /**
                     *                          G
                     *             U(RED)               P(RED)
                     */
                    if (x == leftOf(parentOf(x))) {
                    //如果插入的X是左节点
                     /**
                        *                            G
                        *            U(BLACK)                        P(RED)
                        *                                       X
                        */
                        x = parentOf(x);
                        //以P为节点进行右旋
                        rotateRight(x);
                    }
                    //右旋后
                    /**
                     *                            G
                     *            U(BLACK)                        P(RED)
                     *                                                        X
                     */
                    setColor(parentOf(x), BLACK);
                    setColor(parentOf(parentOf(x)), RED);
                    //以G为节点进行左旋
                    rotateLeft(parentOf(parentOf(x)));
                }
            }
        }
        //红黑树的根节点始终是黑色
        root.color = BLACK;
    }

再看看HashMap的实现

在HashMap中,在JDK8后开始用红黑树代替链表,查找由O(n) 变成了 O(Logn)

源码分析如下:

for (int binCount = 0; ; ++binCount) {
                    if ((e = p.next) == null) {
                        p.next = newNode(hash, key, value, null);
                        //JDK8 的hashmap,链表到了8就需要变成颗红黑树了
                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                            treeifyBin(tab, hash);
                        break;
                    }

红黑树的维护代码部分如下:

//hashmap的红黑树平衡
         static <K,V> TreeNode<K,V> balanceInsertion(TreeNode<K,V> root,
                                                            TreeNode<K,V> x) {
                    x.red = true;
                    //死循环加变量定义,总感觉JAVA很少这样写代码 哈
                    for (TreeNode<K,V> xp, xpp, xppl, xppr;;) {
                        //xp X父节点, XPP X的祖父节点,  XPPL 祖父左节点  XXPR 祖父右节点
                        if ((xp = x.parent) == null) {
                            x.red = false;
                            return x;
                        }
                        // 如果父节点是黑色, 或者XP父节点是空,直接返回
                        else if (!xp.red || (xpp = xp.parent) == null)
                            return root;

                        // 下面的代码就和上面的很treeMap像了,

                        if (xp == (xppl = xpp.left)) {
                             // 第一种情况, 赋值xppl
                            //父节点是左节点的情况,下面这种
                            /**
                             *                         G
                             *               P(RED)              U
                             */
                            if ((xppr = xpp.right) != null && xppr.red) {
                                //如果红叔的情况
                                 // 这种情况,对应下面 图:情况一
                                /**
                                 *                         G
                                 *               P(RED)              U(RED)
                                 *          X
                                 */
                                 //改变其颜色,
                                xppr.red = false;
                                xp.red = false;
                                xpp.red = true;
                                x = xpp;
                            }
                            else {
                                 // 黑叔的情况
                                //  这种情况
                              /**
                                 *                         G
                                 *               P(RED)              U(BLACK)
                                 */
                                if (x == xp.right) {
                                    //如果插入节点在右边 这种
                                     // 这种情况,对应下面 图:情况二
                                    /**
                                     *                           G
                                     *            P(RED)                        U(BLACK)
                                     *                     X
                                     */
                                    //需要进行左旋
                                    root = rotateLeft(root, x = xp);
                                    xpp = (xp = x.parent) == null ? null : xp.parent;
                                }
                                //左旋后情况都是这种了,对应下面 图:情况三
                                /**
                                 *                           G
                                 *            P(RED)                        U(BLACK)
                                 *      X
                                 */
                                // 到这,X只能是左节点了,而且P是红色,U是黑色的情况
                                if (xp != null) {
                                //把P改成黑色,G改成红色, 以G为节点进行右旋
                                    xp.red = false;
                                    if (xpp != null) {
                                        xpp.red = true;
                                        root = rotateRight(root, xpp);
                                    }
                                }
                            }
                        }
                        else {
                             //父节点在右边的
                            /**
                             *                         G
                             *                 U               P(RED)
                             */
                            //获取U
                            if (xppl != null && xppl.red) {
                                //红父红叔的情况
                                 /**
                                 *                           G
                                 *                 U(RED)               P(RED)
                                 */
                                xppl.red = false;
                                xp.red = false;
                                xpp.red = true;
                                x = xpp;
                            }
                            else {

                                if (x == xp.left) {
                                    //如果插入的X是右节点
                                  /**
                                     *                            G
                                     *            U(BLACK)                        P(RED)
                                     *                                       X
                                     */
                                    root = rotateRight(root, x = xp);
                                    xpp = (xp = x.parent) == null ? null : xp.parent;
                                }
                                //右旋后
                                /**
                                 *                            G
                                 *            U(BLACK)                        P(RED)
                                 *                                                        X
                                 */
                                if (xp != null) {
                                   //把P改成黑色,G改成红色,
                                    xp.red = false;
                                    if (xpp != null) {
                                        xpp.red = true;
                                        //以G节点左旋
                                        root = rotateLeft(root, xpp);
                                    }
                                }
                            }
                        }
                    }

情况图如下

情况1

情况2

情况3

JDK源码处理红黑树的流程图

可见,其实处理逻辑实现都一样的

三,个人对红黑树理解的方法

1, 如何理解红黑树的O(lgN)的特性?

从2-3-4树去理解

红黑树,其实是一颗 2-3-4的B树,B树都是向上增长的,如果不理解向上增长可以先看看2-3树,这样理解就能知道为什么能O(logn)的查找了

2, 如何理解红黑树的红黑节点意义?

可以把红色节点看成是连接父节点的组成的一个大节点(2个或3个或4个节点组成的一个key),如下:

(此图转自网上)

红色的就是和父节点组成了大节点,

比如

节点7和6,6是红色节点组成,故和它父节点7组成了一个大节点,即 2-3-4树的 6, 7节点

又如

节点 9和10和11,9和10为红色节点,故和10组成了一个2-3-4的3阶节点, 9,10,11(注意顺序有的关性)

3 , B树是如何保持O(lgn)的复杂度的呢?

B+树都是从底布开始往上生长,自动平衡,如 2-3-4树,当节点达到了3个时晋升到上个节点,所以不会产生单独生长一边的情况,形成平衡。

留个问题

4, 数据库里的索引为什么不用红黑树而是用B+树(Mysql)呢? 

后续解答

欢迎关注我的公众号,重现线上各种BUG, 一起来构建我们的知识体系

JAVA中的数据结构 - 真正的去理解红黑树的更多相关文章

  1. JAVA中的数据结构 - 1,红黑树

    背景: 在JDK源码中, 有treeMap和JDK8的HashMap都用到了红黑树去存储 红黑树可以看成B树的一种: 二叉树-->搜索二叉树-->平衡搜索二叉树-->B树--> ...

  2. Java中常见数据结构Map之HashMap

    之前很早就在博客中写过HashMap的一些东西: 彻底搞懂HashMap,HashTableConcurrentHashMap关联: http://www.cnblogs.com/wang-meng/ ...

  3. Java中关于static语句块的理解

    Java中关于static语句块的理解 一.static块会在类被加载的时候执行且仅会被执行一次,一般用来初始化静态变量和调用静态方法. 实例一 public class A{ String name ...

  4. java中的数据结构(集合|容器)

    对java中的数据结构做一个小小的个人总结,虽然还没有到研究透彻jdk源码的地步.首先.java中为何需要集合的出现?什么需求导致.我想对于面向对象来说,对象适用于描述任何事物,所以为了方便对于对象的 ...

  5. [转]详细介绍java中的数据结构

    详细介绍java中的数据结构 本文介绍的是java中的数据结构,本文试图通过简单的描述,向读者阐述各个类的作用以及如何正确使用这些类.一起来看本文吧! 也许你已经熟练使用了java.util包里面的各 ...

  6. 详细介绍java中的数据结构

    详细介绍java中的数据结构 http://developer.51cto.com/art/201107/273003.htm 本文介绍的是java中的数据结构,本文试图通过简单的描述,向读者阐述各个 ...

  7. 关于Java中语句符号及格式的理解

    关于Java中语句符号及格式的理解 这篇文章是撰写的第一篇文章,在此作一下博主是一名在读的工科研究生,种种原因,研二开始决定转行从事程序员工作.开始的自学之路并不算非常顺畅,也走了一点弯路,但一直都坚 ...

  8. Java中的数据结构及排序算法

    (明天补充) 主要是3种接口:List Set Map List:ArrayList,LinkedList:顺序表ArrayList,链表LinkedList,堆栈和队列可以使用LinkedList模 ...

  9. Java集合详解6:TreeMap和红黑树

    Java集合详解6:TreeMap和红黑树 初识TreeMap 之前的文章讲解了两种Map,分别是HashMap与LinkedHashMap,它们保证了以O(1)的时间复杂度进行增.删.改.查,从存储 ...

随机推荐

  1. css:子元素div 上下左右居中方法总结

    最近在面试,不停地收到了知识冲击,尤其是对于一些基础的css.html.js问题居多,所以自我也在做反思,今天就css问题,如何让一个子元素div块元素上下左右居中 (以下总结方法,都已得到验证). ...

  2. PHP框架Yii2.0安装(基础版、高级版)

    最近农成也是切入了yiiframework 2.0,就是安装yii2.0就花费了不少的时间,为此做了很多的弯路,特此写一篇博文来给后面学习的同学少走一点的弯路.写的不好的地方欢迎各位学习的同学们能够指 ...

  3. Sqlserver数据库存储路径的修改

    Sqlserver数据库存储路径的修改 Sqlserver数据库存储路径问题:本系统sqlserver路径默认是存储在C盘目录下的,由于数据会慢慢变大和避免重装系统数据丢失等问题,最好手动将路径设置在 ...

  4. php常用系统函数

    首先纯html页要用meta标签声明编码   <meta http-equiv="Content-Type" content="text/html; charset ...

  5. JS函数的属性

    1.arguments.callee //经典的阶乘(递归)函数 function factorial(num) { if (num <= 1) { return 1; } else { ret ...

  6. new、delete与malloc、free的详解

    内容清单: 1.  C语言中的函数malloc和free 2.  C++中的运算符new和delete 3.  new/delete与malloc/free之间的联系和区别 4.  C/C++程序的内 ...

  7. css3 选择器的比较(一) -- 以字符串开头

    一.  以“字符串”开头 两种用法的区别是: a. 以字符串开头,需要用"-"分割开, b. 以字符串开头,不需要任何分隔符 1. 资料 a) b)  2. html代码 < ...

  8. C#中 什么是装箱和拆箱

    装箱:将值类型包装为引用类型 拆箱:将引用类型转换为值类型   例如 objetct obj = null; obj = ; //装箱 int i = (int) obj; //拆箱

  9. Azure Go Management SDK 中国版使用示例

    简介 刚学习go几天,尝试调用Azure的SDK进行管理API的操作,基本思路是基于注册的AD Application信息生成token,然后再使用Token生成serviceClient,然后再进行 ...

  10. springboot+mybatis+springmvc整合实例

    以往的ssm框架整合通常有两种形式,一种是xml形式,一种是注解形式,不管是xml还是注解,基本都会有一大堆xml标签配置,其中有很多重复性的.springboot带给我们的恰恰是“零配置”,&quo ...