56. 合并区间 leetcode

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

示例 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）首先保存该区间的左端点start和右端点end
3）从该区间的下一个区间开始，依次比较此区间的左端点与上一个区间的右端点，若满足合并条件则记录新合并区间的右端点。注意右端点取当前区间与之前区间右端点的较大值
4）若当前区间不再满足合并条件或者遍历到了集合末尾，就构建新合并区间，其中左端点为初始区间的左端点，右端点为当前所有合并区间右端点的最大值，然后将其加入到结果集合中，接着合并下一个区间

class Solution {
    public int[][] merge(int[][] intervals) {
        if(intervals==null||intervals.length<=1){
            return intervals;
        }
        List<int[]> list = new ArrayList<>();//int [] 表示list 存储是一个个一维数组
        quickSort(intervals,0,intervals.length-1);

        int i=0,n=intervals.length;

        while(i<n){
            int left = intervals[i][0];
            int right = intervals[i][1];
            while(i<n-1 && right>=intervals[i+1][0]){
                right = Math.max(right,intervals[i+1][1]);
                i++;
            }
            list.add(new int[] {left,right});//当遇到一个不满足判断循环的时候，表示不能组成区间，于是先保存 继续寻找下一个区间
            i++;
        }
        return list.toArray(new int[list.size()][2]);



    }
    //实现快排
    public void quickSort(int[][]arr,int low,int high){
        if(low<high){
            int index=getIndex(arr,low,high);
            quickSort(arr,low,index-1);
            quickSort(arr,index+1,high);
        }

    }
    public int getIndex(int[][]arr,int low,int high){
        int temp=arr[low][0];
        int tempR=arr[low][1];
        while(low<high){
            while(low<high&&arr[high][0]>=temp){
                high--;
            }
            arr[low][0]=arr[high][0];
            arr[low][1]=arr[high][1];
            while(low<high&&arr[low][0]<=temp){
                low++;
            }
            arr[high][0]=arr[low][0];
            arr[high][1]=arr[low][1];
        }
        arr[low][0]=temp;
        arr[low][1]=tempR;
        return low;

    }
}

对二维数组按照每一行元素的第一个数字排序，可以使用上面的快排，

 //实现快排
    public void quickSort(int[][]arr,int low,int high){
        if(low<high){
            int index=getIndex(arr,low,high);
            quickSort(arr,low,index-1);
            quickSort(arr,index+1,high);
        }

    }
    public int getIndex(int[][]arr,int low,int high){
        int temp=arr[low][0];
        int tempR=arr[low][1];
        while(low<high){
            while(low<high&&arr[high][0]>=temp){
                high--;
            }
            arr[low][0]=arr[high][0];
            arr[low][1]=arr[high][1];
            while(low<high&&arr[low][0]<=temp){
                low++;
            }
            arr[high][0]=arr[low][0];
            arr[high][1]=arr[low][1];
        }
        arr[low][0]=temp;
        arr[low][1]=tempR;
        return low;

    }
}

对于上面的getIndex() 方法代码，因为int arr[][] 是二维数组，
所以 arr[low] 是一维数组
可以简写为：

 public int getIndex(int[][]arr,int low,int high){
        int[] temp=arr[low];//temp 表示二维数组的第low+1 行，是一个一维数组
        while(low<high){
            while(low<high&&arr[high][0]>=temp[0]){  //用temp数组的第一个元素比较
                high--;
            }
            arr[low]=arr[high];//替换该一维数组
            
            while(low<high&&arr[low][0]<=temp[0]){
                low++;
            }
            arr[high]=arr[low];
        }
        arr[low]=temp;
        return low;
    }

上述代码量有点大，可以用

  Arrays.sort(intervals, new Comparator<int[]>() {//对二维数组进行排序
            @Override
            public int compare(int[] a, int[] b) {
                return a[0]-b[0];//按照每一行的第一个元素升序排列每一行
            }
        });

注意对于一维数组排序， Arrays.sort 的用法，如下：