[LeetCode]57 Insert Interval

https://oj.leetcode.com/problems/insert-interval/

http://blog.csdn.net/linhuanmars/article/details/22238433

/**
 * 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> insert(List<Interval> intervals, Interval newInterval) {
        
        // Validations.
        if (intervals == null)
            return null;
        
        if (newInterval == null)
            return intervals;
            
        // Find insert poistion
        // If overlap, return first merged index * -1;
        
        List<Interval> lists = new ArrayList<>(intervals);
        int index = findPosition(lists, newInterval);
        if (index >= 0) // Just insert
        {
            lists.add(index, newInterval);
            return lists;
        }
        
        // Merge newInterval and the first one.
        index = -index - 1;
        
        merge(lists.get(index), newInterval);
        while (index < lists.size() - 1 && overlap(lists.get(index), lists.get(index + 1)))
        {
            merge(lists.get(index), lists.get(index + 1));
            lists.remove(index + 1);
        }
        return lists;
    }
    
    private int findPosition(List<Interval> intervals, Interval newInterval)
    {
        // intervals are sorted by start asc.
        for (int i = 0 ; i < intervals.size() ; i ++)
        {
            if (overlap(intervals.get(i), newInterval))
            {
                return -(i + 1);
            }
            else if (i == 0 && after(intervals.get(i), newInterval))
            {
                return 0;
            }
            else if (i == intervals.size() - 1 && before(intervals.get(i), newInterval))
            {
                return intervals.size();
            }
            else if (before(intervals.get(i), newInterval) && after(intervals.get(i + 1), newInterval))
            {
                return i + 1;
            }
        }
        return 0;
    }
    
    private boolean overlap(Interval a, Interval b)
    {
        return !(after(a, b) || before(a, b));
    }
    
    // Merge b into a
    private void merge(Interval a, Interval b)
    {
        a.start = Math.min(a.start, b.start);
        a.end = Math.max(a.end, b.end);
    }
    
    // Whether a is before b
    private boolean before(Interval a, Interval b)
    {
        return a.end < b.start;
    }
    
    // A is after b
    private boolean after(Interval a, Interval b)
    {
        return a.start > b.end;
    }
}