集合框架（Java）之TreeMap

TreeMap

TreeMap是Map框架下的最后一个Map。他的数据结构为平衡二叉树（也叫平衡红黑树）。

TreeMap是一个可以保持key高有序性的容器，他存储的也是键值对。底层是平衡二叉树结构。

二叉树，有左右两个子节点，在根节点的左边，都是小于根节点的节点，而根节点的右边都是大于根节点的节点，因此保持了有序性。

而平衡二叉树的意思，就是说，在根节点的左右两边都尽量保持相同数量的节点，这样查找节点的时候，效率也会很高。

正式因为平衡二叉树的数据结构，所以TreeMap实现了有序。而TreeMap的有序实则比LinkedHashMap的有序更为强大，LinkedHashMap的有序只有两种，一种是访问次数次序，一种是存储取出次序。而TreeMap是通过Compartor接口或者子元素实现Comparable，来对key元素的比较和排序的，因此开发者可以自定义比较规则，来进行各种各样的排序。 

---

我们先来看TreeMap的成员变量 

        private final Comparator<? super K> comparator;  //比较器

        private transient Entry<K,V> root = null;    //根节点
 
        private transient int size = 0;              //容器大小

        private transient int modCount = 0;          //修改次数

        private static final boolean RED = false;    //红树

        private static final boolean BLACK = true;   //黑树

---

再来看构造函数

空参构造函数

    public TreeMap() {
        comparator = null;  //如果空参构造，那么比较器为空，但元素必须实现Comparable接口，负责会抛出异常
    }

抛出的是cannot be cast to java.lang.Comparable异常

 

参数为Comparator的构造函数

    public TreeMap(Comparator<? super K> comparator) {
        this.comparator = comparator;  //记录比较器
    }

参数为另一个map的构造函数

    public TreeMap(Map<? extends K, ? extends V> m) {
        comparator = null;
        putAll(m);   //放入所有元素，并且排序平衡二叉树
    }

参数为一个有序map的构造函数

---

我们再来看一下put方法

    public V put(K key, V value) {
        Entry<K,V> t = root;    //t为当前的父节点，初始化为根节点
        if (t == null) {
            //如果为空，先进行一次null比较（不知道意义在哪）
            compare(key, key); // type (and possibly null) check

            root = new Entry<>(key, value, null);   //创建根节点
            size = 1;      //容量设置为1
            modCount++;    //修改次数底层
            return null;   //返回旧节点，没有旧节点就返回null
        }
        int cmp;   //这是comparator的比较结果值（0为相等，正数为大于，负数为小于）
        Entry<K,V> parent;   //parent为父节点变量
        // split comparator and comparable paths
        Comparator<? super K> cpr = comparator;  //cpr为比较器
        if (cpr != null) {   //如果cpr不为空
            do {
                parent = t;  //先把parent初始化为t，t就是root，根节点
                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 {   //else里和if一样的逻辑，只是使用了元素的comparable接口进行比较
            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);
        }
        //在插入操作进行完毕后，需要将现有的二叉树进行平衡，以提高TreeMap的效率
        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;
    }

TreeMap在插入元素的时候，会去循环拿父节点进行比较，如果要插入的元素比父节点小，就抛弃父元素右边所有的节点，如果要插入的元素比父元素大，就抛弃父元素左边所有的元素。最后找到空节点，或者相同的节点，进行插入操作。

---

我们再来看一下delete方法

    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) {
            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 = replacement;
            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) { // return if we are the only node.
            root = null;
        } else { //  No children. Use self as phantom replacement and unlink.
            if (p.color == BLACK)
                fixAfterDeletion(p);

            if (p.parent != null) {
                if (p == p.parent.left)
                    p.parent.left = null;
                else if (p == p.parent.right)
                    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) {
            //如果当前元素的右边有元素，
            Entry<K,V> p = t.right;
            while (p.left != null)
                p = p.left; //将左边元素接过来
            return p;  //等于将t替换成了右边第一个节点
        } 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;   //将t替换成了parent
        }
    }

delete方法不是简单的删除掉当前的元素，而是将当前的元素替换掉。

---

总结：

TreeMap是基于平衡二叉树的一种map容器，他里面的元素必须实现Comparable接口进行比较。