[LC] 56. Merge Intervals

Given a collection of intervals, merge all overlapping intervals.

Example 1:

Input: [[1,3],[2,6],[8,10],[15,18]]
Output: [[1,6],[8,10],[15,18]]
Explanation: Since intervals [1,3] and [2,6] overlaps, merge them into [1,6].

Example 2:

Input: [[1,4],[4,5]]
Output: [[1,5]]
Explanation: Intervals [1,4] and [4,5] are considered overlapping.

NOTE: input types have been changed on April 15, 2019. Please reset to default code definition to get new method signature.

 

Solution 1:

class Solution {
    public int[][] merge(int[][] intervals) {
        List<int[]> res = new ArrayList<>();
        if (intervals.length == 0) {
            return new int[][] {};
        }
        Arrays.sort(intervals, (a, b) -> (a[0] - b[0]));
        int start = intervals[0][0];
        int end = intervals[0][1];
        for (int[] interval: intervals) {
            if (interval[0] <= end) {
                end = Math.max(end, interval[1]);
            } else {
                res.add(new int[]{start, end});
                start = interval[0];
                end = interval[1];
            }
        }
        // need to add back the last tuple
        res.add(new int[]{start, end});
        return res.toArray(new int[][] {});
    }
}

 

class Solution {
    public int[][] merge(int[][] intervals) {
        if (intervals == null || intervals.length == 0 || intervals[0].length == 0) {
            return intervals;
        }
        List<int[]> list = new ArrayList<>();
        int[] startArr = new int[intervals.length];
        int[] endArr = new int[intervals.length];
        for (int i = 0; i < intervals.length; i++) {
            startArr[i] = intervals[i][0];
            endArr[i] = intervals[i][1];
        }
        Arrays.sort(startArr);
        Arrays.sort(endArr);
        int start = startArr[0];
        int end = endArr[0];
        for (int i = 1; i < intervals.length; i++) {
            if (startArr[i] <= end) {
                end = endArr[i];
            } else {
                list.add(new int[]{start, end});
                start = startArr[i];
                end = endArr[i];
            }
        }
        list.add(new int[]{start, end});
        int[][] res = new int[list.size()][2];
        int count = 0;
        for (int i = 0; i < list.size(); i++) {
            res[i][0] = list.get(i)[0];
            res[i][1] = list.get(i)[1];
        }
        return res;
    }
}

 

 

Solution 2:

/**
 * Definition of Interval:
 * public class Interval {
 *     int start, end;
 *     Interval(int start, int end) {
 *         this.start = start;
 *         this.end = end;
 *     }
 * }
 */

public class Solution {
    /**
     * @param intervals: interval list.
     * @return: A new interval list.
     */
    public List<Interval> merge(List<Interval> intervals) {
        // write your code here
        if (intervals == null || intervals.size() <= 1) {
            return intervals;
        }
        List<Interval> res = new ArrayList<>();
        // Collections work on List while Arrays work on array
        Collections.sort(intervals, new Comparator<Interval>() {
            @Override
            public int compare(Interval a, Interval b) {
                return a.start - b.start;
            }
        });
        
        Interval pre = null;
        for (Interval cur: intervals) {
            if (pre == null || cur.start > pre.end) {
                res.add(cur);
                pre = cur;
            } else {
                pre.end = Math.max(cur.end, pre.end);
            }
        }
        return res;
    }
}