LeetCode 刷题记录57. 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:

Input: intervals = [[1,3],[6,9]], newInterval = [2,5]
Output: [[1,5],[6,9]]
Example 2:

Input: intervals = [[1,2],[3,5],[6,7],[8,10],[12,16]], newInterval = [4,8]
Output: [[1,2],[3,10],[12,16]]
Explanation: Because the new interval [4,8] overlaps with [3,5],[6,7],[8,10].
NOTE: input types have been changed on April 15, 2019. Please reset to default code definition to get new method signature.
解法1：
首先考虑本题中列表是有序的
首先考虑newInterval 的最小值都大于intervals中某个列表的最大值，这样我们只需要先加入intervals 中的列表即可
另一种情况newInterval 的最大值都小于intervals中某个列表的最小值，这样我们只需要先加入newInterval
如果newInterval 的最大值都大于等于intervals中某个列表的最小值，这时候我们需要合并列表
新列表的最小值是两者中的最小值，新列表的最大值是两者中的最大值，然后继续循环，看是否满足合并条件（newInterval 的最大值都大于等于intervals中某个列表的最小值）
最后我们需要查看intervals的列表是否添加完，如果没有添加intervals中的剩余列表
例：intervals = [[1,2],[3,5],[6,7],[8,10],[12,16]], newInterval = [4,8]
cur 指向intervals列表的下标，初始为0
首先第一个列表的最大值都小于newInterval，说明我们需要将它添到我们的结果中res = [[1,2]]
第二个列表不满足该循环条件，检查是否满足合并条件newInterval 的最大值都大于等于intervals中某个列表的最小值，3 <= 8
合并列表：最小值为两者中的最小值3，最大值为两者中的最大值8 [3,8]
然后继续查看第三个列表和新的列表是否满足合并条件，6 <= 8
合并列表：最小值为两者中的最小值3，最大值为两者中的最大值8 [3,8]
然后继续查看第四个列表和新的列表是否满足合并条件，8 <= 8
合并列表：最小值为两者中的最小值3，最大值为两者中的最大值10 [3,10]
然后继续查看第四个列表和新的列表不满足合并条件，12 > 10
这时候需要将我们的合并的列表加入到结果集中 res = [[1,2],[3,10]]
最后我们需要查看intervals的列表是否添加完，如果没有添加intervals中的剩余列表res = [[1,2],[3,10],[12,16]]
C++：

class Solution {
public:
    vector<vector<int>> insert(vector<vector<int>>& intervals, vector<int>& newInterval) {
        vector<vector<int>> res;
        int n = intervals.size();
        int cur = 0;
        while(cur < n && intervals[cur][1] < newInterval[0]){
            res.push_back(intervals[cur++]);
        }
        while(cur < n && intervals[cur][0] <= newInterval[1]){
            newInterval[0] = min(intervals[cur][0],newInterval[0]);
            newInterval[1] = max(intervals[cur][1],newInterval[1]);
            cur++;
        }
        res.push_back(newInterval);
        while(cur < n){
            res.push_back(intervals[cur++]);
        }
        return res;
    }
};

java：
最开始的版本方法签名是list，但是最新的代码改成了int[][],与list相比，我们不好确定二维数组的初始大小，因为它插入后数目可能不变，因为合并了列表，也有可能增加了一个，没有合并列表，所以我们还是采用List<int[]>，最后返回时再通过 return res.toArray(new int[res.size()][]);转成二维数组

class Solution {
    public int[][] insert(int[][] intervals, int[] newInterval) {
        List<int[]> res = new ArrayList<>();
        int n = intervals.length;
        int cur = 0;
        while(cur < n && intervals[cur][1] < newInterval[0]){
            res.add(intervals[cur++]);
        }
        while(cur < n && intervals[cur][0] <= newInterval[1]){
            newInterval[0] = Math.min(intervals[cur][0],newInterval[0]);
            newInterval[1] = Math.max(intervals[cur][1],newInterval[1]);
            cur++;
        }
        res.add(newInterval);
        while(cur < n){
            res.add(intervals[cur++]);
        }
        return res.toArray(new int[res.size()][]);
    }
}

class Solution(object):
    def insert(self, intervals, newInterval):
        """
        :type intervals: List[List[int]]
        :type newInterval: List[int]
        :rtype: List[List[int]]
        """
        cur = 0
        res = []
        n = len(intervals)
        while cur < n and intervals[cur][1] < newInterval[0]:
            res.append(intervals[cur])
            cur += 1
        while cur < n and intervals[cur][0] <= newInterval[1]:
            newInterval[0] = min(intervals[cur][0],newInterval[0])
            newInterval[1] = max(intervals[cur][1],newInterval[1])
            cur += 1
        
        res.append(newInterval)
        while cur < n:
            res.append(intervals[cur])
            cur += 1
        
        return res;

解法2：
与解法1类似
这次我们遍历intervals，与解法1不同，用i记录intervals的位置，用cur记录插入的位置
首先考虑newInterval 的最小值都大于intervals中某个列表的最大值，这样我们只需要先加入intervals 中的列表即可，插入的位置要更新
另一种情况newInterval 的最大值都小于intervals中某个列表的最小值，这样我们只需要先加入intervals中的列表即可，此时插入的位置已经固定了
如果newInterval 的最大值都大于等于intervals中某个列表的最小值，这时候我们需要合并列表
遍历完成后，根据插入的位置加入newInterval
c++：

class Solution {
public:
    vector<vector<int>> insert(vector<vector<int>>& intervals, vector<int>& newInterval) {
        vector<vector<int>> res;
        int n = intervals.size();
        int cur = 0;
        for(int i = 0; i < n; i++){
            if(intervals[i][1] < newInterval[0]){
                res.push_back(intervals[i]);
                cur++;
            } else if(intervals[i][0] > newInterval[1]){
                res.push_back(intervals[i]);
            } else{
                newInterval[0] = min(intervals[i][0],newInterval[0]);
                newInterval[1] = max(intervals[i][1],newInterval[1]);
            }
        }
        
        res.insert(res.begin() + cur,newInterval);
        
        return res;
    }
};

java：

class Solution {
    public int[][] insert(int[][] intervals, int[] newInterval) {
        List<int[]> res = new ArrayList<>();
        int n = intervals.length;
        int cur = 0;
        for(int i = 0; i < n; i++){
            if(intervals[i][1] < newInterval[0]){
                res.add(intervals[i]);
                cur++;
            } else if(intervals[i][0] > newInterval[1]){
                res.add(intervals[i]);
            } else{
                newInterval[0] = Math.min(intervals[i][0],newInterval[0]);
                newInterval[1] = Math.max(intervals[i][1],newInterval[1]);
            }
        }
        
        res.add(cur,newInterval);
        return res.toArray(new int[res.size()][]);
    }
}

python：

class Solution(object):
    def insert(self, intervals, newInterval):
        """
        :type intervals: List[List[int]]
        :type newInterval: List[int]
        :rtype: List[List[int]]
        """
        cur = 0
        res = []
        for interval in intervals:
            if interval[1] < newInterval[0]:
                res.append(interval)
                cur += 1
            elif interval[0] > newInterval[1]:
                res.append(interval)
            else:
                newInterval[0] = min(interval[0],newInterval[0])
                newInterval[1] = max(interval[1],newInterval[1])
        
        res.insert(cur, newInterval)
       
        
        return res