3、区间列表的交集（Weekly Contest 122）

最新推荐文章于 2024-12-30 17:28:29 发布

原创最新推荐文章于 2024-12-30 17:28:29 发布 · 219 阅读

0 ·

CC 4.0 BY-SA版权

竞赛专栏收录该内容

253 篇文章

订阅专栏

本文介绍了一种求解两个已排序、成对不相交区间列表交集的算法。通过遍历两个列表，比较区间的起点和终点，找出交集并存储在TreeMap中，最后转换为区间对象数组返回。该算法适用于区间数据处理，如日程安排、资源分配等场景。

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

题目描述：
给定两个由一些闭区间组成的列表，每个区间列表都是成对不相交的，并且已经排序。

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

（形式上，闭区间 [a, b]（其中 a <= b）表示实数 x 的集合，而 a <= x <= b。两个闭区间的交集是一组实数，要么为空集，要么为闭区间。例如，[1, 3] 和 [2, 4] 的交集为 [2, 3]。）

示例：

输入：A = [[0,2],[5,10],[13,23],[24,25]], B = [[1,5],[8,12],[15,24],[25,26]]
输出：[[1,2],[5,5],[8,10],[15,23],[24,24],[25,25]]
注意：输入和所需的输出都是区间对象组成的列表，而不是数组或列表。

提示：

0 <= A.length < 1000
0 <= B.length < 1000
0 <= A[i].start, A[i].end, B[i].start, B[i].end < 10^9
代码：

public static  Interval[] intervalIntersection(Interval[] A, Interval[] B) {
		 Map<Integer, Integer> temMap = new TreeMap<Integer, Integer>();
		int aindex = 0;
		int bindex = 0;
		for ( ;bindex < B.length && aindex < A.length; ) {
			int start = A[aindex].start > B[bindex].start ?A[aindex].start : B[bindex].start;	
			int end = A[aindex].end < B[bindex].end ? A[aindex].end : B[bindex].end;
			if(start <= end){
				temMap.put(start, end);
				if(A[aindex].end > B[bindex].end){
					bindex ++;
				}else {
					aindex ++;
				}
			}else {
				if(A[aindex].start >= B[bindex].end){
					bindex++;
				}else {
					aindex ++;
				}
			}
		}
		System.out.println(temMap.toString());
		Interval [] result = new Interval[temMap.size()];
		int x = 0;
		for (Map.Entry<Integer, Integer> tem : temMap.entrySet()) {
			System.out.println(tem.getKey());
			System.out.println(tem.getValue());
			Interval temint = new Interval(tem.getKey(), tem.getValue());
			
			result[x++] = temint;
		}
		return result;
		
    }

我这里也是使用TreeMap来进行排序，因为提交要求的是按照顺序来进行

看看别人写的代码：
感觉思路差不多：

class Solution {
    public Interval[] intervalIntersection(Interval[] A, Interval[] B) {
        int lengthA = A.length;
        int lengthB = B.length;
        int indexA = 0;
        int indexB = 0;
        List<Interval> intersectionList = new ArrayList<Interval>();
        while (indexA < lengthA && indexB < lengthB) {
            Interval intervalA = A[indexA];
            Interval intervalB = B[indexB];
            Interval intersection = intersection(intervalA, intervalB);
            if (intersection != null) {
               intersectionList.add(intersection);
            }
            if (intervalA.end < intervalB.end) {
                indexA++;
            } else if (intervalA.end > intervalB.end) {
                indexB++;
            } else {
                indexA++;
                indexB++;
            }
        }
        int length = intersectionList.size();
        Interval[] intersectionArray = new Interval[length];
        for (int i = 0; i < length; i++)
            intersectionArray[i] = intersectionList.get(i);
        return intersectionArray;
    }

    private Interval intersection(Interval i1, Interval i2) {
        if (i1 == null || i2 == null)
            return null;
        int start1 = i1.start;
        int end1 = i1.end;
        int start2 = i2.start;
        int end2 = i2.end;
        int intersectionStart = Math.max(start1, start2);
        int intersectionEnd = Math.min(end1, end2);
        if (intersectionStart > intersectionEnd)
            return null;
        else
            return new Interval(intersectionStart, intersectionEnd);
    }
}