LeetCode之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.

自己的代码：

ac没有通过，就因为一个很关键的，没有想到要先对list排序

public static List<Interval> merge(List<Interval> intervals) {
	List<Interval> resultList = new ArrayList<Interval>();
	if(intervals == null) return null;
	if(intervals.size() == 0) return resultList;
	
	int start = Integer.MIN_VALUE; int end = Integer.MIN_VALUE;
	
	for(int i=1,j=0;i<=intervals.size();i++) {
		end = i<intervals.size() ? intervals.get(i-1).end : intervals.get(i-1).start;
		start = i<intervals.size() ? intervals.get(i).start :intervals.get(i-1).end;
		
		while(end >= start && i<=intervals.size()) {
			i++;
			end = i<intervals.size() ? intervals.get(i-1).end : intervals.get(i-1).start;
			start = i<intervals.size() ? intervals.get(i).start :intervals.get(i-1).end;
		}
		
		resultList.add(new Interval(intervals.get(j).start,intervals.get(i-1).end) );
		j = i;
	}
	
	return resultList;
}

别人的代码

Runtime: 11 ms, faster than 91.53% of Java online submissions for Merge Intervals.

Memory Usage: 40 MB, less than 95.54% of Java online submissions for Merge Intervals.

class Solution {
    public List<Interval> merge(List<Interval> intervals) {
        if(intervals == null || intervals.size() <2)
            return intervals;
        List<Interval> result = new ArrayList<Interval>();
        Collections.sort(intervals, new Comparator<Interval>(){
            public int compare(Interval i1, Interval i2){
                return i1.start == i2.start ? i1.end - i2.end  : i1.start-i2.start;
            }
        });
        Interval temp = intervals.get(0);
        for(int i=1; i<intervals.size();i++){
            Interval newI = intervals.get(i);
            if(newI.start<=temp.end){
                temp.start = Math.min(newI.start, temp.start);
                temp.end = Math.max(newI.end, temp.end);
            } else{
                result.add(temp);
                temp = newI;
            }
            
        }
        result.add(temp);
        
        return result;
    }
}

小结：

1）主要是Comparator的使用方法

2）Collections.sort(list,Comparator)的方式来对list排序

3）排序完成后的，前后相邻两个区间，只有这样三种情况：

     

将上面的Comparator排序的部分换成：

intervals.sort((i1, i2) -> Integer.compare(i1.start, i2.start));

程序依然能ac，但是：

Runtime: 45 ms, faster than 38.01% of Java online submissions for Merge Intervals.

Memory Usage: 42.2 MB, less than 72.99% of Java online submissions for Merge Intervals.

Python：

# Definition for an interval.
class Interval:
    def __init__(self, s=0, e=0):
        self.start = s
        self.end = e

class Solution(object):
    def merge(self, intervals):
        """
        :type intervals: List[Interval]
        :rtype: List[Interval]
        """
        if len(intervals) == 0: 
            return []
        intervals = sorted(intervals, key = lambda x: x.start)
        
        res = [intervals[0]]
        for n in intervals[1:]:
            if n.start <= res[-1].end: 
                res[-1].end = max(n.end, res[-1].end)
            else: 
                res.append(n)
        return res
        

1）sorted(intervals, key = lambda x: x.start)，key用来指定按照那个字段来排序

      x此时就可以看做intervals中的一个元素，而x.start就是x中元素的start字段

      这里就表示，对intervals这个列表，按照列表元素的start字段进行排序

      ps：如果列表中start字段相同的两个元素，在排序时，就会维持原样不发生位置变化；

2）res[-1]：取列表最后一个元素的小技巧

3）因为已经按照start排过序了，所以相邻两个区间只有这三种情况

      

测试：

        
if __name__ == "__main__":
    print("---------")
    
    a1 = Interval(1,3)
    a2 = Interval(2,6)
    a3 = Interval(8,10)
    a4 = Interval(15,18)
    
    intervals = [a1,a2,a3,a4]

    s = Solution()
    
    resultList = s.merge(intervals)
    
    for li in resultList:
        print(li.start,li.end)
    
    print("---------++")