[LeetCode] 350. Intersection of Two Arrays II

最新推荐文章于 2024-09-08 20:02:08 发布

空界江海

最新推荐文章于 2024-09-08 20:02:08 发布

阅读量244

点赞数

分类专栏： LeetCode 文章标签： leetcode

本文链接：https://blog.csdn.net/zhao_tw/article/details/52876301

版权

LeetCode 专栏收录该内容

9 篇文章 0 订阅

订阅专栏

350. Intersection of Two Arrays II

Given two arrays, write a function to compute their intersection.

Example:
Given nums1 = [1, 2, 2, 1], nums2 = [2, 2], return [2, 2].

Note:

Each element in the result should appear as many times as it shows in both arrays.
The result can be in any order.

Follow up:

What if the given array is already sorted? How would you optimize your algorithm?
What if nums1's size is small compared to nums2's size? Which algorithm is better?
What if elements of nums2 are stored on disk, and the memory is limited such that you cannot load all elements into the memory at once?

解题思路：
1. 查找删除 O(n^2)

遍历数组长度较小的那个数组的每个数字，在另一个数组中查找每一个数字，若找到，则从该数组中删除。其中遍历小数组需要n，操作的查找和删除需要2n，所以时间复杂度O(n^2).。
class Solution {
public:
    vector<int> intersect(vector<int>& nums1, vector<int>& nums2) {
        vector<int> res;
          vector<int>& mi=nums1.size()<nums2.size()?nums1:nums2;
          vector<int>& ma=nums1.size()>=nums2.size()?nums1:nums2;
        vector<int>::iterator it;
        for(int i=0;i<mi.size();i++){
            it=find(ma.begin(),ma.end(),mi[i]);
            if(it!=ma.end()){
                res.push_back(mi[i]);
                ma.erase(it);
            }
        }
        return res;
    }
};
2. 统计重复数字个数 O(n^2)???

使用两个map分别存储两数组出现的元素的次数，将两数组同时出现的数字存入结果，且应该存入出现次数较少的那个的数量。
class Solution {
public:
    vector<int> intersect(vector<int>& nums1, vector<int>& nums2) {
        vector<int> res;
        if(nums1.empty()||nums2.empty()) return res;
        int i,j,tmp;
        map<int,int> m1,m2;
        for(i=0;i<nums1.size();i++)
            m1[nums1[i]]++;
        for(i=0;i<nums2.size();i++)
            m2[nums2[i]]++;
        map<int, int>::iterator it2 = m2.begin();
        for(;it2!=m2.end();it2++){
             map<int, int>::iterator it1 = m1.find(it2->first);
             if(it1!=m1.end()){
                 tmp = (it1->second)>(it2->second)?(it2->second):(it1->second);
                 while(tmp--)
                     res.push_back(it1->first);
             }
        }
        return res;
    }
};
PS，关于这个方法的时间复杂度有些困惑，分析应该是在O(nlogn)~O(n^2)之间的，但是实际运行时间和第一种方法相同。不造是什么原因。。。
3. 排序法 O(nlogn)

将两个数组分别升序排序。设两个下标i和j，从0开始循环到任一数组结尾，若nums1[i]==nums2[j]，则将这一数字存入结果，否则数字较小的下标+1。
class Solution {
public:
    vector<int> intersect(vector<int>& nums1, vector<int>& nums2) {
        vector<int> res;
        sort(nums1.begin(),nums1.end());
        sort(nums2.begin(),nums2.end());
        for(int i=0,j=0;i<nums1.size()&&j<nums2.size();){
           if(nums1[i]==nums2[j]){
                res.push_back(nums1[i]);
                i++;j++;
            }
            else if(nums1[i]>nums2[j])
                   j++;
            else i++;
        }
        return res;
    }
};
最后回答第三个问题。当nums2过大，只能先存在外存中，使用的时候一个一个读入，并在nums1中查找是否存在。则这种方法时间复杂度约为O(n)。