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].

　　类似以前的merge Intervals,只不过这里实际上是要将一个Interval插入到内部之后，然后再merge一下
而且这里的intervals在这里首先是已经排好序了的：

首先是一个带二分搜索的C++的方法：

class Solution {
public:
    static bool comp(Interval a,Interval b){
        return a.start<b.start;
    }
    vector<Interval> insert(vector<Interval>& intervals, Interval newInterval) {
        if(intervals.size()==0){
            intervals.push_back(newInterval);
            return intervals;
        }
        // sort(intervals.begin(),intervals.end(),comp);
        if(intervals[0].start>newInterval.end){
            intervals.insert(intervals.begin(),newInterval);
            return intervals;
        }
        else if(intervals[intervals.size()-1].end<newInterval.start){
            intervals.push_back(newInterval);
            return intervals;
        }
        int left = binaryS(newInterval.start,intervals,0,intervals.size()-1, true);
        int right = binaryS(newInterval.end, intervals,left, intervals.size()-1,false);
        int delLeft,delRight;
        cout<<left<<right;
        if(left == 0 && intervals[0].start>newInterval.start){
            delLeft = left;
        }
        else if(intervals[left].end>= newInterval.start){
            newInterval.start = intervals[left].start;
            delLeft = left;
        }
        else{
            delLeft = left+1;
        }

        if(right == intervals.size()-1 && intervals[right].end<newInterval.end){
            delRight = right;
        }
        else if(intervals[right].start<= newInterval.end){
            newInterval.end = intervals[right].end;
            delRight = right;
        }
        else{
            delRight = right-1;
        }
        cout<<delLeft<<" "<<delRight<<endl;
        vector<Interval> result;

        for(int i=0;i<delLeft;i++){
            result.push_back(intervals[i]);
        }
        result.push_back(newInterval);
        for(int i=delRight+1;i<intervals.size();i++){
            result.push_back(intervals[i]);
        }
        return result;
        // for(int i=delLeft;i<=delRight;i++){
        //     intervals.erase(intervals.begin()+delLeft);
        // }
        // intervals.push_back(newInterval);
        // return intervals;
    }
    int binaryS(int x, vector<Interval> & intervals, int low, int high, bool isStart){
        if(isStart){


            while(low < high){
                int mid = (low + high +1 ) /2;
                 cout<<low<<high;
                if(intervals[mid].start <= x){
                    low = mid;
                }
                else{
                    high = mid-1;
                }
            }
        }
        else{
            while(low < high){
                int mid = (low + high) /2;
                // cout<<low<<high;
                if(intervals[mid].end < x){
                    low = mid+1;
                }
                else{
                    high = mid;
                }
            }
        }
        return low;
    }
};

 

java版本的代码如下所示：

/**
 * 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) {
        List<Interval> ret = new ArrayList<Interval>();
        int sz = intervals.size();
        if(sz == 0){
            ret.add(newInterval);
            return    ret;
        }
        int prev = 0, next = 1;
        while(next < sz){
            if(newInterval != null && intervals.get(prev).end >= newInterval.start){
                intervals.get(prev).end = Math.max(intervals.get(prev).end, newInterval.end);
                newInterval = null;
            }else if(newInterval == null){
                if(intervals.get(prev).end >= intervals.get(next).start){
                    intervals.get(prev).end = Math.max(intervals.get(prev).end, intervals.get(next).end);
                    next++;
                }else{
                    ret.add(intervals.get(prev));
                    prev = next;
                    next++;
                }
            }else{
                ret.add(intervals.get(prev));
                prev++;
                next++;
            }
        }
        intervals.get(prev).end = Math.max(intervals.get(prev).end, intervals.get(sz-1).end);
        ret.add(intervals.get(prev));
        return ret;
    }
}