leetcode-56-合并区间

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

 

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

 

 

先给这些数组进行排序，开始元素最小的在最前面

public static int[][] merge(int[][] intervals) {
    if (intervals.length == 0 || intervals[0].length == 0) {
        return new int[][]{};
    }
    int right = intervals.length - 1, left = 0;
    sort(intervals, left, right);
    return mergeInner(intervals);
}

使用快速排序

public static int[][] sort(int[][] intervals, int left, int right) {
    if (left < right) {
        int low = left, high = right;
        int[] target = Arrays.copyOf(intervals[low], intervals[low].length);
        while (low < high) {
            while (low < high && target[0] <= intervals[high][0]) {
                high--;
            }
            swap(intervals, low, high);
            while (low < high && target[0] >= intervals[low][0]) {
                low++;
            }
            swap(intervals, high, low);
        }
        swap(intervals, low, target);
        sort(intervals, left, low - 1);
        sort(intervals, low + 1, right);
    }
    return intervals;
}

public static void swap(int[][] intervals, int i, int j) {
    for (int a = 0; a < intervals[0].length; a++) {
        intervals[i][a] = intervals[j][a];
    }
}

public static void swap(int[][] intervals, int i, int[] target) {
    for (int a = 0; a < intervals[0].length; a++) {
        intervals[i][a] = target[a];
    }
}

从数组最开始判断，当第一个数组的结尾小于第二个数组的开头时，说明没有重合部分，就把第二个数组放进结果数组，继续遍历，如果大于等于的话，说明有重合，需要合并这两个数组，只需要改变前一个数组的结尾元素。

public static int[][] mergeInner(int[][] intervals) {
    int column = intervals[0].length;
    int[][] res = new int[1][column];
    res[0] = Arrays.copyOf(intervals[0], column);
    int high = column - 1;
    for (int i = 1; i < intervals.length; i++) {
        if (res[res.length - 1][high] < intervals[i][0]) {
            int[][] temp = new int[res.length + 1][column];
            System.arraycopy(res, 0, temp, 0, res.length);
            int next = res.length;
            res = temp;
            res[next] = Arrays.copyOf(intervals[i], column);
        } else {
            res[res.length - 1][high] = Math.max(intervals[i][high], res[res.length - 1][high]);
        }
    }
    return res;
}