[LeetCode]Insert Interval

struct Interval {
	int start;
	int end;
	Interval() : start(0), end(0) {}
	Interval(int s, int e) : start(s), end(e) {}
};
class Solution {
//first binary search find the insertion position
//then process its forward and afterward intervals
public:
	vector<Interval> insert(vector<Interval> &intervals, Interval newInterval) {
		// Start typing your C/C++ solution below
		// DO NOT write int main() function
		//if(intervals.size() <= 0) return vector<Interval>();
		int position = BinarySearch(intervals, newInterval);

		for (int i = position; i < intervals.size(); ++i)//process afterward intervals
		{
			if(intervals[i].start <= newInterval.end)
			{
				newInterval.end = max(newInterval.end, intervals[i].end);
				intervals.erase(intervals.begin()+i);
				--i;
			}
		}
		intervals.insert(intervals.begin()+position, newInterval);
		if(position-1 >= 0 && intervals[position-1].end >= intervals[position].start)//process foreward interval
		{
			intervals[position-1].end = max(intervals[position-1].end, intervals[position].end);
			intervals.erase(intervals.begin()+position);
		}
		return intervals;
	}

	int BinarySearch( vector<Interval> & intervals, const Interval& newInterval ) 
	{
		//throw std::exception("The method or operation is not implemented.");
		int l = 0; int r = intervals.size()-1;
		while (l <= r)
		{
			int m = l+(r-l)/2;
			if (intervals[m].start < newInterval.start)
				l = m+1;
			else if (intervals[m].start >= newInterval.start)
				r = m-1;
		}
		return l;
	}


};

second time

/**
 * 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:
    bool overlap(Interval& interval, int newStart, int newEnd)
    {
        if(newStart <= interval.start && interval.start <= newEnd) return true;
        if(interval.start <= newStart && newStart <= interval.end) return true;
        return false;
    }
    int binarySearch(vector<Interval>& intervals, Interval newInterval)
    {
        int left = 0;
        int right = intervals.size()-1;
        while(left <= right)
        {
            int mid = left+(right-left)/2;
            if(intervals[mid].start >= newInterval.start) right = mid-1;
            else left = mid+1;
        }
        return right;
    }
    vector<Interval> insert(vector<Interval> &intervals, Interval newInterval) {
        // Start typing your C/C++ solution below
        // DO NOT write int main() function
        if(intervals.size() == 0) return vector<Interval>(1, newInterval);
        int pos = binarySearch(intervals, newInterval);
        int newStart = newInterval.start;
        int newEnd = newInterval.end;
        vector<Interval> ans;
        //save result
        for(int i = 0; i < pos; ++i) ans.push_back(intervals[i]);
        
        if(pos != -1)
        {
            //first merge
            if(overlap(intervals[pos], newStart, newEnd))
            {
                newStart = min(intervals[pos].start, newStart);
                newEnd = max(intervals[pos].end, newEnd);
            }
            else ans.push_back(intervals[pos]);
        }
        //the following merge
        pos++;
        while(pos < intervals.size())
        {
            if(overlap(intervals[pos], newStart, newEnd)) 
            {
                newStart = min(intervals[pos].start, newStart);
                newEnd = max(intervals[pos].end, newEnd);
                pos++;
            }
            else break;
        }
        ans.push_back(Interval(newStart, newEnd));
        for(int i = pos; i < intervals.size(); ++i) ans.push_back(intervals[i]);
        
        return ans;
    }
};