LeetCode第56题：合并区间（中等）

LeetCode第56题：合并区间（中等）

• 题目：给出一个区间的集合，请合并所有重叠的区间。
• 解法一：这道题有三个需要注意的地方，①给出的数组是无需的，合并之前需要进行排序；②结果要求是数组形式，但数组长度不固定，只能在最后又重新定义一个长度合适的数组赋值；③数组不仅包含交叉的情况，还存在包含的情况。反复尝试后，还是有不通过的情况，以下为错误答案，

class Solution {
    public int[][] merge(int[][] intervals) {
        int n = intervals.length;
        
        int ans[][] = new int[n][2];
        if(n==0) return ans;
        if(n==1) return intervals;
        int i=0,j=1,k=0,m=0;
        
        for(int l=0;l<n-1;l++)
        {
            for(int h=0;h<n-1-l;h++)
            {
                if(intervals[h][0] > intervals[h+1][0])
                {
                    int temp=intervals[h][0];
                    intervals[h][0]=intervals[h+1][0];
                    intervals[h+1][0]=temp;

                    temp=intervals[h][1];
                    intervals[h][1]=intervals[h+1][1];
                    intervals[h+1][1]=temp;
                }
            }
        }


        ans[k][0]=intervals[i][0];
        ans[k][1]=intervals[i][1];
        while(i<n && j<n){
            
            if(ans[k][1] >= intervals[j][0]){
                if(ans[k][1] > intervals[j][1]){
                    i=++j;
                }else{
                    ans[k][1] = intervals[j][1];
                    i=++j;
                }
            }else{
                k++;
                //i++;
                //j=i+1;
                ans[k][0]=intervals[i][0];
                ans[k][1]=intervals[i][1];
            }

        }



        int ansLast[][] = new int[k+1][2];
        for(int l=0;l<=k;l++){
            ansLast[l][0] = ans[l][0];
            ansLast[l][1] = ans[l][1];
        }
        
        return ansLast;
    }
}

• 解法二：评论里的答案，在官方解法上补充了Interval类。难怪评论里都吐槽这道题的答案，真是烦。。。。

class Solution {
    private static class Interval {
        int start;
        int end;
        Interval(int[] interval) {
            this.start = interval[0];
            this.end = interval[1];
        }

        int[] toArray() {
            return new int[]{this.start, this.end};
        }
    }

    private static class IntervalComparator implements Comparator<Interval> {

        @Override
        public int compare(Interval a, Interval b) {
            return Integer.compare(a.start, b.start);
        }
    }

    public int[][] merge(int[][] intervals) {
        List<Interval> intervalsList = new LinkedList<>();
        for (int[] interval : intervals) {
            intervalsList.add(new Interval(interval));
        }
        intervalsList.sort(new IntervalComparator());

        LinkedList<Interval> merged = new LinkedList<>();
        for (Interval interval : intervalsList) {
            // if the list of merged intervals is empty or if the current
            // interval does not overlap with the previous, simply append it.
            if (merged.isEmpty() || merged.getLast().end < interval.start) {
                merged.add(interval);
            }
            // otherwise, there is overlap, so we merge the current and previous
            // intervals.
            else {
                merged.getLast().end = Math.max(merged.getLast().end, interval.end);
            }
        }

        int i = 0;
        int[][] result = new int[merged.size()][2];
        for (Interval mergedInterval : merged) {
            result[i] = mergedInterval.toArray();
            i++;
        }
        return result;
    }
}