【Java】【LeetCode】56. Merge Intervals

题目：

Given a collection of intervals, merge all overlapping intervals.

Example 1:

Input: [[1,3],[2,6],[8,10],[15,18]]
Output: [[1,6],[8,10],[15,18]]
Explanation: Since intervals [1,3] and [2,6] overlaps, merge them into [1,6].

Example 2:

Input: [[1,4],[4,5]]
Output: [[1,5]]
Explanation: Intervals [1,4] and [4,5] are considered overlapping.

NOTE: input types have been changed on April 15, 2019. Please reset to default code definition to get new method signature.

 

题解：

这道题主要难点是改写Comparator。 

 Comparator接口定义了两个方法：compare（ ）和equals（ ）。这里给出的compare（ ）方法按顺序比较了两个元素：
　　
　　int compare(Object obj1, Object obj2)
　　
　 　obj1和obj2是被比较的两个对象。当两个对象相等时，该方法返回0；当obj1大于obj2时，返回一个正值；否则，返回一个负值。如果用于比较 的对象的类型不兼容的话，该方法引发一个ClassCastException异常。通过覆盖compare（ ），可以改变对象排序的方式。例如，通过创建一个颠倒比较输出的比较函数，可以实现按逆向排序。
　　
　　这里给出的equals( )方法，测试一个对象是否与调用比较函数相等：
　　
　　boolean equals(Object obj)
　　
　　obj是被用来进行相等测试的对象。如果obj和调用对象都是Comparator的对象并且使用相同的排序。该方法返回true.否则返回false.重载equals（ ）方法是没有必要的，大多数简单的比较函数都不这样做。

 

具体代码如下：

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.List;

public class MergeIntervals
{

    public static void main(String[] args)
    {
        /**
         * Example 1:
         * Input: [[1,3],[2,6],[8,10],[15,18]]
         * Output: [[1,6],[8,10],[15,18]]
         * Explanation: Since intervals [1,3] and [2,6] overlaps, merge them into [1,6].
         */
        int[][] input1 = { { 1, 3 }, { 8, 10 }, { 2, 6 }, { 15, 18 } };
        int[][] output1 = merge(input1);
        LeetCodeUtil.printIntTwoDimensionalArray(output1);
        /**
         * Example 2:
         * Input: [[1,4],[4,5]]
         * Output: [[1,5]]
         * Explanation: Intervals [1,4] and [4,5] are considered overlapping.
         */
        int[][] input2 = { { 1, 4 }, { 4, 5 } };
        int[][] output2 = merge(input2);
        LeetCodeUtil.printIntTwoDimensionalArray(output2);
    }

    public static int[][] merge(int[][] intervals)
    {
        if (intervals == null || intervals.length <= 1)
        {
            return intervals;
        }
        Comparator<int[]> comparator = new Comparator<int[]>()
        {

            @Override
            public int compare(int[] o1, int[] o2)
            {
                return o1[0] - o2[0];
            }
        };
        // sort intervals by using self-defined Comparator
        Arrays.sort(intervals, comparator);
        List<int[]> list = new ArrayList<int[]>();
        int[] prev = intervals[0];
        for (int i = 1; i < intervals.length; i++)
        {
            int[] curr = intervals[i];
            if (prev[1] >= curr[0])
            {
                // merged case
                int[] merged = { prev[0], Math.max(prev[1], curr[1]) };
                prev = merged;
            }
            else
            {
                list.add(prev);
                prev = curr;
            }
        }
        list.add(prev);
        int[][] result = new int[list.size()][2];
        for (int i = 0; i < list.size(); i++)
        {
            result[i] = list.get(i);
        }
        return result;
    }
}