LeetCode349 数组的交集（哈希表）

本文链接： https://blog.csdn.net/No__names/article/details/89074593

题目描述：

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

示例 1:

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

示例 2:

输入: nums1 = [4,9,5], nums2 = [9,4,9,8,4]
输出: [9,4]

说明:

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

思路一：

数组排序，去重，然后对每一个A中的元素，判断在B中是否存在。时间复杂度O(n^2)。

代码如下：

class Solution {
public:
    //去重
    static vector<int> distinct(vector<int> &A) {
        vector<int> ans;
        sort(A.begin(), A.end());
        ans.push_back(A[0]);
        for (int i = 1; i < A.size(); i++) {
            if (A[i] != ans[ans.size() - 1])
                ans.push_back(A[i]);
        }
        return ans;
    }
    
    //求交集
    vector<int> intersection(vector<int>& A, vector<int>& B) {
        vector<int> ans;
        if (A.size() == 0 || B.size()== 0)
            return ans;
        A = distinct(A);
        B = distinct(B);
        int index=0;
        for (int i = 0; i < A.size(); i++) {
            for (int j = index; j < B.size(); j++) {
                if (A[i] == B[j]) {
                    ans.push_back(A[i]);
                    index = j;
                    if (index == B.size() - 1)
                        return ans;
                    break;
                }
                else if (j == B.size()-1&&A[i]>B[j])
				    return ans;
            }
        }
        return ans;
    }
};

思路二：思路借鉴于博客最快速度求两个数组之交集算法与hash

快速排序，去重，时间复杂度O(nlogn)，然后使用指针遍历两个数组，指针遍历部分的时间复杂度是O(n)，因此算法的时间复杂度取决于排序算法的复杂度，若使用线性时间排序算法，则整个算法时间复杂度可减少为O(n)。指针遍历部分之所以能控制时间复杂度在O(n)内是因为排序带来的良好性质。

指针遍历部分思路如下:

int count()
{
    total=i=j=0;
    while(i<n && j<n)
    {
        if(a[i]<b[j]) i++;
        else if(a[i]>b[j])j++
        else{
            total++;
            i++;
            j++;
        }
    }
    return total;
}

思路三：查找是否存在的问题，可以考虑哈希表，在常数时间内查找某一元素是否存在。

用小的集合建立哈希表map，遍历大的集合，若在哈希表map中存在相关元素且防止重复的哈希表dinstinct中不存在相关元素，则将该元素放入交集ans，且将该元素放入防止重复的哈希表dinstinct中。时间复杂度O(max(A.size(),B.size()))，额外空间复杂度O(min(A.size(),B.size()))。

代码如下：

class Solution {
public:
    vector<int> intersection(vector<int>&A, vector<int> &B) {
        //A是大的集合
        if (A.size() < B.size())
            swap(A, B);
        unordered_map <int, int> map;
        unordered_map<int, int> distinct;
        vector<int> ans;
        for (auto i : B) 
            map[i] = 1;
        for (auto i : A) {
            if (map.count(i) && !distinct.count(i)) {
                ans.push_back(i);
                distinct[i] = 1;
            }
        }
        return ans;
    }
};

LeetCode349 数组的交集（哈希表）

猜你喜欢