java区间值配置 java中怎么表示一个区间

转载

mob64ca13fc5fb6 2024-07-10 16:03:09

文章标签 java区间值配置数据结构 leetcode 算法数组 文章分类 Java 后端开发

文章目录

java.56.合并区间(merge-intervals)
思考

第一种情况，第二种情况，完全不相交
第三种情况，第四种情况，包含
第五种情况，第六种情况，相交
代码思路

代码一
代码二
代码三
练习
参考资料

java.56.合并区间(merge-intervals)

给出一个区间的集合，请合并所有重叠的区间。

示例 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] 可被视为重叠区间。

思考

两个区间相交，有六种情况

第一种情况，第二种情况，完全不相交

假设，有两个区别[a,b]和[c,d]

1	2	3	4	5	6	7	8
a		b
					c		d

或者

1	2	3	4	5	6	7	8
					a		b
c		d

第三种情况，第四种情况，包含

1	2	3	4	5	6	7	8
a							b
		c				d

或者

1	2	3	4	5	6	7	8
		a				b
c							d

第五种情况，第六种情况，相交

1	2	3	4	5	6	7	8
a		b
	c					d

或者

1	2	3	4	5	6	7	8
	a					b
c			d

代码思路

根据上面的例子可以发现有6种不同的状态，但有一半是重复的，比如[a,b]和[c,d]不相交，[c,d]和[a,b]不相交，这就可以算作是一种，只需要将这两个区间排好序就可以了，这样就省掉一半的重复情况。那么留下来的就是三种不同的情况:

[a,b]和[c,d]不相交，这两个区间都会保留下来[a,b]被包含在[c,d]内，这两个区间需要合并[a,b]和[c,d]有部分重叠，这两个区间需要合并第一种情况（1、2）很好判断，只要b<c就说明这两个区间完全不相交，此时就把这两个区间都保留下来即可。第二种（3、4）和第三种情况(5、6)，都是满足c<b。c<b时有两种结果，区间的开头当然还是a，区间的结尾我们取max(b,d)。


（		）
	（		）

所以第二、第三种情况时，我们新合并的区间范围就是:[a, max(b,d)]。

代码一

代码这里的if条件语句是拿第一种情况(b<c)来判断的，如果不是第一种情况，那么就是第二、第三种情况。当然，你拿c<b来判断，问题也不大。有些人看到arr.get(arr.size()-1)以为是拿最后一个出来判断，不应该是拿第一个和第二个区间判断吗。其实，第一次比较之前，以前有一个元素加入到List集合模拟的队列中，所以，第一次比较，其实是第一个区间和第二个区间比较，后面的代码，不相交的情况成立加入队列。相交的情况就是队列最后的区间和要进入队列的区间合并。合并这里的代码也非常巧妙。

class Solution {
    public int[][] merge(int[][] intervals) {
        if(intervals==null || intervals.length==0) {
            return intervals;
        }
        //先按区间的一个元素排序一遍
        Arrays.sort(intervals, (x,y)->x[0]-y[0] );
        List<int[]> arr = new ArrayList<int[]>();
        arr.add(intervals[0]);
        for(int i=1;i<intervals.length;++i) {
            //[x1,x2]和[y1,y2]比较，如果x2<y1说明这两个区间不想交
            if(arr.get(arr.size()-1)[1] < intervals[i][0]) {
                arr.add(intervals[i]);
            }
            //否则，将这两个区间合并为 [x1,max(x2,y2)]
            else {
                arr.get(arr.size()-1)[1] = Math.max(arr.get(arr.size()-1)[1],intervals[i][1]);
            }
        }
        return arr.toArray(new int[arr.size()][2]);
    }
}

代码二

class Solution {
    public int[][] merge(int[][] intervals) {
        // 先按照区间起始位置排序
        Arrays.sort(intervals, (v1, v2) -> v1[0] - v2[0]);
        // 遍历区间
        int[][] res = new int[intervals.length][2];
        int idx = -1;
        for (int[] interval: intervals) {
            // 如果结果数组是空的，或者当前区间的起始位置 > 结果数组中最后区间的终止位置，
            // 则不合并，直接将当前区间加入结果数组。
            if (idx == -1 || interval[0] > res[idx][1]) {
                res[++idx] = interval;
            } else {
                // 反之将当前区间合并至结果数组的最后区间
                res[idx][1] = Math.max(res[idx][1], interval[1]);
            }
        }
        return Arrays.copyOf(res, idx + 1);
    }
}

代码三

java快排3ms

public int[][] merge(int[][] intervals) {
        if(intervals.length==0) return new int[0][0];
        List<int[]> ans = new ArrayList<>();
        int[] cur;
        sort(intervals,0,intervals.length-1);
        cur=intervals[0];
        for(int i=1;i<intervals.length;i++){
            if(intervals[i][0]<=cur[1]){
                if(intervals[i][1]>cur[1]) cur[1]=intervals[i][1];
                else continue;
            }else{
                ans.add(cur);
                cur=intervals[i];
            }
        }
        ans.add(cur);
        
        return ans.toArray(new int[ans.size()][]);
    }
    public void sort(int[][] intervals,int l,int r){
        if(l>=r) return;
        int p=partition(intervals,l,r);
        sort(intervals,l,p-1);
        sort(intervals,p+1,r);
    }
    public int partition(int[][] intervals,int l,int r){
        int[] temp = intervals[l];
        while(l<r){
            while(l<r){
                if(intervals[r][0]<temp[0]){
                    intervals[l]=intervals[r];
                    break;
                }
                r--;
            }
            while(l<r){
                if(intervals[l][0]>temp[0]){
                    intervals[r]=intervals[l];
                    break;
                }
                l++;
            }
        }
        intervals[l]=temp;
        return l;
    }