Insert Interval

Given a set of non-overlapping intervals, insert a new interval into the intervals (merge if necessary).

You may assume that the intervals were initially sorted according to their start times.

Example 1:
Given intervals [1,3],[6,9], insert and merge [2,5] in as [1,5],[6,9].

Example 2:
Given [1,2],[3,5],[6,7],[8,10],[12,16], insert and merge [4,9] in as [1,2],[3,10],[12,16].

This is because the new interval [4,9] overlaps with [3,5],[6,7],[8,10].

Analysis: 

1. See the comments. Note that merge may happen on more than one interval. 

2. We can also sort all of the intervals first and then apply the same logic of Merge Intervals for this problem. 

/**
 * 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> insert(ArrayList<Interval> intervals, Interval newInterval) {
        ArrayList<Interval> res = new ArrayList<Interval>();
        if(intervals.size() == 0) {     // intervals is empty
            res.add(newInterval);
            return res;
        }
        if(newInterval==null) return intervals;     // newInterval is null
        
        boolean foundInsertPos = false;
        for(int i=0; i<intervals.size(); i++) {
            Interval oldInterval = intervals.get(i);
            if(!foundInsertPos) {
                if(newInterval.start>=oldInterval.start && newInterval.start<=oldInterval.end) {    // *** start in between
                    if(newInterval.end <= oldInterval.end) {    // old contains new
                        res.add(oldInterval);
                        foundInsertPos = true;
                    }
                    else if(newInterval.end > oldInterval.end) {
                        newInterval.start = oldInterval.start;  // intersect
                    }
                }
                else if(newInterval.start < oldInterval.start) {     // *** start in left
                    if(newInterval.end < oldInterval.start) {   // do not intersect
                        res.add(newInterval);   // order is matter here
                        res.add(oldInterval);
                        foundInsertPos = true;
                    }
                    else if(newInterval.end>=oldInterval.start && newInterval.end<=oldInterval.end) {   // end in between
                        newInterval.end = oldInterval.end;
                    }
                    else if(newInterval.end > oldInterval.end) {    // new contains old
                        continue;   // may merge more than one interval
                    }
                }
                else if(newInterval.start > oldInterval.end) {      // *** start in right
                    res.add(oldInterval);
                }
            }
            else {
                res.add(oldInterval);
            }
        }
        if(!foundInsertPos) res.add(newInterval);   // newInterval's start is greater than the last oldInterval's 
        
        return res;
    }
}