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

/**
 * Definition for an interval.
 * struct Interval {
 *     int start;
 *     int end;
 *     Interval() : start(0), end(0) {}
 *     Interval(int s, int e) : start(s), end(e) {}
 * };
 */
 
 [1,5]  [5,7]  ---> [1,7]
 
class Solution {
public:
    vector<Interval> insert(vector<Interval> &intervals, Interval newInterval) 
    {
        vector<Interval> res;
        if (intervals.size() == 0)
        {
            res.push_back(newInterval);
            return res;
        }
        Interval tmp1(INT_MIN,INT_MIN);
        intervals.insert(intervals.begin(),tmp1);
        Interval tmp2(INT_MAX,INT_MAX);
        intervals.push_back(tmp2);
        int pre = 0, next = 0;
        for (int i=1;i<intervals.size();i++)
        {
            if (intervals[i].start <= newInterval.start)
                pre = i;
            if (intervals[i].end < newInterval.end)
                next = i;
        }
        next++;
        if (pre<next)
        {
            if (intervals[pre].end >= newInterval.start && intervals[next].start <= newInterval.end)  //[1,3] [7,9] [16,19] insert [2,18]
            {
                Interval tmp = Interval(intervals[pre].start, intervals[next].end);
                intervals.insert(intervals.begin()+pre, tmp);
                intervals.erase(intervals.begin() + pre +1, intervals.begin() + next +2);
            }
            else if (intervals[pre].end >= newInterval.start) //[1,3] [7,9] [16,19] insert [2,6]
            {
                Interval tmp = Interval(intervals[pre].start, newInterval.end);
                intervals.insert(intervals.begin()+pre, tmp);
                intervals.erase(intervals.begin() + pre +1, intervals.begin() + next +1);
            }
            else if (intervals[next].start <= newInterval.end) //[1,3] [7,9] [16,19] insert [4,8]
            {
                Interval tmp = Interval(newInterval.start, intervals[next].end);
                intervals.erase(intervals.begin() + pre +1, intervals.begin() + next +1);
                intervals.insert(intervals.begin()+pre+1, tmp);
                
            }
            else //[1,3] [7,9] [16,19] insert [4,5]
            {
                Interval tmp = Interval(newInterval.start, newInterval.end);
                intervals.erase(intervals.begin() + pre +1, intervals.begin() + next);
                intervals.insert(intervals.begin()+pre+1, tmp);
            }
        }
        intervals.erase(intervals.begin());
        intervals.erase(intervals.end()-1);
        return intervals;
    }
};

//网上看到的思路  比较简单
class Solution {
public:
    vector<Interval> insert(vector<Interval> &intervals, Interval newInterval) 
    {
        vector<Interval>  res;
        int cur  = 0, n = intervals.size();
        while(cur<n && intervals[cur].end<newInterval.start)
        {
            res.push_back(intervals[cur++]);
        }
        while(cur<n && intervals[cur].start<=newInterval.end)
        {
            newInterval.start = min(intervals[cur].start, newInterval.start);
            newInterval.end = max(intervals[cur++].end, newInterval.end);
        }
        res.push_back(newInterval);
        while(cur<n)
        {
            res.push_back(intervals[cur++]);
        }
        return res;
    }
};

测试

#include<algorithm>
#include<iostream>
#include<vector>
#include<limits.h>
using namespace std;



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> res;
        if (intervals.size() == 0)
        {
            res.push_back(newInterval);
            return res;
        }
        Interval tmp1(INT_MIN,INT_MIN);
        intervals.insert(intervals.begin(),tmp1);
        Interval tmp2(INT_MAX,INT_MAX);
        intervals.push_back(tmp2);
        int pre = 0, next = 0;
        for (int i=1;i<intervals.size();i++)
        {
            if (intervals[i].start <= newInterval.start)
                pre = i;
            if (intervals[i].end < newInterval.end)
                next = i;
        }
        next++;
        if (pre<next)
        {
            if (intervals[pre].end >= newInterval.start && intervals[next].start <= newInterval.end)  //[1,3] [7,9] [16,19] insert [2,18]
            {
                Interval tmp = Interval(intervals[pre].start, intervals[next].end);
                intervals.insert(intervals.begin()+pre, tmp);
                intervals.erase(intervals.begin() + pre +1, intervals.begin() + next +2);
            }
            else if (intervals[pre].end >= newInterval.start) //[1,3] [7,9] [16,19] insert [2,6]
            {
                Interval tmp = Interval(intervals[pre].start, newInterval.end);
                intervals.insert(intervals.begin()+pre, tmp);
                intervals.erase(intervals.begin() + pre +1, intervals.begin() + next +1);
            }
            else if (intervals[next].start <= newInterval.end) //[1,3] [7,9] [16,19] insert [4,8]
            {
                Interval tmp = Interval(newInterval.start, intervals[next].end);
                intervals.erase(intervals.begin() + pre +1, intervals.begin() + next +1);
                intervals.insert(intervals.begin()+pre+1, tmp);
                
            }
            else //[1,3] [7,9] [16,19] insert [4,5]
            {
                Interval tmp = Interval(newInterval.start, newInterval.end);
                intervals.erase(intervals.begin() + pre +1, intervals.begin() + next);
                intervals.insert(intervals.begin()+pre+1, tmp);
            }
        }
        intervals.erase(intervals.begin());
        intervals.erase(intervals.end()-1);
        return intervals;
    }
};
class Solution1 {
public:
    vector<Interval> insert(vector<Interval> &intervals, Interval newInterval) 
    {
        vector<Interval>  res;
        int cur  = 0, n = intervals.size();
        while(cur<n && intervals[cur].end<newInterval.start)
        {
            res.push_back(intervals[cur++]);
        }
        while(cur<n && intervals[cur].start<=newInterval.end)
        {
            newInterval.start = min(intervals[cur].start, newInterval.start);
            newInterval.end = max(intervals[cur++].end, newInterval.end);
        }
        res.push_back(newInterval);
        while(cur<n)
        {
            res.push_back(intervals[cur++]);
        }
        return res;
    }
};

int main()
{
    Solution s;
    Solution1 s1;
    vector<Interval> intervals;
    Interval tmp1(1,5);
    intervals.push_back(tmp1);
    /*
    Interval tmp2(6,9);
    intervals.push_back(tmp2);
    Interval tmp3(16,19);
    intervals.push_back(tmp3);*/
    
    Interval newInterval(5,10);
    vector<Interval>res = s.insert(intervals, newInterval);
    vector<Interval>res1 = s1.insert(intervals, newInterval);
    
    for (int i=0;i<res.size();i++)
    {
        cout<<"start :"<<res[i].start<<" next :"<<res[i].end<<endl;
    }
    for (int i=0;i<res1.size();i++)
    {
        cout<<"start :"<<res1[i].start<<" next :"<<res1[i].end<<endl;
    }
}