L349. L350两个数组的交集

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

示例 1:

输入: nums1 = [1,2,2,1], nums2 = [2,2]
输出: [2]
示例 2:

输入: nums1 = [4,9,5], nums2 = [9,4,9,8,4]
输出: [9,4]
说明:

输出结果中的每个元素一定是唯一的。（这个就表示不允许重复）
我们可以不考虑输出结果的顺序。

class Solution {
    public int[] intersection(int[] nums1, int[] nums2) {
        int len1 = nums1.length, len2 = nums2.length;
        
        HashSet<Integer> set = new HashSet<>();
        HashSet<Integer> s2 = new HashSet<>();
        for(int i = 0; i < len1; i++){
            set.add(nums1[i]);
        }
        for(int i = 0; i < len2; i++){
            if(set.contains(nums2[i])){
                s2.add(nums2[i]);
            }
        }
        int[] res = new int[s2.size()];
        int i= 0;
        for(int nn: s2){
            res[i++] = nn;
        }
        return res;
    }
}

2.利用内置函数

class Solution {
    public int[] intersection(int[] nums1, int[] nums2) {
        int len1 = nums1.length, len2 = nums2.length;
        
        HashSet<Integer> set = new HashSet<>();
        HashSet<Integer> s2 = new HashSet<>();
        for(int i = 0; i < len1; i++){
            set.add(nums1[i]);
        }
        for(int i = 0; i < len2; i++){
            s2.add(nums2[i]);
        }
        //利用内置函数
        set.retainAll(s2);
        int[] res = new int[set.size()];
        int i= 0;
        for(int nn: set){
            res[i++] = nn;
        }
        return res;
    }
}

L350

350. 两个数组的交集 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 的元素存储在磁盘上，磁盘内存是有限的，并且你不能一次加载所有的元素到内存中，你该怎么办？
1使用hashmap计算次数、

class Solution {
    public int[] intersect(int[] nums1, int[] nums2) {
        int len1 = nums1.length, len2 = nums2.length;
        if(len1 > len2) return intersect(nums2, nums1);//直接交换就可以了
        HashMap<Integer, Integer> map = new HashMap<>();//改用hashMap,记录元素的个数
        //这里最终的结果允许出现重复的
        for(int nn :nums1){
            map.put(nn ,map.getOrDefault(nn, 0) + 1);
        }
        int k = 0;
        int [] ans = new int[len1];//现在大小不确定，但是可以使用函数
        for(int nn: nums2){
            int cnt = map.getOrDefault(nn, 0);//注意不能直接使用get
            if(cnt > 0){
                ans[k++] = nn;
                map.put(nn, map.get(nn) - 1);//每取一次，就-1
            }
        }
        return Arrays.copyOfRange(ans, 0, k);

    }

}

当输入数据是有序的，推荐使用此方法。在这里，我们对两个数组进行排序，并且使用两个指针在一次扫面找出公共的数字。

class Solution {
    public int[] intersect(int[] nums1, int[] nums2) {
        int len1 = nums1.length, len2 = nums2.length;
        //先排序
        Arrays.sort(nums1);
        Arrays.sort(nums2);
        int i = 0, j = 0, k = 0;
        int ans[] = new int[len1];
        
        while(i < len1 && j < len2){//只要有一个到结尾就停下来
            if(nums1[i] < nums2[j]){
                i++;
            }else if(nums1[i] > nums2[j]){
                j++;
            }else {//如果相同
                ans[k++] = nums1[i++];
                j++;
            }
        }
        return Arrays.copyOfRange(ans, 0, k);

    }

}

解法三：通过归并外排将两个数组排序后再使用排序双指针查找
对应进阶问题三，如果内存十分小，不足以将数组全部载入内存，那么必然也不能使用哈希这类费空间的算法，只能选用空间复杂度最小的算法，即解法一。

但是解法一中需要改造，一般说排序算法都是针对于内部排序，一旦涉及到跟磁盘打交道（外部排序），则需要特殊的考虑。归并排序是天然适合外部排序的算法，可以将分割后的子数组写到单个文件中，归并时将小文件合并为更大的文件。当两个数组均排序完成生成两个大文件后，即可使用双指针遍历两个文件，如此可以使空间复杂度最低。