leetcode初级算法--两个数组的交集 II（Python）

题目：

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

思考一，先排序两个数组，再遍历两个数组，如果数组1的数字小那就i增大，如果数组2的数字小那j就增大，，不然两个都相等则加入到新的列表里，最后输出列表

class Solution:
    def intersect(self, nums1: List[int], nums2: List[int]) -> List[int]:
        q = []
        nums1.sort()
        nums2.sort()
        i = j = 0
        while(i<len(nums1) and j<len(nums2)):
            if(nums1[i]>nums2[j]):
                j+=1
            elif (nums1[i]<nums2[j]):
                i+=1
            else:
                q.append(nums2[j])
                i += 1
                j += 1
        
        return q

 

思考2：尝试使用字典：

class Solution:
    def intersect(self, nums1: List[int], nums2: List[int]) -> List[int]:
        q = {}
        q2 = []
        for i in nums1:
            if i in q:
                q[i] += 1 
            else:
                q[i] = 1
        for j in nums2:
            if j in q and q[j]>0:
                q[j]-=1
                q2.append(j)
        return q2

 很明显比上一个快很多

别人的思考与代码：

1、使用map解决
还可以使用map来解决，具体操作如下

遍历nums1中的所有元素，把它存放到map中，其中key就是nums1中的元素，value就是这个元素在数组nums1中出现的次数。遍历nums2中的所有元素，查看map中是否包含nums2的元素，如果包含，就把当前值加入到集合list中，然后对应的value要减1。最后再把集合list转化为数组即可

    public int[] intersect(int[] nums1, int[] nums2) {
        HashMap<Integer, Integer> map = new HashMap<>();
        ArrayList<Integer> list = new ArrayList<>();

        //先把数组nums1的所有元素都存放到map中，其中key是数组中
        //的元素，value是这个元素出现在数组中的次数
        for (int i = 0; i < nums1.length; i++) {
            map.put(nums1[i], map.getOrDefault(nums1[i], 0) + 1);
        }

        //然后再遍历nums2数组，查看map中是否包含nums2的元素，如果包含，
        //就把当前值加入到集合list中，然后再把对应的value值减1。
        for (int i = 0; i < nums2.length; i++) {
            if (map.getOrDefault(nums2[i], 0) > 0) {
                list.add(nums2[i]);
                map.put(nums2[i], map.get(nums2[i]) - 1);
            }
        }

        //把集合list转化为数组
        int[] res = new int[list.size()];
        for (int i = 0; i < list.size(); i++) {
            res[i] = list.get(i);
        }
        return res;
    }

这个方法相当于把列表1加入Python的字典中，是个不错的想法

2、使用迭代器去解决（这个还是很厉害的，耗时0ms）

#include <algorithm>
class Solution {
public:
    vector<int> intersect(vector<int>& nums1, vector<int>& nums2) {
        vector<int>target;
        sort(nums1.begin(),nums1.end());
        sort(nums2.begin(),nums2.end());
        for(vector<int>::iterator it1=nums1.begin(),it2=nums2.begin();it1!=nums1.end()&&it2!=nums2.end();)
        {
            if(*it1<*it2 ) it1++;
            else if(*it1==*it2)
            {
                target.push_back(*it1);
                 it1++;
                 it2++;
            }
            else if(*it1>*it2 ) it2++;
        }
        return target;
    }
};

3、java双指针

class Solution {
    public int[] intersect(int[] nums1, int[] nums2) {
        int len1 = nums1.length, len2 = nums2.length;
        int len = len1<len2?len1:len2;
        int[] ans = new int[len];
        if(len1 == 0 || len2 == 0){  //处理边界条件
            return ans;
        }
        Arrays.sort(nums1);
        Arrays.sort(nums2);
        int i=0, j=0, k=0;
        while(i<len1 && j<len2){
            if(nums1[i] == nums2[j]){
                ans[k++] = nums1[i];
                i++;
                j++;
            }else if(nums1[i] < nums2[j]){
                i++;
            }else{
                j++;
            }
        }
        return Arrays.copyOfRange(ans, 0, k);
    }
}

4、哈希表

var intersect = function(nums1, nums2) {
    // 哈希表
    const map={},arr=[];
    for(const i of nums1){
        // 统计nums1中每个元素的个数
        if(map[i]){
            map[i]++
        }else {
            map[i]=1;
        }
    }
    for(const j of nums2){
        // 记住当前元素的个数
        const num=map[j];
        // 判断当前元素个数，并一次压入arr中
        if(num>0){
            arr.push(j);
            map[j]--;
        }
    }
    return arr;
};