【java集合】Map--TreeMap

最新推荐文章于 2020-09-29 17:29:24 发布
最新推荐文章于 2020-09-29 17:29:24 发布
阅读量344 收藏
点赞数
分类专栏： java-集合 文章标签： java TreeMap collection map

一、关于红黑二叉树简介
TreeMap 是红黑二叉树算法实现。
- 红黑树简介
红黑树又称红-黑二叉树，它首先是一颗二叉树，它具有二叉树所有的特性。同时红黑树更是一颗自平衡的排序二叉树。
基本的二叉树需要满足一个基本性质–即树中的任何节点的值大于它的左子节点，且小于它的右子节点。按照这个基本性质使得树的检索效率大大提高。
我们知道在生成二叉树的过程是非常容易失衡的，最坏的情况就是一边倒（只有右/左子树），这样势必会导致二叉树的检索效率大大降低（O(n)），所以为了维持二叉树的平衡，大牛们提出了各种实现的算法，如：AVL，SBT，伸展树，TREAP ，红黑树等等。
平衡二叉树必须具备如下特性：它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。也就是说该二叉树的任何一个等等子节点，其左右子树的高度都相近。
这里写图片描述
红黑树顾名思义就是红色或者黑色平衡二叉树，通过颜色约束二叉树的平衡。
对于一颗有效且平衡的二叉树需要遵守如下规则：

  • 每个节点只能是红色或者黑色
  • 根节点是黑色
  • 每个叶节点（NIL 节点，空节点）是黑色
  • 一个节点是红色，则它的两个节点都是黑色，不能包含两个相邻的红色节点
  • 从任何一个节点到叶子节点，黑色节点的个数是相同的

详细了解红黑树结构，请参考：

1、红黑树数据结构剖析：http://www.cnblogs.com/fanzhidongyzby/p/3187912.html
2、红黑二叉树详解及理论分析 ：http://blog.csdn.NET/kartorz/article/details/8865997
3、教你透彻了解红黑树 ：blog.csdn.Net/v_july_v/article/details/6105630
4、经典算法研究系列：五、红黑树算法的实现与剖析 ：http://blog.csdn.net/v_JULY_v/article/details/6109153
5、示例，红黑树插入和删除过程：http://saturnman.blog.163.com/blog/static/557611201097221570/
6、红黑二叉树详解及理论分析 ：http://blog.csdn.net/kartorz/article/details/8865997

二、TreeMap重要方法源码解析

put 方法：

    public V put(K key, V value) {
        Entry<K,V> t = root;
        //<1>获取根节点，如果根节点为null,作为根节点插入
        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
        //<2>获取排序仪
        Comparator<? super K> cpr = comparator;
        if (cpr != null) {
        //<2.1> 排序仪器不为空，do-while循环遍历寻找节点最底层叶子节点
            do {
                parent = t;
                cmp = cpr.compare(key, t.key);
                //根据“即树中的任何节点的值大于它的左子节点，且小于它的右子节点”特性，生成如下逻辑，
                //如果 源节点key小于目标节点key，从"左"节点遍历，否则从"右"节点遍历。
                if (cmp < 0)
                    t = t.left;
                else if (cmp > 0)
                    t = t.right;
                else
                    return t.setValue(value);
            } while (t != null);
        }
        else {
        //<2.2> 排序仪器为空，按自然排序
            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);
        }
        //<3>遍历到最底层节点位置，作为新节点的父节点
        Entry<K,V> e = new Entry<>(key, value, parent);
        //<3.1>还是遵守“即树中的任何节点的值大于它的左子节点，且小于它的右子节点”特性
        //新key小于父节点key，作为左节点插入；大于，则作为右节点插入
        if (cmp < 0)
            parent.left = e;
        else
            parent.right = e;
        fixAfterInsertion(e);
        size++;
        modCount++;
        return null;
    }

