浅析Java源码之HashMap外传-红黑树Treenode(已鸽)

　　(这篇文章暂时鸽了，有点理解不能，点进来的小伙伴可以撤了)

　　刚开始准备在HashMap中直接把红黑树也过了的，结果发现这个类不是一般的麻烦，所以单独开一篇。

　　由于红黑树之前完全没接触过，所以这篇博客相当于探索(其实之前的博客都是边看源码边写的，全是探索)。

　　

　　红黑树没见过，树我还是知道的，所以先上一张帅图：

　　

　　红黑树在这个基本树的基础上还多了red，暂时不知道啥意思，慢慢探索。

　　先来一个类总览：

    static final class TreeNode<K,V> extends LinkedHashMap.Entry<K,V> {
        // ...
    }

　　这个红黑树继承了一个另外一个类中的静态内部类：

    static class Entry<K,V> extends HashMap.Node<K,V> {}

　　这个类也继承了一个静态内部类，竟然是HashMap中的Node，真是无语的循环！

　　这些东西虽然绕来绕去，但是总的特性就是两个字：链表！！！！！！！！！

变量

　　废话不多说，首先来看一个这个类的内部变量：

    // 父节点
    TreeNode<K,V> parent;
    // 左右子节点
    TreeNode<K,V> left;
    TreeNode<K,V> right;
    // ???
    TreeNode<K,V> prev;
    // 红黑树的精髓 => red!
    boolean red;

　　这些节点的意思都比较直接，按理讲在正常的树中只有父、左、右三个，这里的prev和red暂时不清楚干嘛用的。

　　

构造函数

　　接下来是构造函数

    TreeNode(int hash, K key, V val, Node<K,V> next) {
        super(hash, key, val, next);
    }

　　super！然后我跑去看了下LinkedHashMap.Entry的构造函数，还是super！！！！

　　绕了一圈，最后还是回到了Node的构造函数，如下：

    Node(int hash, K key, V value, Node<K,V> next) {
        this.hash = hash;
        this.key = key;
        this.value = value;
        this.next = next;
    }

　　没啥好讲的。

　　

　　需要注意的是，静态内部类都是作为工具来使用的，所以不从常规的添加节点、查询来讲解，直接从链表转红黑树的方法入手，看到什么方法讲什么方法，Let's go！

    // tab为HashMap的数组
    final void treeify(Node<K,V>[] tab) {
        TreeNode<K,V> root = null;
        // 这里的this是需要树转换数组索引处的第一个链表元素
        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;
                    // 根据hash值的大小区分左右
                    if ((ph = p.hash) > h)
                        dir = -1;
                    else if (ph < h)
                        dir = 1;
                    // 当出现hash碰撞 暂时不管这个
                    else if ((kc == null &&
                            (kc = comparableClassFor(k)) == null) ||
                            (dir = compareComparables(kc, k, pk)) == 0)
                        dir = tieBreakOrder(k, pk);
                    // 这里的xp变成了root
                    TreeNode<K,V> xp = p;
                    // 这个表达式不加括号看起来真是恶心
                    // 根据dir判断root.left或者root.right是否为null
                    if ((p = (dir <= 0) ? p.left : p.right) == null) {
                        // 设置下一个元素的parent为root
                        x.parent = xp;
                        // 设置root的left或right
                        if (dir <= 0)
                            xp.left = x;
                        else
                            xp.right = x;
                        root = balanceInsertion(root, x);
                        break;
                    }
                }
            }
        }
        moveRootToFront(tab, root);
    }

　　在前面的转换中，其实参数tab并没有用上，所以暂时只需要关注链表本身。

　　在balanceInsertion方法之前，只完成了两件事：

1、将链表的第一个元素设置为根节点

2、将第二个元素的hash与根节点做比较，然后设置根节点的left或right为该元素

　　画个帅图：

　　接下来看balanceInsertion方法做了什么，该方法接受两个参数：根节点、根节点的left(right)节点。

　　这个方法真长，让我深深的吸了一口气。

    static <K, V> TreeNode<K, V> balanceInsertion(TreeNode<K, V> root,TreeNode<K, V> x) {
        // 红属性
        x.red = true;
        // xp => x的父节点
        // xpp => xp的父节点
        // xppl => xpp.left
        // xppr => xpp.right
        for (TreeNode<K, V> xp, xpp, xppl, xppr;;) {
            // 当x为根节点时
            // 这时xp已经被赋值 xp => root
            if ((xp = x.parent) == null) {
                x.red = false;
                return x;
            }
            // 根节点red为false 所以直接返回root 
            else if (!xp.red || (xpp = xp.parent) == null)
                return root;
                
            // more code...
        }
    }

