汇总区间-合并区间-插入区间（力扣）

 区间的一些问题。

//合并区间
class Solution {
    public int[][] merge(int[][] intervals) {
    //首先定义一个数组，用于存放最后的结果
    ArrayList<int[]> res = new ArrayList<>();
    //进行判断，如果长度小于2或者为空，返回本身
    if(intervals==null || intervals.length<2)return intervals;
    //进行排序操作
    Arrays.sort(intervals,(a,b)->a[0]-b[0]);
    //使用循环进行遍历操作
    for(int[] interval : intervals){
        //进行主要的判断 如果当前的数组为空，就将第一个元素进行加入操作 如果后一个数组的第一个元素大于前一个数组的第二个元素 也进行加入操作
        if(res.size()==0||interval[0]>res.get(res.size()-1)[1]){
            res.add(interval);
           }
        //否则 进行区间合并的操作        
        else{
            res.get(res.size()-1)[1]=Math.max(res.get(res.size()-1)[1],interval[1]);
       }
    
    }
    return res.toArray(new int[res.size()][2]);//转换为最后的结果
    }
}

class Solution {
    public List<String> summaryRanges(int[] nums) {
       //定义一个数组
       ArrayList<String> res = new ArrayList<>();
       //本题最主要的思想是nums[i]+1==nums[i+1]
       for(int i=0;i<nums.length;i++){
            int start = i;
            //使用while循环进行跳步操作
            while(start<nums.length-1 && nums[start]+1==nums[start+1]) start++;
            if(start==i) res.add(String.valueOf(nums[i]));
            else{
                res.add(nums[i]+"->"+nums[start]);
                }
        //进行一个赋值操作，向后走start步
        i = start;
        }
        return res;

        }
}

插入区间的操作类似于上述的合并区间的操作。不同之处在于有一个新的数组要进行添加进去。添加这个新数组的代码如下：

public int[][] insert(int[][] intervals, int[] newInterval) {
    //首先 定义一个新的数组 比原来的长度长一个
    int[][] newIntervals = new int[intervals.length+1][2];
    for(int i=0;i<intervals.length;i++){
            newIntervals[i] = intervals[i];
            }
     newIntervals[intervals.length]=newInterval;
}

之后的代码类似于汇总区间的代码：

class Solution {
    public int[][] insert(int[][] intervals, int[] newInterval) {
        int[][] newIntervals = new int[intervals.length + 1][2];
        // 复制原始数组的元素
        for (int i = 0; i < intervals.length; i++) {
            newIntervals[i] = intervals[i];
        }
        // 插入新的区间
        newIntervals[intervals.length] = newInterval;
        ArrayList<int[]> res = new ArrayList<>();
        if(newIntervals == null || newIntervals.length<2) return newIntervals;
        Arrays.sort(newIntervals,(a,b)->a[0]-b[0]);
        for(int[] interval : newIntervals){
            if(res.size()==0 || interval[0]>res.get(res.size()-1)[1]) res.add(interval);
            else res.get(res.size()-1)[1] = Math.max(res.get(res.size()-1)[1],interval[1]);
        }
        return res.toArray(new int[res.size()][2]);
    }
}

用最少的箭射爆气球

这题的思路大致就是求一个交集，之前的思路都是求一个并集

class Solution {
    public int findMinArrowShots(int[][] points) {
        if(points==null || points.length<2)return 1;
        //对points数组进行排序操作 可以更好的进行操作
        Arrays.sort(points,(a,b)->Integer.compare(a[1],b[1]));
        //定义箭的个数
        int arrow = 1;
        //定义一个数组 记录points数组的第一位
        int[] cur = points[0];
        //进行for循环遍历操作
        for(int i=1;i<points.length;i++){
                if(points[i][0]>cur[1]){//比较后一个数组第一位是否大于前一个数组的第二位 成功 则箭加一
                        arrow++;
                        cur = points[i];//向后移动
                    }
            }
        return arrow;
    }
}

Arrays.sort(newIntervals,(a,b)->a[0]-b[0]);

 输入 [[-2147483646, -2147483645], [2147483646, 2147483647]] 会产生错误，这是因为在 Arrays.sort(points, (a, b) -> a[0] - b[0]) 这行代码中，当两个整数之间的差值超出 int 类型的范围时，会发生整数溢出。

Arrays.sort(points, (a, b) -> Integer.compare(a[1], b[1]));

使用这个调整的代码即可解决问题。