LeetCode057 Insert Interval(Conner case is very trivia)

Input: intervals = [[1,3],[6,9]], newInterval = [2,5]
Output: [[1,5],[6,9]]
You may assume that the intervals were initially sorted according to their start times.

this is a really simple problem, and do not start hard.

and once you understand this is a simple problem, the rest is really simple.

but the following code is wrong in some cases. why?

class Solution {
    public int[][] insert(int[][] intervals, int[] newInterval) {
        List<int[]> res = new ArrayList<>();
        int start = newInterval[0];
        int end = newInterval[1];
        if (intervals == null || intervals.length == 0) {
            return new int[][]{newInterval};
        }
        
        int i = 0;
        while (i < intervals.length && intervals[i][1] < start) {
            res.add(intervals[i]);
            i++;
        }
        int[] mergeInterval = new int[2];
        while (i < intervals.length && intervals[i][0] <= end) {
            start = Math.min(start, intervals[i][0]);
            end = Math.max(end, intervals[i][1]);
            mergeInterval = new int[]{start, end};
            i++;
        }
        res.add(mergeInterval);
        while (i < intervals.length) {
            res.add(intervals[i++]);
        }
        int[][] output = new int[res.size()][2];
        int j = 0;
        for (int[] item: res) {
            output[j++] = item;
        }
        return output;
    }
}

because after the first while loop, i might reach the end of intervals. but we did not return immedidately. and we might add(0,0) in the tail of our res. why? because we initialize mergeInterval = new int[2]; and although we didn’t enter the next while loop, we still add(mergeInterval)

and I have a sense that this problem happens many times before, so it’s better if not use multiple consecutive while.

class Solution {
    public int[][] insert(int[][] intervals, int[] newInterval) {
        List<int[]> res = new ArrayList<>();
        int start = newInterval[0];
        int end = newInterval[1];
        
        
        for (int[] interval: intervals) {
            if (newInterval == null || interval[1] < start) {
                res.add(interval);
            } else if (interval[0] > end) {
                res.add(newInterval);
                res.add(interval);
            } else {
                newInterval[0] = Math.min(newInterval[0], interval[0]);
                newInterval[1] = Math.max(newInterval[1], interval[1]);
            }
        }
        int[][] output = new int[res.size()][2];
        int i = 0;
        for (int[] item: res) {
            output[i++] = item;
        }
        return output;
    }
}

however, there still have conner case that not considered. when intervals is empty and newInterval is not empty.
and this conner case is really frustrating, because after you add that conner case, you will have many other problems.
and the better thing fot us to solve this conner case is to:

class Solution {
    public int[][] insert(int[][] intervals, int[] newInterval) {
        List<int[]> res = new ArrayList<>();
        
        int start = newInterval[0];
        int end = newInterval[1];
        
        for (int[] interval: intervals) {
            if (newInterval == null || interval[1] < start) {
                res.add(interval);
            } else if (interval[0] > end) {
                res.add(newInterval);
                res.add(interval);
                newInterval = null;
            } else {
                newInterval[0] = Math.min(newInterval[0], interval[0]);
                newInterval[1] = Math.max(newInterval[1], interval[1]);
            }
        }
        if (newInterval != null) {
            res.add(newInterval);
        }
        int[][] output = new int[res.size()][2];
        int i = 0;
        for (int[] item: res) {
            output[i++] = item;
        }
        return output;
    }
}