合并区间题目

leetcode题目

分析

先按照每个区间左端点排序

可以发现这样一种现象：①区间和②区间不可以合并，那么③区间的起点一定是>=4的，所以③区间也不可以和①区间合并。同理④区间以及以后的区间更不可能和①区间合并。
那么我们遍历①②③…区间，每次遇到不可以合并的区间，就说明结果集中需要增加一个新区间。

package com.company.test1;

import java.util.ArrayList;
/*
*
* 减少比较次数
* 先按照starti排序，那么判断是否合并时只需要比较interval[i][1]和interval[j][0]即可*/
/*连续的区间才可以合并*/
public class Test9 {
    public static void main(String[] args) {
        /*int[][] intervals={
                {1,3},
                {2,6},
                {8,10},
                {15,18}

        };*/
        /*int[][] intervals={
                {15,18},
                {2,6},
                {8,10},
                {1,3}

        };*/
        int[][] intervals={{2,3},{5,5},{2,2},{3,4},{3,4}};

        quickSort(intervals,0,intervals.length-1);


//        尝试合并list最后一个元素+intervals遍历的当前元素
//        能合并，则修改list最后一个元素
//        不能合并，则将intervals遍历的当前元素加入list

//                int[][] intervals={{2,3},{2,2},{3,4},{3,4},{5,5}};
        /*
        * {2,3}
        * {2,3}
        * {2,4}
        * {2,4}
        * {2,4}{5,5}
        * */
        ArrayList<int[]> list=new ArrayList<>();
        list.add(intervals[0]);
        for (int i = 1; i < intervals.length; i++) {
            int[] last=list.get(list.size()-1);
            int[] arr=merge2(last,intervals[i]);
            if(arr==null){
                list.add(intervals[i]);
            }else{
                list.remove(list.size()-1);
                list.add(arr);
            }
        }
//        构造输出数组

        int newLen=list.size();
        int[][] newIntervals=new int[newLen][2];
        for (int i = 0; i < newIntervals.length; i++) {
                newIntervals[i]=list.get(i);
        }
        return;


    }
    public static void quickSort(int[][] intervals,int left,int right){
        if(right-left+1<=1){
            return;
        }
//        <=第一个元素的放左边，>第一个元素的放右边
        int j=right;
        for (int i = left+1; i < j; i++) {
            if(intervals[i][0]>intervals[left][0]){
                for (; i<j; j--) {

                    if(intervals[j][0]<=intervals[left][0]){

                        swap(intervals,i,j);
                        break;
                    }
                }
            }


        }
        /*别忘了递归排序左边和右边。*/
        if(intervals[j][0]<=intervals[left][0]){
            swap(intervals,left,j);
            if(j-1>left)
            quickSort(intervals,left,j-1);
            if(right>j+1)
            quickSort(intervals,j+1,right);

        }
        else{
            swap(intervals,left,j-1);
            if(j-2>left)
            quickSort(intervals,left,j-2);
            if(right>j)
            quickSort(intervals,j,right);

        }
    }
    public static void swap(int[][] intervals,int i,int j){
        int[] temp=intervals[i];
        intervals[i]=intervals[j];
        intervals[j]=temp;
    }
    public static int[] merge2(int[] interval1,int[] interval2){
        if(interval1[1]<interval2[0] ){//无法合并
            return null;
        }else{
            int max=interval1[1]>interval2[1]?interval1[1]:interval2[1];
            interval1=new int[]{interval1[0],max};
            return interval1;
        }
    }

}