【两次过】Lintcode 156. 合并区间

给出若干闭合区间，合并所有重叠的部分。

样例

Given intervals => merged intervals:

[                     [
  (1, 3),               (1, 6),
  (2, 6),      =>       (8, 10),
  (8, 10),              (15, 18)
  (15, 18)            ]
]

挑战

O(n log n) 的时间和 O(1) 的额外空间。

---

解题思路：

先对区间进行排序，按start升序，end降序排列，也就是先让大区间排前面，当覆盖掉小区间时方便计算。

然后依次遍历排序后的区间，分为三种情况：覆盖、交叉、分离，具体见代码。

/**
 * Definition of Interval:
 * public classs Interval {
 *     int start, end;
 *     Interval(int start, int end) {
 *         this.start = start;
 *         this.end = end;
 *     }
 * }
 */

public class Solution {
    /**
     * @param intervals: interval list.
     * @return: A new interval list.
     */
    public List<Interval> merge(List<Interval> intervals) {
        // write your code here
        //按start升序，end降序排列，也就是先让大区间排前面，当覆盖掉小区间时方便计算
         Collections.sort(intervals, new Comparator<Interval>(){
            @Override
            public int compare(Interval a, Interval b){
                if(a.start != b.start)
                    return a.start - b.start;
                else
                    return a.end - b.end;
            }
        });

        List<Interval> res = new ArrayList<>();
        
        int start = -1;//存储上一个区间的start
        int end = -1;//存储上一个区间的end
        for(Interval i : intervals){
            //如果上一个区间已经包含了此区间，则跳过此区间
            if(start <= i.start && end >= i.end){
                continue;
            }
            //如果上一个区间与当前区间有交叉，则合并两区间
            else if(i.start <= end){
                res.remove(res.size()-1);
                res.add(new Interval(start, i.end));
                end = i.end;
            //否则直接将其加入结果集中，并刷新start与end
            }else{
                start = i.start;
                end = i.end;
                res.add(i);
            }
        }
        
        return res;
    }
}

二刷：

/**
 * Definition of Interval:
 * public classs Interval {
 *     int start, end;
 *     Interval(int start, int end) {
 *         this.start = start;
 *         this.end = end;
 *     }
 * }
 */

public class Solution {
    /**
     * @param intervals: interval list.
     * @return: A new interval list.
     */
    public List<Interval> merge(List<Interval> intervals) {
        // write your code here
        List<Interval> res = new ArrayList<>();
        if(intervals == null || intervals.size() == 0)
            return res;
        
        //按start升序，end降序排列
        Collections.sort(intervals, new Comparator<Interval>(){
            @Override
            public int compare(Interval a, Interval b){
                if(a.start != b.start)
                    return a.start - b.start;
                else
                    return a.end - b.end;
            }
        });
        
        int start = intervals.get(0).start;//存储上一个区间的start
        int end = intervals.get(0).end;//存储上一个区间的end
        
        for(int i=1; i<intervals.size(); i++){
            //如果上一个区间已经包含了此区间，则跳过此区间
            if(intervals.get(i).start <= end && intervals.get(i).end <= end)
                continue;
            //如果上一个区间与当前区间有交叉，则合并两区间
            else if(intervals.get(i).start <= end && intervals.get(i).end > end)
                end = intervals.get(i).end;
            //否则直接将其加入结果集中，并刷新start与end
            else{
                res.add(new Interval(start, end));
                start = intervals.get(i).start;
                end = intervals.get(i).end;
            }            
        }
        
        res.add(new Interval(start, end));
        
        return res;
    }
}