LeetCode OJ 之 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].

给一个没有重叠的区间集合，插入一个新的区间，如果有重叠就合并。假设区间最初是有序的。

思路：

1、线性查找： 
如果新区间的end < 当前区间的start，不用找下去了，把新区间插入到当前区间的前面，然后返回。
如果当前区间的end小于新区间的start，继续遍历找下一个区间。
如果当前区间和新区间发生重合，则start取两者最小的start，end取两者较大的end，生成一个新的区间，并把当前区间删除。然后继续遍历。

如果遍历一直到区间末尾程序还没返回，就把新区间插入到原来区间的末尾。

但是上面的思路的代码不能AC了，超时了（尽管是线性）。

2、二分法查找区间：

通过二分查找找到最大的索引h，h是满足 intervals[h].start<=newInterval.end;
通过二分查找找到最小的索引l，l是满足 intervals[l].end>=newInterval.start;
如果l>h,在l前插入直接新区间即可；
如果l==h，将intervals[l]区间与newInterval合并即可；
如果l<h,需要将intervals[l]至intervals[h]的区间与newInterval合并。

代码1：

超时：

/**
 * 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)
    {
        vector<Interval>::iterator iter = intervals.begin();
        while(iter != intervals.end())
        {
            if(newInterval.end < iter->start)
            {
                intervals.insert(iter,newInterval);
                return intervals;
            }
            else
            {
                if(newInterval.start > iter->end)
                {
                    iter++;
                    continue;
                }
                else
                {
                    newInterval.start = min(newInterval.start , iter->start);
                    newInterval.end = max(newInterval.end , iter->end);
                    iter = intervals.erase(iter);//把原来区间删除，iter指向原来区间的下一个
                }
            }
        }
        intervals.insert(intervals.end() , newInterval);
        return intervals;
    }
};

代码2：

/**
 * 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)
    {
        int i=intervals.size();
        //if(0==i)
        int high=i-1;
        int low=0;
        int h=-1;
        int l=i;
        while(low<=high)
        {
            int mid=(low+high)/2;
            if(intervals[mid].start > newInterval.end)
            {
                high=mid-1;
            }
            else
            {
                h=mid;
                low=mid+1;
            }
        }
        if(h==-1)
        {
            intervals.insert(intervals.begin(),newInterval);//插入最前面，即所有的区间start都大于新区间的end
            return intervals;
        }
        high=i-1;
        low=0;
        while(low<=high)
        {
            int mid=(low+high)/2;
            if(intervals[mid].end < newInterval.start)
            {
                low=mid+1;
            }
            else
            {
                l=mid;
                high=mid-1;
            }
        }   
        if(l == i)
        {
            intervals.push_back(newInterval);//插到最后面，即所有的区间end都小于新区间的start
            return intervals;
        }
        if(l == h)    //说明只需要改变一个区间
        {
            intervals[l].start = min(intervals[l].start,newInterval.start);
            intervals[l].end = max(intervals[l].end,newInterval.end);
        }
        else 
            if(l > h) //原来的一个区间都不要改变，只是在l前面插入新的区间
            {
                intervals.insert(intervals.begin()+l,newInterval);
            }else   //要合并l到h的多个区间
            {
                newInterval.start = min(intervals[l].start,newInterval.start);
                newInterval.end = max(intervals[h].end,newInterval.end);
                //iterator erase( iterator start, iterator end );erase函数要么删除指定位置loc的元素,要么删除区间[start, end)的所有元素.返回值是指向删除的最后一个元素的下一位置的迭代器
                intervals.erase(intervals.begin()+l,intervals.begin()+h+1);//删除l到h（包括l和h），所以这里h要+1
                intervals.insert(intervals.begin()+l,newInterval);//在l前面插入新区间
            }
        return intervals;
    }
};