jdk1.8 HashMap红黑树源码解析

这篇博客主要讲解
HashMap1.8的新增特性:红黑树,关于HashMap的其他内容推荐博客HashMap真的教科级讲解

一、什么是红黑树

  1. 每个节点要么是黑色,要么是红色。(节点非黑即红)
  2. 根节点是黑色。
  3. 每个叶子节点(NIL)是黑色。
  4. 如果一个节点是红色的,则它的子节点必须是黑色的。(也就是说父子节点不能同时为红色)
  5. 从一个节点到该节点的子孙节点的所有路径上包含相同数目的黑节点。(这一点是平衡的关键)

其实就是一颗比较平衡的又红又黑的二叉树

  • 下面是我根据它的特性画出的一颗平衡树:

画图不易啊哈哈哈

image

二、为什么HashMap要用红黑树而不是二叉查找树或者B树或者B+树

1. 不用二叉查找树的原因

虽然二叉查找树查找复杂度也是log(n),并且实现容易,但是增删改操作会破环二叉查找树的平衡性,最坏的情况有可能变成一个线性链表,搜索复杂度退化为(n),那么情况就会变的糟糕。后来演化出了二三树,但是它的操作难度过大,实现起来困难。为了能够平衡,它需要处理不同的节点类型;多次比较操作来将节点下移;上移来拆分4-node节点;拆分4-node节点的情况有很多种。关于二三树可以看博客

二三树

所以就用红黑色来作为标记,这样为了保持平衡的基本操作就只有左旋,右旋,改变颜色。但其实步骤依然很繁琐。

2. 不用二叉平衡查找树原因

二叉平衡查找树规定每一个结点的左右结点之差不超过1,追求绝对的平衡。在插入之后进行调整的次数不能确定;而红黑树达到的是绝对的平衡,而且插入之后的调整在3次以内,保证其效率为log(n)

3. 不用B/B+树的原因

B和B+树主要用于数据存储在磁盘上的场景,比如数据库索引就是用B+树实现的。这两种数据结构的特点就是树比较矮胖,每个结点存放一个磁盘大小的数据,这样一次可以把一个磁盘的数据读入内存,减少磁盘转动的耗时,提高效率。而红黑树多用于内存中排序,也就是内部排序,因此HashMap使用红黑树作为它的一种数据结构,当链表长度大于TREEIFY_THRESHOLD(默认为8)会将链表转化为红黑树,这样复杂度变为log(n)。

三、HshMap中红黑树定义

