双指针题目：区间列表的交集

题目

标题和出处

标题：区间列表的交集

出处：986. 区间列表的交集

难度

4 级

题目描述

要求

给定两个由闭区间组成的列表，$\text{firstList}$ 和 $\text{secondList}$，其中 ${\text{firstList[i] = [start}}_{\text{i}}{\text{, end}}_{\text{i}}\text{]}$，${\text{secondList[j] = [start}}_{\text{j}}{\text{, end}}_{\text{j}}\text{]}$。同一个区间列表中的区间各不相交，并且已经排序。

返回这两个区间列表的交集。

闭区间 $\text{[a, b]}$（其中 $\text{a}\le \text{b}$）表示满足 $\text{a}\le \text{x}\le \text{b}$ 的实数 $\text{x}$ 的集合。

两个闭区间的交集是一组实数，为空集或闭区间。例如，$\text{[1, 3]}$ 和 $\text{[2, 4]}$ 的交集为 $\text{[2, 3]}$。

示例

示例 1：

输入：$\text{firstList = [[0,2],[5,10],[13,23],[24,25]], secondList = [[1,5],[8,12],[15,24],[25,26]]}$
输出：$\text{[[1,2],[5,5],[8,10],[15,23],[24,24],[25,25]]}$

示例 2：

输入：$\text{firstList = [[1,3],[5,9]], secondList = []}$
输出：$\text{[]}$

数据范围

• $\text{0}\le \text{firstList.length, secondList.length}\le \text{1000}$
• $\text{firstList.length}+\text{secondList.length}\ge \text{1}$
• $\text{0}\le {\text{start}}_{\text{i}}<{\text{end}}_{\text{i}}\le {\text{10}}^{\text{9}}$
• ${\text{end}}_{\text{i}}<{\text{start}}_{\text{i + 1}}$
• $\text{0}\le {\text{start}}_{\text{j}}<{\text{end}}_{\text{j}}\le {\text{10}}^{\text{9}}$
• ${\text{end}}_{\text{j}}<{\text{start}}_{\text{j + 1}}$

解法

思路和算法

由于给定的两个区间列表满足同一个区间列表中的区间各不相交且已经按升序排序，因此不需要处理区间合并，只需要从左到右同时遍历两个区间列表即可计算交集。

使用一个列表存储区间列表的交集。用 ${\text{index}}_1$ 和 ${\text{index}}_2$ 分别表示区间列表 $\text{firstList}$ 和 $\text{secondList}$ 的下标，初始时 ${\text{index}}_1={\text{index}}_2=0$。

当 ${\text{index}}_1$ 和 ${\text{index}}_2$ 都未超出区间列表的下标范围时，同时遍历两个区间列表，记 ${\text{interval}}_1=\text{firstList}[{\text{index}}_1]$，${\text{interval}}_2=\text{secondList}[{\text{index}}_2]$，记 $\text{start}=\max ({\text{interval}}_1[0],{\text{interval}}_2[0])$，$\text{end}=\min ({\text{interval}}_1[1],{\text{interval}}_2[1])$，执行如下操作。

1. 如果 $\text{start}\le \text{end}$，则当前的两个区间 ${\text{interval}}_1$ 和 ${\text{interval}}_2$ 的交集为 $[\text{start},\text{end}]$，将 $[\text{start},\text{end}]$ 添加到交集列表中。如果 $\text{start}>\text{end}$，则当前的两个区间 ${\text{interval}}_1$ 和 ${\text{interval}}_2$ 的交集为空，不添加到交集列表中。

2. 比较当前的两个区间 ${\text{interval}}_1$ 和 ${\text{interval}}_2$ 的末端，即 ${\text{interval}}_1[1]$ 和 ${\text{interval}}_2[1]$，将末端较小的区间对应的下标向右移动一位。具体做法如下。

   • 如果 ${\text{interval}}_1[1]={\text{interval}}_2[1]$，则 ${\text{interval}}_1$ 和 ${\text{interval}}_2$ 都不可能和两个区间列表中的其余区间有交集，因此将 ${\text{index}}_1$ 和 ${\text{index}}_2$ 同时向右移动一位。

   • 如果 ${\text{interval}}_1[1]<{\text{interval}}_2[1]$，则 ${\text{interval}}_1$ 不可能和 $\text{secondList}$ 中的其余区间有交集，但是 ${\text{interval}}_2$ 仍可能和 $\text{firstList}$ 中的其余区间有交集，因此将 ${\text{index}}_1$ 向右移动一位。

   • 如果 ${\text{interval}}_1[1]>{\text{interval}}_2[1]$，则 ${\text{interval}}_2$ 不可能和 $\text{firstList}$ 中的其余区间有交集，但是 ${\text{interval}}_1$ 仍可能和 $\text{secondList}$ 中的其余区间有交集，因此将 ${\text{index}}_2$ 向右移动一位。

重复上述操作，直到 ${\text{index}}_1$ 和 ${\text{index}}_2$ 当中至少有一个下标超出区间列表的下标范围。如果一个下标超出区间列表的下标范围，则该下标所在的区间列表中的所有区间都已经被遍历过，因此不可能有更多的非空交集，此时得到完整的交集。

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

代码

class Solution {
    public int[][] intervalIntersection(int[][] firstList, int[][] secondList) {
        List<int[]> intersectionList = new ArrayList<int[]>();
        int length1 = firstList.length, length2 = secondList.length;
        int index1 = 0, index2 = 0;
        while (index1 < length1 && index2 < length2) {
            int[] interval1 = firstList[index1];
            int[] interval2 = secondList[index2];
            int start = Math.max(interval1[0], interval2[0]);
            int end = Math.min(interval1[1], interval2[1]);
            if (start <= end) {
                intersectionList.add(new int[]{start, end});
            }
            if (interval1[1] <= interval2[1]) {
                index1++;
            }
            if (interval1[1] >= interval2[1]) {
                index2++;
            }
        }
        return intersectionList.toArray(new int[intersectionList.size()][]);
    }
}

复杂度分析

• 时间复杂度：$O(m+n)$，其中 $m$ 和 $n$ 分别是区间列表 $\text{firstList}$ 和 $\text{secondList}$ 的长度。双指针遍历两个区间列表各一次。

• 空间复杂度：$O(m+n)$，其中 $m$ 和 $n$ 分别是区间列表 $\text{firstList}$ 和 $\text{secondList}$ 的长度。存储区间交集的列表需要 $O(m+n)$ 的空间。