HashMap之TreeNode

HashMap之TreeNode

##简述
在分析HashMap之前先说一下内部类TreeNode。TreeNode类是一颗红黑树的各种操作。当然TreeNode不只是简单的红黑树操作，还有与HashMap业务相关的代码
先看一下类的继承关系

Entry是一个接口，主要有一些让子类去实现的get、set方法
Node是一个单向链表
最后就是TreeNode红黑树了

先看一下简单的Node单向链表，然后再看复杂一点的TreeNode

static class Node<K,V> implements Map.Entry<K,V> {
    final int hash;
    final K key;
    V value;
    Node<K,V> next;

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

    public final K getKey()        { return key; }
    public final V getValue()      { return value; }
    public final String toString() { return key + "=" + value; }

    public final int hashCode() {
        return Objects.hashCode(key) ^ Objects.hashCode(value);
    }

    public final V setValue(V newValue) {
        V oldValue = value;
        value = newValue;
        return oldValue;
    }

    public final boolean equals(Object o) {
        if (o == this)
            return true;
        if (o instanceof Map.Entry) {
            Map.Entry<?,?> e = (Map.Entry<?,?>)o;
            if (Objects.equals(key, e.getKey()) &&
                Objects.equals(value, e.getValue()))
                return true;
        }
        return false;
    }
}

很简单，一个Node相当于链表的一个节点，next属性对应着下一个节点

TreeNode
TreeNode也是，一个TreeNode代表红黑树的一个节点
红黑树是在二叉查找树基础上，对每一个节点添加一个颜色属性形成的，同时整个红黑二叉树需要同时满足一下五条性质

1. 每个节点或是红色，或是黑色的
2. 跟节点是黑色的
3. 每个叶节点（NIL）是黑色的
4. 如果一个节点是红色的，则它的两个子节点都是黑色的
5. 对每个节点，从该节点到其所有后代叶节点的简单路径上，均包含相同数码的黑节点
   如图
   
   叶节点（NIL）不包含任何数据，只是一个标记，没有实际意义

下面通过红黑树的插入、删除、查找、左旋、右旋进一步了解TreeNode

先看一下构造

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

可以看到调用了父类的构造方法，也就是说，TreeNode是红黑树的同时也是一个单项链表

##旋转
先说一下左旋和右旋操作
添加和删除操作肯能会违反红黑树的的性质，而保持红黑树的性质是通过旋转来操作的

如添加了一个红节点N就违反了性质4，在通过2个动图看一下是怎么旋转的

左旋

右旋

以上面的静态图来说明右旋操作，左旋一样，只是操作是相反的
上图添加了节点N违反性质4，右旋G节点：

• 使P成为根节点并变成黑色满足性质2
• G成为P的右节点
• P的右节点成为G的左节点

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

代码虽然不多，但是有点乱，我们一点一点的分析。我们假设传入的参数roo是G节点，p也是G节点
参数root是根节点，p是被旋转的节点
变量l是p的左节点、pp是p的父节点、lr是l右节点

第4行判断p不等于null并把左节点赋值给l，如果l为null的话就不能右旋了
第5行是完成上面性质c，并把值赋值给lr
第7行把p的父节点赋值给l的父节点，并把值赋值给pp，因为我们传入的参数G没有父节点，所以pp为null，为了满足红黑树的性质2，把颜色设置成黑色
第9行和第11行，是判断p是左节点还是右节点，如果是右节点则吧父节点的右节点设置成l，反之亦然
第13行设置l的右节点为p，也就是P的右节点设置成G
第14行设置p的父节点为l，也就是设置G的父节点为P

##查找
从当前节点查找指定节点，根据参数h判断是从左边还是右边查找

   final TreeNode<K, V> find(int h, Object k, Class<?> kc) {
    TreeNode<K, V> p = this;
    do {
        int ph, dir;K pk;
        TreeNode<K, V> pl = p.left, pr = p.right, q;
        if ((ph = p.hash) > h)
            p = pl;
        else if (ph < h)
            p = pr;
        else if ((pk = p.key) == k || (k != null && k.equals(pk)))
            return p;
        else if (pl == null)
            p = pr;
        else if (pr == null)
            p = pl;
        else if ((kc != null ||
                (kc = comparableClassFor(k)) != null) &&
                (dir = compareComparables(kc, k, pk)) != 0)
            p = (dir < 0) ? pl : pr;
        else if ((q = pr.find(h, k, kc)) != null)
            return q;
        else
            p = pl;
    } while (p != null);
    return null;
}

参数h是TreeNode的hash，而hash就是保持平衡二叉树的字段，通过它进行比较，小的放左边，大的放右边
参数k是要查找的节点的key
参数kc是要查找节点实现的key的运行时类型

第2行p赋值当前节点，从当前节点开始查找
变量ph是当前节点的hash
变量dir是Comparable接口的比较结果
变量pl当前节点的左节点
变量pr当前节点的右节点
变量q是右节点查找时候的返回值，如果找到了返回找到的节点

分3点来说find方法

1.find方法根据当前节点的hash与参数的h比较，如果大于pl赋值给p，如果小于pr赋值给p，相等的情况通过当前