两个数组的交集
题目：
给定两个数组，编写一个函数来计算它们的交集。
示例1：
输入：nums1 = [1,2,2,1], nums2 = [2,2]
输出：[2,2]
示例2：
输入：nums1 = [4,9,5], nums2 = [9,4,9,8,4]
输出：[4,9]
说明：
- 输出结果中每个元素出现的次数，应与元素在两个数组中出现的次数一致。
- 我们可以不考虑输出结果的顺序。
进阶：
- 如果给定的数组已经排好序呢？将如何优化你的算法呢？
- 如果 nums1 的大小比 nums2 小很多，哪种方法更优？
- 如果 nums2 的元素存储在磁盘上，内存是有限的，并且你不能一次加载所有的元素到内存中，你该怎么办？
题目来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/intersection-of-two-arrays-ii
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
我的思路：
首先，最简单的方法，迭代nums1[N]，再嵌套迭代nums2[M]，比较如果相同记录下来，时间复杂度O（N*M）。但这个方法也有问题，如果nums1 = [1,2,2,2,1]，nums2 = [2,2]，这个时候输出应该是[2,2]，简单的迭代输出显然是[2,2,2]。
第二个思路，先将nums1和nums2处理成两个Map，key存数组中的元素，value存该元素出现的次数。然后我们再迭代，这样就保障了元素出现次数的正确。
class Solution {
public int[] intersect(int[] nums1, int[] nums2) {
HashMap<Integer, Integer> map1 = new HashMap<>(nums1.length);
HashMap<Integer, Integer> map2 = new HashMap<>(nums2.length);
HashMap<Integer, Integer> resultMap = new HashMap<>(Math.max(nums1.length, nums2.length));
List<Integer> resultList = new ArrayList<>();
for (int a : nums1) {
if (map1.containsKey(a)) {
int temp = map1.get(a);
map1.replace(a, ++temp);
} else {
map1.put(a, 1);
}
}
for (int a : nums2) {
if (map2.containsKey(a)) {
int temp = map2.get(a);
map2.replace(a, ++temp);
} else {
map2.put(a, 1);
}
}
for (Map.Entry<Integer, Integer> entry : map1.entrySet()) {
int key = entry.getKey();
int value = entry.getValue();
if (map2.containsKey(key)) {
resultMap.put(key, Math.min(value, map2.get(key)));
}
}
for (Map.Entry<Integer, Integer> entry : resultMap.entrySet()) {
for (int i = 0; i < entry.getValue(); i++) {
resultList.add(entry.getKey());
}
}
return resultList.stream().mapToInt(Integer::valueOf).toArray();
}
}
当然，可以看下这个题解。这个是我在github上找的一个热门的算法题解项目（小浩算法）。当然，官方的题解也很不错，Leetcode牛逼。
Leetcode官方给出的哈希题解相比个人的解法有了一个更好的优化，及我们只需要把最长的那个数组转为hash表，然后遍历另一个数组，当数组中某一元素在hash表中存在同时其value>0，则将该元素记录下来并将value--。这个的好处在于时间复杂度确定了O（min(N,M)），同时也只用对一个数组进行hash转换。
class Solution {
public int[] intersect(int[] nums1, int[] nums2) {
// 这里很精彩，通过一个递归保证nums1始终为最长的数组
if (nums1.length > nums2.length) {
return intersect(nums2, nums1);
}
// nums1转hash表
Map<Integer, Integer> map = new HashMap<Integer, Integer>();
for (int num : nums1) {
int count = map.getOrDefault(num, 0) + 1;
map.put(num, count);
}
int[] intersection = new int[nums1.length];
// index为输出数组下标
int index = 0;
// 遍历nums2
for (int num : nums2) {
// 获取key对应的value，key不存在返回0
int count = map.getOrDefault(num, 0);
// 当count>0时，进行下一步计算
if (count > 0) {
// 先将key放入输出数组，在将下标指向下一位
intersection[index++] = num;
// 计数减一
count--;
// 这里是对map的整理，个人感觉除非remove比put快很多，否则不需要再做一次判断
if (count > 0) {
map.put(num, count);
} else {
map.remove(num);
}
}
}
// Arrays.copyOfRange方法，将数组从下标0到下标index截取并返回一个新数组
return Arrays.copyOfRange(intersection, 0, index);
}
}
进阶:
如果给定的数组已经排好序呢？将如何优化你的算法呢？
这里我确实没什么思路。所以看看别人的解法，揣测下别人的思路。这里是leetcode官方的题解二。
class Solution {
public int[] intersect(int[] nums1, int[] nums2) {
// 先排序
Arrays.sort(nums1);
Arrays.sort(nums2);
int length1 = nums1.length, length2 = nums2.length;
int[] intersection = new int[Math.min(length1, length2)];
// 使用双指针，index1指向nums1，index2指向nums2，index指向输出数组
int index1 = 0, index2 = 0, index = 0;
// 迭代，当双指针中有一个遍历完数组后，跳出循环
while (index1 < length1 && index2 < length2) {
// 两个下标指向的元素比较大小，小的向后移一位。注意这里是已从小到大排好序了
if (nums1[index1] < nums2[index2]) {
index1++;
} else if (nums1[index1] > nums2[index2]) {
index2++;
} else {
// 相同的情况下，双指针向后移一位，记录该元素，同时index向后移一位
intersection[index] = nums1[index1];
index1++;
index2++;
index++;
}
}
return Arrays.copyOfRange(intersection, 0, index);
}
}
使用sort()方法，其底层是用的二分法。二分法的时间复杂度为logn 。所以此时间复杂度为O（mlogm + nlogn）。
如果 nums1 的大小比 nums2 小很多，哪种方法更优？
这种显然是第一种hash的更优
如果 nums2 的元素存储在磁盘上，内存是有限的，并且你不能一次加载所有的元素到内存中，你该怎么办？
在leetcode的解答上有两种说法，一种是使用方法一更优，一种是考虑使用外部磁盘，可以使用外部排序，及归并排序，将两个小文件和成一个大文件，并排好序。个人觉得仁者见仁智者见智了。
