LeetCode-Merge Intervals

最新推荐文章于 2021-08-03 03:36:41 发布

disappearedgod

最新推荐文章于 2021-08-03 03:36:41 发布

阅读量758

点赞数

分类专栏：排序 LeetCode 链表文章标签： LeetCode List Sort

本文链接：https://blog.csdn.net/disappearedgod/article/details/39270243

版权

LeetCode 同时被 3 个专栏收录

94 篇文章 0 订阅

订阅专栏

链表

18 篇文章 0 订阅

订阅专栏

排序

5 篇文章 0 订阅

订阅专栏

作者：disappearedgod

文章出处：http://blog.csdn.net/disappearedgod/article/details/39270243

时间：2014-9-14

题目

Merge Intervals

Total Accepted: 15563 Total Submissions: 74645 My Submissions

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

想法

代码

/**
 * 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) {
        if(intervals == null )
            return intervals;
        //List<Interval> retlist = new List<Interval>();
        List<Interval> retlist = sort(intervals);
        for(int i = 1; i < retlist.size(); i++){
            if(merge(retlist,i-1,i))
               i--;
        }
        return retlist;
    }
    public List<Interval> sort(List<Interval> intervals){
        List<Interval> retlist = new LinkedList<Interval>();
        while(!intervals.isEmpty()){
            int minPos = 0;
            int min = Integer.MAX_VALUE;
            for(int i = 0; i < intervals.size(); i++){
                Interval tmp = intervals.get(i);
                if(tmp.start < min){
                    min = tmp.start;
                    minPos = i;
                }
            }
            retlist.add(intervals.get(minPos));
            intervals.remove(minPos);
        }
        return retlist;
    }
    public boolean merge(List<Interval> intervals, int i, int j){
        Interval a = intervals.get(i);
        Interval b = intervals.get(j);
        if(a.end < b.start){
            return false;
        }
        int low = Math.min(a.start, b.start);
        int high = Math.max(a.end, b.end);
        a.start = low;
        a.end = high;
        intervals.remove(j);
        return true;
    }
}

调用Collection减少时间

/**
 * 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) {
        if(intervals == null )
            return intervals;
        //List<Interval> retlist = new List<Interval>();

        Collections.sort(intervals, new IntervalComparator());
        for(int i = 1; i < intervals.size(); i++){
            if(merge(intervals,i-1,i))
               i--;
        }
        return intervals;
    }
    class IntervalComparator implements Comparator<Interval>{
        public int compare(Interval a, Interval b){
            return a.start - b.start;
        }
    }
    public boolean merge(List<Interval> intervals, int i, int j){
        Interval a = intervals.get(i);
        Interval b = intervals.get(j);
        if(a.end < b.start){
            return false;
        }
        int low = Math.min(a.start, b.start);
        int high = Math.max(a.end, b.end);
        a.start = low;
        a.end = high;
        intervals.remove(j);
        return true;
    }
}

他人代码

/**
 * 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 ArrayList<Interval> merge(ArrayList<Interval> intervals) {
 
		if (intervals == null || intervals.size() <= 1)
			return intervals;
 
		// sort intervals by using self-defined Comparator
		Collections.sort(intervals, new IntervalComparator());
 
		ArrayList<Interval> result = new ArrayList<Interval>();
 
		Interval prev = intervals.get(0);
		for (int i = 1; i < intervals.size(); i++) {
			Interval curr = intervals.get(i);
 
			if (prev.end >= curr.start) {
				// merged case
				Interval merged = new Interval(prev.start, Math.max(prev.end, curr.end));
				prev = merged;
			} else {
				result.add(prev);
				prev = curr;
			}
		}
 
		result.add(prev);
 
		return result;
	}
}
 
class IntervalComparator implements Comparator<Interval> {
	public int compare(Interval i1, Interval i2) {
		return i1.start - i2.start;
	}
}