TreeMap和TreeSet

TreeMap是最近遇到的，它可以根据key值自动排序，默认状态是对key进行递增排序，也可以自定义

treemap的存放顺序和实际位置并不相同，算是无序集合

treemap的常用 方法在下面 （转载）

public class TreeMapTest {
    public static void main(String[] agrs){
        //创建TreeMap对象：
        TreeMap<String,Integer> treeMap = new TreeMap<String,Integer>();
        System.out.println("初始化后,TreeMap元素个数为：" + treeMap.size());

        //新增元素:
        treeMap.put("hello",1);
        treeMap.put("world",2);
        treeMap.put("my",3);
        treeMap.put("name",4);
        treeMap.put("is",5);
        treeMap.put("huangqiuping",6);
        treeMap.put("i",6);
        treeMap.put("am",6);
        treeMap.put("a",6);
        treeMap.put("developer",6);
        System.out.println("添加元素后,TreeMap元素个数为：" + treeMap.size());

        //遍历元素：
        Set<Map.Entry<String,Integer>> entrySet = treeMap.entrySet();
        for(Map.Entry<String,Integer> entry : entrySet){
            String key = entry.getKey();
            Integer value = entry.getValue();
            System.out.println("TreeMap元素的key:"+key+",value:"+value);
        }

        //获取所有的key：
        Set<String> keySet = treeMap.keySet();
        for(String strKey:keySet){
            System.out.println("TreeMap集合中的key:"+strKey);
        }

        //获取所有的value:
        Collection<Integer> valueList = treeMap.values();
        for(Integer intValue:valueList){
            System.out.println("TreeMap集合中的value:" + intValue);
        }

        //获取元素：
        //获取集合内元素key为"huangqiuping"的值
        Integer getValue = treeMap.get("huangqiuping");
        //获取集合内第一个元素
        String firstKey = treeMap.firstKey();
        //获取集合内最后一个元素
        String lastKey =treeMap.lastKey();
        //获取集合内的key小于"huangqiuping"的key
        String lowerKey =treeMap.lowerKey("huangqiuping");
        //获取集合内的key大于等于"huangqiuping"的key
        String ceilingKey =treeMap.ceilingKey("huangqiuping");
        //获取集合的key从"a"到"huangqiuping"的元素
        SortedMap<String,Integer> sortedMap =treeMap.subMap("a","my");

        //删除元素：
        //删除集合中key为"huangqiuping"的元素
        Integer removeValue = treeMap.remove("huangqiuping");
        //清空集合元素：
        treeMap.clear(); 

        //判断方法：
        //判断集合是否为空
        boolean isEmpty = treeMap.isEmpty();
        //判断集合的key中是否包含"huangqiuping"
        boolean isContain = treeMap.containsKey("huangqiuping");
    }
}

排序，和自定义排序如下（转载）

public class SortedTest implements Comparable<SortedTest> {
    private int age;
    public SortedTest(int age){
        this.age = age;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    //自定义对象，实现compareTo(T o)方法：
    public int compareTo(SortedTest sortedTest) {
        int num = this.age - sortedTest.getAge();
        //为0时候，两者相同：
        if(num==0){
            return 0;
        //大于0时，传入的参数小：
        }else if(num>0){
            return 1;
        //小于0时，传入的参数大：
        }else{
            return -1;
        }
    }
}

public class TreeMapTest {
    public static void main(String[] agrs){
        //自然顺序比较
        naturalSort();
    }
     //自然排序顺序：
    public static void naturalSort(){
        //第一种情况：Integer对象
        TreeMap<Integer,String> treeMapFirst = new TreeMap<Integer, String>();
        treeMapFirst.put(1,"huangqiuping");
        treeMapFirst.put(6,"huangqiuping");
        treeMapFirst.put(3,"huangqiuping");
        treeMapFirst.put(10,"huangqiuping");
        treeMapFirst.put(7,"huangqiuping");
        treeMapFirst.put(13,"huangqiuping");
        System.out.println(treeMapFirst.toString());

        //第二种情况:SortedTest对象
        TreeMap<SortedTest,String> treeMapSecond = new TreeMap<SortedTest, String>();
        treeMapSecond.put(new SortedTest(10),"huangqiuping");
        treeMapSecond.put(new SortedTest(1),"huangqiuping");
        treeMapSecond.put(new SortedTest(13),"huangqiuping");
        treeMapSecond.put(new SortedTest(4),"huangqiuping");
        treeMapSecond.put(new SortedTest(0),"huangqiuping");
        treeMapSecond.put(new SortedTest(9),"huangqiuping");
        System.out.println(treeMapSecond.toString());
    }
}

TreeMap不仅可以自定义排序，可以让元素放进来以后变得有序，也可以利用二分法对最近的元素进行查找，如最近的比其小的元素，和最近的比其大的元素。这个API可以应用到很多题目上去，下面给出例题。

 这里就需要treeMap的API了

代码如下

class MyCalendar {
    TreeMap<Integer, Integer> treeMap;
    public MyCalendar() {
        treeMap = new TreeMap<>();
    }
    public boolean book(int start, int end) {
        if (treeMap.isEmpty()) {
            treeMap.put(start, end);
            return true;
        }
//寻找左边最近的元素
        Map.Entry<Integer, Integer> floorEntry = treeMap.floorEntry(start);
//寻找右边最近的元素
        Map.Entry<Integer, Integer> ceilingEntry = treeMap.ceilingEntry(start);
        if (floorEntry != null && floorEntry.getValue() > start) {
            return false;
        }
        if (ceilingEntry != null && ceilingEntry.getKey() < end) {
            return false;
        }
//添加元素，由treemap内部进行自动排序
        treeMap.put(start, end);
        return true;
    }
}

Treeset也是一个道理，不过它是作为set。

类似的题目如下所示

 即采用滑动窗口的形式，当添加新元素时，将其与集合内相邻的两个元素进行比较，如果符合条件则为true，这里就需要用到treeset的自动排序功能（至于底层如何排序的具体再学）

代码如下所示

class Solution {
    public boolean containsNearbyAlmostDuplicate(int[] nums, int k, int t) {
        TreeSet<Integer> treeSet = new TreeSet<>();
        for (int i = 0; i < nums.length; i++) {
            Integer cur = nums[i];
            // 寻找比cur小的最大数和比cur大的最小数，查找 l->cur 和 cur->r 范围
            Integer l = treeSet.floor(cur);
            Integer r = treeSet.ceiling(cur);
            if (l != null && (long) cur - l <= t) return true;
            if (r != null && (long) r - cur <= t) return true;
            treeSet.add(cur);
            // 维持一个大小为 k 的滑动窗口
            if (i >= k) treeSet.remove(nums[i - k]);
        }
        return false;
    }
}