寻找右区间

给定一组区间，对于每一个区间 i，检查是否存在一个区间 j，它的起始点大于或等于区间 i 的终点，这可以称为 j 在 i 的“右侧”。

对于任何区间，你需要存储的满足条件的区间 j 的最小索引，这意味着区间 j 有最小的起始点可以使其成为“右侧”区间。如果区间 j 不存在，则将区间 i 存储为 -1。最后，你需要输出一个值为存储的区间值的数组。

注意:

你可以假设区间的终点总是大于它的起始点。
你可以假定这些区间都不具有相同的起始点。

示例 1:
输入: [ [1,2] ]
输出: [-1]
解释:集合中只有一个区间，所以输出-1。

示例 2:
输入: [ [3,4], [2,3], [1,2] ]
输出: [-1, 0, 1]
解释:对于[3,4]，没有满足条件的“右侧”区间。
对于[2,3]，区间[3,4]具有最小的“右”起点;
对于[1,2]，区间[2,3]具有最小的“右”起点。

示例 3:
输入: [ [1,4], [2,3], [3,4] ]
输出: [-1, 2, -1]
解释:对于区间[1,4]和[3,4]，没有满足条件的“右侧”区间。
对于[2,3]，区间[3,4]有最小的“右”起点。

暴力

对于集合中的每个区间，记录下该区间的终点值last； 扫描其他所有区间，找到其起点值大于last的区间。每个区间的结果存储在res数组中
时间复杂度：O(n^2)：找到每个区间的答案需要扫描整个区间集合。
空间复杂度：O(n)：数组 res 具有 n 个元素

class Solution {
    public int[] findRightInterval(int[][] intervals) {
    	if(intervals == null) return -1;
        int nums = intervals.length;
        if(nums == 1 || nums == 0) return -1;
        int[] res = new int[nums];
        for(int i = 0; i<nums; i++){
            int curLast = intervals[i][1];
            int min = Integer.MAX_VALUE;
            int minIndex = -1;
            for(int j=0; j<nums; i++){
                if(i==j) continue;
                if(intervals[j][0] >= curLast && intervals[j][0] < min){
                    minIndex = j;
                }
            }
            res[i] = minIndex;         
        }
        return res;
    }
}

哈希+排序

使用一个哈希表 hash，存储数据的形式是键值对：Key 对应区间，而Value 对应在intervals 数组中特定区间的索引。

根据区间的起点对intervals 数组进行排序。之前已经将数组的索引存储在哈希表中，以便排序后也能获得对应的索引。
由于 intervals 数组是基于起点排序的，并且对于给定的区间，结束点总是大于起始点。因此我们只需要使用索引 j 搜索区间 i+1< j < ni+1<j<n，这样按升序扫描时遇到第一个区间就是所需的结果。

时间复杂度：O(n^2)

1. 排序使用了O(nlog(n))的时间
2. i的移动区间：0~n-1
3. j的移动区间：(n-1)+(n-2)+…+1 = n*(n-1)/2 = O(n^2)

空间复杂度：O(n)：res和hash均存储了n个元素

import java.util.HashMap;
class Solution {
    public int[] findRightInterval(int[][] intervals) {
        int nums = intervals.length;
        //if(nums == 1) return -1;
        int[] res = new int[nums];

        HashMap<int[],Integer> hash = new HashMap();
        for(int i=0; i < nums; i++){
            hash.put(intervals[i], i);
        }
        Arrays.sort(intervals, (a,b) -> a[0]-b[0]); //排序的时候，只需要对起点进行排序即可
        for(int i=0; i < nums; i++){
            int min = Integer.MAX_VALUE;
            int minIndex = -1;
            for(int j = i + 1; j < nums; j++){
                if(intervals[j][0] >= intervals[i][1] && intervals[j][0] < min){
                    min = intervals[j][0];
                    minIndex = hash.get(intervals[j]);
                }
            }
            res[hash.get(intervals[i])] = minIndex;
        }
        return res;

    }
}

排序 + 二分查找

因为 intervals 有序，则我们不必用线性的方法来搜索所需的区间，而是可以利用二分查找来找到我们所需的区间。
如果找到所需的区间，则从哈希表中获取对用的所有添加到res 中，反之则添加 -1。

