Leetcode-Merge Intervals

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].

Anaylsis:

Method 1: Sort the start points and end points respectively. For the ith point, if the (i-1)th end point is smaller than the ith start point, then the previous i-1 intervals are merged to one interval.

Method 2: Count the delta value at each time point. start: +1, end:-1. Then starting from the first time point, if the accumulative value reaches 0, then we get one interval.

Solution 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) {
        List<Interval> res = new ArrayList<Interval>();
        if (intervals.size()==0) return res;
        if (intervals.size()==1){
            res.add(intervals.get(0));
            return res;
        }
        
        
        List<Integer> sList = new ArrayList<Integer>();
        List<Integer> eList = new ArrayList<Integer>();
        for (int i=0;i<intervals.size();i++){
            sList.add(intervals.get(i).start);
            eList.add(intervals.get(i).end);
        }
        Collections.sort(sList);
        Collections.sort(eList);
        
        int p1=0;
        while (p1<sList.size()){
            int p2 = p1+1;
            while (p2<sList.size() && sList.get(p2)<=eList.get(p2-1)) p2++;
            Interval inter = new Interval(sList.get(p1),eList.get(p2-1));
            res.add(inter);
            p1 = p2;
        }
        
        return res;
    }
}

Solution 2:

/**
 * 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) {
        Map<Integer,Integer> pMap = new HashMap<Integer,Integer>();
        List<Integer> pList = new ArrayList<Integer>();

        //Count the delta at each point.
        for (int i=0;i<intervals.size();i++){
            Interval cur = intervals.get(i);
            if (pMap.containsKey(cur.start)){
                pMap.put(cur.start,pMap.get(cur.start)+1);
            } else {
                pList.add(cur.start);
                pMap.put(cur.start,1);
            }
            if (pMap.containsKey(cur.end)){
                pMap.put(cur.end,pMap.get(cur.end)-1);
            } else {
                pList.add(cur.end);
                pMap.put(cur.end,-1);
            }
            }
        
        //Now, sort the time points.
        Collections.sort(pList);
        
        //Now construct new interval list.
        List<Interval> res = new ArrayList<Interval>();
        int index1 = 0;
        while (index1<pList.size()){
            int val = pMap.get(pList.get(index1));
            int index2 = index1;
            while (val!=0){
                index2++;
                val += pMap.get(pList.get(index2));
            }
            Interval one = new Interval(pList.get(index1),pList.get(index2));
            res.add(one);
            index1 = index2+1;            
        }
        return res;
    }
}

The most important thing here is to consider that the intervals are not sorted!.