【leetcode-双指针】合并区间/插入区间/汇总区间

合并区间

以数组 intervals 表示若干个区间的集合，其中单个区间为 intervals[i] = [starti, endi] 。请你合并所有重叠的区间，并返回一个不重叠的区间数组，该数组需恰好覆盖输入中的所有区间。

示例 1：
输入：intervals = [[1,3],[2,6],[8,10],[15,18]]
输出：[[1,6],[8,10],[15,18]]
解释：区间 [1,3] 和 [2,6] 重叠, 将它们合并为 [1,6].

示例 2：
输入：intervals = [[1,4],[4,5]]
输出：[[1,5]]
解释：区间 [1,4] 和 [4,5] 可被视为重叠区间。

排序

按区间左端点排序。

class Solution {
    public int[][] merge(int[][] intervals) {
        Arrays.sort(intervals, new Comparator<int[]>() {
            public int compare(int[] interval1, int[] interval2) {
                return interval1[0] - interval2[0];
            }
        });
        List<int[]> merged = new ArrayList<int[]>();
        for (int i = 0; i < intervals.length; ++i) {
            int last = merged.size() - 1;
            int left = intervals[i][0], right = intervals[i][1];
            if (last == -1 || merged.get(last)[1] < left) {
                merged.add(new int[]{left, right});
            } else {
                merged.get(last)[1] = Math.max(merged.get(last)[1], right);
            }
        }
        return merged.toArray(new int[merged.size()][]);
    }
}

排序+双指针

class Solution {
    public int[][] merge(int[][] intervals) {
        int len = intervals.length;
        Arrays.sort(intervals, Comparator.comparingInt(a -> a[0]));
        List<int[]> merged = new ArrayList<int[]>();
        int cur = 0;
        while (cur < len) {
            int right = intervals[cur][1];
            int next = cur + 1;
            while (next < len && intervals[next][0] <= right) {
                right = Math.max(right, intervals[next++][1]);
            }
            merged.add(new int[]{intervals[cur][0], right});
            cur = next;
        }
        return merged.toArray(new int[merged.size()][]);
    }
}

插入区间

给你一个 无重叠的 ，按照区间起始端点排序的区间列表。
在列表中插入一个新的区间，你需要确保列表中的区间仍然有序且不重叠（如果有必要的话，可以合并区间）。

示例 1：
输入：intervals = [[1,3],[6,9]], newInterval = [2,5]
输出：[[1,5],[6,9]]

示例 2：
输入：intervals = [[1,2],[3,5],[6,7],[8,10],[12,16]], newInterval = [4,8]
输出：[[1,2],[3,10],[12,16]]
解释：这是因为新的区间 [4,8] 与 [3,5],[6,7],[8,10] 重叠。

示例 3：
输入：intervals = [], newInterval = [5,7]
输出：[[5,7]]

示例 4：
输入：intervals = [[1,5]], newInterval = [2,3]
输出：[[1,5]]

示例 5：
输入：intervals = [[1,5]], newInterval = [2,7]
输出：[[1,7]]

模拟法

找到与插入区间重叠的区间，将它们合并成更大的插入区间。

class Solution {
    public int[][] insert(int[][] intervals, int[] newInterval) {
        int left = newInterval[0];
        int right = newInterval[1];

        boolean isInserted = false;
        List<int[]> result = new ArrayList<int[]>();
        for (int[] interval : intervals) {
            if (interval[0] > right) {
                if (!isInserted) {
                    result.add(new int[]{left, right});
                    isInserted = true;                    
                }
                result.add(interval);
            } else if (interval[1] < left) {
                result.add(interval);
            } else {
                left = Math.min(left, interval[0]);
                right = Math.max(right, interval[1]);
            }
        }
        if (!isInserted) {
            result.add(new int[]{left, right});
        }
        return result.toArray(new int[result.size()][]);
    }
}

汇总区间

给定一个无重复元素的有序整数数组 nums 。
返回 恰好覆盖数组中所有数字 的 最小有序 区间范围列表。也就是说，nums 的每个元素都恰好被某个区间范围所覆盖，并且不存在属于某个范围但不属于 nums 的数字 x 。
列表中的每个区间范围 [a,b] 应该按如下格式输出：

• “a->b” ，如果 a != b
• “a” ，如果 a == b

示例 1：
输入：nums = [0,1,2,4,5,7]
输出：[“0->2”,“4->5”,“7”]
解释：区间范围是：
[0,2] --> “0->2”
[4,5] --> “4->5”
[7,7] --> “7”

示例 2：
输入：nums = [0,2,3,4,6,8,9]
输出：[“0”,“2->4”,“6”,“8->9”]
解释：区间范围是：
[0,0] --> “0”
[2,4] --> “2->4”
[6,6] --> “6”
[8,9] --> “8->9”

示例 3：
输入：nums = []
输出：[]

示例 4：
输入：nums = [-1]
输出：["-1"]

示例 5：
输入：nums = [0]
输出：[“0”]

双指针

class Solution {
    public List<String> summaryRanges(int[] nums) {
        int len = nums.length;
        List<String> result = new ArrayList<>();
        int start = 0;
        for (int end = 0; end < len; end++) {
            if (end + 1 == len || nums[end] + 1 != nums[end + 1]) {
                StringBuilder sb = new StringBuilder();
                sb.append(nums[start]);
                if (start != end)
                    sb.append("->").append(nums[end]);
                result.add(sb.toString());
                start = end + 1;
            }
        }
        return result;
    }
}