二维数组还能只访问一维？sort自定义比较器进行排序

回学校平时课多，没太多时间刷随想录了，看看题解写一下对代码的理解吧。今天看的这两题中代码中出现了二维数组中单独使用其中的一维（点击跳转）和利用sort方法对二维数组进行排序（点击跳转），下面总结一下。

406.根据身高重建队列

题目描述

假设有打乱顺序的一群人站成一个队列，数组 people 表示队列中一些人的属性（不一定按顺序）。每个 people[i] = [hi, ki] 表示第 i 个人的身高为 hi ，前面 正好 有 ki 个身高大于或等于 hi 的人。

请你重新构造并返回输入数组 people 所表示的队列。返回的队列应该格式化为数组 queue ，其中 queue[j] = [hj, kj] 是队列中第 j 个人的属性（queue[0] 是排在队列前面的人）。

示例 1：

• 输入：people = [[7,0],[4,4],[7,1],[5,0],[6,1],[5,2]]
• 输出：[[5,0],[7,0],[5,2],[6,1],[4,4],[7,1]]
• 解释：
  • 编号为 0 的人身高为 5 ，没有身高更高或者相同的人排在他前面。
  • 编号为 1 的人身高为 7 ，没有身高更高或者相同的人排在他前面。
  • 编号为 2 的人身高为 5 ，有 2 个身高更高或者相同的人排在他前面，即编号为 0 和 1 的人。
  • 编号为 3 的人身高为 6 ，有 1 个身高更高或者相同的人排在他前面，即编号为 1 的人。
  • 编号为 4 的人身高为 4 ，有 4 个身高更高或者相同的人排在他前面，即编号为 0、1、2、3 的人。
  • 编号为 5 的人身高为 7 ，有 1 个身高更高或者相同的人排在他前面，即编号为 1 的人。
  • 因此 [[5,0],[7,0],[5,2],[6,1],[4,4],[7,1]] 是重新构造后的队列。

示例 2：

• 输入：people = [[6,0],[5,0],[4,0],[3,2],[2,2],[1,4]]
• 输出：[[4,0],[5,0],[2,2],[3,2],[1,4],[6,0]]

提示：

• 1 <= people.length <= 2000
• 0 <= hi <= 10^6
• 0 <= ki < people.length

题目数据确保队列可以被重建

思路

与分发糖果很像，不能想着又看people第一维的数据，又看第二维的数据，先只看h，对h降序排序，特殊情况是：当h相同时，按k升序排序，之后再根据k的大小，对应插入下标为k的位置。

代码

class Solution {
    public int[][] reconstructQueue(int[][] people) {
        // 身高从大到小排（身高相同k小的站前面）
        Arrays.sort(people, (a, b) -> {
            if (a[0] == b[0]) return a[1] - b[1];   // a - b 是升序排列，故在a[0] == b[0]的狀況下，會根據k值升序排列
            return b[0] - a[0];   //b - a 是降序排列，在a[0] != b[0]，的狀況會根據h值降序排列
        });

        LinkedList<int[]> que = new LinkedList<>();

        for (int[] p : people) {
            que.add(p[1],p);   //Linkedlist.add(index, value)，會將value插入到指定index裡。
        }

        return que.toArray(new int[people.length][]);
    }
}

代码解释

自定义排序方法之Lambda表达式：

 下面是出现的Lambda表达式：

(a, b) -> {  
    if (a[0] == b[0]) return a[1] - b[1];  
    return b[0] - a[0];  
}

这是一个比较器的缩略版本，其中a和b都是二维数组（由前面传入的people是一个二维数组，所以它a和b也是），而a[0]和a[1]分别表示二维数组中第一列数据（a[0][i]）和第二列数据(a[i][1])，这个函数与正常自定义比较器是一个意思，关于Lambda表达式，转载一篇大佬的文章：Java中Lambda表达式使用及详解_java lambda表达式-CSDN博客。

然后关于比较器的理解：

a(第一个参数) - b(第二个参数) —— 升序

b(第二个参数) - a(第一个参数) —— 降序 

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

题目描述

在二维空间中有许多球形的气球。对于每个气球，提供的输入是水平方向上，气球直径的开始和结束坐标。由于它是水平的，所以纵坐标并不重要，因此只要知道开始和结束的横坐标就足够了。开始坐标总是小于结束坐标。

