求两个数组的交集c++

这里提供两种方法：

方法一：使用set

a = [1, 2, 3, 4, 5]
b = [4, 5, 6, 7, 8]

set_a = set(a)
set_b = set(b)

c = set_a & set_b

print(list(c))  # 输出 [4, 5]

方法二：使用列表推导式

a = [1, 2, 3, 4, 5]
b = [4, 5, 6, 7, 8]

c = [i for i in a if i in b]

print(c)  # 输出 [4, 5]

以上两种方法都可以求出两个数组的交集c。

相关问题

c++求两个数组交集

在C++中，你可以通过多种算法来找出两个数组的交集。这里介绍一种常见的方法，即使用哈希集合（如STL中的unordered_set）来简化操作。以下是基本步骤：

1. 首先，创建一个哈希集合（unordered_set），用于存储第一个数组的所有元素。
2. 然后，遍历第二个数组，对于每个元素，检查它是否已经在哈希集合中。如果在，就说明它是两个数组的交集。
3. 最后，将找到的交集元素保存到一个新的数组或容器中。

#include <iostream>
#include <unordered_set>
using namespace std;

vector<int> intersect(vector<int>& nums1, vector<int>& nums2) {
    unordered_set<int> set1(nums1.begin(), nums1.end());
    vector<int> result;
    
    for (int num : nums2) {
        if (set1.find(num) != set1.end()) {
            result.push_back(num);
        }
    }
    
    return result;
}

// 示例
int main() {
    vector<int> arr1 = {1, 2, 2, 1}; // 第一个数组
    vector<int> arr2 = {2, 2, 3, 4}; // 第二个数组

    vector<int> intersection = intersect(arr1, arr2);

    for (int i : intersection) {
        cout << i << " ";
    }

    return 0;
}

两个数组取交集C++

在C++中，要计算两个数组的交集，可以采用多种方法。这里提供一种常见的做法，即使用哈希集合（如`std::unordered_set`）来存储第一个数组的所有元素，然后遍历第二个数组，检查每个元素是否在哈希集合中存在。以下是步骤：

#include <iostream>
#include <unordered_set>
#include <vector>

std::vector<int> intersect(std::vector<int>& nums1, std::vector<int>& nums2) {
    // 创建一个哈希集合来存储nums1的元素
    std::unordered_set<int> hashSet(nums1.begin(), nums1.end());

    // 创建一个结果向量用于存放交集
    std::vector<int> result;

    // 遍历nums2，如果元素在hashSet中，则添加到结果中
    for (int num : nums2) {
        if (hashSet.find(num) != hashSet.end()) {
            result.push_back(num);
        }
    }

    return result;
}

int main() {
    std::vector<int> nums1 = {1, 2, 2, 1};
    std::vector<int> nums2 = {2, 2};
    std::vector<int> intersection = intersect(nums1, nums2);
    for (int i : intersection) {
        std::cout << i << " ";
    }
    return 0;
}

在这个例子中，函数`intersect`会返回两个数组`nums1`和`nums2`中的交集元素。注意，这种方法假设数组中不会有重复的整数，并且不考虑顺序。