《LeetCode之每日一题》：47.两个数组的交集

Posted 2021-06-15 是七喜呀！

两个数组的交集

• 有关题目
• • 题解

题目链接： 两个数组的交集

有关题目

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

示例 1：

输入：nums1 = [1,2,2,1], nums2 = [2,2]
输出：[2]

示例 1：

输入：nums1 = [1,2,2,1], nums2 = [2,2]
输出：[2]

说明：

输出结果中的每个元素一定是唯一的。
我们可以不考虑输出结果的顺序。

题解

法一：两个集合–哈希表

思路：使用哈希表来降低时间复杂度

代码一：

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        unordered_set<int> set1,set2;
        for (auto& num1 : nums1)
        {
            set1.insert(num1);
        }
        for (auto& num2 : nums2)
        {
            set2.insert(num2);
        }
        
        return getIntersection(set1,set2);
    }
vector<int> getIntersection(unordered_set<int>& set1, unordered_set<int>& set2)
{
    if(set1.size() > set2.size())
        return getIntersection(set2,set1);
    vector<int> intersection;
    for (auto& num : set1)
    {
        if (set2.find(num) != set2.end())//set.count(num)也可以
            intersection.push_back(num);
    }
    return intersection;
}
};

时间复杂度：O(m + n)
空间复杂度：O(m + n)

代码二：

		//对上面的set2进行优化
        //if (set1.find(num2))
        //set2.insert(nums2)
        class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        unordered_set<int> set1,set2;
        for (auto& num : nums1)
        {
            set1.insert(num);
        }
        for (auto& num : nums2)
        {
        //优化代码一
            if (set1.find(num) != set1.end())//find
                set2.insert(num);
        }
        vector<int> intersection;//同时注意这边要用容器来装set2中的值，直接返回set就出错了
        for (auto& num : set2)
            intersection.push_back(num);
            return intersection;
    }
};

代码三：

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        vector<int> ans;
        unordered_set<int> mp{nums1.begin(),nums1.end()};
        for(auto& num2 : nums2)
        {
            if (mp.find(num2) != mp.end())
                {
                    mp.erase(num2);
                    ans.emplace_back(num2);
                }
        }
        return ans;
    }
};

时间复杂度：O(m + n)
空间复杂度：O(m + n)

法二：二分查找

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        unordered_set<int> set;
        sort(nums2.begin(), nums2.end());
        for (auto& target : nums1)
        {
            if (binarySearch(nums2,target) && !set.count(target))
            {
                set.insert(target);
            }
        }
         vector<int> intersection;
        for (auto& num : set)
            intersection.push_back(num);
        return intersection;
    }
    
bool binarySearch(vector<int>& nums2,int target)
{
    int l = 0, r = nums2.size() - 1;
    while(l <= r)
    {
        int mid = l + (r - l) / 2;
        if (nums2[mid] == target)
            return true;
        else if (nums2[mid] < target)
            l = mid + 1;
        else 
            r = mid - 1;
    }
    return false;
}
};

时间复杂度：nlog n。nums2的排序nlogn，加上nums1的遍历 m,加上二分查找的log m，共计nlog n。
空间复杂度：O(Max{m,n})

法三：排序 + 双指针

思路：先排序，再使用双指针

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        sort(nums1.begin(),nums1.end());
        sort(nums2.begin(),nums2.end());
        int len1 = nums1.size(),len2 = nums2.size();
        int idx1 = 0,idx2 = 0;
        vector<int> intersection;
        while(idx1 < len1 && idx2 < len2)
        {
            int num1 = nums1[idx1],num2 = nums2[idx2];
            if (num1 == num2)
                {
                    if (!intersection.size() || num1 != intersection.back())//back就是用来保证元素的唯一性的
                    //而前一个条件是用来防止当intersection中无元素，造成非法访问
                        intersection.push_back(num1);
                        //别忘了两个指针同时往后面移动
                        idx1++;
                        idx2++;
                }
            else if (num1 < num2)
                idx1++;
            else 
                idx2++;
        }
        return intersection;
    }
};