【JAVA】两个数组的交集 II——力扣每日一题（一）（2020.07.13）

た入场券 2023-02-25 14:28 12阅读 0赞

### 目录 ###

*  题目：350. 两个数组的交集 II
 *  方法一：简单、暴力（有问题）
 *  方法二：哈希表
 *  方法三：排序
 *  结语

> 如果你从本文中学习到丝毫知识，那么请您点点**关注、点赞、评论和收藏**  
> 大家好，我是[爱做梦的鱼][Link 1]，我是东北大学大数据实验班大三的小菜鸡，非常渴望优秀，羡慕优秀的人，个人博客为：[爱做梦的鱼https://zihao.blog.csdn.net/][https_zihao.blog.csdn.net]，微信公众号、微信视频号为[【程序猿干货铺】][Link 2]，qq交流群为：[1107710098][]，  
> ![程序猿干货铺][Image 1]

> 如果你同样热爱算法，那么请**关注**我，我将每日更新力扣的每日一题的题解+代码，每周更新力扣周赛题解+代码  
> [专栏《力扣每日一题》][Link 3]  
> [专栏《力扣周赛》][Link 4]  
> [专栏《力扣大厂模拟面试算法题》][Link 5]

# 题目：350. 两个数组的交集 II #

> [题目地址（点击直接跳转）https://leetcode-cn.com/problems/intersection-of-two-arrays-ii/][https_leetcode-cn.com_problems_intersection-of-two-arrays-ii]

给定两个数组，编写一个函数来计算它们的交集。

**示例 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的元素存储在磁盘上，磁盘内存是有限的，并且你不能一次加载所有的元素到内存中，你该怎么办？

# 方法一：简单、暴力（有问题） #

public class V1 { 
        public static void main(String[] args) { 
            int[] a = { 1, 2, 2, 1};
            int[] b = { 2, 2};
            int[] c = { 2};
            int[] d = { 6, 6, 4, 4, 0, 0, 8, 1, 2};
            int[] e = { 6};
    // System.out.println(Arrays.toString(new V1().intersect(a, b)));
    // System.out.println(Arrays.toString(new V1().intersect(a, c)));
            System.out.println(Arrays.toString(new V1().intersect(d, e)));
        }
    
        public int[] intersect(int[] nums1, int[] nums2) { 
            //交集长度一定不会超过长度较小的那个数组的长度,没有用ArrayList这些可变数组是因为他们很浪费空间
            int[] result = new int[Math.min(nums1.length, nums2.length)];
            int index = 0;
            for (int i : nums1) { 
                for (int j = 0; j < nums2.length; j++) { 
                    if (i == nums2[j]) { 
                        result[index++] = nums2[j];
                        nums2[j] = -1; //万一数组中会出现-1，那我们这种做法就是错误的
                        break;
                    }
                }
            }
            return Arrays.copyOfRange(result, 0, index );
        }
    }

![在这里插入图片描述][20200713153159460.png]  
**以下方法二和方法三（题解+代码）全部来自力扣官方题解，我实在无法超越**

> 作者：LeetCode-Solution  
> 链接：[https://leetcode-cn.com/problems/intersection-of-two-arrays-ii/solution/liang-ge-shu-zu-de-jiao-ji-ii-by-leetcode-solution/][https_leetcode-cn.com_problems_intersection-of-two-arrays-ii_solution_liang-ge-shu-zu-de-jiao-ji-ii-by-leetcode-solution]  
> 来源：力扣（LeetCode） 著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

# 方法二：哈希表 #

由于同一个数字在两个数组中都可能出现多次，因此需要用哈希表存储每个数字出现的次数。对于一个数字，其在交集中出现的次数等于该数字在两个数组中出现次数的最小值。

首先遍历第一个数组，并在哈希表中记录第一个数组中的每个数字以及对应出现的次数，然后遍历第二个数组，对于第二个数组中的每个数字，如果在哈希表中存在这个数字，则将该数字添加到答案，并减少哈希表中该数字出现的次数。

为了降低空间复杂度，首先遍历较短的数组并在哈希表中记录每个数字以及对应出现的次数，然后遍历较长的数组得到交集。

class Solution { 
        public int[] intersect(int[] nums1, int[] nums2) { 
            if (nums1.length > nums2.length) { 
                return intersect(nums2, nums1);
            }
            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];
            int index = 0;
            for (int num : nums2) { 
                int count = map.getOrDefault(num, 0);
                if (count > 0) { 
                    intersection[index++] = num;
                    count--;
                    if (count > 0) { 
                        map.put(num, count);
                    } else { 
                        map.remove(num);
                    }
                }
            }
            return Arrays.copyOfRange(intersection, 0, index);
        }
    }

![在这里插入图片描述][20200714000011102.png]  
**复杂度分析**

时间复杂度：O(m+n)，其中 mm 和 nn 分别是两个数组的长度。需要遍历两个数组并对哈希表进行操作，哈希表操作的时间复杂度是 O(1)，因此总时间复杂度与两个数组的长度和呈线性关系。

空间复杂度：O(min(m,n))，其中 mm 和 nn 分别是两个数组的长度。对较短的数组进行哈希表的操作，哈希表的大小不会超过较短的数组的长度。为返回值创建一个数组 intersection，其长度为较短的数组的长度。

# 方法三：排序 #

如果两个数组是有序的，则可以便捷地计算两个数组的交集。  
首先对两个数组进行排序，然后使用两个指针遍历两个数组。  
初始时，两个指针分别指向两个数组的头部。每次比较两个指针指向的两个数组中的数字，如果两个数字不相等，则将指向较小数字的指针右移一位，如果两个数字相等，将该数字添加到答案，并将两个指针都右移一位。当至少有一个指针超出数组范围时，遍历结束。

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)];
            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 { 
                    intersection[index] = nums1[index1];
                    index1++;
                    index2++;
                    index++;
                }
            }
            return Arrays.copyOfRange(intersection, 0, index);
        }
    }

