【JAVA】九 TreeMap

最新推荐文章于 2024-10-17 10:01:05 发布

maguochao_Mark

最新推荐文章于 2024-10-17 10:01:05 发布

阅读量408

点赞数

CC 4.0 BY-SA版权

分类专栏： JAVA 文章标签： java treemap

本文链接：https://blog.youkuaiyun.com/maguochao_Mark/article/details/51706309

JAVA 专栏收录该内容

13 篇文章

订阅专栏

本文深入剖析了Java中的TreeMap数据结构，介绍了TreeMap的内部实现原理，包括红黑树的特性与平衡调整机制，并探讨了TreeMap的构造方法、元素添加过程及其在不同场景下的应用。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

【JAVA】九 TreeMap

这里写图片描述

JDK API

java.util

Class TreeMap

TreeMap定义

public class TreeMap<K,V>
    extends AbstractMap<K,V>
    implements NavigableMap<K,V>, Cloneable, java.io.Serializable

TreeMap属性

    //使用comparator 实现排序
    private final Comparator<? super K> comparator;
    //根节点
    private transient Entry<K,V> root = null;
    //当前TreeMap长度
    private transient int size = 0;
    //更改次数
    private transient int modCount = 0;

TreeMap构造

    /**
     * 构造一个新的空树映射,使用的自然排序键。所有 key 插入地图必须实现Comparable interface .
     * 如果用户试图 put key 的类型违反了约束,将会throw a ClassCastException .
     */
    public TreeMap() {
        comparator = null;
    }

    // 根据提供 Comparator 比较方式建立 TreeMap ,其他约束同上
    public TreeMap(Comparator<? super K> comparator) {
        this.comparator = comparator;
    }


    // 接受Map子集, 遵照自然排序 ,其他约束同上
    public TreeMap(Map<? extends K, ? extends V> m) {
        comparator = null;
        putAll(m);
    }

    // 构造一个新的树包含相同TreeMap,使用相同的顺序指定排序,这方法在线性时间内运行.
    public TreeMap(SortedMap<K, ? extends V> m) {
        comparator = m.comparator();
        try {
            buildFromSorted(m.size(), m.entrySet().iterator(), null, null);
        } catch (java.io.IOException cannotHappen) {
        } catch (ClassNotFoundException cannotHappen) {
        }
    }

TreeMap 添加元素

compare

compare(key, key)用于比较两个key,在compare方法中如果comparator为空的话就会调用Comparable接口的比较功能,实际实际上我们常用的Java类型都有实现Comparable接口,我们列举几个java类爱看看

String

