算法题:两个数组的交集 难度：简单 知识点：哈希表、二分查找、双指针

题目:
给你两个整数数组 nums1 和 nums2 ，请你以数组形式返回两数组的交集。返回结果中每个元素出现的次数，应与元素在两个数组中都出现的次数一致（如果出现次数不一致，则考虑取较小值）。可以不考虑输出结果的顺序。

这道题本来题目都没读懂的…😶

然后这是自己哈希表的解法

class Solution {
    public int[] intersect(int[] nums1, int[] nums2) {
        int size1,size2;
        size1 = nums1.length;
        size2 = nums2.length;
        int k = 0;
        int count=0;
        if (nums1.length > nums2.length) {
            return intersect(nums2, nums1);
        }

        int[] ru = new int[size2];
        int j = 0;
        Map<Integer,Integer> map = new HashMap<>();

            for(int i=0;i<size1;i++){
                if(map.get(nums1[i])!=null){
                    map.put(nums1[i],map.get(nums1[i])+1);
                }else{
                    map.put(nums1[i],1);
                }
            }
            for(k=0;k<size2;k++){
            if(map.get(nums2[k])!=null){
               
                if(map.get(nums2[k])==0){
                     continue;
                }
                ru[j]=nums2[k];
                     count+=1;
                j++;
                 map.put(nums2[k],map.get(nums2[k])-1);
               
                
              }
            }

        
     return Arrays.copyOfRange(ru, 0, count);
        

    }
}

先把最短的数组弄出来，如果nums2小的话，就return一次，从新进入一次intersect（）,然后把短的数组先遍历一遍，重复出现的map的值就加一
然后遍历长的nums2数组，每在map中找到一个存在的，就值减1，然后把这个键加入数组中，然后不断重复…

最后新学到的Araays的工具类的新方法 copyOfRange(要修改的数组，开始下标，结束下标)。

同样的时间复杂度，但更简洁

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);
    }
}

//内容中有个新方法getOrDefault(), sites.getOrDefault(1, “Not Found”);
1 代表你要搜索的key，如果找到了就返回值，没找到就返回你自己设置的默认值“Not Found"

解法2 排序 + 双指针

如果两个数组是有序的，则可以使用双指针的方法得到两个数组的交集。

首先对两个数组进行排序，然后使用两个指针遍历两个数组。

初始时，两个指针分别指向两个数组的头部。每次比较两个指针指向的两个数组中的数字，如果两个数字不相等，则将指向较小数字的指针右移一位，如果两个数字相等，将该数字添加到答案，并将两个指针都右移一位。当至少有一个指针超出数组范围时，遍历结束。

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);
    }
}

（优解都取自力扣）