452. 用最少数量的箭引爆气球

题目：

思路：

【1】首先如果画图，那么根据图我们可知一般都是选取右边界值的地方射出可以引爆最多的气球，而对于数组里面的数最好是有序的，因为便于检索。当然在排序过程中我们习惯了用 两值相减的方式 即 O1-O2这种，但是这种对于INT数据的边界值会存在溢出的情况导致 正数-负数 本应该是正数的情况，由于溢出变为 负数 这种，故应该直接用 1 ，-1，0来返回。

 

 

代码展示：

//时间57 ms 击败 44.22%
//内存75.1 MB 击败 50.38%
class Solution {
    public int findMinArrowShots(int[][] points) {
        if (points.length <= 1) return points.length;
        // 然后排序
        // 原本写法
        /**
        Arrays.sort(points, new Comparator<int[]>() {
            @Override
            public int compare(int[] o1, int[] o2) {
                // 结果说明：当o1和o2都是int 时
                // return o1-o2:升序排列
                // return o2-o1:降序排列
                // 优先按左边值排序，左边值相同则按右边值排序 ，
                // 但是这种遇到溢出的情况就不好搞了，
                // 如[[-2147483646,-2147483645],[2147483646,2147483647]]
                // return (o1[0] != o2[0]) ? o1[0] - o2[0] : o1[1] - o2[1];
                // 改为
                if (o1[1] > o2[1]) {
                    // 交换位置
                    return 1;
                } else if (o1[1] < o2[1]) {
                    // 不交换位置
                    return -1;
                } else {
                    // 不交换位置，不排序
                    return 0;
                }
            }
        });**/
        // lambda表达式写法
        // Arrays.sort(points, (o1, o2) -> Integer.compare(o1[1], o2[1]));
        // 在Java 8中被引入的Comparator.comparing，提取对象属性，按照指定规则排序
        Arrays.sort(points, Comparator.comparingInt(o -> o[1]));
        
        long maxPos = points[0][1];
        int count = 1;
        for (int i = 1; i < points.length; i++){
            // 如果该气球的左边界在上一支箭的射程范围内，
            // 则表示也可以被该箭引爆
            if (points[i][0] <= maxPos){
                continue;
            }else {
                // 否则需要多射出一支箭，且记录该箭的最大右边界
                maxPos = points[i][1];
                count++;
            }
        }

        return count;
    }
}

//时间30 ms 击败 100%
//内存75 MB 击败 59.54%
class Solution {
    public int findMinArrowShots(int[][] points) {
         // 声明points的长度
        int n = points.length;
        // 调用快速排序方法
        quick_sort(points, 0, n - 1);
        int res = 1, r = points[0][1];
        for (int i = 1; i < n; i++) {
            if (points[i][0] > r) {
                res++;
                r = points[i][1];
            }
        }
        return res;
    }
    
    private void quick_sort(int[][] q, int l, int r) {
        if (l >= r) return;
        // 声明x坐标,下标，边界值
        int x = q[l + r >> 1][1], i = l - 1, j = r + 1;
        while (i < j) {
            while (q[++i][1] < x);
            while (q[--j][1] > x);
            if (i < j) {
                int[] t = q[i];
                q[i] = q[j];
                q[j] = t;
            }
        }
        quick_sort(q, l, j);
        quick_sort(q, j + 1, r);
    }
}