[Leetcode 86] 57 Insert Interval

Problem:

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:

The basic way is to go through the intervals and compared each of them with the new interval. Two situations happens:

1. They intersect. For intersection cases, just generate a new interval that merging the former two together and continue to go through the vector.

2. They don't intersect. There are two sub-situations here:

　　a. The i-th interval in the vector has a start time larger than the merged interval's end time. For this case, it means we find the place to put the newly merged interval. Push it 　　　　 and then push all the remaining intervals into the result vector.

　　b. The i-th interval in the vectoe has an end time less than the merged interval's start time. For this case, we need to push the i-th interval into the result and check the next 　　　　 interval in the vector.

3. Some special cases to be considered are that the newInterval includes the whole vector, is the last one in the result vector etc.

Code:

/**
 * 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> insert(vector<Interval> &intervals, Interval newInterval) {
        // Start typing your C/C++ solution below
        // DO NOT write int main() function
        vector<Interval> res;
        
        if (intervals.size() == 0) {
            res.push_back(newInterval);
            return res;
        }
        
        for (int i = 0; i < intervals.size(); i++) {
            if (intersect(newInterval, intervals[i])) {
                newInterval = merge(newInterval, intervals[i]);
                if (i == intervals.size()-1)
                    res.push_back(newInterval);
            }
            else if (newInterval.start > intervals[i].end) {
                res.push_back(intervals[i]);
                if (i == intervals.size() - 1)
                    res.push_back(newInterval);
            } 
            else if (newInterval.end < intervals[i].start) {
                res.push_back(newInterval);
                for (int j=i; j<intervals.size(); j++)
                    res.push_back(intervals[j]);
                    
                break;
            }
            
        }
        
        return res;
    }
    
    bool intersect(const Interval &a, const Interval &b) {
        return !((a.start > b.end) || (b.start > a.end));
    }
    
    Interval merge(const Interval &a, const Interval &b) {
        Interval res;
        res.start = min(a.start, b.start);
        res.end = max(a.end, b.end);
        return res;
    }
    
    int min(const int &a, const int &b) { return (a < b) ? a : b; }
    
    int max(const int &a, const int &b) { return (a > b) ? a : b; }
};