![在这里插入图片描述][20200714000038251.png]  
**复杂度分析**

时间复杂度：O(mlogm+nlogn)，其中 mm 和 nn 分别是两个数组的长度。对两个数组进行排序的时间复杂度是 O(mlogm+nlogn)，遍历两个数组的时间复杂度是 O(m+n)，因此总时间复杂度是O(mlogm+nlogn)。

空间复杂度：O(min(m,n))，其中 mm 和 nn 分别是两个数组的长度。为返回值创建一个数组 intersection，其长度为较短的数组的长度。不过在 C++ 中，我们可以直接创建一个 vector，不需要把答案临时存放在一个额外的数组中，所以这种实现的空间复杂度为 O(1)。

# 结语 #

如果 nums2的元素存储在磁盘上，磁盘内存是有限的，并且你不能一次加载所有的元素到内存中。那么就无法高效地对nums2进行排序，因此推荐使用方法二而不是方法三。在方法二中，nums2 只关系到查询操作，因此每次读取nums2中的一部分数据，并进行处理即可。

[Link 1]: https://blog.csdn.net/weixin_43124279
[https_zihao.blog.csdn.net]: https://zihao.blog.csdn.net/
[Link 2]: https://s1.ax1x.com/2020/06/11/tHUSvq.png
[1107710098]: https://s1.ax1x.com/2020/06/26/NroKrd.jpg
[Image 1]: 
[Link 3]: https://blog.csdn.net/weixin_43124279/category_10194088.html
[Link 4]: https://blog.csdn.net/weixin_43124279/category_10194115.html
[Link 5]: https://blog.csdn.net/weixin_43124279/category_10202733.html
[https_leetcode-cn.com_problems_intersection-of-two-arrays-ii]: https://leetcode-cn.com/problems/intersection-of-two-arrays-ii/
[20200713153159460.png]: /images/20230209/af44e58f50b64792870f9fcc2870123b.png
[https_leetcode-cn.com_problems_intersection-of-two-arrays-ii_solution_liang-ge-shu-zu-de-jiao-ji-ii-by-leetcode-solution]: https://leetcode-cn.com/problems/intersection-of-two-arrays-ii/solution/liang-ge-shu-zu-de-jiao-ji-ii-by-leetcode-solution/
[20200714000011102.png]: /images/20230209/98d0113498434c998a5e7d41402313e4.png
[20200714000038251.png]: /images/20230209/186530b010624a98842229c85d0f093e.png