1. 我们先看看HashMap中红黑树的定义和它内部的方法

 static final class TreeNode<K,V> extends LinkedHashMap.Entry<K,V> {
        TreeNode<K,V> parent;  //父亲节点 red-black tree links
        TreeNode<K,V> left;//左子树
        TreeNode<K,V> right;//右子树
        TreeNode<K,V> prev;    // needed, to unlink next upon deletion删除的时候使用
        boolean red;//标记颜色,默认红色
        TreeNode(int hash, K key, V val, Node<K,V> next) {
            super(hash, key, val, next);
        }
        final TreeNode<K,V> root(){//返回节点的根节点
        ...
        }
        static <K,V> void moveRootToFront(Node<K,V>[] tab, TreeNode<K,V> root){
            ... //把给定节点设为桶中的第一个元素
        }
        final TreeNode<K,V> find(int h, Object k, Class<?> kc){
            ... //从当前结点this开始通过给定的hash和key查找结点
        }
        final TreeNode<K,V> getTreeNode(int h, Object k) {
        ... // 从根节点开始寻找节点
        }
         static int tieBreakOrder(Object a, Object b) {
         ...//用来排序
         }
         final void treeify(Node<K,V>[] tab){
             ...//链表树化
         }
         final Node<K,V> untreeify(HashMap<K,V> map){
             ...//转化回链表
         }
         final TreeNode<K,V> putTreeVal(HashMap<K,V> map, Node<K,V>[] tab,
                                       int h, K k, V v){
                                           ...//放入树节点
                                       }
        
        final void removeTreeNode(HashMap<K,V> map, Node<K,V>[] tab,
                                  boolean movable) {
            ...//删除节点
                                  }
        final void split(HashMap<K,V> map, Node<K,V>[] tab, int index, int bit){
            ...//Resize()调用
        }
        static <K,V> TreeNode<K,V> rotateLeft(TreeNode<K,V> root,
                                              TreeNode<K,V> p){
            ...//左旋                                                  }
        static <K,V> TreeNode<K,V> rotateRight(TreeNode<K,V> root, TreeNode<K,V> p){
            ...//右旋
            }
        static <K,V> TreeNode<K,V> balanceInsertion(TreeNode<K,V> root,TreeNode<K,V> x) {
            ...//插入后保持平衡
        }
        static <K,V> TreeNode<K,V> balanceDeletion(TreeNode<K,V> root,TreeNode<K,V> x) {
            ...//删除后保持平衡
        }
         static <K,V> boolean checkInvariants(TreeNode<K,V> t) {}
        
  • TreeNode是HashMap中红黑树的结构,TreeNode继承自LinkedHashMap中的内部类——LinkedHashMap.Entry,而这个内部类又继承自Node,所以TreeNode形成一颗树的同时,也形成链表。

2. 树化过程

  1. 在putVal过程中,如果计算的数组下标不为null,那么说明链表中已经存在过key值,那么下一步找到它并将其覆盖。如果是第一个结点,那么覆盖;如果已经是红黑树,那么把这个结点放入红黑树;如果是链表那么遍历,如果找到这个结点需要判断加入这个结点之后链表长度是否>TREEIFY_THRESHOLD。如果是,那么需要将链表树化,调用treeifyBin
 final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
                  ...
                  if ((e = p.next) == null) {
                        p.next = newNode(hash, key, value, null);
                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                            treeifyBin(tab, hash);
                        break;
                    }
                    ...
     }
  1. 这个方法先判断树化是否达到阙值,否则先进行扩容。然后把Node转化为TreeNode,并且单链表转化为双链表。再调用treeify将其树化
final void treeifyBin(Node<K,V>[] tab, int hash) {
        int n, index; Node<K,V> e;
        if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
           resize();//先判断有没有达到树化阙值
        else if ((e = tab[index = (n - 1) & hash]) != null) {
            TreeNode<K,V> hd = null, tl = null;
            do {
                TreeNode<K,V> p = replacementTreeNode(e, null);//把每个Node结点转化为Treenode结点
                if (tl == null)
                    hd = p;//头节点为空
                else {
                    p.prev = tl;//串联Treenode结点,转化为双链表
                    tl.next = p;
                }
                tl = p;
            } while ((e = e.next) != null);
            if ((tab[index] = hd) != null)
                hd.treeify(tab);//树化
        }
    }
  1. 这个方法就是对TreeNode双链表进行遍历,将其插入。如果是Root为空,那么把结点标记为黑色作为根节点。否则一直比较大小,一直到p为null说明已经找到了它要插入的叶节点的位置,那么就将其插入,插入之后还要调用balanceInsertion使其插入之后树依然能够平衡。
  2. 比如在下面这张图中要插入的结点是50,先与p(初始化为根节点)比较,p=p.left,此时p为45,p=p.right,再跟56比较,p=p.left,然后此时p为null,就把它插入到p的左子树。插入一个红色结点。然后调整红黑树的平衡


    image

final void treeify(Node<K,V>[] tab) {
            TreeNode<K,V> root = null;
            for (TreeNode<K,V> x = this, next; x != null; x = next) {
                next = (TreeNode<K,V>)x.next;
                x.left = x.right = null;
                if (root == null) {
                    x.parent = null;
                    x.red = false;
                    root = x;
                }
                else {
                    K k = x.key;
                    int h = x.hash;
                    Class<?> kc = null;
                    for (TreeNode<K,V> p = root;;) {
                        int dir, ph;
                        K pk = p.key;
                        if ((ph = p.hash) > h)
                            dir = -1;
                        else if (ph < h)
                            dir = 1;
                        else if ((kc == null &&
                                  (kc = comparableClassFor(k)) == null) ||
                                 (dir = compareComparables(kc, k, pk)) == 0)
                            dir = tieBreakOrder(k, pk);

                        TreeNode<K,V> xp = p;
                        if ((p = (dir <= 0) ? p.left : p.right) == null) {
                            x.parent = xp;
                            if (dir <= 0)
                                xp.left = x;
                            else
                                xp.right = x;
                            root = balanceInsertion(root, x);
                            break;
                        }
                    }
                }
            }
            moveRootToFront(tab, root);
        }

2. 左旋,右旋,插入

上面说到了红黑树的插入,那么我们就不得说一下红黑树的两个基本操作了,也就是左旋和右旋

1. 左旋(借用一个博主的图)
image

经过左旋操作,A结点移到左边,A结点的右结点C来到了A的位置,并且C结点的左结点成为A结点的右结点。然后我们继续看看源码的左旋具体怎么操作的:

        static <K,V> TreeNode<K,V> rotateLeft(TreeNode<K,V> root,
                                              TreeNode<K,V> p) {
            //即将左旋的是p,r是p的右子树,如果p和r都不为空进行左旋
            TreeNode<K,V> r, pp, rl;
            if (p != null && (r = p.right) != null) {
            //1.r1是r的左子树,,r1不为空,将他挂到p的右边。
                if ((rl = p.right = r.left) != null)
                    rl.parent = p;
            //2.如果p的父节点为空,那么r就是根节点,并且标记为黑色
                if ((pp = r.parent = p.parent) == null)
                    (root = r).red = false;
                //p是父节点的子节点,那么r挂到pp的左子树
                else if (pp.left == p)
                    pp.left = r;
        //p是父节点的右节点,那么r挂到pp的右子树
                else
                    pp.right = r;
                    3.最后把p挂到r的左子树,就完成了左旋操作
                r.left = p;
                p.parent = r;
            }
            return root;
        }
image
  1. 把C挂到A右子树上,变成这样


    image
  2. 判断A有没有父亲,没有的话C就是root,否则挂到父亲的左子树或者右子树
    这里A没有父节点,那么root就是C,否则就是把C挂到A的父亲底下
  3. A挂到C的左子树中


    image
2. 右旋

操作基本相似,可以自己看一下源码分析一下,如果看不明白,那就画画图,那应该能搞明白了

 static <K,V> TreeNode<K,V> rotateRight(TreeNode<K,V> root,
                                               TreeNode<K,V> p) {
            TreeNode<K,V> l, pp, lr;
            if (p != null && (l = p.left) != null) {
                if ((lr = p.left = l.right) != null)
                    lr.parent = p;
                if ((pp = l.parent = p.parent) == null)
                    (root = l).red = false;
                else if (pp.right == p)
                    pp.right = l;
                else
                    pp.left = l;
                l.right = p;
                p.parent = l;
            }
            return root;
        }

四、红黑树的插入

红黑树的插入操作很多,但还是有迹可循
代码就是下面的思路的实现

  1. 插入的为根节点,则直接把颜色改成黑色即可。
  2. 插入的节点的父节点是黑色节点,则不需要调整,因为插入的节点会初始化为红色节点,红色节点是不会影响树的平衡的。
  3. 插入的节点的祖父节点为null,即插入的节点的父节点是根节点,直接插入即可(因为根节点肯定是黑色)。
  4. 插入的节点父节点和祖父节点都存在,并且其父节点是祖父节点的左节点。这种情况稍微麻烦一点,又分两种子情况:
  • i. 插入节点的叔叔节点是红色,则将父亲节点和叔叔节点都改成黑色,然后祖父节点改成红色即可。
  • ii.插入节点的叔叔节点是黑色或不存在:
    • a.若插入节点是其父节点的右孩子,则将其父节点左旋,
    • b.若为左孩子,则将其父节点变成黑色节点,将其祖父节点变成红色节点,然后将其祖父节点右旋。
  1. 插入的节点父节点和祖父节点都存在,并且其父节点是祖父节点的右节点。这种情况跟上面是类似的,分两种子情况:
  • i.插入节点的叔叔节点是红色,则将父亲节点和叔叔节点都改成黑色,然后祖父节点改成红色即可。
  • ii.插入节点的叔叔节点是黑色或不存在:
    • a.若插入节点是其父节点的左孩子,则将其父节点右旋
    • b.若为右孩子,则将其父节点变成黑色节点,将其祖父节点变成红色节点,然后将其祖父节点左旋。
static <K,V> TreeNode<K,V> balanceInsertion(TreeNode<K,V> root,
                                                    TreeNode<K,V> x) {
            x.red = true;
            for (TreeNode<K,V> xp, xpp, xppl, xppr;;) {
            //场景一:插入的为根节点,标记为黑色即可
                if ((xp = x.parent) == null) {
                    x.red = false;
                    return x;
                }
            //2和3,插入的结点的父亲是黑色或者没有祖父结点,不需要操作
                else if (!xp.red || (xpp = xp.parent) == null)
                    return root;
            //插入的节点父节点和祖父节点都存在并且父亲是祖父左结点
                if (xp == (xppl = xpp.left)) {
                i:插入节点的叔叔节点是红色:父亲节点和叔叔节点都改成黑色,然后祖父节点改成红色即可。
                    if ((xppr = xpp.right) != null && xppr.red) {
                        xppr.red = false;
                        xp.red = false;
                        xpp.red = true;
                        x = xpp;//x指向祖父
                    }
                    
            ii:插入节点的叔叔节点是黑色或不存在
                    else {
                    a:.若插入节点是其父节点的右孩子,则将其父节点左旋
                        if (x == xp.right) {
                            root = rotateLeft(root, x = xp);
                            xpp = (xp = x.parent) == null ? null : xp.parent;
                        }
                        若为左孩子,则将其父节点变成黑色节点,将其祖父节点变成红色节点,然后将其祖父节点右旋。
                        if (xp != null) {
                            xp.red = false;
                            if (xpp != null) {
                                xpp.red = true;
                                root = rotateRight(root, xpp);
                            }
                        }
                    }
                }
        插入的节点父节点和祖父节点都存在,并且其父节点是祖父节点的右节点
                else {
                //i.插入节点的叔叔节点是红色,则将父亲节点和叔叔节点都改成黑色,然后祖父节点改成红色即可。
                    if (xppl != null && xppl.red) {
                        xppl.red = false;
                        xp.red = false;
                        xpp.red = true;
                        x = xpp;
                    }
                    - //ii.插入节点的叔叔节点是黑色或不存在
                    else {
                    //a.若插入节点是其父节点的左孩子,则将其父节点右旋
                        if (x == xp.left) {
                            root = rotateRight(root, x = xp);
                            xpp = (xp = x.parent) == null ? null : xp.parent;
                        }                        b.若为右孩子,则将其父节点变成黑色节点,将其祖父节点变成红色节点,然后将其祖父节点左旋
                        if (xp != null) {
                            xp.red = false;
                            if (xpp != null) {
                                xpp.red = true;
                                root = rotateLeft(root, xpp);
                            }
                        }
                    }
                }
            }
        }

四、红黑树删除

先进行删除,然后调整

1. 二叉搜索树的删除

  1. 情景1:待删除的节点无左右孩子:直接删除即可
  2. 情景2:待删除的节点只有左孩子或者右孩子:则直接把该节点的父节点指向它的左孩子或者右孩子即可
  3. 情景3:待删除的节点既有左孩子又有右孩子:情景3稍微复杂一点,需要先找到其右子树的最左孩子(或者左子树的最右孩子),即左(右)子树中序遍历时的第一个节点,然后将其与待删除的节点互换,最后再删除该节点(如果有右子树,则右子树上位)。总之,就是先找到它的替代者,找到之后替换这个要删除的节点,然后再把这个节点真正删除掉。
  • 源码:
 final void removeTreeNode(HashMap<K,V> map, Node<K,V>[] tab,
                                  boolean movable) {
            int n;
            if (tab == null || (n = tab.length) == 0)
                return;
            int index = (n - 1) & hash;
            TreeNode<K,V> first = (TreeNode<K,V>)tab[index], root = first, rl;
            TreeNode<K,V> succ = (TreeNode<K,V>)next, pred = prev;
            if (pred == null)
                tab[index] = first = succ;
            else
                pred.next = succ;
            if (succ != null)
                succ.prev = pred;
            if (first == null)
                return;
            if (root.parent != null)
                root = root.root();
            if (root == null || root.right == null ||
                (rl = root.left) == null || rl.left == null) {
                tab[index] = first.untreeify(map);  // too small
                return;
            }
            TreeNode<K,V> p = this, pl = left, pr = right, replacement;
            if (pl != null && pr != null) {
                TreeNode<K,V> s = pr, sl;
                while ((sl = s.left) != null) // find successor
                    s = sl;
                boolean c = s.red; s.red = p.red; p.red = c; // swap colors
                TreeNode<K,V> sr = s.right;
                TreeNode<K,V> pp = p.parent;
                if (s == pr) { // p was s's direct parent
                    p.parent = s;
                    s.right = p;
                }
                else {
                    TreeNode<K,V> sp = s.parent;
                    if ((p.parent = sp) != null) {
                        if (s == sp.left)
                            sp.left = p;
                        else
                            sp.right = p;
                    }
                    if ((s.right = pr) != null)
                        pr.parent = s;
                }
                p.left = null;
                if ((p.right = sr) != null)
                    sr.parent = p;
                if ((s.left = pl) != null)
                    pl.parent = s;
                if ((s.parent = pp) == null)
                    root = s;
                else if (p == pp.left)
                    pp.left = s;
                else
                    pp.right = s;
                if (sr != null)
                    replacement = sr;
                else
                    replacement = p;
            }
            else if (pl != null)
                replacement = pl;
            else if (pr != null)
                replacement = pr;
            else
                replacement = p;
                //如果p是叶子节点,p==replacement,否则replacement为p的右子树中最左节点
            if (replacement != p) {
                TreeNode<K,V> pp = replacement.parent = p.parent;
                if (pp == null)
                    root = replacement;
                else if (p == pp.left)
                    pp.left = replacement;
                else
                    pp.right = replacement;
                p.left = p.right = p.parent = null;
            }
//若待删除的节点p时红色的,则树平衡未被破坏,无需进行调整。
    //否则删除节点后需要进行调整
            TreeNode<K,V> r = p.red ? root : balanceDeletion(root, replacement);

            if (replacement == p) {  // detach
                TreeNode<K,V> pp = p.parent;
                p.parent = null;
                if (pp != null) {
                    if (p == pp.left)
                        pp.left = null;
                    else if (p == pp.right)
                        pp.right = null;
                }
            }
            if (movable)
                moveRootToFront(tab, r);
        }

2. 调整

除完之后,如果替代者是红色节点,则不需要调整,如果是黑色节点,则会导致左子树和右子树路径中黑色节点数量不一致,需要进行红黑树的调整

  1. 情景1:只有右孩子且为红色,直接用右孩子替换该节点然后变成黑色即可。
  2. 情景2:只有右孩子且为黑色,那么删除该节点会导致父节点的左子树路径上黑色节点减一,此时只能去借助右子树,从右子树中借一个红色节点过来即可,具体取决于右子树的情况,这里又分成两种:
  • i. 兄弟节点是红色,则此时父节点是黑色,且兄弟节点肯定有两个孩子,且兄弟节点的左右子树路径上均有两个黑色节点,此时只需将兄弟节点与父节点颜色互换,然后将父节点左旋,左旋后,兄弟节点的左子树SL挂到了父节点p的右孩子位置,这时会导致p的右子树路径上的黑色节点比左子树多一,此时再SL置为红色即可
  • ii.兄弟节点是黑色,那么就只能打它孩子的主意了,这里主要关注远侄子(兄弟节点的右孩子,即SR)的颜色情况,这里分成两种情况
    • a.远侄子SR是黑色,近侄子任意(白色代表颜色可为任意颜色),则先将S转为红色,然后右旋,再将SL换成P节点颜色,P涂成黑色,S也涂成黑色,再进行左旋即可。其实简单说就是SL上位,替换父节点位置
    • b.远侄子SR为红色,近侄子任意(该子树路径中有且仅有一个黑色节点),则先将兄弟节点与父节点颜色互换,将SR涂成黑色,再将父节点左旋即可。
  • 源码:
       static <K,V> TreeNode<K,V> balanceDeletion(TreeNode<K,V> root,
                                                TreeNode<K,V> x) {
            for (TreeNode<K,V> xp, xpl, xpr;;)  {
                if (x == null || x == root)
                    return root;
                else if ((xp = x.parent) == null) {
                    x.red = false;
                    return x;
                }
                else if (x.red) {
                    x.red = false;
                    return root;
                }
                else if ((xpl = xp.left) == x) {
                    if ((xpr = xp.right) != null && xpr.red) {
                        xpr.red = false;
                        xp.red = true;
                        root = rotateLeft(root, xp);
                        xpr = (xp = x.parent) == null ? null : xp.right;
                    }
                    if (xpr == null)
                        x = xp;
                    else {
                        TreeNode<K,V> sl = xpr.left, sr = xpr.right;
                        if ((sr == null || !sr.red) &&
                            (sl == null || !sl.red)) {
                            xpr.red = true;
                            x = xp;
                        }
                        else {
                            if (sr == null || !sr.red) {
                                if (sl != null)
                                    sl.red = false;
                                xpr.red = true;
                                root = rotateRight(root, xpr);
                                xpr = (xp = x.parent) == null ?
                                    null : xp.right;
                            }
                            if (xpr != null) {
                                xpr.red = (xp == null) ? false : xp.red;
                                if ((sr = xpr.right) != null)
                                    sr.red = false;
                            }
                            if (xp != null) {
                                xp.red = false;
                                root = rotateLeft(root, xp);
                            }
                            x = root;
                        }
                    }
                }
                else { // symmetric
                    if (xpl != null && xpl.red) {
                        xpl.red = false;
                        xp.red = true;
                        root = rotateRight(root, xp);
                        xpl = (xp = x.parent) == null ? null : xp.left;
                    }
                    if (xpl == null)
                        x = xp;
                    else {
                        TreeNode<K,V> sl = xpl.left, sr = xpl.right;
                        if ((sl == null || !sl.red) &&
                            (sr == null || !sr.red)) {
                            xpl.red = true;
                            x = xp;
                        }
                        else {
                            if (sl == null || !sl.red) {
                                if (sr != null)
                                    sr.red = false;
                                xpl.red = true;
                                root = rotateLeft(root, xpl);
                                xpl = (xp = x.parent) == null ?
                                    null : xp.left;
                            }
                            if (xpl != null) {
                                xpl.red = (xp == null) ? false : xp.red;
                                if ((sl = xpl.left) != null)
                                    sl.red = false;
                            }
                            if (xp != null) {
                                xp.red = false;
                                root = rotateRight(root, xp);
                            }
                            x = root;
                        }
                    }
                }
            }
        }

部分内容参考博客参考

推荐阅读更多精彩内容

  • 写在前面 当在10亿数据中只需要进行10几次比较就能查找到目标时,不禁感叹编程之魅力!人类之伟大呀! —— 学红黑...
    安卓大叔阅读 77,773评论 119 325
  • 1、红黑树介绍 红黑树又称R-B Tree,全称是Red-Black Tree,它是一种特殊的二叉查找树,红黑树的...
    文哥的学习日记阅读 4,336评论 0 30
  • 上一篇:Java集合-ConcurrentHashMap工作原理和实现JDK8 本文学习知识点 1、二叉查找树,以...
    Misout阅读 8,838评论 8 57
  • 写这篇文章之前,本来是打算写HashMap的源码分析,但是jdk1.8之后的HashMap对位桶+链表的结构进行了...
    宛丘之上兮阅读 2,621评论 0 5
  • 这个周看算法导论,看到红黑树,看的我云里雾里绕啊。虽然最后看懂了,据我估计,要是过一个星期不看保证忘干净,因此决定...
    充满活力的早晨阅读 651评论 0 3