力扣LeetCode56题：合并区间（Arrays.sort()方法的扩展使用）

题目：

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

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

示例 2:
输入: [[1,4],[4,5]]
输出: [[1,5]]
解释: 区间 [1,4] 和 [4,5] 可被视为重叠区间。

分析：

题目看起来还是挺简单的一个题目，就是要求并区间，数学里面我们都知道怎么做。

那如果对于示例 1 和示例 2 来说，当前一个区间的右端点 > 后一个的左端点，就可以将这两个区间合并。

但是，示例的两个输入，区间的左端点是有序的，而实际输入可能是乱的。

所以这个问题就变成了，先要对原来的输入进行按照区间左端点的排序，再进行合并操作。

相关知识

那么体现在实现层面，就是对二维数组的 intervals[x][0] 进行排序，之后再从头到尾遍历一遍，用 intervals[x][1] 和 intervals[y][0] 作比较。

（如果自己还是实现一个排序算法应该不是这个题目的重点？）
调用 Arrays.sort 算法的扩展操作：

Arrays.sort()方法原则上只能对一维数组进行排序，但是这里需要对二维数组的某一列进行排序，就用到了这个函数的进阶

扩充 Comparator 接口，排序时将此接口的实现传递给 Collections.sort 方法或者Arrays.sort 方法进行排序。

Arrays.sort()方法的源码分析可以参考这篇博客：

浅谈Arrays.sort()原理

尤其当集合中的对象不支持自比较 或者 自比较的功能不能满足需求 时可以使用它来进行指定，比如说在一些实际应用里面：有一个学生类，包含一些信息，名单出来之后想按照他们的其中一个属性语文成绩排序这样的情况。

这里我们想要对二维数组进行排序，并且要指定排序的是这个二维数组里面的啥东西，所以要利用这个接口实现类来进行指定。

具体的使用方法如下：

对于一个一维数组：

int[] a={1,2,3,4,5}

我们本来调用Arrays.sort()方法的时候可以这样

Arrays.sort(a);

就完全可以了，表示对a数组进行排序，因为他里面的元素世界可以进行排序，是基本类型。

如果数组a是这样呢：

int[ ][ ] a= new int[ ][ ]{{1,3},{1,2},{4,5},{3,7}};

遇到这里的二维数组，这里面的每个元素是一个数组对象，没有实现Comparator接口，所以如果想要排序需要我们实现这个接口：

Arrays.sort(a,new Comparator<int[]>(){
    @Override
    public int compare(int[] a,int[] b){
        return a[0]-b[0];
    }
});

这段代码的功能就是，对于a数组进行排序，实现了一个 Comparator 接口。

在这里面，我们用 compare 方法规定，对于两个元素的比较（两个元素都是一维数组），a 和 b 数组，返回这两个数组第 0 个元素的比较结果。

也就是对二维数组排序的时候，按照里面每一个元素（是一个一位数组）的第一列元素进行比较。

这样的写法也可以进行简化成 Lambda 表达式：（java 8 之后支持的新特性）

Arrays.sort(arr,(a,b)->a[0]-b[0]);

表达的是和上面复写compare方法一样的意思：对于a和b的比较，比较a[0]和b[0]。

实现

于是我们可以写出这道题目的代码：

排序，按照第一列排序，得到区间的左端点有序的一组区间集合
开始合并；
1. 两个区间合并的条件是前一个区间的右端点大于等于后一个区间的左端点。
2. 合并之后左端点为前一个区间的左端点；右端点为两个区间的右端点中较大的一个。（比如 [1,4][2,3] ，合完之后左右端点都是第一个区间）
合并完之后整个数组的内容是变少的，移动也不方便，因此将不需要的部分进行处理；
将结果重新遍历放进一个新数组，作为答案返回。



class Solution {
    public int[][] merge(int[][] intervals) {
    	//首先让区间左端点有序
        Arrays.sort(intervals, (o1, o2) -> o1[0] - o2[0]);
        
        int row=intervals.length;
        int row1=intervals.length;
        int i=0;
        while(i<row){
            int j=i+1;
            while(j<row&&intervals[j][0]<=intervals[i][1]){
                
                intervals[i][1]=intervals[j][1]>=intervals[i][1]?intervals[j][1]:intervals[i][1];

                intervals[j][0]=Integer.MIN_VALUE;//为了方便被合并过的标记一下
                intervals[j][1]=Integer.MIN_VALUE;

                row1--;//记录答案的数组size，每合并一次就会少一个元素

                j++;
            }
            i=j;//调到下一个没有被判断过的开始
        }

        //然后重新赋值返回答案
        int[][] ans=new int[row1][2];

        for(int j=0,k=0;j<row&&k<row1;j++){
            if(intervals[j][0]>Integer.MIN_VALUE){
                ans[k][0]=intervals[j][0];
                ans[k][1]=intervals[j][1];
                k++;
            }
        }
        return ans;
    }
}