【LeetCode】56 合并区间

最新推荐文章于 2025-08-23 13:25:16 发布

AsceticW

最新推荐文章于 2025-08-23 13:25:16 发布

阅读量133

点赞数

CC 4.0 BY-SA版权

分类专栏： LeetCode

本文链接：https://blog.youkuaiyun.com/qq_36269372/article/details/83987084

LeetCode 专栏收录该内容

25 篇文章

订阅专栏

本文深入探讨了区间合并算法，提供两种实现思路。一种是通过遍历区间并合并重叠部分，时间复杂度为O(n^2)；另一种是先排序再合并，效率更高，时间复杂度为O(n)。通过具体示例，展示了如何将重叠的区间有效合并。

给出一个区间的集合，请合并所有重叠的区间。
示例 1:
输入: [[1,3],[2,6],[8,10],[15,18]]
输出: [[1,6],[8,10],[15,18]]
解释: 区间[1,3] 和 [2,6] 重叠, 将它们合并为 [1,6].
示例 2:
输入: [[1,4],[4,5]]
输出: [[1,5]]
解释: 区间 [1,4] 和 [4,5] 可被视为重叠区间。

解题思路
1 比较简单的思路是对每个区间进行遍历，将和它重叠的区间合并并删除相应区间。时间复杂度是O(n^2)。
2 第一种思路情况较多，细枝末节很容易出错。第二种思路是将起点和终点分别排序，若第n+1个起点大于第n个终点，那么就可以确定一个合并后的区间。时间复杂度是O(n)。
3 下面给出了两种思路的实现。

第一种思路：

/**
 * 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; }
 * }
 */
class Solution {
    public List<Interval> merge(List<Interval> intervals) {
        int i = 0;
        while (i < intervals.size()){
            Interval i1 = intervals.get(i);
            boolean flag = false;
            int j = 0;
            while (j < intervals.size()){
                if(j == i){
                    j++;
                    continue;
                }
                Interval i2 = intervals.get(j);          
                if (i1.start == i2.start){
                    if (i1.end < i2.end){
                        i1.end = i2.end;
                        intervals.set(i,i1);
                        flag = true;
                    }
                    intervals.remove(j);
                    j--;
                }
                else if (i1.start < i2.start){
                    if (i1.end >= i2.end){
                        intervals.remove(j);
                        j--;
                    }
                    else if (i1.end >= i2.start){
                        i1.end = i2.end;
                        intervals.set(i,i1);
                        flag = true;
                        intervals.remove(j);
                        j--;
                    }
                }
                else if (i1.start > i2.start){
                    if (i2.end >= i1.end){
                        i1.start = i2.start;
                        i1.end = i2.end;
                        intervals.set(i,i1);
                        flag = true;
                        intervals.remove(j);
                        j--;
                    }
                    else if (i2.end >= i1.start){
                        i1.start = i2.start;
                        intervals.set(i,i1);
                        flag = true;
                        intervals.remove(j);
                        j--;
                    }
                }   
                j++;
            }
            if (!flag)
                i++;            
        }
        return intervals;
    }
}

第二种思路：

/**
 * 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; }
 * }
 */
class Solution {
    public List<Interval> merge(List<Interval> intervals) {
        int size = intervals.size();
        int[] starts = new int[size];
        int[] ends = new int[size];
        List<Interval> result = new ArrayList<>();
        
        for (int i = 0;i < size;i++){
            starts[i] = intervals.get(i).start;
            ends[i] = intervals.get(i).end;
        }
        
        Arrays.sort(starts);
        Arrays.sort(ends);
        
        for (int i = 0, j = 0;i < size;i++){
            if (i == size - 1||starts[i+1] > ends[i]){
                result.add(new Interval(starts[j], ends[i]));
                j = i+1;
            }
        }
        
        return result;
    }
}