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].

思路一

先对 intervals 按 start 排序，再合并相邻的。

因为 leetcode 好像不支持 sort( v.begin(), v.end(), cmp ); 的三参格式的sort。所以我就写了一个。

/**
 * Definition for an interval.
 * struct Interval {
 *     int start;
 *     int end;
 *     Interval() : start(0), end(0) {}
 *     Interval(int s, int e) : start(s), end(e) {}
 * };
 */
class Solution {
public:
    void mysort(vector<Interval> &intervals)
    {
        int num = intervals.size();
        for(int i=0;i<num-1;i++)
            for(int j=i+1;j<num;j++)
                if(intervals[i].start>intervals[j].start)
                {
                    Interval tmp = intervals[i];
                    intervals[i] = intervals[j];
                    intervals[j] = tmp;
                }
    }

    vector<Interval> merge(vector<Interval> &intervals) {
        // Start typing your C/C++ solution below
        // DO NOT write int main() function
        vector<Interval> result;
        int num = intervals.size();
        if(num<=1)
            return intervals;
        mysort(intervals);
        Interval myinter = intervals[0];
        Interval newinter;
        int i=1;
        while(i<num)
        {
            Interval tmp = intervals[i];
            newinter.start = min(myinter.start,tmp.start);
            if(myinter.end>=tmp.start)  //have interaction
            {       
                if(myinter.end<=tmp.end)
                    newinter.end = tmp.end;
                else
                    newinter.end = myinter.end;
                myinter = newinter;
            }   
            else
            {
                result.push_back(myinter);
                myinter = tmp;
            }
            i++;
        }  
        result.push_back(myinter);
        return result;
    }   
    
};

思路二

这里我们就不需要再排序了，而是用类似于插入排序的思想，依次将第 i 个interval 插入到前面 i-1 个intervals 已经形成的结果intervals 中。

/**
 * Definition for an interval.
 * struct Interval {
 *     int start;
 *     int end;
 *     Interval() : start(0), end(0) {}
 *     Interval(int s, int e) : start(s), end(e) {}
 * };
 */
class Solution {
public:
    vector<Interval> merge(vector<Interval> &intervals) {
        // Start typing your C/C++ solution below
        // DO NOT write int main() function
        vector<Interval> result;
        for(int i=0;i<intervals.size();i++)
        {
            insert(result,intervals[i]);
        }
        return result;
    }
    
    void insert(vector<Interval> &intervals, Interval newInterval) {  
        // Start typing your C/C++ solution below   
        // DO NOT write int main() function   
        int i=0;  
        for(i=0;i<intervals.size();i++)  
        {  
            if(newInterval.start>intervals[i].end)  
                continue ;  
            if(newInterval.end<intervals[i].start)  
            {  
                intervals.insert(intervals.begin()+i,1,newInterval);  
                return ;  
            }  
            else if(newInterval.end<intervals[i].end)  
                 {  
                     intervals[i].start = min(newInterval.start,intervals[i].start);  
                     return ;  
                 }  
                 else  
                 {  
                     newInterval.start = min(newInterval.start,intervals[i].start);  
                     intervals.erase(intervals.begin()+i);  
                     i--;  
                 }  
        }   
        intervals.insert(intervals.begin()+i, 1, newInterval);  
        return ;  
    }  
    
};

 

最新 java

/**
 * 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> intervals) {
        List<Interval> result = new ArrayList<Interval>();
        if(intervals == null || intervals.size() == 0){
            return result;
        }
        Collections.sort(intervals, new Comparator<Interval>() {
        	public int compare(Interval i1, Interval i2) {
        		return i1.start - i2.start;
        	}
        });
        Interval pre = intervals.get(0);
        for(int i=1; i<intervals.size(); i++){
            Interval cur = intervals.get(i);
            if(pre.end < cur.start){
                result.add(pre);
                pre = cur;
            } else {
                Interval merge = new Interval(pre.start, Math.max(pre.end, cur.end));
                pre = merge;
            }
        }
        result.add(pre);
        return result;
    }
}