LeetCode #57 | Insert Interval

最新推荐文章于 2026-06-26 23:12:21 发布

原创最新推荐文章于 2026-06-26 23:12:21 发布 · 290 阅读

0 ·

本内容遵循CC 4.0 BY-SA版权协议

收录于

leetcode

本文介绍了一种区间合并算法，该算法用于将一个新区间插入到已排序且非重叠的区间数组中，并确保插入后数组仍保持递增及无交集状态。通过实例演示了如何在两种不同场景下进行区间合并。

首先是题目：

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

也就是说，往一个递增排列，区间之间不相交的区间数组中，插入一个区间，让这个数组继续保持递增且区间没有交集的状态。

思路比较简单。首先，试图在一个向量中移动元素是一个很蠢的想法，我们肯定用空间换时间，直接新构造一个向量往里填入最终结果。

然后，考虑做法。把区间看做两个数，且数递增排序，那么n个区间会得到一个2n大小的数组。找出要插入区间的两个的端点的位置，把在这两个位置中间的点全部去掉即可。当然，我们在构造这个数组的时候就可以将在要插入区间里的数“扔掉”。于是，最坏的情况需要O(4n)的时间复杂度，即遍历两遍区间的两端（此时插入区间和原区间没有任何合并）。

下面上代码

/**
 * 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) 
    {
        int size = intervals.size();
        vector<Interval> res; // result
        vector<int> list;
        bool flag = false, flag2 = false;
        int i = 0;
        if(intervals.empty())
        {
            res.push_back(newInterval);
            return res;
        }
        while(i < size)
        {
            if(!flag)
            {
                if(newInterval.start < intervals[i].start)
                {
                    list.push_back(newInterval.start);
                    flag = true;
                    continue;
                }
                else if(newInterval.start <= intervals[i].end)
                {
                    list.push_back(intervals[i].start);
                    flag = true;
                    continue;
                }
                else if(i == size-1)
                {
                    list.push_back(intervals[i].start);
                    list.push_back(intervals[i].end);
                    list.push_back(newInterval.start);
                    list.push_back(newInterval.end);
                    break;
                }
                list.push_back(intervals[i].start);
                list.push_back(intervals[i].end);
                ++i;
            }
            else if(!flag2 && flag)
            {
                if(newInterval.end < intervals[i].start)
                {
                    list.push_back(newInterval.end);
                    flag2 = true;
                    continue;
                }
                else if(newInterval.end <= intervals[i].end)
                {
                    list.push_back(intervals[i].end);
                    flag2 = true;
                    ++i;
                    continue;
                }
                else if(i == size-1)
                {
                    list.push_back(newInterval.end);
                    break;
                }
                ++i;
            }
            else if(flag && flag2)
            {
                list.push_back(intervals[i].start);
                list.push_back(intervals[i].end);
                ++i;
            }
        }
        size = list.size();
        Interval tmp;
        for(int index=0;index<size;index+=2)
        {
            tmp.start = list[index];
            tmp.end = list[index+1];
            res.push_back(tmp);
        }
        return res;
    }
};

标签

#leetcode #算法