TreeMap源码分析

目录

 

TreeMap底层采用红黑树存储

TreeMap构造函数

TreeMap Put分析

TreeMap Get分析

TreeMap Remove分析

---

TreeMap底层采用红黑树存储

TreeMap构造函数

public TreeMap() {
    comparator = null;//只是把比较器置为null,并未开辟空间
}

TreeMap Put分析

初次put,将新节点赋值给红黑树根节点，之后put,从root节点开始，通过key比较大小
1.比root节点的key小，则与root节点的左子树根节点比较大小
2.比root节点的key大，则与root节点的右子树根节点比较大小
3.和root节点的key相等，则直接覆盖值

循环到每个节点，流程都和走到root节点的操作是一样的，跳出循环的俩个条件：
1.和当前节点的key相等，直接覆盖值并返回
2.左子树或右子树的节点为null(证明整个红黑树中没有找到一个key相等的，此时会根据最后一次比较的结果挂在最后循环的节点的左方或右方)

public V put(K key, V value) {
    Entry<K,V> t = root;//红黑树的根节点
    if (t == null) {//第一次put
        compare(key, key); //如果比较器为null,就用默认的比较器

        root = new Entry<>(key, value, null);//将初次添加的节点设置为root节点
        size = 1;
        modCount++;
        return null;
    }
    int cmp;
    Entry<K,V> parent;
    // split comparator and comparable paths
    Comparator<? super K> cpr = comparator;
    if (cpr != null) {//使用用户指定的比较器
        do {
            parent = t;//红黑树根节点
            cmp = cpr.compare(key, t.key);
            if (cmp < 0)//如果和当前循环出的节点比较得到的结果<0,证明应该挂在左子树上，所以再跟左子树根节点比较
                t = t.left;
            else if (cmp > 0)//如果和当前循环出的节点比较得到的结果>0,证明应该挂在右子树上，所以再跟右子树根节点比较
                t = t.right;
            else//如果和当前循环出的节点比较得到的结果=0，则会用新值覆盖原来的节点里存放的值，然后return
                return t.setValue(value);
        } while (t != null);
    }
    else {//使用默认比较器
        if (key == null)
            throw new NullPointerException();
        @SuppressWarnings("unchecked")
            Comparable<? super K> k = (Comparable<? super K>) key;//使用默认比较器
        do {//和使用用户指定的比较器比叫过程是一样的
            parent = t;
            cmp = k.compareTo(t.key);
            if (cmp < 0)
                t = t.left;
            else if (cmp > 0)
                t = t.right;
            else
                return t.setValue(value);
        } while (t != null);
    }
    Entry<K,V> e = new Entry<>(key, value, parent);
    if (cmp < 0)//代码能执行到这里代表新节点和红黑树中所有节点比较都不相等(如果中间有相等的直接覆盖值返回了)，
               //此时parent已经是目标节点（新节点需要被挂的位置，比较的结果<0,挂在左面
        parent.left = e;
    else //比较的结果>0,挂在右面
        parent.right = e;
    fixAfterInsertion(e);
    size++;
    modCount++;
    return null;
}

TreeMap Get分析

从root节点开始，通过key比较大小
1.比root节点的key小，则与root节点的左子树根节点比较大小
2.比root节点的key大，则与root节点的右子树根节点比较大小
3.和root节点的key相等，则直接返回值
循环到每个节点，流程都和走到root节点的操作是一样的,跳出循环的条件：
是找到一个key相等的即是目标节点，返回该节点的值就可以

final Entry<K,V> getEntry(Object key) {
    // Offload comparator-based version for sake of performance
    if (comparator != null)
        return getEntryUsingComparator(key);
    if (key == null)
        throw new NullPointerException();
    @SuppressWarnings("unchecked")
        Comparable<? super K> k = (Comparable<? super K>) key;
    Entry<K,V> p = root;
    while (p != null) {
        int cmp = k.compareTo(p.key);
        if (cmp < 0)
            p = p.left;
        else if (cmp > 0)
            p = p.right;
        else
            return p;
    }
    return null;
}

TreeMap Remove分析

先获取到目标节点，
1.如果目标节点有右子树或左子树中的一个：就将其子树替换到被删除的位置即可

2.如果同时有右子树和左子树，则取右子树上最小的节点作为替换被删除位置的节点，并将最小节点的右子树替换最小节点的位置链接到最小节点的父节点上
最后将最小节点存储到被删除的位置

public V remove(Object key) {
    Entry<K,V> p = getEntry(key);//先通过TreeMap的get方法获取到目标节点
    if (p == null)
        return null;

    V oldValue = p.value;
    deleteEntry(p);
    return oldValue;
}
private void deleteEntry(Entry<K,V> p) {
    modCount++;
    size--;

    // If strictly internal, copy successor's element to p and then make p
    // point to successor.
    if (p.left != null && p.right != null) {//要删除的节点有左孩子也有右孩子，则将p赋值为p的后面的一个节点（左子树的最左部）
        Entry<K,V> s = successor(p);
        p.key = s.key;
        p.value = s.value;
        p = s;
    } // p has 2 children

    // Start fixup at replacement node, if it exists.
    Entry<K,V> replacement = (p.left != null ? p.left : p.right);//先取左后取右的原因：父节点比它左边的大，比它右边的小

    if (replacement != null) {//要删除的节点有孩子
        // Link replacement to parent
        replacement.parent = p.parent;
        if (p.parent == null)//要删除的节点是root节点
            root = replacement;//就将replacement赋值给root
        else if (p == p.parent.left)//要删除的节点是父节点的左孩子，就将父节点的左孩子设置为要删除节点的后一个节点
            p.parent.left  = replacement;
        else//要删除的节点是父节点的右孩子，就将父节点的右孩子设置为要删除节点的后一个节点
            p.parent.right = replacement;

        // Null out links so they are OK to use by fixAfterDeletion.
        p.left = p.right = p.parent = null;

        // Fix replacement
        if (p.color == BLACK)
            fixAfterDeletion(replacement);
    } else if (p.parent == null) { //要删除的节点是root节点
        root = null;
    } else { //要删除的节点没有孩子，是叶子节点
        if (p.color == BLACK)
            fixAfterDeletion(p);

        if (p.parent != null) {
            if (p == p.parent.left)//如果要删除的节点挂在直接父节点的左边，就将父节点的左边设置为null
                p.parent.left = null;
            else if (p == p.parent.right)//如果要删除的节点挂在直接父节点的右边，就将父节点的右边设置为null,
                p.parent.right = null;
            p.parent = null;
        }
    }
}

static <K,V> TreeMap.Entry<K,V> successor(Entry<K,V> t) {
    if (t == null)
        return null;
    else if (t.right != null) {//右子树肯定不是null,循环找到左节点，一直找到底，即是目标节点（需要被提上去的节点，因为父节点被删除了，如果此时左子树右子树都有的话，父节点的后一个就是目标节点）
        Entry<K,V> p = t.right;
        while (p.left != null)
            p = p.left;
        return p;
    } else {
        Entry<K,V> p = t.parent;
        Entry<K,V> ch = t;
        while (p != null && ch == p.right) {
            ch = p;
            p = p.parent;
        }
        return p;
    }

}