HashMap是如何将链表转换成红黑树的

结论:

  1. HashMap会在put元素的时候判断当前链表长度是否达到了树的阈值且数组长度大于最小转换树的长度,如果满足触发转换树的操作
  2. 通过treeifybin方法将Node节点的链表转换成TreeNode节点的双向链表
  3. 通过treeify方法将TreeNode节点的链表转换成红黑树
  4. 保证数组槽的第一个节点是红黑树的根节点

具体操作:

  • putval方法(删除了无关代码):对链表进行遍历,判断是否达到了树的阈值,如果达到了调用treeifyBin方法

     for (int binCount = 0; ; ++binCount) {
         if ((e = p.next) == null) {
             p.next = newNode(hash, key, value, null);
             if (binCount >= TREEIFY_THRESHOLD - 1) // 如果长度到达树的阈值,触发转红黑树操作
                 treeifyBin(tab, hash);
             break;
         }
         if (e.hash == hash && // 如果发现key和hash都相同的就跳出
             ((k = e.key) == key || (key != null && key.equals(k))))
             break;
         p = e;
     }
    
  • treeifyBin方法:如果数组长度不满足转换成树的最小长度,先进行数组扩容(因为数组扩容也就变向的减小了链表的长度),如果满足条件,会先将单向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);
                 if (tl == null)
                     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方法:通过key和value比较得到节点应该放在树的左面还是右面,插入后调用balanceInsertion方法进行树的平衡操作,代码这里就不展示了,就是红黑树的那几个基本情况

      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;
                      // 通过key和value比较得到节点应该放在树的左面还是右面
                      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); // 将树的根节点指向数组
      }
    
  • 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) {
          int index = (n - 1) & root.hash;
          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)
                  ((TreeNode<K,V>)rn).prev = rp;
              if (rp != null)
                  rp.next = rn;
              if (first != null)
                  first.prev = root;
              root.next = first;
              root.prev = null;
          }
          assert checkInvariants(root); // 验证红黑树的准确性
      }
    }
    
  • 0
    点赞
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值