一支弓箭可以沿着 x 轴从不同点完全垂直地射出。在坐标 x 处射出一支箭，若有一个气球的直径的开始和结束坐标为 xstart，xend， 且满足  xstart ≤ x ≤ xend，则该气球会被引爆。可以射出的弓箭的数量没有限制。 弓箭一旦被射出之后，可以无限地前进。我们想找到使得所有气球全部被引爆，所需的弓箭的最小数量。

给你一个数组 points ，其中 points [i] = [xstart,xend] ，返回引爆所有气球所必须射出的最小弓箭数。

示例 1：

• 输入：points = [[10,16],[2,8],[1,6],[7,12]]
• 输出：2
• 解释：对于该样例，x = 6 可以射爆 [2,8],[1,6] 两个气球，以及 x = 11 射爆另外两个气球

示例 2：

• 输入：points = [[1,2],[3,4],[5,6],[7,8]]
• 输出：4

示例 3：

• 输入：points = [[1,2],[2,3],[3,4],[4,5]]
• 输出：2

示例 4：

• 输入：points = [[1,2]]
• 输出：1

示例 5：

• 输入：points = [[2,3],[2,3]]
• 输出：1

提示：

• 0 <= points.length <= 10^4
• points[i].length == 2
• -2^31 <= xstart < xend <= 2^31 - 1

思路

区间重叠问题。用贪心思想做，贪的局部最优就是：让尽可能多的区间重复。话虽然说的这么简单，但是具体代码又该如何实现呢？还有一个问题：如何判断区间是否重复呢？

为了解决上面两个问题，首先先对给的二维数组排序：先按照每个区间下限，升序排序，如示例 1中排序后是：points = [[1,6],[2,8],[7,12],[10,16]]。这样，判断重复就是：第 i 个区间的下限是否小于等于第 i - 1 个区间的上限。说到这，结合代码随想录里的题理解一下：

 然后如果不满足这个条件，则就需要多加一根箭才能射爆，还有一个问题：当找到两个连续的区间之后，如何寻找第三个、四个？还是这样判断？（第 i 个区间的下限是否小于等于第 i - 1 个区间的上限）但是，看上面的样例图气球1和气球2满足重叠区间判断条件，然后到了气球2与气球3也满足，但是又不满足气球1了，这三个气球还是需要2根箭。看图也能看出了，当找到一组气球区间满足之后，需要跟新第i个区间的下限为第i个区间下限和第i-1个区间上限的最小值。这样就把前面几判断可以一起射爆的气球1联系起来了，不至于顾此失彼！

代码

class Solution {
    public int findMinArrowShots(int[][] points) {
        // 根据气球直径的开始坐标从小到大排序
        // 使用Integer内置比较方法，不会溢出
        Arrays.sort(points, (a, b) -> Integer.compare(a[0], b[0]));

        int count = 1;  // points 不为空至少需要一支箭
        for (int i = 1; i < points.length; i++) {
            if (points[i][0] > points[i - 1][1]) {  // 气球i和气球i-1不挨着，注意这里不是>=
                count++; // 需要一支箭
            } else {  // 气球i和气球i-1挨着
                points[i][1] = Math.min(points[i][1], points[i - 1][1]); // 更新重叠气球最小右边界
            }
        }
        return count;
    }
}

总结

今天这两道题都涉及到了二维数组中单独使用其中的一维和利用sort方法对二维数组进行排序。接下来总结一下：

二维数组中单独使用其中的一维

由于数组底层的实现逻辑，在空间中是连续的空间，一个二维数组int[][] A，在增强for循环遍历（如上面出现的sort中，自带增强for）时，A[0]表示A[i][0]，A[[1]表示A[i][1]。这是由于增强for循环的循环变量是一个一维数组，如下面这个例子：

// eg. people = [[7,0],[4,4]]
for (int[] p : people) {// people传入的是首地址 如[7,0]或[4,4]
            System.out.print(p[0] + " " + p[1]);
    }
/** 输出结果：
    7 0
    4 4
*/

sort自定义排序

这两题都涉及到了二维数组，并且都需要进行排序，在没有特殊要求的情况下，要想升序排序，用Integer内置方法：

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

但是，如果要另加排序条件，则需要自定义排序方法如406.根据身高重建队列中的代码：

 Arrays.sort(people, (a, b) -> {
            if (a[0] == b[0]) return a[1] - b[1];   // a - b 是升序排列，故在a[0] == b[0]的狀況下，會根據k值升序排列
            return b[0] - a[0];   //b - a 是降序排列，在a[0] != b[0]，的狀況會根據h值降序排列
        });