　　很遗憾，返回的特别快，这里的x为根节点的子节点，而根节点的父节点为null，所以这里直接返回root，返回后break，进入下一个循环。

　　总的来说，这个函数在第一次什么都没有做。

　　下一次循环时，x为链表中第三个元素，这里就存在一种新情况：dir的值。

　　首先当dir的值与上次不同时，我们假设在第二次判断中，x的hash值小于根节点root，于是dir为-1，这样就有：

    xp.left = x;

　　而第三次，x的hash值比根节点大，而root.right此时仍为null，所以有

    xp.right = x;

　　这样，根节点的两个儿子就集齐了。

　　另外一种情况就是dir的值与上次相同，此时p.left即root.left不为null，所以会进入下一轮内循环。此时的p不再是root，而是root.left，即第二个链表元素。

　　同样，第二个链表元素作为父节点与当前节点的hash作比较，然后设置对应的left/right。

　　此时，balanceInsertion函数就会进入下一个判断分支：

    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) {/**/}
            else if (!xp.red || (xpp = xp.parent) == null){/**/ }
            //  此时xpp为root 父元素正好等于root.left
            if (xp == (xppl = xpp.left)) {
                // 此时xpp.right还没有值
                if ((xppr = xpp.right) != null && xppr.red) {
                    // ...
                } else {
                    if (x == xp.right) {
                        // ...
                    }
                    if (xp != null) {
                        // ...
                    }
                }
            } else {
                // ...
            }
        }
    }

　　这里的分支特别多。。。先看看当前的情况，并假设2次都是left，父、父父均无右节点，如图：

　　

　　一个一个情况的讨论，反正基本的塞节点已经明白了。这种情况下，会进入如下分支：

    if (xp == (xppl = xpp.left)) {
        // 此时xpp.right还没有值
        if ((xppr = xpp.right) != null && xppr.red) {
            // ...
        } else {
            if (x == xp.right) {
                // ...
            }
            if (xp != null) {
                // 父节点黑了
                xp.red = false;
                if (xpp != null) {
                    // 父父节点红了
                    xpp.red = true;
                    root = rotateRight(root, xpp);
                }
            }
        }
    } else {
        // ...
    }

　　这种情况下，将父节点置黑，父父节点置红，并调用另外一个方法rotateRight。

　　直接看这个方法，接受两个参数：根节点、父父节点(还是root)：

    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) {
                // p.left = l.right
                if ((lr = p.left = l.right) != null)
                    lr.parent = p;
                // l.parent = p.parent
                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;
    }

　　这个函数应该是叫做向右翻转红黑树，在理解的时候尽量不要把p当做根节点，而是一个普通的节点。

　　另外，这里就直接讲解各种情况下的翻转效果。

　　每一个if语句中的赋值都会改变树的结构，这里不太好讲，用图来一步一步解释，当前例子：

　　

　　可见，翻转后，原来的root被转移到了l的右边，l变成了新的root且red被置false，函数返回新的root。

　　现在讨论更加普遍的情况，首先看在什么情况下会调用右翻转，将上一个函数中的第一个判断分支抽出如下：

    // true
    xp == (xppl = xpp.left)
    // false
    (xppr = xpp.right) != null && xppr.red
    // true
    xp != null
    // true
    xpp != null

　　false代表这是else分支。

1、父元素为父父元素的left

2、父父元素的right为null或者父父元素的red为真

3、父元素及父父元素均不为null

　　很明显，上面的翻转符合这个条件，这里还有另外两种情况，即：

、

　　针对这两种情况的翻转给出对应的结果图：

、

　　可以看出，在p为根节点时，l会被转换为新的根节点，并且有：

    l.right = p;
    p.left = l.right

　　然而，在p不为根节点时，情况稍微会不一样：

　　这种情况下不会根节点替换，仅仅是p与l进行换位。

　　下面来看第二个分支：

    // false
    xp == (xppl = xpp.left)
    // false
    xppl != null && xppl.red
    // true
    x == xp.left

　　即：

1、父元素为父父元素的right

2、父父元素的left为null或者red为真

3、当前元素为父元素的left

　　这里的参数不太一样：

    root = rotateRight(root, x = xp);

　　直接看图吧！

　　我要疯了！！！！

　　

　　技术太渣，暂时不搞这个数据结构。。。