删除节点

  /**
     * Delete node p, and then rebalance the tree.
     */
    private void deleteEntry(Entry<K,V> p) {
        modCount++;
        size--;

        //<1>当前节点有左节点和右节点
        if (p.left != null && p.right != null) {
        //<1.1>寻找替换节点，注：删除不是直接删除节点，而是找替换节点替换当前节点
            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.
        //<2> 如果<1>找到的替换节点包含左节点，则用左节点替换，否则用右节点替换
        Entry<K,V> replacement = (p.left != null ? p.left : p.right);
        //<2.1> 替换节点不为空
        if (replacement != null) {
            // Link replacement to parent
            replacement.parent = p.parent;
            //<2.1.1>当前要删除节点为根节点，直接将替换节点设置为根节点
            if (p.parent == null)
                root = replacement;
            //<2.1.2>当前要删除节点为左节点，替换节点替换左节点
            else if (p == p.parent.left)
                p.parent.left  = replacement;
            //<2.1.3>当前要删除节点为右节点，替换节点替换右节点
            else
                p.parent.right = replacement;

            //<2.2> 删除P节点
            p.left = p.right = p.parent = null;

            //<2.3> 如果当前节点颜色为黑色，调整红黑树使其保持平衡
            //注：遵守红黑树特性：任意节点下的子节点的黑色节点树相同
            if (p.color == BLACK)
                fixAfterDeletion(replacement);
        } else if (p.parent == null) { // <2.2>当前要删除节点为父节点.
            root = null;
        } else { //<2.3>当前要删除节点没有子节点，直接删除该节点
            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;  
        }   
        /* 
         * 选择左子树的最右子树 
         */  
        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;  
        }  
    }  

/**
* 替换节点后，调整红黑二叉树，使其保持平衡
*/
private void fixAfterDeletion(Entry<K,V> x) {  
        // 删除节点需要一直迭代，知道 直到 x 不是根节点，且 x 的颜色是黑色  
        while (x != root && colorOf(x) == BLACK) {  
            if (x == leftOf(parentOf(x))) {      //若X节点为左节点  
                //获取其兄弟节点  
                Entry<K,V> sib = rightOf(parentOf(x));  

                /* 
                 * 如果兄弟节点为红色----（情况3.1） 
                 * 策略：改变W、P的颜色，然后进行一次左旋转 
                 */  
                if (colorOf(sib) == RED) {       
                    setColor(sib, BLACK);       
                    setColor(parentOf(x), RED);    
                    rotateLeft(parentOf(x));  
                    sib = rightOf(parentOf(x));  
                }  

                /* 
                 * 若兄弟节点的两个子节点都为黑色----（情况3.2） 
                 * 策略：将兄弟节点编程红色 
                 */  
                if (colorOf(leftOf(sib))  == BLACK &&  
                    colorOf(rightOf(sib)) == BLACK) {  
                    setColor(sib, RED);  
                    x = parentOf(x);  
                }   
                else {  
                    /* 
                     * 如果兄弟节点只有右子树为黑色----（情况3.3） 
                     * 策略：将兄弟节点与其左子树进行颜色互换然后进行右转 
                     * 这时情况会转变为3.4 
                     */  
                    if (colorOf(rightOf(sib)) == BLACK) {  
                        setColor(leftOf(sib), BLACK);  
                        setColor(sib, RED);  
                        rotateRight(sib);  
                        sib = rightOf(parentOf(x));  
                    }  
                    /* 
                     *----情况3.4 
                     *策略：交换兄弟节点和父节点的颜色， 
                     *同时将兄弟节点右子树设置为黑色，最后左旋转 
                     */  
                    setColor(sib, colorOf(parentOf(x)));  
                    setColor(parentOf(x), BLACK);  
                    setColor(rightOf(sib), BLACK);  
                    rotateLeft(parentOf(x));  
                    x = root;  
                }  
            }   

            /** 
             * X节点为右节点与其为做节点处理过程差不多，这里就不在累述了 
             */  
            else {  
                Entry<K,V> sib = leftOf(parentOf(x));  

                if (colorOf(sib) == RED) {  
                    setColor(sib, BLACK);  
                    setColor(parentOf(x), RED);  
                    rotateRight(parentOf(x));  
                    sib = leftOf(parentOf(x));  
                }  

                if (colorOf(rightOf(sib)) == BLACK &&  
                    colorOf(leftOf(sib)) == BLACK) {  
                    setColor(sib, RED);  
                    x = parentOf(x);  
                } else {  
                    if (colorOf(leftOf(sib)) == BLACK) {  
                        setColor(rightOf(sib), BLACK);  
                        setColor(sib, RED);  
                        rotateLeft(sib);  
                        sib = leftOf(parentOf(x));  
                    }  
                    setColor(sib, colorOf(parentOf(x)));  
                    setColor(parentOf(x), BLACK);  
                    setColor(leftOf(sib), BLACK);  
                    rotateRight(parentOf(x));  
                    x = root;  
                }  
            }  
        }  

        setColor(x, BLACK);  
    }

