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()==){
             intervals.push_back(newInterval);
             return intervals;
         }
         // sort(intervals.begin(),intervals.end(),comp);
         if(intervals[].start>newInterval.end){
             intervals.insert(intervals.begin(),newInterval);
             return intervals;
         }
         else if(intervals[intervals.size()-].end<newInterval.start){
             intervals.push_back(newInterval);
             return intervals;
         }
         int left = binaryS(newInterval.start,intervals,,intervals.size()-, true);
         int right = binaryS(newInterval.end, intervals,left, intervals.size()-,false);
         int delLeft,delRight;
         cout<<left<<right;
         if(left ==  && intervals[].start>newInterval.start){
             delLeft = left;
         }
         else if(intervals[left].end>= newInterval.start){
             newInterval.start = intervals[left].start;
             delLeft = left;
         }
         else{
             delLeft = left+;
         }

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

         for(int i=;i<delLeft;i++){
             result.push_back(intervals[i]);
         }
         result.push_back(newInterval);
         for(int i=delRight+;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 + ) /;
                  cout<<low<<high;
                 if(intervals[mid].start <= x){
                     low = mid;
                 }
                 else{
                     high = mid-;
                 }
             }
         }
         else{
             while(low < high){
                 int mid = (low + high) /;
                 // cout<<low<<high;
                 if(intervals[mid].end < x){
                     low = mid+;
                 }
                 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;
     }
 }