#57 Insert Interval

最新推荐文章于 2020-11-04 20:53:35 发布

yoyooyooo

最新推荐文章于 2020-11-04 20:53:35 发布

阅读量126

点赞数

分类专栏： leetcode 文章标签： java leetcode

本文链接：https://blog.csdn.net/YY_Tina/article/details/108504238

版权

leetcode 专栏收录该内容

188 篇文章 0 订阅

订阅专栏

Description

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

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

解题思路

以题目中给出的example为例，目标其实是要找到newInterval在旧序列中的插入位置。

当找到了插入位置之后，将两个位置之间的其他间隔删除，就能做到插入新序列的操作

在这里插入图片描述
像上图中，得到插入位置1之前和2之前，啧删除位于两者之间的位置1

需要注意的点

空数组出现的情况

input:[[]], [5, 7]

重复数据出现的情况

input:[[1, 3], [5, 7]], [3, 4]

点间隔出现的情况

input:[[5, 7]], [0,0]

代码

class Solution {
    public int[][] insert(int[][] intervals, int[] newInterval) {
    	# 记录插入位置
        int i, j;
        int len = intervals.length;
		
		# 处理空数组 
        if(len == 0){
            int[][] answer = new int[1][2];
            answer[0][0] = newInterval[0];
            answer[0][1] = newInterval[1];
            return answer;
        }
        
        # 寻找插入位置
        for(i = 0; i < 2 * len;){
            if((i >= 2 * len) || (intervals[i / 2][0] > newInterval[0])){
                break;
            }
            i++;
            if((i >= 2 * len) || (intervals[i / 2][1] > newInterval[0])){
                break;
            }
            i++;
        }
        for(j = i - 1; j < 2 * len;){
            if((j >= 2 * len) || (intervals[j / 2][0] > newInterval[1])){
                break;
            }
            j++;
            if((j >= 2 * len) || (intervals[j / 2][1] > newInterval[1])){
                break;
            }
            j++;
        }
        
        # 防止因为i - 1造成的j = -1
        j = j < 0? 0: j;

		# temp数组用于存放保留的间隔字段（只有当插入位置位于两个间隔之间的时候才需要更新数组，如[1, 3], [6, 9]插入[2, 5]时候，2位于[1, 3]中间，不需要更新，5位于3], [6中间，需要更新）
        int k = 0;
        List<Integer> temp = new ArrayList<Integer>();
        while(k < i){
            temp.add(intervals[k / 2][k % 2]);
            k++;
        }
        if(i % 2 == 0){
            temp.add(newInterval[0]);
        }
        if(j % 2 == 0){
            temp.add(newInterval[1]);
        }
        k = j;
        while(k < 2 * len){
            temp.add(intervals[k / 2][k % 2]);
            k++;
        }
        
        # 去除可以重叠的间隔，但注意点间隔的保留（如[1, 3], [3, 4]可合并为[1, 4]， 但[0, 0], [2, 4]不能合并为[2, 4]）
        for(i = 0; i < temp.size() - 1; i++){
            if((temp.get(i) >= temp.get(i + 1)) && (i % 2 == 1)){
                temp.remove(i);
                temp.remove(i);
                i--;
            }
        }
        
        # 根据去重后的数组重现间隔 
        int length = temp.size() / 2;
        int[][] answer = new int[length][2];
        for(i = 0; i < length; i ++){
            answer[i][0] = temp.get(2 * i);
            answer[i][1] = temp.get(2 * i + 1);
        }
        
        return answer;
    }
}