Insert Interval & Merge Intervals

Insert Intervals

Given a non-overlapping interval list which is sorted by start point.

Insert a new interval into it, make sure the list is still in order and non-overlapping (merge intervals if necessary).

Example

Insert [2, 5] into [[1,2], [5,9]], we get [[1,9]].

Insert [3, 4] into [[1,2], [5,9]], we get [[1,2], [3,4], [5,9]].

分析：

Create a new array list, insert the smaller interval in the new array and use a counter to keep track of the total number of smaller intervals. If we find an interval overlapping with the new one, we need to change the start and end.

 class Solution {
     public int[][] insert(int[][] intervals, int[] newInterval) {
         List<int[]> resultList = new ArrayList<>();
         boolean hasInserted = false;
         for (int[] interval : intervals) {
             if (interval[] > newInterval[]) {
                 if (!hasInserted) {
                     resultList.add(newInterval);
                     hasInserted = true;
                 }
                 resultList.add(interval);
             } else if (interval[] < newInterval[]) {
                 resultList.add(interval);
             } else {
                 newInterval[] = Math.min(newInterval[], interval[]);
                 newInterval[] = Math.max(newInterval[], interval[]);
             }
         }

         if (!hasInserted) {
             resultList.add(newInterval);
         }

         return resultList.toArray(new int[][]);
     }
 }

Merge Intervals

Given a collection of intervals, merge all overlapping intervals.

Example

Given intervals => merged intervals:

[                     [
  [1, 3],               [1, 6],
  [2, 6],      =>       [8, 10],
  [8, 10],              [15, 18]
  [15, 18]            ]
]

Analyze:

Sort first, then merge intervals if they overlap.

 /**
  * Definition for an interval.
  * public class Interval {
  *     int start;
  *     int end;
  *     Interval() { start = 0; end = 0; }
  *     Interval(int s, int e) { start = s; end = e; }
  * }
  */
 public class Solution {
     public List<Interval> merge(List<Interval> list) {
         if (list == null || list.size() <= ) return list;

         // Collections.sort(list, (Interval a, Interval b) -> a.start - b.start);
         list.sort((i1, i2) -> Integer.compare(i1.start, i2.start));

         for (int i = ; i < list.size(); i++) {
             if (overlap(list.get(i), list.get(i - ))) {
                 list.get(i - ).start = Math.min(list.get(i).start, list.get(i - ).start);
                 list.get(i - ).end = Math.max(list.get(i).end, list.get(i - ).end);
                 list.remove(i);
                 i--;
             }
         }
         return list;
     }

     boolean overlap(Interval i1, Interval i2) {
         return Math.max(i1.start, i2.start) <= Math.min(i1.end, i2.end);
     }
 }