时间复杂度：O((n.log(n))。排序花费了 O(n.log(n)) 的时间，二分查找花费了 O(log(n)) 的时间。
空间复杂度：O(n)，res 和 hash 均存储了 n 个元素。

在二分查找的时候，传入的是区间的右端点，查找的是大于等于区间的右端点的第 1 个值，因此它的反面就是：小于一定不是解。根据这个“减而治之”的策略，编写二分查找算法。
注意：一种特判的情况，如果有序的最后一个元素都小于传入的区间的右端点，那么直接返回 -1。

import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;

public class Solution {

    public int[] findRightInterval(int[][] intervals) {
        int len = intervals.length;
        if (len == 0) {
            return new int[0];
        }

        // 对原始区间进行预处理，key：起点，value：索引
        // 题目中说：你可以假定这些区间都不具有相同的起始点
        Map<Integer, Integer> hashMap = new HashMap<>(len);

        int[] arr = new int[len];
        int[] res = new int[len];
        for (int i = 0; i < len; i++) {
            hashMap.put(intervals[i][0], i);
            arr[i] = intervals[i][0];
        }

        Arrays.sort(arr);

        for (int i = 0; i < len; i++) {
            int index = binarySearch(arr, intervals[i][1]);
            if (index == -1) {
                res[i] = -1;
            } else {
                res[i] = hashMap.get(arr[index]);
            }
        }
        return res;
    }

    /**
     * 查找第 1 个大于等于 target 的元素的索引
     *
     * @param arr
     * @param target
     * @return
     */
    private int binarySearch(int[] arr, int target) {
        int len = arr.length;
        // 特判
        if (arr[len - 1] < target) {
            return -1;
        }

        int left = 0;
        int right = len - 1;
        while (left < right) {
            int mid = (left + right) >>> 1;
            if (arr[mid] < target) {
                left = mid + 1;
            } else {
                right = mid;
            }
        }
        return left;
    }
}

使用二分搜索树

因为需要绑定对应关系，还须要排序，查找大于等于的第 1 个元素，恰好就是“天花板函数” ceiling 的功能，一种数据结构“红黑树”就正好同时满足了这些需求，即：

红黑树 = 哈希表 + 排序

import java.util.Arrays;
import java.util.Map;
import java.util.TreeMap;

public class Solution2 {

    public int[] findRightInterval(int[][] intervals) {
        int len = intervals.length;
        if (len == 0) {
            return new int[0];
        }

        TreeMap<Integer, Integer> treeMap = new TreeMap<>();
        int[] res = new int[len];
        for (int i = 0; i < len; i++) {
            treeMap.put(intervals[i][0], i);
        }
        for (int i = 0; i < len; i++) {
            Map.Entry<Integer, Integer> entry = treeMap.ceilingEntry(intervals[i][1]);
            if (entry == null) {
                res[i] = -1;
            } else {
                res[i] = entry.getValue();
            }
        }
        return res;
    }
}

注

• int min = Integer.MAX_VALUE;
• “你可以假定这些区间都不具有相同的起始点。”–>区间都不相同，可以做hashmap的key
  import java.util.HashMap;
• “你可以假设区间的终点总是大于它的起始点” --> 区间内部的有序性，可以进行排序—> 可以二分查找
• 排序后，会打乱原来的索引，但是结果要求返回！！所以使用哈希表去记录原来的索引（需要记录的是索引，value就是索引）
• Arrays.sort(intervals, (a,b) -> a[0]-b[0]); 根据起点值排序
  实现Comparator接口的复写compare()方法

/*注意，要想改变默认的排列顺序，不能使用基本类型（int,double, char）而要使用它们对应的类*/
Integer[] a = {9, 8, 7, 2, 3, 4, 1, 0, 6, 5};
//定义一个自定义类MyComparator的对象
Comparator cmp = new MyComparator();
Arrays.sort(a,cmp);
	for(int arr:a) {
    		               System.out.print(arr + " ");
    		           }
    		       }
    		   }
    		   //实现Comparator接口
    		   class MyComparator implements Comparator<Integer>{
    		      @Override
    		       public int compare(Integer o1, Integer o2) {
    		        /*如果o1小于o2，我们就返回正值，如果o1大于o2我们就返回负值，
    		         这样颠倒一下，就可以实现降序排序了,反之即可自定义升序排序了*/
    		       return o2-o1;    
       }
    	
  }