原文链接：http://blog.csdn.net/chenssy/article/details/26668941

Mr_w_Mis
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
源码分析-TreeMap
千念飞羽的专栏
12-22 818
TreeMap概述首先TreeMap是实现了NavigableMap和SortMap的Map，从实现的角度说是红黑树。红黑树红黑树是平衡搜索树的一种，也是使用最多的一种树，其特点 对于所有的动态集合操作都可以保证以最坏O(lgn)的时间复杂度来运行。 每个节点都包含一个储存位来表示节点的颜色，非红即黑。 通过对任何一条从根节点到叶子节点的简单路径上各个节点的颜色进行约束，红黑树确保没有一条路径会比其
java 中sub_Java中TreeMap的subMap()方法: TreeMap.subMap() - Break易站
weixin_39830688的博客
02-13 1518
Java中的java.util.TreeMap.subMap(K startKey，K endKey)方法用于返回由参数中指定范围的键定义的映射的部分或部分。在一个或另一个map中所做的任何更改都将反映其他map中的更改。句法：Tree_Map.subMap(K startKey，K endKey)参数：该方法采用Key类型的两个参数：startKey：这是指map的起点或下点，包括要考虑的点。e...
集合系列 Map（十五）：TreeMap
weixin_30746117的博客
08-28 130
TreeMap 是 Map 集合的有序实现，其底层是基于红黑树的实现，能够早 log(n) 时间内完成 get、put 和 remove 操作。 public class TreeMap<K,V> extends AbstractMap<K,V> implements NavigableMap<K,V>, Cloneable, java...
【集合源码系列】TreeMap中子Map源码解析
菜鸡也有大佬梦
09-29 329
范围查找 在 SortedMap 接口中，定义了按照 key 查找范围，返回子 SortedMap 结果的方法 #subMap(K fromKey, K toKey) #headMap(K toKey) #tailMap(K fromKey) 在 NavigableMap 中，定义了按照 key 查找范围，返回子 NavigableMap 结果的方法： #subMap(K fromKey, K toKey) #subMap(K fromKey, boolean fromInclusive, K toK
集合系列 Map：TreeMap
qq_40902067的博客
05-11 250
TreeMap 是 Map 集合的有序实现，其底层是基于红黑树的实现，能够早 log(n) 时间内完成 get、put 和 remove 操作。 public class TreeMap<K,V> extends AbstractMap<K,V> implements NavigableMap<K,V>, Cloneable, java.io.Serializable TreeMap 继承自 AbstractMap，还实现了 NavigableMap接口
java集合-TreeMap的使用
06-14
TreeMap是一种基于红黑树实现的有序映射（SortedMap）。它实现了NavigableMap接口，可以按照键的自然顺序或自定义排序规则对键值对进行排序和访问。
Java-Java集合体系-List-Set
07-12
理解并熟练运用Java集合体系中的List、Set、Map接口及其实现类，对于日常开发和面试来说至关重要，因为它们是许多Java框架和库的基础。在实际项目中，根据需求选择合适的集合类型可以提高代码的效率和可维护性。在...
java 集合----Map、Collection
09-02
Java集合框架是编程中不可或缺的一部分，它提供了多种数据结构，如列表(List)、集(Set)以及映射(Map)，便于我们高效地存储、管理和操作数据。本文将深入探讨Map和Collection接口，以及它们的实现类，特别是HashSet和...
java-集合-知识点汇总
09-05
Java集合可以分为两大类：Collection和Map。 Java集合的类型 Java集合有多种类型，常见的有ArrayList、LinkedList、HashSet、TreeSet、HashMap、TreeMap等。 * ArrayList：是一个基于数组的列表实现，支持随机...
Java-Java集合教程
最新发布
11-13
Java集合框架是Java编程语言中一个非常重要的组成部分，它提供了数据结构和算法的实现，使得在处理对象集合时更加高效和灵活。Java集合教程通常会涵盖以下关键知识点： 1. **集合接口**： - `Collection`：这是...
Java集合框架之Map--TreeMap源码分析
ChangWen的博客
11-17 1127
TreeMap基于红黑树（点击查看树、红黑树相关内容）实现。查看“键”或“键值对”时，它们会被排序（次序由Comparable或Comparator决定）。TreeMap的特点在于，所得到的结果是经过排序的。TreeMap是唯一的带有subMap()方法的Map，它可以返回一个子树。
java源码分析之TreeMap深入篇
jzhf2012的专栏
01-25 6295
TreeMap有Values、EntrySet、KeySet、PrivateEntryIterator、EntryIterator、ValueIterator、KeyIterator、DescendingKeyIterator、NavigableSubMap、AscendingSubMap、DescendingSubMap、SubMap、Entry共十三个内部类。Entry是在TreeMap中用于
红黑树TreeMap使用
ZERO
09-04 332
转载自：http://blog.csdn.net/chenssy/article/details/26668941 TreeMap的实现是红黑树算法的实现。 红黑树简介        红黑树又称红-黑二叉树，它首先是一颗二叉树，它具体二叉树所有的特性。同时红黑树更是一个自平衡的排序二叉树。        一个基本的二叉树都需要满足一个基本性质，即树中的任何节点的值大于它的左子节
java1.8 常用集合源码学习：TreeMap
猫耳山在天边
10-28 336
1、api 基于红黑树（Red-Black tree）的 NavigableMap 实现。该映射根据其键的自然顺序进行排序，或者根据创建映射时提供的 Comparator 进行排序，具体取决于使用的构造方法。 此实现为 containsKey、get、put 和 remove 操作提供受保证的 log(n) 时间开销。这些算法是 Cormen、Leiserson 和 Rivest 的 In
java集合系列——Map之TreeMap介绍（九）
阿飞云漫步
03-05 1万+
TreeMap是一个有序的key-value集合，基于红黑树（Red-Black tree）的 NavigableMap实现。该映射根据其键的自然顺序进行排序，或者根据创建映射时提供的 Comparator进行排序，具体取决于使用的构造方法。
Java的TreeMap和HashMap的介绍和使用
yo_bc的博客
02-12 1万+
1. TreeMap的介绍和使用 第1部分 TreeMap介绍 TreeMap 简介 TreeMap 是一个有序的key-value集合，它是通过红黑树实现的。 TreeMap 继承于AbstractMap，所以它是一个Map，即一个key-value集合。 TreeMap 实现了NavigableMap接口，意味着它支持一系列的导航方法。比如返回有序的key集合
Java里多个Map的性能比较（TreeMap、HashMap、ConcurrentSkipListMap）
热门推荐
我的博客
10-14 4万+
比较Java原生的 3种Map的效率。 1.  TreeMap 2.  HashMap 3.  ConcurrentSkipListMap 结果： 模拟150W以内海量数据的插入和查找，通过增加和查找两方面的性能测试，结果如下： Map类型 插入 查找（在100W数据量中）   10W 50W 100W 150W 0-1W 0-25W 0
TreeSet/HashSet（TreeMap/HashMap） 区别
sinat_25444819的博客
10-09 438
1、构造函数 TreeSet的无参构造函数如下 public TreeSet() { this(new TreeMap<E,Object>()); } TreeSet(NavigableMap<E,Object> m) { this.m = m; } 也就是说底层存储数据的是一个TreeMap，TreeMap是由红...
Cartographer SLAM——submap的建立过程（一）
poplar的专栏
05-26 5654
Cartographer 3D中submap的建立过程1. LocalTrajectoryBuilder3D::AddRangeData（）1） 激光点云原始数据的时间同步2) 检查是否已经经过了基于IMU的姿态初始化，主要通过检测当前帧开始时间和上一帧pos的时间判断: 1. LocalTrajectoryBuilder3D::AddRangeData（） 接口具体为： std::unique...
java集合类之map的treemap
06-06
TreeMap是Java集合框架中的一种Map实现，它基于红黑树数据结构实现。TreeMap中的元素按照键的自然顺序或者自定义顺序进行排序，因此它是一个有序的Map。TreeMap提供了一系列的方法来操作Map中的元素，例如添加、删除、查找等。由于它是有序的，因此可以方便地进行范围查找和排序操作。但是，由于它是基于红黑树实现的，因此在插入、删除和查找操作中的时间复杂度为O(log n)。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值