题解 | #合并区间#

思路

• 先排序，再遍历比较

方法一

• 用双指针来记录上一个插入到结果数组的中区间；

import java.util.*;
/**
 * Definition for an interval.
 * public class Interval {
 *     int start;
 *     int end;
 *     Interval() { start = 0; end = 0; }
 *     Interval(int s, int e) { start = s; end = e; }
 * }
 */
public class Solution {
    public ArrayList<Interval> merge(ArrayList<Interval> intervals) {
        ArrayList<Interval> res = new ArrayList<>();
        if(intervals.size() == 0)
            return res;
        // 定制排序：将二维数组重新排序
        Collections.sort(intervals, new Comparator<Interval>(){
            @Override
            public int compare(Interval o1, Interval o2){
                if(o1.start != o2.start){
                    return o1.start - o2.start;
                } else {
                    return o1.end - o2.end;
                }
            }
        });

        // preStart记录上一次插入的区间的左边界   
        // preEnd记录上一次插入的区间的右边界
        int preStart = -1, preEnd = -1;
        for(Interval cur : intervals){
            if(preEnd == -1){
                preStart = cur.start;
                preEnd = cur.end;
                continue;
            }
            if(preEnd >= cur.start){  // 重叠区间
                if(preEnd < cur.end)  // 新区间的右边界比前一个区间的右边界大
                    preEnd = cur.end;
            } else {  // 不重叠
                Interval temp = new Interval(preStart, preEnd);
                res.add(temp);
                preStart = cur.start;
                preEnd = cur.end;
            }
        }
        // 插入最后一个合理区间
        res.add(new Interval(preStart, preEnd));
        return res;
    }
}

方法二

• 使用临时变量记录结果数组上一次插入的区间

import java.util.*;
/**
 * Definition for an interval.
 * public class Interval {
 *     int start;
 *     int end;
 *     Interval() { start = 0; end = 0; }
 *     Interval(int s, int e) { start = s; end = e; }
 * }
 */
public class Solution {
    public ArrayList<Interval> merge(ArrayList<Interval> intervals) {
        ArrayList<Interval> res = new ArrayList<>();
        if(intervals.size() == 0){
            return res;
        }

        // 升序排序
        // 集合类采用Collections.sort
        // 比如[[1,4],[0,2]]  --> [[0,2],[1,4]]
        Collections.sort(intervals, (o1, o2) -> {
            if(o1.start != o2.start){
                return o1.start - o2.start;
            } 
            return o1.end - o2.end;
        });

        // 结果计数器
        int count = 0;
        res.add(intervals.get(0));  // 添加第一个元素
        for(int i = 1; i < intervals.size(); ++i){
            Interval oldVal = intervals.get(i);  // 获取原二维数组的第i个索引的元素
            Interval newVal = res.get(count);  // 获取结果二维数组的第count个索引的数据
            if(oldVal.start <= newVal.end){  // 存在重叠区间
                // 比如[[1,4], [2,3]] 不满足
                if(oldVal.end > newVal.end){
                    int newStart = newVal.start;
                    int newEnd = oldVal.end;  // 用大值更新右区间
                    // 删除旧值
                    res.remove(count);
                    // 添加新值
                    res.add(new Interval(newStart, newEnd));
                }
            } else {
                res.add(new Interval(oldVal.start, oldVal.end));
                ++count;  // 结果数组元素+1
            }
        }
        return res;
    }
}