LeetCode-Sort&Array-56-M：合并区间（Merge Intervals）

给出一个区间的集合，请合并所有重叠的区间。

示例 1:
输入: [[1,3],[2,6],[8,10],[15,18]]
输出: [[1,6],[8,10],[15,18]]
解释: 区间 [1,3] 和 [2,6] 重叠, 将它们合并为 [1,6].

思路

（1）首先排好二维数组，表达式还不会Arrays.sort(intervals, (i1, i2) -> Integer.compare(i1[0], i2[0]));
（2）迭代比较更新
（3）添加值，特殊在于对值得处理刚刚好，先添加一次，后面再次从[0, 0]开始.

https://leetcode.com/problems/merge-intervals/discuss/21222/A-simple-Java-solution

解法1

执行用时 :7 ms, 在所有 Java 提交中击败了87.52%的用户
内存消耗 :37.9 MB, 在所有 Java 提交中击败了91.54%的用户

注意点：
（1）二维数组也是可以直接写array.length
（2）关于二维数组的排序。调用Arrays.sort()，并在里面重写，使用Comparator比较器
（3）不定长的数组就要使用ArrayList()方法，然后在返回值时需要在处理一下，return res.toArray(new int[res.size()][]);
（4）小区间可能是全包在大区间里的，所以区间尾部还是需要使用Math.max()

class Solution {

	public int[][] merge(int[][] intervals) {
		if (intervals.length <= 1){
            return intervals;
        }

		//Arrays.sort(intervals, (i1, i2) -> Integer.compare(i1[0], i2[0]));
        Arrays.sort(intervals, new Comparator<int[]>(){
            public int compare(int[] a, int[] b){
                return a[0]-b[0];
            }
        });

        int[] newInter =intervals[0];

        //int[][] res =new int[][];
        List<int[]> res = new ArrayList<>();
        res.add(newInter);

        for(int[] inter : intervals){  //int[][] 
            if(inter[0] <= newInter[1]){
                newInter[1] = Math.max(newInter[1], inter[1]);  //newInter[1] = inter[1];
            }else{
                newInter = inter;
                res.add(newInter);
            }
        }

        return res.toArray(new int[res.size()][]); //return res;
	}
}

解法1-2

2020/2/12更新

（1）刚开始写想的是用本身的intervals，没有重新建立一个ArrayList。发现数据输出时第一个数组仍旧存在，第二个数组是合并后的。

class Solution {
    public int[][] merge(int[][] intervals) {
        
        List<int[]> list = new ArrayList<>();
        if(intervals.length == 0){
            return intervals;
        }
        Arrays.sort(intervals, new Comparator<int[]>(){
            public int compare(int[] a, int[] b){
                return a[0]-b[0];
            }
        });

        int[] inter = intervals[0];
        list.add(inter);

        for(int[] interval: intervals){
            if(inter[1] >= interval[0]){
                inter[1] = Math.max(inter[1], interval[1]);
            }else{
                inter = interval;
                list.add(inter);
            }
        }
        
        return list.toArray(new int[list.size()][]);
    }
      
}

解法1-3

2020/3/18 更新

（1）排序今天需要OK
（2）ArrayList<int[]>转化 int[][] ，res.toArray(new int[res.size()][])

class Solution {
    public int[][] merge(int[][] intervals) {
        
        //边界情况
        if(intervals.length <= 1){
            return intervals;
        }
        
        //排序
        Arrays.sort(intervals, new Comparator<int[]>(){
            public int compare(int[] a, int[] b){
                return a[0] - b[0];
            }
        });
        
        ArrayList<int[]> res = new ArrayList<>();
        // inter变量，一直在中间层起着关键作用 
        int[] inter = intervals[0];
        // 数组是引用类型，后面值改变仍旧可以关联，先添加一次
        res.add(inter);
        
        for(int[] interval : intervals){
            if(inter[1] >= interval[0]){
                // 一直合并，直到无法继续合并
               inter[1] =Math.max(inter[1], interval[1]);
            }else{
                inter = interval;
                res.add(inter);
            }
        }
        
        // 转化类型
        return res.toArray(new int[res.size()][]);
    }
}