两个数组的交集
题目:
给定两个数组,编写一个函数来计算它们的交集。
示例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 map1 = new HashMap<>(nums1.length);
HashMap map2 = new HashMap<>(nums2.length);
HashMap resultMap = new HashMap<>(Math.max(nums1.length, nums2.length));
List 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 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 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 map = new HashMap();
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的解答上有两种说法,一种是使用方法一更优,一种是考虑使用外部磁盘,可以使用外部排序,及归并排序,将两个小文件和成一个大文件,并排好序。个人觉得仁者见仁智者见智了。