public final class String
    implements java.io.Serializable, Comparable<String>, CharSequence {

Integer

public final class Integer extends Number implements Comparable<Integer> {

在这里要注意一点,Comparable的compareTo方法是接收一个参数与自身比较.
而Comparator是接收两个参数,进行比较,那么这里在程序设计上是不同的 .
compare

    final int compare(Object k1, Object k2) {
        return comparator==null ? ((Comparable<? super K>)k1).compareTo((K)k2)
            : comparator.compare((K)k1, (K)k2);
    }

put

put方法接收key,value.
key 为null将会抛出 NullPointerException 异常 .
如果root为空,那么将加入的元素做为根节点.
方法中有两种比较方式,一种是默认比较方式compareTo,而另一种是用户定义的compare方法 .
确定比较方式后,用do while循环比较当前key与treemap中节点key .
cmp是比较结果 , cmp < 0 继续向左寻找 , cmp > 0 继续向右寻找 , 当比较结果相等的时候 , 说明是相同的key , 那么将要替换当前元素的 value , 并把老的value返回 .
经过以上条件的过滤 , 才将值添加到treemap节点的左或右 .
fixAfterInsertion(e) 添加值后修复整个treemap , 也是treemap中含金量比较高的方法 , 下面介绍 .


    public V put(K key, V value) {
        Entry<K,V> t = root;
        if (t == null) {
            compare(key, key); // type (and possibly null) check

            root = new Entry<>(key, value, null);
            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)
                    t = t.left;
                else if (cmp > 0)
                    t = t.right;
                else
                    return t.setValue(value);
            } while (t != null);
        }
        else {
            if (key == null)
                throw new NullPointerException();
            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.left = e;
        else
            parent.right = e;
        fixAfterInsertion(e);
        size++;
        modCount++;
        return null;
    }

fixAfterInsertion

如果没有fixAfterInsertion这个方法 , 那么treemap与hashmap差别并不大 . 下面我们一步一步了解treemap及fixAfterInsertion方法 .
treemap是一个Red Black Tree (红黑树) , 红黑树首先是一个二叉树 , 这一点在上面的put方法中我们已经得到了证实 , 再插入元素时分了左右两个节点这正是二叉树特点 . 红黑树在二叉树基础上加入了颜色的属性 , 这个颜色的属性分为红色与黑色 .
相对与AVL Tree 追求高平衡 ,Red Black Tree 更加注重性能 , Red Black Tree也可以说是相对平衡 .
RBT 的这5个性质中
1. 每个结点的颜色只能是红色或黑色。
2. 根结点是黑色的。
3. 每个叶子结点都带有两个空的黑色结点（被称为黑哨兵），如果一个结点n的只有一个左孩子，那么n的右孩子是一个黑哨兵；如果结点n只有一个右孩子，那么n的左孩子是一个黑哨兵。
4. 如果一个结点是红的，则它的两个儿子都是黑的。也就是说在一条路径上不能出现相邻的两个红色结点。
5. 对于每个结点来说，从该结点到其子孙叶结点的所有路径上包含相同数目的黑结点。
关于Red Black Tree 数据结构详细介绍可以参考我这篇文章 .
我们聊回fixAfterInsertion方法 , 默认添加的元素节点为红色 , 非根节点并当前节点父节点为红色时 , 会一直向上寻找来修复节点与节点之间的平衡性 . 在修改平衡性的过程中 , 会对当前树的节点位置进行旋转更改操作 , 旋转操作分为左左 / 右右 / 左右 / 右左 , 颜色更改红黑 .
正是fixAfterInsertion方法在treemap添加元素后 , 对treemap的修复操作 , 才使得treemap符合了RBT的数据结构条件 .

private void fixAfterInsertion(Entry<K,V> x) {
        x.color = RED;

        while (x != null && x != root && x.parent.color == RED) {
            if (parentOf(x) == leftOf(parentOf(parentOf(x)))) {
                Entry<K,V> y = rightOf(parentOf(parentOf(x)));
                if (colorOf(y) == RED) {
                    setColor(parentOf(x), BLACK);
                    setColor(y, BLACK);
                    setColor(parentOf(parentOf(x)), RED);
                    x = parentOf(parentOf(x));
                } else {
                    if (x == rightOf(parentOf(x))) {
                        x = parentOf(x);
                        rotateLeft(x);
                    }
                    setColor(parentOf(x), BLACK);
                    setColor(parentOf(parentOf(x)), RED);
                    rotateRight(parentOf(parentOf(x)));
                }
            } else {
                Entry<K,V> y = leftOf(parentOf(parentOf(x)));
                if (colorOf(y) == RED) {
                    setColor(parentOf(x), BLACK);
                    setColor(y, BLACK);
                    setColor(parentOf(parentOf(x)), RED);
                    x = parentOf(parentOf(x));
                } else {
                    if (x == leftOf(parentOf(x))) {
                        x = parentOf(x);
                        rotateRight(x);
                    }
                    setColor(parentOf(x), BLACK);
                    setColor(parentOf(parentOf(x)), RED);
                    rotateLeft(parentOf(parentOf(x)));
                }
            }
        }
        root.color = BLACK;
    }