leetcode 28: 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].

/**
 * Definition for an interval.
 * struct Interval {
 *     int start;
 *     int end;
 *     Interval() : start(0), end(0) {}
 *     Interval(int s, int e) : start(s), end(e) {}
 * };
 */
class Solution {
public:
    vector<Interval> merge(vector<Interval> &intervals) {
        // Start typing your C/C++ solution below
        // if intervals are sorted. it would be easy.
        if( intervals.size() <= 1) return intervals;
        
        insertion_sort( intervals );
        
        vector<Interval> rel;
        Interval base = intervals[0];
        rel.push_back( base );
        
        for( int i=1; i< intervals.size(); i++) {
            Interval & pre = rel.back();
            Interval & next = intervals[i];
            
            if( pre.end < next.start ) {
                rel.push_back( next );
            } else if( pre.end < next.end) {
                pre.end = next.end;
            } // otherwise, do nohting since base case has already included the new one.           
        }        
        return rel;
    }
    
    void insertion_sort( vector<Interval> &intervals ) {
        for( int i=1; i< intervals.size(); i++) {
            Interval temp = intervals[i]; 
            int j=i-1;
            while(j>=0) { 
                if(intervals[j].start>temp.start || (intervals[j].start==temp.start && intervals[j].end>temp.end) ) {
                    intervals[j+1] = intervals[j];
                    j--;
                } else {
                    break;
                }
            }
            intervals[j+1] = temp;
        }
    }
};

/**
 * 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) {
        // Start typing your Java solution below
        // DO NOT write main() function
        if(intervals.size() <=1) return intervals;
        
        Collections.sort(intervals, new IntervalComparator());
        ArrayList<Interval> res = new ArrayList<Interval>();
        res.add( intervals.get(0) );

        for(int i=1; i<intervals.size(); i++) {
            
            int last = res.size() - 1;
            if( intervals.get(i).start > res.get(last).end) 
                res.add(intervals.get(i));
            else if(intervals.get(i).end <= res.get(last).end)
                continue;
            else {
                res.get(last).end = intervals.get(i).end;   
            }
        }
        
        return res;
    }
    
    class IntervalComparator implements Comparator{
        public int compare(Object o1, Object o2) {
            if( !(o1 instanceof Interval) || !(o2 instanceof Interval))
                return -1;
            
            Interval i1 = (Interval)o1;
            Interval i2 = (Interval)o2;
            
            if(i1.start<i2.start) 
                return -1;
            else if(i1.start>i2.start)
                return 1;
            else {
                if(i1.end > i2.end)
                    return 1;
                else if(i1.end < i2.end) 
                    return -1;
                else return 0;
            }    
        }
    }
}