【Insert Interval】cpp

最新推荐文章于 2020-09-03 23:43:46 发布

weixin_34129696

最新推荐文章于 2020-09-03 23:43:46 发布

阅读量52

点赞数

CC 4.0 BY-SA版权

原文链接：http://www.cnblogs.com/xbf9xbf/p/4557060.html

本文详细解析了如何在已排序的区间集合中插入新区间并进行合并操作，包括不同版本代码的实现与优化，从繁琐到简洁的过程，以及合并区间时的注意事项。通过实例演示和代码对比，提供了易于理解和实现的方法。

题目：

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) {}
 * };
 */
class Solution {
public:
        vector<Interval> insert(vector<Interval>& intervals, Interval newInterval)
        {
            vector<Interval> ret;
            int i = 0;
            // search for start insert position
            for ( ; i<intervals.size(); ++i )
            {
                if ( newInterval.start > intervals[i].end )
                {
                    ret.push_back(intervals[i]);
                }
                else
                {
                    break;
                }
            }
            // newInterval larger than all the existed intervals
            if ( i==intervals.size() )
            {
                ret.push_back(newInterval);
                return ret;
            }
            int start = std::min( intervals[i].start, newInterval.start );
            // search for the end insert position
            for ( ;i<intervals.size();++i )
            {
                if ( newInterval.end <= intervals[i].end ) break;
            }
            // newInterval end is larger than all the range
            if ( i==intervals.size() )
            {
                ret.push_back(Interval(start, newInterval.end));
                return ret;
            }
            if ( newInterval.end<intervals[i].start )
            {
                ret.push_back(Interval(start,newInterval.end));
                ret.insert(ret.end(), intervals.begin()+i, intervals.end());
                return ret;
            }
            if ( newInterval.end==intervals[i].start )
            {
                ret.push_back(Interval(start,intervals[i].end));
                if ( i<intervals.size()-1 )
                {
                    ret.insert(ret.end(), intervals.begin()+i+1, intervals.end());
                }
                return ret;
            }
            if ( newInterval.end > intervals[i].start )
            {
                ret.push_back(Interval(start,intervals[i].end));
                if ( i<intervals.size()-1 )
                {
                    ret.insert(ret.end(), intervals.begin()+i+1,intervals.end());
                }
                return ret;
            }
        }
};

tips：

这道题的总体感觉就是很繁琐，因为要考虑各种边界情况，等或者不等；虽然能AC但是这一版代码比较丑陋。

看能不能改一版漂亮一些的。

===================================

学习了一个迭代版的，代码很漂亮，但是会超时。

/**
 * 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 it = intervals.begin();
            while ( it!=intervals.end() )
            {
                if ( newInterval.end < it->start )
                {
                    intervals.insert(it, newInterval);
                    return intervals;    
                }
                else if ( it->end < newInterval.start )
                {
                    it++;
                } 
                else
                {
                    newInterval.start = std::min(newInterval.start, it->start);
                    newInterval.end = std::max(newInterval.end, it->end);
                    intervals.erase(it);
                }
            }
            intervals.insert(intervals.end(), newInterval);
            return intervals;
        }
};

=======================================

还是觉得自己的第一次AC的代码太乱，网上搜了一下，模仿大神（http://yucoding.blogspot.sg/2013/01/leetcode-question-35-insert-interval.html）重新写了一版AC的代码。

/**
 * 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;
            // insert the new Interval
             vector<Interval>::iterator it = intervals.begin();
             for( ; it!=intervals.end(); ++it )
             {
                 if ( newInterval.start < it->start )
                 {
                     intervals.insert(it, newInterval);
                     break;
                 }
             }
             if ( it==intervals.end() )
             {
                 intervals.insert(it, newInterval);
             }
             // merge the intervals
             ret.push_back(*intervals.begin());
             for ( it=intervals.begin()+1; it!=intervals.end(); ++it )
             {
                 if ( it->start > ret.back().end )
                 {
                     ret.push_back(*it);
                 }
                 else
                 {
                     ret.back().start = std::min(ret.back().start, it->start);
                     ret.back().end = std::max(ret.back().end, it->end);
                 }
             }
             return ret;
        }
};

tips:

这一版的代码采用了新的思路。

1. 题中给定了原有的interval集合是按照start排好序的；因此，首先要找到合适的位置，将newInterval插进去。

2. 插进去之后，就有可能存在intervals之间存在overlap的情况，因此再merge（http://www.cnblogs.com/xbf9xbf/p/4557153.html）一遍就OK。

在merge的过程中有个细节：不用维护start和end，ret.back().start和ret.back().end就可以。这个比自己原来写的merge intervals要好，学习了这个细节。

=============================================

第二次过这道题，直接参照的最简洁的思路：

（1）先insert：条件是i->end > newInterval.start（即肯定有重叠）根据newInterval.start的大小先插进去

（2）再merge：修改ret.back().start和ret.back().end的值

/**
 * 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;
            vector<Interval>::iterator i=intervals.begin();
            for ( ; i!=intervals.end(); ++i )
            {
                if ( i->end > newInterval.start ){
                    intervals.insert(i, newInterval);
                    break;
                }
            }
            if ( i==intervals.end() ) intervals.insert(i, newInterval);
            ret.push_back(*intervals.begin());
            for ( i=intervals.begin()+1; i!=intervals.end(); ++i )
            {
                if ( i->start > ret.back().end )
                {
                    ret.push_back(*i);
                }
                else
                {
                    ret.back().start = min(ret.back().start, i->start);
                    ret.back().end = max(ret.back().end, i->end);
                }
            }
            return ret;
    }
};