Leetcode 56. Merge Intervals [medium][java]

Given a collection of intervals, merge all overlapping intervals.

Example

Ignored Cases

Note

1. The original array is not sorted, so maybe the latter intervals should put in front of the previous ones.

Solution 1
Consideration

1. we can sort the original intervals first.
2. Then, we check if the intervals overlaps.

Time complexity: O(n^2+n), space complexity: O(4n).

class Solution {
    public int[][] merge(int[][] intervals) {
        if(intervals == null || intervals.length <= 1)
            return intervals;
        
        //sort the array
        for(int i = 0; i < intervals.length; i++) {
            int min = i;
            for(int j = i+1; j < intervals.length; j++) {
                if(intervals[j][0] < intervals[min][0]) {
                    min = j;
                } else if(intervals[j][0] == intervals[min][0] && intervals[j][1] < intervals[min][1])
                    min = j;
            }
            swap(intervals, i, min);
        }
        
        List<Integer> startIndex = new ArrayList();
        List<Integer> endIndex = new ArrayList();
        int start = intervals[0][0];
        int end = intervals[0][1];
        for(int i = 1; i < intervals.length; i++) {
            if(intervals[i][0] > end) {
                startIndex.add(start);
                endIndex.add(end);
                start = intervals[i][0];
                end = intervals[i][1];
            } else {
                if(intervals[i][0] < start)
                    start = intervals[i][0];
                if(intervals[i][1] > end)
                    end = intervals[i][1];
            }
        }
        startIndex.add(start);
        endIndex.add(end);
        
        int[][] res = new int[startIndex.size()][2];
        for(int i = 0; i < res.length; i++) {
            res[i][0] = startIndex.get(i);
            res[i][1] = endIndex.get(i);
        }
        return res;
    }
    
    private void swap(int[][] intervals, int i, int j) {
        int x = intervals[i][0];
        int y = intervals[i][1];
        intervals[i][0] = intervals[j][0];
        intervals[i][1] = intervals[j][1];
        intervals[j][0] = x;
        intervals[j][1] = y;
    }
}

Solution 2: use Arrays.sort() function

class Solution {
    public int[][] merge(int[][] intervals) {
        if(intervals == null || intervals.length <= 1)
            return intervals;
        
        Arrays.sort(intervals, (a, b) -> Integer.compare(a[0], b[0]));
        HashMap<Integer, Integer> mergedHashList=new HashMap<>();
		
		mergedHashList.put(intervals[0][0], intervals[0][1]);
		int lastKey=intervals[0][0], lastValue=intervals[0][1];
		for(int i=1; i<intervals.length; i++) {
			
				if(intervals[i][0] <= lastValue) {
                    lastValue=(lastValue >= intervals[i][1]) ? lastValue: intervals[i][1];
					mergedHashList.put(lastKey, lastValue);
                    					
				}
				else {
					mergedHashList.put(intervals[i][0], intervals[i][1]);
					lastKey=intervals[i][0];
					lastValue=intervals[i][1];
					
				}
			
		}
        int[][] returnArray=new int[mergedHashList.size()][2];
        int count = 0;
        for(Map.Entry<Integer, Integer> entry: mergedHashList.entrySet()) {
            returnArray[count][0] = entry.getKey();
            returnArray[count][1] = entry.getValue();
            count++;
        }
        return returnArray;
    }
}

References

1. https://leetcode.com/problems/merge-intervals/discuss/339714/Java-another-simple-solution