Merge Intervals 合并区间@LeetCode

采用的是和Insert Interval一样的思想，只不过最开头要先排序一下，用到了java的Collections.sort(List<Interval> list, Comparator<? super Interval> c)

自己实现了一个Comparator的compare方法

http://blog.csdn.net/fightforyourdream/article/details/16876485

package Level4;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;

import Utility.Interval;

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

Discuss


 *
 */
public class S56 {

	public static void main(String[] args) {
		ArrayList<Interval> intervals = new ArrayList<Interval>();
		intervals.add(new Interval(2,3));
		intervals.add(new Interval(3,4));
		intervals.add(new Interval(6,7));
		intervals.add(new Interval(1,10));
		
		
		System.out.println(merge(intervals));
	}

	public static ArrayList<Interval> merge(ArrayList<Interval> intervals) {
		ArrayList<Interval> ret = new ArrayList<Interval>();
		if(intervals.size() == 0){
			return ret;
		}
		
		// 要先按照start的顺序排序一下，这样就能保证全部能merge了！
		Collections.sort(intervals, new Comparator<Interval>() {
			@Override
			public int compare(Interval o1, Interval o2) {
				return o1.start - o2.start;		// 升序排
			}
		});
		
		Interval ref = intervals.get(0);
		for(int i=1; i<intervals.size(); i++){
			Interval cur = intervals.get(i);
			if(cur.end < ref.start){
				ret.add(cur);
			}else if(ref.end < cur.start){
				ret.add(ref);
				ref = cur;
			}else{
				ref = new Interval(Math.min(ref.start, cur.start), Math.max(ref.end, cur.end));
			}
		}
		ret.add(ref);
		return ret;
	}
	
	

}

Second try:

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;

/*
 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].
 */
public class MergeIntervals {

	public static void main(String[] args) {

	}

	public ArrayList<Interval> merge(ArrayList<Interval> intervals) {
		if(intervals==null || intervals.size()==0){
			return intervals;
		}
		Collections.sort(intervals, new Comparator<Interval>() {
			@Override
			public int compare(Interval o1, Interval o2) {
				return o1.start-o2.start;		// 按照start的升序排列
			}
		});
		
		Interval merged = intervals.get(0);
		ArrayList<Interval> ret = new ArrayList<Interval>();
		for(int i=1; i<intervals.size(); i++){
			Interval cur = intervals.get(i);
			if(cur.end < merged.start){
				ret.add(cur);
			}else if(merged.end < cur.start){
				ret.add(merged);
				merged = cur;
			}else{
				int min = Math.min(cur.start, merged.start);
				int max = Math.max(cur.end, merged.end);
				merged = new Interval(min, max);
			}
		}
		
		ret.add(merged);
		return ret;
	}
	
	public static class Interval{
		int start;
		int end;
		public Interval(){
			start = 0;
			end = 0;
		}
		public Interval(int s, int e){
			start = s;
			end = e;
		}
	}
}

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