Leetcode: Merge Intervals

Given a collection of intervals, merge all overlapping intervals.

For example,

Given [1,3], [2,6], [8,10], [15,18],

return [1,6], [8,10], [15,18].

Runtime Analysis:

Since we are given a set of n intervals, to combine them, we need to at least traverse each interval once, thus taking O(n) time where n is the number of intervals. The lower bound of our algorithm must at least be (Omega) Ω(n). 
  
One possible approach would be to sort the list of intervals by:

1. Starting Value
2. Ending Value

In this case, you would get a list of sorted intervals by their starting values. To sort the intervals, you could: 

1. Create your own interval class implementing the Comparable Interface, and providing the appropriate compareTo() method
2. Create a custom Comparator Class implementing the Compare() method. 

Then, simple call sort() on the list (providing your Comparator if you chose (2)). 

One approach could be to visit every possible consecutive pair of intervals in the list and try to combine the pair if they overlap. In a list with N intervals, we have N-1 possible pairs to combine. However, after you traversed each consecutive pair, if you combined at least 1 pair during that loop, it is possible that the new interval made could also overlap with its neighbor, so you would have to continue to loop N-2 times. In the worse case, all intervals overlap with each other or and thus taking O(n2) time.

A quadratic runtime, unfortunately, is not fast enough in this case. There is a better O(n) approach. 

Runtime: O(n)




Algorithmic Approach:

Normally, without sorting the intervals by start, we would have 4 basic cases of intersection:

However, after sorting, we are left with Diagrams (2) and (4) on the right hand side. In both cases, we can apply the following algorithm:

Given interval A, B intersect, our new interval is: [A_start, Max(A_end, B_end)]

The final step would be to determine if our intervals did overlap. 

Given intervals P and D, we know that the intervals intersect if fd < kp. This condition tells us if we need to merge our intervals or not.

Java Code: 

/**
 * 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; }
 * }
 */
 
class IntervalComparator implements Comparator<Interval>{
    public int compare(Interval a, Interval b){
        if(a.start < b.start){
            return -1;
        }else if(a.start > b.start){
            return 1;
        }else{
            if(a.end < b.end){
                return -1;
            }else if(a.end > b.end){
                return 1;
            }else{
                return 0;
            }
        }
    }
     
 }
 
public class Solution {
    
    public List<Interval> merge(List<Interval> intervals) {
        
        List<Interval> list = new ArrayList<Interval>();
        
        if(intervals.size() == 0)
            return list;
        
        Collections.sort(intervals, new IntervalComparator());
        
        list.add(intervals.get(0));
        
        for(int i = 1; i < intervals.size(); i++){
            if(intervals.get(i).start <= list.get(list.size()-1).end){
                list.get(list.size()-1).end = Math.max(intervals.get(i).end, list.get(list.size()-1).end);
            }else{
                list.add(intervals.get(i));
            }
        }
        return list;
    }
}