目录
moveRootToFront（树的根节点移至数组的首个元素）
前言
在介绍红黑树前，需要对HashMap的数据结构和相应的主流程需要有一定了解
treeifyBin（树化）
java.util.HashMap#treeifyBin
final void treeifyBin(Node<K,V>[] tab, int hash) {
int n, index; Node<K,V> e;
// 判断table数组为null或者table数组的长度小于64，则不会树化，只是调用resize进行扩容
if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
resize();
// 通过寻址找到数组的索引位里的元素是否为null（这里会找到链表的头节点）
else if ((e = tab[index = (n - 1) & hash]) != null) {
// hd是树首节点
// tl是树尾节点
TreeNode<K,V> hd = null, tl = null;
do { // 遍历链表，将单向链表改造成双向链表，并且将每个节点替换成TreeNode
// 创建TreeNode，将Node节点替换成TreeNode
TreeNode<K,V> p = replacementTreeNode(e, null);
if (tl == null)
// 链表头节点赋值给hd（第一次循环）
hd = p;
else {
// 设置当前节点和前驱和后驱节点（第二次循环开始）
p.prev = tl;
tl.next = p;
}
tl = p;
} while ((e = e.next) != null);
if ((tab[index] = hd) != null)
// 改造为红黑树
hd.treeify(tab);
}
}treeify
java.util.HashMap.TreeNode#treeify
final void treeify(Node<K,V>[] tab) {
// 定义根节点
TreeNode<K,V> root = null;
// 循环遍历链表(x为当前节点)，每遍历一次会将next赋值给x
for (TreeNode<K,V> x = this, next; x != null; x = next) {
// 将当前节点x的下一个节点赋值给next
next = (TreeNode<K,V>)x.next;
x.left = x.right = null;
if (root == null) {
// 第一次循环会执行，定义根节点（将x赋值给root），节点设置为黑色（红黑树的根节点 一定是黑色）
x.parent = null;
x.red = false;
root = x;
}
else {
// 当前链表节点的key
K k = x.key;
// 当前链表节点的hash
int h = x.hash;
Class<?> kc = null;
// 从根节点开始遍历
for (TreeNode<K,V> p = root;;) {
// dir 标识方向（左右）
// ph标识当前树节点的hash值
int dir, ph;
K pk = p.key;
// 如果当前树节点hash值大于当前链表节点的hash值，标识当前链表节点会放到当前树节点的左侧
if ((ph = p.hash) > h)
dir = -1;
else if (ph < h) // 如果当前树节点hash值小于当前链表节点的hash值，标识当前链表节点会放到当前树节点的左侧
dir = 1;
// 走到这说明当前树节点的hash值和当前链表节点的hash值相等
// 下面判断如果条件满足其中一种，都会通过tieBreakOrder获取dir值（通过identityHashCode）
// 1.当前链表节点的key没有实现comparable接口，
// 2.当前链表节点实现comparable接口，当前树节点和链表节点通过comparable的方式比较后是相同Class的实例
else if ((kc == null &&
(kc = comparableClassFor(k)) == null) ||
(dir = compareComparables(kc, k, pk)) == 0)
dir = tieBreakOrder(k, pk);
TreeNode<K,V> xp = p;
// 根据dir值判断是在当前链表节点是在当前树节点的左侧/右侧，并且为null（为null说明当前树节点为叶子节点）
// 如果当前树节点就是叶子节点，那么根据dir的值，就可以把当前链表节点挂载到当前树节点的左或者右侧了
// 如果当前树节点不是叶子节点，那么最终会以当前树节点的左孩子或者右孩子为起始节点，再重新进行遍历寻找当前链表节点的位置
// 挂载之后，还需要重新把树进行平衡。平衡之后，就可以针对下一个链表节点进行处理了
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;
}
}
}
}
// 把所有的链表节点都遍历完之后，最终构造出来的树可能经历多个平衡操作，根节点目前到底是链表的哪一个节点是不确定的
// 因为我们要基于树来做查找，所以就应该把tab[N]得到的元素一定是根节点，而目前只是链表的第一个节点对象，所以要做相应的处理
//把红黑树的根节点设为其所在的数组的第一个元素（这个方法里做的事情，就是保证树的根节点一定也要成为链表的首节点）
moveRootToFront(tab, root);
}putTreeVal（树的pulVal）
java.util.HashMap.TreeNode#putTreeVal
final TreeNode<K,V> putTreeVal(HashMap<K,V> map, Node<K,V>[] tab,
int h, K k, V v) {
Class<?> kc = null;
boolean searched = false;
// 获取根节点
TreeNode<K,V> root = (parent != null) ? root() : this;
// 从根节点开始遍历
for (TreeNode<K,V> p = root;;) {
int dir, ph; K pk;
// 如果当前树节点hash值大于当前插入节点的hash值，标识当前插入节点会放到当前树节点的左侧
if ((ph = p.hash) > h)
dir = -1;
// 如果当前树节点hash值小于当前插入节点的hash值，标识当前插入节点会放到当前树节点的右侧
else if (ph < h)
dir = 1;
// 如果当前树节点的key和当前插入节点的key一致，直接返回当前树节点
else if ((pk = p.key) == k || (k != null && k.equals(pk)))
return p;
// 走到这说明hash相等key不相等的情况
// 下面判断如果条件满足其中一种，就会进入if进行逻辑执行
// 1.当前插入节点的key没有实现comparable接口，
// 2.当前插入节点实现comparable接口，当前树节点和当前插入节点通过comparable的方式比较后是相同Class的实例
else if ((kc == null &&
(kc = comparableClassFor(k)) == null) ||
(dir = compareComparables(kc, k, pk)) == 0) {
// 未遍历过树
if (!searched) {
TreeNode<K,V> q, ch;
searched = true;
// 以下条件满足其中一个，就会返回当前树节点
// 1.当前节点的左孩子不为null并且通过从当前节点的左孩子开始查找，通过find方法进行递归查找后能找到和插入节点一致的节点
// 2.当前节点的右孩子不为null并且通过从当前节点的右孩子开始查找，通过find方法进行递归查找后能找到和插入节点一致的节点
if (((ch = p.left) != null &&
(q = ch.find(h, k, kc)) != null) ||
((ch = p.right) != null &&
(q = ch.find(h, k, kc)) != null))
return q;
}
// 树已遍历过或者通过上面的if找不到合适的节点，那么通过identityHashCode比较获取dir值
dir = tieBreakOrder(k, pk);
}
TreeNode<K,V> xp = p;
// 根据dir值判断是在当前插入节点是在当前树节点的左侧/右侧，并且为null（为null说明当前树节点为叶子节点）
// 如果当前树节点就是叶子节点，那么根据dir的值，就可以把当前链表节点挂载到当前树节点的左或者右侧了
// 如果当前树节点不是叶子节点，那么最终会以当前树节点的左孩子或者右孩子为起始节点，再重新进行遍历寻找当前链表节点的位置
if ((p = (dir <= 0) ? p.left : p.right) == null) {
// 当前树节点的next节点
Node<K,V> xpn = xp.next;
// 创建新的TreeNode节点
TreeNode<K,V> x = map.newTreeNode(h, k, v, xpn);
if (dir <= 0)
// 将创建的树节点放在当前树节点的左侧
xp.left = x;
else
// 将创建的树节点放在当前树节点的右侧
xp.right = x;
// 当前树节点的next为创建的树节点
xp.next = x;
// 创建的树节点的父节点和前驱节点为当前树节点（TreeNode既是一个红黑树结构，也是一个双链表结构，因此这里需要维护）
x.parent = x.prev = xp;
if (xpn != null)
((TreeNode<K,V>)xpn).prev = x;
// 重新平衡并且将根节点置顶
moveRootToFront(tab, balanceInsertion(root, x));
return null;
}
}
}removeTreeNode（树的remove）
java.util.HashMap.TreeNode#removeTreeNode
final void removeTreeNode(HashMap<K,V> map, Node<K,V>[] tab,
boolean movable) {
// --- 链表的处理start ---
int n;
// 数组为空直接返回
if (tab == null || (n = tab.length) == 0)
return;
// 通过位运算获取索引位
int index = (n - 1) & hash;
// fisrt为数组的头节点，root=first
TreeNode<K,V> first = (TreeNode<K,V>)tab[index], root = first, rl;
// succ为删除节点node的下一个节点，pred为删除节点node的前一个节点
TreeNode<K,V> succ = (TreeNode<K,V>)next, pred = prev;
// pred节点为null，则代表删除节点node为头节点，
if (pred == null)
tab[index] = first = succ;
else // pred非null，说明删除节点node非头节点
// 这里解释一下
// node.prev.next = node.next;
// 正常是 pred.next = node -> node.next = succ
// 现在是 pred.next = node.next = succ，跳过了node，也就相当于把node删除了（前驱节点与后继节点相连，跳过node节点）
pred.next = succ;
// succ节点(node.next节点)不为空
if (succ != null)
// succ.prev(node.next.prev)节点设置为pred(node.prev), 与前面对应（后继节点与前驱节点相连，跳过node节点）
// 等同于 node.next.prev = node.prev
succ.prev = pred;
// 在数组中找不到对应索引位的节点，直接return
if (first == null)
return;
// 获取根节点（这里不知道啥情况会发生，正常红黑树平衡后数组头节点就是根几点）
if (root.parent != null)
root = root.root();
/**
* 当以下三个条件任一满足时，当满足红黑树条件时，说明该位置元素的长度少于6，需要对该位置元素链表化
* 1、root == null：根节点为空，树节点数量为0
* 2、root.right == null：右孩子为空，树节点数量最多为2
* 3、(rl = root.left) == null || rl.left == null)：
* (rl = root.left) == null：左孩子为空，树节点数最多为2
* rl.left == null：左孩子的左孩子为NULL，树节点数最多为6
*/
if (root == null
|| (movable
&& (root.right == null
|| (rl = root.left) == null
|| rl.left == null))) {
// 去树化
tab[index] = first.untreeify(map); // too small
return;
}
// --- 链表的处理end ---
// --- 红黑树的处理start ---
// p-待删除节点，pl-待删除节点的左子节点，pr-待删除节点的右子节点，replacement-替换节点
TreeNode<K,V> p = this, pl = left, pr = right, replacement;
// 第一种情况，待删除节点p有左右子节点
if (pl != null && pr != null) {
TreeNode<K,V> s = pr, sl;
// 第一步：找到当前节点的后继节点（值大于当前删除节点值的最小节点，以右子树为根节点，查找它对应的最左节点）
// 这里有两种情况：
// 1.以删除节点p的右孩子pr为查找起始节点一直往左孩子找能找到最匹配的节点
// 2.以删除节点p的右孩子pr为查找起始节点找不到，也就是s=pr
while ((sl = s.left) != null) // find successor
s = sl;
// 第二步：交换后继节点和删除节点的颜色
// c-找到的最匹配的后继节点颜色是否为红色，待删除节点P和找到最匹配的后继节点s颜色互换
boolean c = s.red; s.red = p.red; p.red = c; // swap colors
// sr-后继节点的右孩子（后继节点是肯定不存在左孩子的，如果存在的话，那么它肯定不是后继节点）
TreeNode<K,V> sr = s.right;
// pp-待删除节点p的父节点
TreeNode<K,V> pp = p.parent;
// 第三步：交换当前节点和后继节点
// 如果后继节点s与当前删除节点的右孩子相等（当前节点只有一个右孩子) --s=pr
if (s == pr) { // p was s's direct parent
// 两者交换
p.parent = s;
s.right = p;
}
else { // 后继节点 != 当前节点的右孩子 -- s != pr
// 匹配到的后继节点s的父节点
TreeNode<K,V> sp = s.parent;
// 后继节点s的父节点存在，交换p和s，将p的父节点指向sp
if ((p.parent = sp) != null) {
// 后继节点是sp的左节点，sp的左节点指向p
if (s == sp.left)
sp.left = p;
else // 后继节点是sp的右节点，sp的右节点指向p
sp.right = p;
}
// 完成s和p的交换后，将s的右孩子指向pr，pr的父节点指向s
if ((s.right = pr) != null)
pr.parent = s;
}
// 第四步：修改当前节点p（左孩子）和后继节点s（右孩子）的孩子节点，当前节点现在变成后继节点了，故其左孩子为null
p.left = null;
// 原先后继节点s的存在右孩子sr，因s和p交换了，所以将sr设置为p的右孩子，sr的父节点指向p
if ((p.right = sr) != null)
sr.parent = p;
// 原先待删除节点p存在左孩子pl，因s和p交换了，所以将pl设置为s的左孩子，pl的父亲节点指向s
if ((s.left = pl) != null)
pl.parent = s;
// 原先待删除节点p的父节点为Null，说明原先p为根节点，因s和p交换了，所以s是根节点
if ((s.parent = pp) == null)
root = s;
// 原先待删除节点p的父节点pp != Null 并且为左孩子，pp左节点此时为s
else if (p == pp.left)
pp.left = s;
else // 原先待删除节点p的父节点pp != Null 并且为右孩子，pp右节点此时为s
pp.right = s;
// 原先后继节点s有右节点（也就是s只有一个右孩子），替代节点就是s的右节点sr
if (sr != null)
replacement = sr;
else // 原先后继节点s没有右节点（s没有任何子节点），替代节点就是p本身
replacement = p;
}
// 第二种情况，待删除节点p只有左子节点pl，替换节点就是pl
else if (pl != null)
replacement = pl;
else if (pr != null) // 第三种情况，待删除节点p只有右子节点pr，替换节点就是pr
replacement = pr;
else // 第四种情况，待删除节点p没有左右子节点，替换节点就是本身p
replacement = p;
if (replacement != p) { // 走到这说明是替换节点不是本身的情况
// 移除p，将替换节点的父亲节点指向p的父亲节点
TreeNode<K,V> pp = replacement.parent = p.parent;
if (pp == null) // 没有父亲节点，说明替换节点为根节点
root = replacement;
else if (p == pp.left) // p是pp的左孩子，pp的左孩子设置为替换节点
pp.left = replacement;
else
pp.right = replacement; // p是pp的右孩子，pp的右孩子设置为替换节点
// 删除p节点，p的左右指针置为null，让gc回收
p.left = p.right = p.parent = null;
}
// p节点是否为红色？ 红色就不用管了，黑色就需要平衡
TreeNode<K,V> r = p.red ? root : balanceDeletion(root, replacement);
// 替换节点是p本身
if (replacement == p) { // detach
TreeNode<K,V> pp = p.parent;
p.parent = null;
if (pp != null) { // 交换完后的p有父节点
if (p == pp.left) // 如果p是父节点的左孩子，删除完p后将pp的左孩子指向null
pp.left = null;
else if (p == pp.right) // 如果p是父节点的右孩子，删除完p后将pp的右孩子指向null
pp.right = null;
}
}
// movable为true，这里默认为true，可能发生删除平衡（根节点可能发生改变），需要将根节点root移到链表的头部
if (movable)
moveRootToFront(tab, r);
}图例
情况1（删除节点存在左右节点）
情况2（删除节点只存在左节点）
情况3（删除节点只存在右节点）
情况4（删除节点左右节点都不存在）
split（树的resize）
java.util.HashMap.TreeNode#split
final void split(HashMap<K,V> map, Node<K,V>[] tab, int index, int bit) {
// 这个this就是在resize方法中遍历原数组取到的节点（oldTab[j]）
TreeNode<K,V> b = this;
// Relink into lo and hi lists, preserving order
// 这边和链表一样也做了高低位链表
TreeNode<K,V> loHead = null, loTail = null;
TreeNode<K,V> hiHead = null, hiTail = null;
int lc = 0, hc = 0;
// 遍历红黑树（TreeNode既是红黑树又是双向链表），内部的逻辑和单向链表的差不多，只是变成了双向链表
for (TreeNode<K,V> e = b, next; e != null; e = next) {
next = (TreeNode<K,V>)e.next;
e.next = null;
if ((e.hash & bit) == 0) {
if ((e.prev = loTail) == null)
loHead = e;
else
loTail.next = e;
loTail = e;
// 统计低位链表的个数
++lc;
}
else {
if ((e.prev = hiTail) == null)
hiHead = e;
else
hiTail.next = e;
hiTail = e;
// 统计高位链表的个数
++hc;
}
}
// 低位链表有数据，判断个数是否<=6,是的话进行去树化（内部就是遍历双向链表，将TreeNode替换成Node）
if (loHead != null) {
if (lc <= UNTREEIFY_THRESHOLD)
tab[index] = loHead.untreeify(map);
else {
// >6,低位链表在新数组树化
tab[index] = loHead;
if (hiHead != null) // (else is already treeified)
loHead.treeify(tab);
}
}
// 高位链表有数据，判断个数是否<=6,是的话进行去树化（内部就是遍历双向链表，将TreeNode替换成Node）
if (hiHead != null) {
if (hc <= UNTREEIFY_THRESHOLD)
tab[index + bit] = hiHead.untreeify(map);
else {
// >6,高位链表在新数组树化
tab[index + bit] = hiHead;
if (loHead != null)
hiHead.treeify(tab);
}
}
}balanceInsertion（树的节点插入平衡）
java.util.HashMap.TreeNode#balanceInsertion
static <K,V> TreeNode<K,V> balanceInsertion(TreeNode<K,V> root,
TreeNode<K,V> x) {
// 默认插入节点的颜色为红色
x.red = true;
// xp为x的父亲，xpp为x的爷爷,xppl为x的爷爷的左孩子，xppr为x的爷爷的右孩子
// 开始无限循环
for (TreeNode<K,V> xp, xpp, xppl, xppr;;) {
// 如果当前插入的节点x的父节点为Null，代表当前节点x为root根节点，将x标记为黑色，直接返回当前插入的节点x作为根节点
if ((xp = x.parent) == null) {
x.red = false;
return x;
}
// 1.父节点为黑色
// 2.父节点为红色但是爷爷节点为null（不可能存在这种场景，根节点不可能为红色，这里只是为了赋值）
// 以上两种情况满足其中一种直接返回root节点,不需要调整
else if (!xp.red || (xpp = xp.parent) == null)
return root;
// 能执行到这，说明父节点xp为红色
// 父节点 = 爷爷左孩子
// L1
if (xp == (xppl = xpp.left)) {
// 爷爷右孩子不为null && 爷爷右孩子为红色节点（此时这里代表爷爷的左孩子和右孩子都为红色节点）
// x的插入会破坏红黑树的结构父子节点不可能双红
// L1-1
if ((xppr = xpp.right) != null && xppr.red) {
// 将父节点和爷爷右孩子调整为黑色，爷爷节点调整成红色，将爷爷节点当做当前插入的节点重新循环判断调整
xppr.red = false;
xp.red = false;
xpp.red = true;
x = xpp;
}
else { // 走到这说明爷爷右孩子为Null 或者 爷爷右孩子为黑色节点
// 当前插入节点x为父节点xp的右孩子
// L1-2
if (x == xp.right) {
// LR双红，需要左旋
// xp节点进行左旋，刷新当前对应变量
root = rotateLeft(root, x = xp);
xpp = (xp = x.parent) == null ? null : xp.parent;
}
// 走到这说明此时已经是LL双红
// 将父亲xp节点调整为黑色
// 将爷爷节点xpp调整为为红色，爷爷节点xpp进行右旋
// L1-3
if (xp != null) {
xp.red = false;
if (xpp != null) {
xpp.red = true;
root = rotateRight(root, xpp);
}
}
}
}
else { // 父亲节点xp是爷爷节点xpp的右孩子 // L2
// 爷爷节点有左孩子并且为红色节点
// L2-1
if (xppl != null && xppl.red) {
// 将父节点和爷爷左孩子调整为黑色，爷爷节点调整成红色，将爷爷节点当做当前插入的节点重新循环判断调整
xppl.red = false;
xp.red = false;
xpp.red = true;
x = xpp;
}
else { // 走到这说明爷爷左孩子为Null 或者 爷爷左孩子为黑色节点
// 当前插入节点x为父节点xp的左孩子
// L2-2
if (x == xp.left) {
// RL双红，需要右旋
// xp节点进行右旋，刷新当前对应变量
root = rotateRight(root, x = xp);
xpp = (xp = x.parent) == null ? null : xp.parent;
}
// 走到这说明此时已经是RR双红
// 将父亲xp节点调整为黑色
// 将爷爷节点xpp调整为为红色，爷爷节点xpp进行左旋
// L2-3
if (xp != null) {
xp.red = false;
if (xpp != null) {
xpp.red = true;
root = rotateLeft(root, xpp);
}
}
}
}
}
}rotateLeft（左旋）
java.util.HashMap.TreeNode#rotateLeft
static <K,V> TreeNode<K,V> rotateLeft(TreeNode<K,V> root,
TreeNode<K,V> p) {
// r为支点的右孩子节点，pp为支点的父节点，rl为支点右孩子的左节点
TreeNode<K,V> r, pp, rl;
// 支点p和支点右孩子r不能为null
if (p != null && (r = p.right) != null) {
// 支点右孩子r存在左孩子，将支点右孩子r的左孩子rl赋值给支点右孩子（也就是p的右节点此时为rl）
// 将rl的父节点指向支点p（r的父节点还是p还未变）
if ((rl = p.right = r.left) != null)
rl.parent = p;
// 支点p的父节点为null，将r的父节点指向p的父节点null
// 说明r为根节点，颜色设置为黑色
if ((pp = r.parent = p.parent) == null)
(root = r).red = false;
else if (pp.left == p) // 支点p有父节点pp，p为父节点pp的左节点，左旋将p节点替换成r节点
pp.left = r;
else // 支点p有父节点pp，p为父节点pp的右节点，左旋将p节点替换成r节点
pp.right = r;
// 将r的左节点设置为p，p的父节点设置为r
r.left = p;
p.parent = r;
}
return root;
}rotateRight（右旋）
java.util.HashMap.TreeNode#rotateRight
static <K,V> TreeNode<K,V> rotateRight(TreeNode<K,V> root,
TreeNode<K,V> p) {
// l为支点的左孩子节点，pp为支点的父节点，lr为支点左孩子的右节点
TreeNode<K,V> l, pp, lr;
// 支点p和支点左孩子l不能为null
if (p != null && (l = p.left) != null) {
// 支点左孩子l存在右孩子，将支点左孩子l的右孩子lr赋值给支点左孩子（也就是p的左节点此时为lr）
// 将lr的父节点指向支点p（l的父节点还是p还未变）
if ((lr = p.left = l.right) != null)
lr.parent = p;
// 支点p的父节点为null，将l的父节点指向p的父节点null
// 说明l为根节点，颜色设置为黑色
if ((pp = l.parent = p.parent) == null)
(root = l).red = false;
else if (pp.right == p) // 支点p有父节点pp，p为父节点pp的右节点，右旋将p节点替换成l节点
pp.right = l;
else // 支点p有父节点pp，p为父节点pp的左节点，右旋将p节点替换成r节点
pp.left = l;
// 将l的右节点设置为p，p的父节点设置为r
l.right = p;
p.parent = l;
}
return root;
}图例
父节点xp = 爷爷xpp左孩子xppl（L1）
父节点xp = 爷爷xpp右孩子xppr（L2）
balanceDeletion（树的节点删除平衡）
java.util.HashMap.TreeNode#balanceDeletion
进入这个方法的前提是删除节点黑色的，有两种情况：
-
替换节点与删除节点相等：x == replacement == p
-
替代节点与删除节点不相等：x == replacement != p
static <K,V> TreeNode<K,V> balanceDeletion(TreeNode<K,V> root,
TreeNode<K,V> x) {
// x-替换节点，xp-父节点,xpl-父节点的左孩子,xpr-父节点的右孩子节点
for (TreeNode<K,V> xp, xpl, xpr;;) {
// 情况1：替换节点为Null或者替换节点是根节点，直接返回
if (x == null || x == root)
return root;
// 情况2：替换节点没有父节点，说明替换节点为根节点，设置为黑色直接返回
else if ((xp = x.parent) == null) {
x.red = false;
return x;
}
// 情况3：删除节点的颜色是黑色的，删除之后黑色高度减1，如果替换节点是红色，将其设置为黑色，可以保证 1、与替换之前的黑色高度相等 2、满足红黑树的所有特性
else if (x.red) {
x.red = false;
return root;
}
// 走到这说明删除节点为黑色，替换节点x为黑色
// 情况4：替换节点是父节点的左孩子
else if ((xpl = xp.left) == x) {
// 父节点xp的右孩子xpr存在且为红色
// xpr变黑，父节点xp变红，以父节点为支点进行左旋，刷新当前xpr的节点变量值
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;
}
// xpr为Null,将x设置为父亲节点xp
if (xpr == null)
x = xp;
else { // xpr != null 并且xpr为黑色
// sl-兄弟节点xpr的左孩子，sr-兄弟节点xpr的右孩子
TreeNode<K,V> sl = xpr.left, sr = xpr.right;
// sl和sr没有一个为红色节点
if ((sr == null || !sr.red) &&
(sl == null || !sl.red)) {
// 兄弟节点xpr为红色，替换节点x指向父节点xp，继续遍历
xpr.red = true;
x = xp;
}
else { // sr和sl中存在一个红节点
// sl是红节点
// sl设为黑色，xpr设为红色，以xpr为支点进行右旋，重新设置xpr的节点变量值
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;
}
// 如果xpr存在，也就是替换节点x存在兄弟节点xpr
if (xpr != null) {
// xpr节点与xp节点同色
xpr.red = (xp == null) ? false : xp.red;
// sr节点不为空，将其变成黑色
if ((sr = xpr.right) != null)
sr.red = false;
}
// xp节点不为Null,将xp节点设置为黑色进行左旋
if (xp != null) {
xp.red = false;
root = rotateLeft(root, xp);
}
x = root;
}
}
}
else { // symmetric // 情况5：替换节点是父节点的右孩子
// 父节点xp的左孩子xpl存在且为红色
// xpl变黑，父节点xp变红，以父节点为支点进行右旋，刷新当前xpl的节点变量值
if (xpl != null && xpl.red) {
xpl.red = false;
xp.red = true;
root = rotateRight(root, xp);
xpl = (xp = x.parent) == null ? null : xp.left;
}
// xpl为Null,将x设置为父亲节点xp
if (xpl == null)
x = xp;
else { // xpl != null 并且xpl为黑色
// sl-兄弟节点xpl的左孩子，sr-兄弟节点xpl的右孩子
TreeNode<K,V> sl = xpl.left, sr = xpl.right;
// sl和sr没有一个为红色节点
if ((sl == null || !sl.red) &&
(sr == null || !sr.red)) {
// 兄弟节点xpl设为红色，替换节点x指向父节点xp，继续遍历
xpl.red = true;
x = xp;
}
else {
// sr和sl中存在一个红节点
// sr是红节点
// sr设为黑色，xpl设为红色，以xpl为支点进行左旋，重新设置xpl的节点变量值
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;
}
// 如果xpl存在，也就是替换节点x存在兄弟节点xpl
if (xpl != null) {
// xpl节点与xp节点同色
xpl.red = (xp == null) ? false : xp.red;
// sl节点不为空，将其变成黑色
if ((sl = xpl.left) != null)
sl.red = false;
}
// xp节点不为Null,将xp节点设置为黑色进行右旋
if (xp != null) {
xp.red = false;
root = rotateRight(root, xp);
}
x = root;
}
}
}
}
}moveRootToFront（树的根节点移至数组的首个元素）
java.util.HashMap.TreeNode#moveRootToFront
static <K,V> void moveRootToFront(Node<K,V>[] tab, TreeNode<K,V> root) {
int n;
if (root != null && tab != null && (n = tab.length) > 0) {
// 位运算，获取root根节点在数组中的索引位
int index = (n - 1) & root.hash;
// 获取table相应索引位的首个元素
TreeNode<K,V> first = (TreeNode<K,V>)tab[index];
// 判断数组的首个元素是否为根节点，这里不相等才会走逻辑
if (root != first) {
Node<K,V> rn;
// 直接将根节点赋值给数组对应索引位的首个元素
tab[index] = root;
// 用一个临时变量存储根节点的前驱节点
TreeNode<K,V> rp = root.prev;
if ((rn = root.next) != null)
// 如果根节点的后驱节点不为null，将根节点的后驱节点的前驱节点指向根节点的前驱节点（相当于把根节点给移除了）
((TreeNode<K,V>)rn).prev = rp;
if (rp != null)
// 根节点的前驱节点不为null，将根节点的前驱节点的后驱节点指向根节点的后驱节点（和上一步相同，只是要维护前驱和后驱节点）
rp.next = rn;
if (first != null)
// 将根节点设置为数组的首个元素
first.prev = root;
// 将根节点的后驱节点指向first
root.next = first;
// 根节点的前驱节点设置为null
root.prev = null;
}
assert checkInvariants(root);
}
}
扫一扫
6929
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
