LeetCode-算法初级-数组-6-两个数字的交集 II

class Solution {
public:
    vector<int> intersect(vector<int>& nums1, vector<int>& nums2) {
        sort(nums1.begin(),nums1.end());
        sort(nums2.begin(),nums2.end());
        vector<int> nums3;
        int i=nums1.size();
        int w=nums2.size();
        int n=0,q=0;
      while(n<i&&q<w)
      {
        if(n<i)
        {
                if(q<w)
            {
                if(nums1[n] == nums2[q])
                {
                    nums3.push_back(nums1[n]);
                    
                }
                else if(n>0&&q>0)
                {
                    if(nums1[n]!=nums1[n-1]&&nums2[q]!=nums2[q-1])
                    {
                        if(nums1[n]<nums2[q])
                        {
                            q--;
                        }
                        else n--;
                    }
                    else if(nums1[n]!=nums1[n-1])
                    {
                        n--;
                    }
                    else if(nums2[q]!=nums2[q-1])
                    {
                        q--;
                    }
                }
                else
                {
                     if(nums1[n]<nums2[q])
                    {
                        q--;
                    }
                    else n--;
                }
                q++;
            }
            n++;
     
        }
      }
        return nums3;

    }
};

在代码里打备注太麻烦了，所以简单写一下我愚蠢的思路。

题目：

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

数组乱序加上可以不考虑输出结果的顺序，所以可以先进行排序方便后面的处理所以直接用sort函数。然后同步两个数组开头开始分成三种情况，一种两个相同，一种其中一个改变一个没有改变，一种两个都发生了改变。然后分类讨论然后遍历。

官方思路力扣

方法一：哈希表

class Solution {
public:
    vector<int> intersect(vector<int>& nums1, vector<int>& nums2) {
        if (nums1.size() > nums2.size()) {
            return intersect(nums2, nums1);//交换数组
        }
        unordered_map <int, int> m;//开哈希表
        for (int num : nums1) {//遍历
            ++m[num];
        }
        vector<int> intersection;
        for (int num : nums2) {
            if (m.count(num)) {//哈希表的.count()只有0，1，只能用于判断是否存在该数字
                intersection.push_back(num);//将数字推入数组
                --m[num];
                if (m[num] == 0) {
                    m.erase(num);
                }
            }
        }
        return intersection;
    }
};

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

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

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

哈希表遍历

for (auto i = hash.begin(); i != hash.end(); i++)

查找

某个元素是否在哈希表中，可以使用hash.find(x) != hash.end(),或者hash.count(x) > 0

在unordered_map中插入元素，可以使用hash[key] = value。

删除

在unordered_set 跟unordered_map 中删除元素，都用hash.erase(key)。
注意，在unordered_map 中，即使hash[key] == 0，如果之前已经将key存入到hash中，然后通过hash[key] -- 使得hash[key] == 0，hash 中还会存在key ，也就是说此时hash.count(key) == 1。
在个别场景下，可能需要一次性删除 unordered_map 容器中存储的所有键值对，可以使用clear()方法，其语法格式如下：

    void clear()
    {
    hash.clear();
    }

方法二：排序 + 双指针

class Solution {
public:
    vector<int> intersect(vector<int>& nums1, vector<int>& nums2) {
        sort(nums1.begin(), nums1.end());
        sort(nums2.begin(), nums2.end());
        int length1 = nums1.size(), length2 = nums2.size();
        vector<int> intersection;
        int index1 = 0, index2 = 0;
        while (index1 < length1 && index2 < length2) {
            if (nums1[index1] < nums2[index2]) {
                index1++;
            } else if (nums1[index1] > nums2[index2]) {
                index2++;
            } else {
                intersection.push_back(nums1[index1]);
                index1++;
                index2++;
            }
        }
        return intersection;
    }
};

和我思路一样，但是简便很多很多。