Given a collection of intervals, merge all overlapping intervals. For example, Given [1,3],[2,6],[8,10],[15,18], return [1,6],[8,10],[15,18].
这道题跟Insert Intervals这道题很像，最开头要先对Intervals里面的Interval排序一下，用到了java的Collections.sort(List<Interval> list, Comparator<? super Interval> c)。 排序以Interval的start为第一标准，从小到大，如果start一样的情况下，才以end作为第二标准。这样排序的好处是，简化了接下来处理的难度。
我们只需要把intervals里的interval依次添加到结果集合里，每次将要添加时，只需要判断当前这个interval的start跟结果集合里面最后一个Interval的end谁大，如果结果集合里面最后一个Interval的end大，说明overlap了，需要改一下这个end就好了，否则没有Overlap，直接添加该Interval进结果集合里就好了。
sort的好处是，只用管end，不用管start, 因为新添加的Interval的start至少是大于等于结果集合里面已经添加的Interval的start的。换言之，start不受影响，简化了我们的处理。
所以本问题的关键在于给Intervals排序，可以用java的Collections.sort(List<Interval> list, Comparator<? super Interval> c)。因为Interval是我们自己定义的，所以我们也需要自己定义Comparator,而不能用默认的。我们可以写一个我们自己的Comparator来override默认的。规则是按起始点排序，然后如果起始点相同就按结束点排序。整个算法是先排序，然后再做一次线性遍历，时间复杂度是O(nlogn+n)=O(nlogn)，空间复杂度是O(1)，因为不需要额外空间，只有结果集的空间。
/**
* 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 List<Interval> merge(List<Interval> intervals) {
ArrayList<Interval> res = new ArrayList<Interval>();
if (intervals == null || intervals.size() == 0) {
return intervals;
}
Comparator<Interval> comp = new Comparator<Interval>() {
public int compare(Interval t1, Interval t2) {
if (t1.start == t2.start) {
return t1.end - t2.end;
}
return t1.start - t2.start;
}
};
Collections.sort(intervals, comp);
res.add(intervals.get(0));
for (int i=1; i<intervals.size(); i++) {
if (res.get(res.size()-1).end >= intervals.get(i).start) {
res.get(res.size()-1).end = Math.max(res.get(res.size()-1).end, intervals.get(i).end);
}
else {
res.add(intervals.get(i));
}
}
return res;
}
}
第一次做, 不能一股脑的用heap 啊
/**
* 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 List<Interval> merge(List<Interval> intervals) {
List<Interval> ans = new ArrayList<>();
if (intervals == null || intervals.size() == 0) {
return ans;
}
Comparator<Interval> comp = new Comparator<Interval>(){
public int compare(Interval a, Interval b) {
return a.start == b.start ? a.end - b.end : a.start - b.start;
}
};
Comparator<Interval> cmp = new Comparator<Interval>(){
public int compare(Interval a, Interval b) {
return b.end - a.end;
}
};
Collections.sort(intervals, comp);
PriorityQueue<Interval> heap = new PriorityQueue<>(cmp);
heap.add(intervals.get(0));
for (int i = 1; i < intervals.size(); i++) {
if (heap.peek().end >= intervals.get(i).start) {
Interval cur = heap.poll();
Interval merge = new Interval(cur.start, Math.max(cur.end, intervals.get(i).end));
heap.add(merge);
} else {
heap.add(intervals.get(i));
}
}
while (!heap.isEmpty()) {
ans.add(heap.poll());
}
return ans;
}
}