LeetCode - Merge Intervals

最新推荐文章于 2021-01-03 22:31:30 发布

原创最新推荐文章于 2021-01-03 22:31:30 发布 · 210 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#array #sort

leetcode 专栏收录该内容

127 篇文章

订阅专栏

本文介绍了如何在LeetCode上解决区间合并问题，包括两种方法：一种是使用插入排序进行合并，时间复杂度为O(n^2)；另一种是先对区间进行排序，然后在原区间列表中进行合并，时间复杂度为O(n*logn)。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

https://leetcode.com/problems/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].

这道题可以直接用之前 Insert Interval 那道题的代码，就是新建一个list，然后把原来的interval一个一个insert进去就行。代码如下：

public class Solution {
    public List<Interval> merge(List<Interval> intervals) {
        List<Interval> rst = new LinkedList<Interval>();
        for(int i=0; i<intervals.size(); i++){
            insert(rst, intervals.get(i));
        }
        return rst;
    }
    
    public List<Interval> insert(List<Interval> intervals, Interval newInterval) {
        int i = 0;
        while(i<intervals.size()){
            if(newInterval.end < intervals.get(i).start) 
            {
                intervals.add(i,newInterval);
                break;
            }
            else if(newInterval.start > intervals.get(i).end){
                if(i==(intervals.size()-1)){
                    intervals.add(i+1, newInterval);
                    break;
                }
                else{
                    i++;
                    continue;
                }
            } 
            else{
                Interval tmp = intervals.remove(i);
                tmp.start = Math.min(tmp.start, newInterval.start);
                tmp.end = Math.max(tmp.end, newInterval.end);
                newInterval = tmp;
            }
        }
        
        if(i==intervals.size()) intervals.add(newInterval);
        return intervals;
    }
}

但是这种方法时间复杂度是O(n^2)，所以另一个方法是先给所有interval排序，再merge，这样merge过程只需要O(n)就行了，但排序需要O(n*lgn)，所以总时间应该是O(n*lgn)。排序是用的重载Comparator函数。排序后就不需要重新定义一个List，直接在原来List基础上改就行了。代码如下：

public class Solution {
    public List<Interval> merge(List<Interval> intervals) {
        if(intervals.size()==0) return intervals;
        
        Collections.sort(intervals, new Comparator<Interval>(){
            @Override
            public int compare(Interval o1, Interval o2){
                return o1.start-o2.start;
            }
        });
        
        int i = 0;
        while(i < (intervals.size()-1)){
            Interval current = intervals.get(i);
            Interval next = intervals.get(i+1);
            if(next.start>current.end) i++;
            else{
                intervals.remove(i+1);
                current.start = Math.min(current.start, next.start);
                current.end = Math.max(current.end, next.end);
            }
        }
        return intervals;
    }
}

注意这里sort的一个参数是Comparator类的对象，并且在块内直接初始化了这个Comparator类，重载了这个类的compare函数。这部分的代码很不熟，要多写几遍。