Leetcode-Array-57（insert Interval）

 

给定一组不重叠的间隔，在间隔中插入一个新的间隔（如有必要，合并）。

您可以假设间隔最初按照起始时间进行排序。

示例1：
给定间隔[1,3],[6,9]，插入和合并[2,5]为[1,5],[6,9]。

示例2：
给定[1,2],[3,5],[6,7],[8,10],[12,16]，插入并合并[4,9]为[1,2],[3,10],[12,16]。

这是因为新的间隔[4,9]与之重叠[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) {}

 

 

 * };

 

*/

当然，leetcode拥有良好的函数处理平台，但有时候我想知道如何编写出来一个完整的程序，现在我给出一种编写方法吧。

/**
 * 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> ret;
        if(intervals.empty())
        {
            ret.push_back(newInterval);
            return ret;
        }
            
        int i = 0;
        while(i < intervals.size())
        {
            //no overlapping
            if(newInterval.end < intervals[i].start)
            {
                ret.push_back(newInterval);
                while(i < intervals.size())
                {
                    ret.push_back(intervals[i]);
                    i ++;
                }
                return ret;
            }
            else if(newInterval.start > intervals[i].end)
                ret.push_back(intervals[i]);
            //overlapping
            else
            {
                newInterval.start = min(newInterval.start, intervals[i].start);
                newInterval.end = max(newInterval.end, intervals[i].end);
            }
            i ++;
        }
        ret.push_back(newInterval);      
        return ret;
    }
};

这个是没有主函数的。

 

 

#include <iostream>
#include <string>
#include <algorithm>
#include <vector>
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> ret;
        if(intervals.empty())
        {
            ret.push_back(newInterval);
            return ret;
        }
        
        int i = 0;
        while(i < intervals.size())
        {
            //no overlapping
            if(newInterval.end < intervals[i].start)
            {
                ret.push_back(newInterval);
                while(i < intervals.size())
                {
                    ret.push_back(intervals[i]);
                    i ++;
                }
                return ret;
            }
            else if(newInterval.start > intervals[i].end)
                ret.push_back(intervals[i]);
            //overlapping
            else
            {
                newInterval.start = min(newInterval.start, intervals[i].start);
                newInterval.end = max(newInterval.end, intervals[i].end);
            }
            i ++;
        }
        ret.push_back(newInterval);
        return ret;
    }
};
int main()
{
    Interval temp;
    Interval temp1;
    vector<Interval> vec;
    for(int i = 0; i < 5; i++) {
        cin >> temp.start >> temp.end;
        vec.push_back(temp);
    }
    cin >> temp1.start >> temp1.end;
    Solution sol;
    vector<Interval>ans = sol.insert(vec,temp1);
    for(int i = 0; i < ans.size(); i++) {
        cout << ans[i].start << ' ' << ans[i].end << endl;
    }
    return 0;
}

这个是完整的。 //已经运行过的

2020.05.31

#这道题的思想是这样：是在给定区间内加入一个新的区间，如果该区间可以和原给定区间融合的话，那就融合，最后给出融合后的新区间。

给定区间是按照顺序排好的区间，所以这里需要考虑的情况是：

#当新区间的结束时间小于循环中区间的开始时间的话，说明该区间范围
我原来代码感觉写的逻辑性不好，

这里应该先判断新区间的开始时间是否大于原区间中循环到的区间的结束时间，如果大于的话，说明原区间循环中的这一个就是可以加入容器的区间。

接着开始判断下一个区间和新区间。

可能写的不是很清楚，大家看代码调试吧

接着开始判断新区间的结束时间与循环区间的开始时间的对比，感觉逻辑没有理清，我重试着写一下

class Solution {
public:
    vector<vector<int>> insert(vector<vector<int>>& intervals, vector<int>& newInterval) {
        vector<vector<int>> ans;
       // bool flag = false;        //新区间是否放置进答案
        for(int i = 0; i < intervals.size(); i++){
            if(newInterval[0] > intervals[i][1]){
                ans.push_back(intervals[i]);
                //cout<<ans[0][0]<<endl;
                //cout<<newInterval[0] <<" "<<intervals[i][1]<<endl;
                //continue;
            }
            else if(newInterval[1] < intervals[i][0]){
                //这样是和同一个区间的开始与结束相比
                //cout<<newInterval[0] <<" "<<intervals[i][1]<<endl;
                ans.push_back(newInterval);
                for(; i < intervals.size(); i++)
                    ans.push_back(intervals[i]);
                return ans;
            }
            else {
                newInterval[0] = min(newInterval[0], intervals[i][0]);  //区间合并
                newInterval[1] = max(newInterval[1], intervals[i][1]);
            }
        }
        //cout<< newInterval[0]<<" "<<newInterval[1]<<endl;
        ans.push_back(newInterval);
        return ans;
    }
};

 

至于最后为什么会再添加一个新区间呢？这是因为for循环的是原有区间个数，如果新区间的开始时间大于所有原区间的再大结束时间，就需要在容器最后添加新区间。