排序题目：合并区间

题目

标题和出处

标题：合并区间

出处：56. 合并区间

难度

5 级

题目描述

要求

给定区间数组 $\text{intervals}$，其中 ${\text{intervals[i] = [start}}_{\text{i}}{\text{, end}}_{\text{i}}\text{]}$，合并所有重叠的区间，并返回一个不重叠的区间数组，该数组覆盖输入中的所有区间。

示例

示例 1：

输入：$\text{intervals = [[1,3],[2,6],[8,10],[15,18]]}$
输出：$\text{[[1,6],[8,10],[15,18]]}$
解释：区间 $\text{[1,3]}$ 和 $\text{[2,6]}$ 重叠, 将它们合并为 $\text{[1,6]}$。

示例 2：

输入：$\text{intervals = [[1,4],[4,5]]}$
输出：$\text{[[1,5]]}$
解释：区间 $\text{[1,4]}$ 和 $\text{[4,5]}$ 可被视为重叠区间。

数据范围

• $\text{1}\le \text{intervals.length}\le {\text{10}}^{\text{4}}$
• $\text{intervals[i].length}=\text{2}$
• $\text{0}\le {\text{start}}_{\text{i}}\le {\text{end}}_{\text{i}}\le {\text{10}}^{\text{4}}$

解法

思路和算法

为了合并数组 $\text{intervals}$ 中的所有重叠的区间，需要首先将所有的区间排序，然后判断是否有重叠的区间，并将重叠的区间合并。

对区间排序的方法是，首先将区间按照开始位置升序排序，如果存在多个区间的开始位置相同，则按照结束位置降序排序。排序之后，相同开始位置的多个区间中，第一个区间是最长的区间，对于每个开始位置只需要保留最长的区间。

由于无法事先知道合并后剩余多少个区间，因此使用列表存储合并后的区间。遍历排序后的数组 $\text{intervals}$，首先将首个区间（即 $\text{intervals}[0]$）添加到列表中，然后对其余的区间依次判断是否需要和已有的区间合并，并更新列表。

由于相同开始位置的多个区间只保留最长的区间，因此对于遍历到的每个区间，需要判断该区间与数组 $\text{intervals}$ 中的上一个区间的开始位置是否相同，如果相同则跳过。当前区间不跳过时，将当前区间记为 $\text{curr}$，将列表中的最后一个区间记为 $\text{prev}$。由于已经对数组 $\text{intervals}$ 排序，因此 $\text{prev}$ 的开始位置一定小于 $\text{curr}$ 的开始位置。比较 $\text{curr}$ 的开始位置和 $\text{prev}$ 的结束位置，执行如下操作。

• 如果 $\text{curr}$ 的开始位置小于等于 $\text{prev}$ 的结束位置，则 $\text{prev}$ 和 $\text{curr}$ 重叠，需要合并，合并之后的区间的开始位置是 $\text{prev}[0]$（因为 $\text{prev}[0]<\text{curr}[0]$），结束位置是 $\max (\text{prev}[1],\text{curr}[1])$。更新 $\text{prev}[1]$ 的值，即可实现合并，不需要将 $\text{curr}$ 添加到列表中。

• 如果 $\text{curr}$ 的开始位置大于 $\text{prev}$ 的结束位置，则 $\text{prev}$ 和 $\text{curr}$ 不重叠，因此将 $\text{curr}$ 添加到列表中。

遍历结束之后，将列表转成数组返回。

代码

class Solution {
    public int[][] merge(int[][] intervals) {
        Arrays.sort(intervals, (a, b) -> {
            if (a[0] != b[0]) {
                return a[0] - b[0];
            } else {
                return b[1] - a[1];
            }
        });
        List<int[]> mergedList = new ArrayList<int[]>();
        mergedList.add(intervals[0]);
        int length = intervals.length;
        for (int i = 1; i < length; i++) {
            int[] curr = intervals[i];
            int[] prev = mergedList.get(mergedList.size() - 1);
            if (curr[0] == prev[0]) {
                continue;
            }
            if (curr[0] <= prev[1]) {
                prev[1] = Math.max(prev[1], curr[1]);
            } else {
                mergedList.add(curr);
            }
        }
        return mergedList.toArray(new int[mergedList.size()][]);
    }
}

复杂度分析

• 时间复杂度：$O(n\log n)$，其中 $n$ 是数组 $\text{intervals}$ 的长度。排序需要 $O(n\log n)$ 的时间，排序后遍历数组合并区间需要 $O(n)$ 的时间，时间复杂度是 $O(n\log n)$。

• 空间复杂度：$O(n)$，其中 $n$ 是数组 $\text{intervals}$ 的长度。存储合并后的区间的列表需要 $O(n)$ 的空间。