leetcode56——合并区间

题意：

 解法1：

class Solution {
    public int[][] merge(int[][] intervals) {//n行  2列
        //尾元素 大于下一组的首元素 就要合并
        //先进行数组 排序 即 [1,3]  [2,6]
        if(intervals.length==1) return intervals;
        int[][] res=new int[intervals.length][];

        ArrayList<int[]> list=new ArrayList<>();

        //按首元素 进行排序
        intervals=sortmaopao(intervals);

        int big=0;

        int start1=0;
        int start2=0;
        int end1=0;
        int end2=0;

        int count=0;
        for(int k=0;k<intervals.length;k++){
            big=k+1;
            //if(big==intervals.length) break;// big  可能会有一个越界问题
            if(k==intervals.length-1){
                //添加
                //res[count]=intervals[k];
                list.add(new int[] {intervals[k][0],intervals[k][1]});
                break;
            }

            start1=intervals[k][0];
            end1=intervals[k][1];
            start2=intervals[big][0];
            end2=intervals[big][1];
            if(end1>=start2){
                //缩小处理

                if(end1>end2){
                    //直接加入  k所在数组
                    intervals[big]=intervals[k];//更新 big值

                    //list.add(intervals[k]);
                }else{
                    //取k的首  取big的尾
                    intervals[big][0]=start1;//更新big值
                    //list.add(intervals[big]);
                }

                //如何更新呢
            }else{
                //list.add(intervals[k]);
                //res[count++]=intervals[k];

                list.add(new int[] {intervals[k][0],intervals[k][1]});
            }

        } 

       // return res;
       return  list.toArray(new int[list.size()][2]);


    }

    //先将数组进行排序
    public int[][] sortmaopao(int[][] intervals){
        if(intervals.length==1) return intervals;

        //利用冒泡排序 
        int[] tem=null;
        for(int i=0;i<intervals.length;i++){
            for(int j=i+1;j<intervals.length;j++){
                if(intervals[i][0]>intervals[j][0]){
                    tem=intervals[i];

                    intervals[i]=intervals[j];

                    intervals[j]=tem;
                }
            }
        }

        return intervals;
    }
}

思路： 原数组 是一个n行 2列的数组

先按照每行的首 num 进行排序

然后分情况比较

知识点：

如何返回一个保存不定长度的数组呢？

如果使用int[] num=new int[x];  那么数组长度一开始就固定死了，当然你也可以通过Array去操作 但略显麻烦

推荐方法：

第一步：
集合返回数组  即 list.toArray()

ArrayList<int[]> list=new ArrayList<>();

第二步：

本题是要返回一个二维数组   ，而 集合返回的是一个一维数组，

那么我们在添加元素的时候 在一维数组里  加入一维数组即可

list.add(new int[] {intervals[k][0],intervals[k][1]});

第三步：

list.Array()  是集合转换为数组的方法

list.toArray(new int[list.size()][2])  是定义一个多大的数组

list.toArray(new int[list.size()][2])

# 排序

排序算法累计ing

解法2

先进行二维数组排序
按照二维数组的0号元素进行从小到大排序

设置一个右边界pos，后续数组的左边界小于等于pos都是和pos有交集的，同时每次都更新一下pos

for循环结束之后 将最后一组边界数值加入list

ArrayList加入数组 (泛型首先是数组) list.add(new int[] {num1,num2});
ArrayList转化为n*m数组 list.toArray(new int[m][n]);

class Solution {
    public int[][] merge(int[][] intervals) {
        int n=intervals.length;
        if(n==1) return intervals;
        //结果返回数组格式
        //ArrayList  .toArray(new int[list.size()][2]);
        //按0号元素进行从小到大排序
        ArrayList<int[]> list=new ArrayList<>();
        Arrays.sort(intervals,new Comparator<int[]>(){
            public int compare(int[] p1,int[] p2){
                if(p1[0]>p2[0]){
                    return 1;
                }else if(p1[0]<p2[0]){
                    return -1;
                }else{
                    return 0;
                }
            }
        });

        int pos=intervals[0][1];
        int left=intervals[0][0];
        int right=intervals[0][1];
        //将pos表示右边界  判断后续排序的数组的左边界是否在范围之内。
        for(int i=1; i<n;i++){
            if(pos>=intervals[i][0]){
                //有交集 更新左右范围
                //left=Math.min(left , intervals[i][0]);
                right=Math.max(right,intervals[i][1]);
                pos=right;
            }else{
                //无交集 加入数组 改变pos
                list.add(new int[]{left,right});//加入链表
                pos=intervals[i][1];
                left=intervals[i][0];
                right=intervals[i][1];
            }
        }
        //跳出循环 加入最后一个左右范围
        list.add(new int[]{left,right});


        return list.toArray(new int[list.size()][2]);
    }
}