#56合并区间medium

code1:
public int[][] merge(int[][] intervals) {
        List<int[]> res = new ArrayList<>();
        if (intervals == null || intervals.length == 0)
            return res.toArray(new int[0][]);

        // Arrays.sort(intervals, (a, b) -> a[0] - b[0]);// a[0] - b[0]大于0就交换顺序
        // 根据二维数组第一个数字大小按每一行整体排序
        Arrays.sort(intervals, new Comparator<int[]>() {
            @Override
            public int compare(int[] o1, int[] o2) {
                // TODO Auto-generated method stub
                return o1[0] - o2[0];
            }
        });
        int i = 0;
        while (i < intervals.length) {
            int left = intervals[i][0];
            int right = intervals[i][1];
            // i不能到最后一行,所以要小于(数组的长度 - 1)
            // 判断所在行的right和下一行的left大小,对right重新进行赋最大值,之后再不断进行while循环判断
            while (i < intervals.length - 1 && right >= intervals[i + 1][0]) {
                i++;
                right = Math.max(right, intervals[i][1]);
            }
            res.add(new int[] { left, right });
            i++;
        }
        return res.toArray(new int[0][]);
    }

code2：

class Solution {
    public int[][] merge(int[][] intervals) {
        Arrays.sort(intervals,(a,b)->a[0]-b[0]);
        Stack<int[]> stack = new Stack<>();
        
        for(int[] a: intervals){
            
            if(stack.isEmpty()) stack.push(a);
            else{
                
                int[] arr = stack.pop();
                if(arr[1] >= a[0]) {
                    int[] combine = { arr[0] , Math.max( arr[1] , a[1] ) };
                    stack.push(combine);
                }else{
                    stack.push(arr);
                    stack.push(a);
                }
                    
            }
            
        }
        
        return stack.toArray(new int[0][]);
    }
}
code3:

class Solution {

    class Interval{
        int num1;
        int num2;
        public Interval(int a,int b){
            num1 = a;
            num2 = b;
        }
    }
    public int[][] merge(int[][] intervals) {
        Arrays.sort(intervals, new Comparator<int[]>() {//排序 按照数组第一个数从小到大
            @Override
            public int compare(int[] o1, int[] o2) {
                return o1[0]-o2[0];
            }
        });
        List<Interval> list = new ArrayList<>();//用于保存合并之后的区间
        for(int i = 0;i<intervals.length;i++){
            
            int left = i+1;//跟下一个数组比较
            int val = intervals[i][1];//将第一个数组的后区间赋值给val
            //循环比较只要前一个数组的后区间大于第二个数组的前区间就说明这个数组是可以合并的，
            //将这个数组的后区间和前一个数组的后区间比较取最大值来进行下一轮比较
            //举个例子[1,4],[2,5],[5,7] 4>2 说明[1,4][2,5]可以合并,
            //区间为[1,5]，val =  Math.max(4,5);将后区间扩大，继续比较下一个数组
            //这时val=5 5>=5 说明[1,5],[5,7]可以合并为[1,7],则最后结果为[1,7]
            while(left < intervals.length && val >=intervals[left][0]){
                val = Math.max(val,intervals[left][1]);
                left++;                
            }
            Interval temp = new Interval(intervals[i][0],val);
            list.add(temp);
            i = left-1;
        }
        int[][] res = new int[list.size()][2];
        for (int i = 0;i<list.size();i++){
            res[i][0] = list.get(i).num1;
            res[i][1] = list.get(i).num2;
        }
        return res;
    }
}