C++数组交集算法：从暴力搜索到哈希优化

1. 问题背景与需求分析

在处理数据时，我们经常需要比较两个数组中的相同元素。比如统计用户兴趣重合度、分析商品购买行为交集，或者处理数据库查询结果的共同部分。这类需求在实际开发中非常常见。

以C++为例，假设我们有两个数组：

cpp复制int arr1[] = {1, 2, 3, 4, 5};
int arr2[] = {3, 4, 5, 6, 7};

期望得到它们的交集{3, 4, 5}。这个看似简单的问题，其实需要考虑多种边界情况：

• 数组可能包含重复元素
• 数组可能为空
• 元素顺序是否需要保持
• 时间复杂度是否有要求
• 空间复杂度是否有限制

2. 基础实现方案

2.1 暴力搜索法

最直观的方法是双重循环遍历：

cpp复制vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
    vector<int> result;
    for (int num1 : nums1) {
        for (int num2 : nums2) {
            if (num1 == num2) {
                result.push_back(num1);
                break;
            }
        }
    }
    return result;
}

注意：这种方法时间复杂度O(n²)，只适合小规模数据。当数组长度超过1000时性能会显著下降。

2.2 哈希表优化

使用unordered_set可以大幅提升效率：

cpp复制vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
    unordered_set<int> set1(nums1.begin(), nums1.end());
    vector<int> res;
    
    for (int num : nums2) {
        if (set1.count(num)) {
            res.push_back(num);
            set1.erase(num); // 避免重复添加
        }
    }
    return res;
}

这种方法：

1. 将第一个数组转为哈希集合（O(n)）
2. 遍历第二个数组检查存在性（O(m)）
3. 总体时间复杂度O(n+m)

3. 进阶解决方案

3.1 排序+双指针法

当内存有限时，可以不用哈希表：

cpp复制vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
    sort(nums1.begin(), nums1.end());
    sort(nums2.begin(), nums2.end());
    
    vector<int> res;
    int i = 0, j = 0;
    while (i < nums1.size() && j < nums2.size()) {
        if (nums1[i] == nums2[j]) {
            if (res.empty() || res.back() != nums1[i]) {
                res.push_back(nums1[i]);
            }
            i++;
            j++;
        } 
        else if (nums1[i] < nums2[j]) {
            i++;
        }
        else {
            j++;
        }
    }
    return res;
}

特点：

• 时间复杂度O(nlogn + mlogm)
• 空间复杂度O(1)（不考虑结果存储）
• 会改变原数组顺序

3.2 处理重复元素的变体

如果需要统计交集元素出现的次数：

cpp复制vector<int> intersectWithCount(vector<int>& nums1, vector<int>& nums2) {
    unordered_map<int, int> countMap;
    vector<int> res;
    
    for (int num : nums1) {
        countMap[num]++;
    }
    
    for (int num : nums2) {
        if (countMap[num]-- > 0) {
            res.push_back(num);
        }
    }
    
    return res;
}

4. 性能对比测试

我们构造两组测试数据：

1. 小数据集（n=100, m=100）
2. 大数据集（n=100000, m=100000）

测试结果（ms）：

结论：

• 小数据量时差异不大
• 大数据量优先选择哈希表方案
• 内存紧张时考虑排序方案

5. 实际应用案例

5.1 用户标签匹配

社交平台中匹配共同兴趣：

cpp复制vector<string> matchInterests(const vector<string>& user1, 
                             const vector<string>& user2) {
    unordered_set<string> set(user1.begin(), user1.end());
    vector<string> common;
    
    for (const auto& interest : user2) {
        if (set.count(interest)) {
            common.push_back(interest);
        }
    }
    
    return common;
}

5.2 电商商品推荐

找出用户浏览历史和购买记录的交集：

cpp复制vector<Product> recommendProducts(const vector<Product>& viewed,
                                 const vector<Product>& bought) {
    unordered_set<int> viewedIDs;
    for (const auto& p : viewed) {
        viewedIDs.insert(p.id);
    }
    
    vector<Product> recommendations;
    for (const auto& p : bought) {
        if (viewedIDs.count(p.id)) {
            recommendations.push_back(p);
        }
    }
    
    return recommendations;
}

6. 常见问题与调试技巧

6.1 内存溢出问题

当数组非常大时（如超过10^6元素）：

• 哈希表方案可能消耗过多内存
• 解决方案：
  • 分批处理数据
  • 使用位图压缩存储（适合整数范围小的情况）

6.2 多线程优化

对于超大规模数据，可以并行处理：

cpp复制// 使用OpenMP并行化哈希表构建
unordered_set<int> set;
#pragma omp parallel for
for (int i = 0; i < nums1.size(); ++i) {
    #pragma omp critical
    set.insert(nums1[i]);
}

6.3 特殊数据类型处理

当元素为自定义类型时：

cpp复制struct Point { int x, y; };

// 需要提供哈希函数
namespace std {
    template<> 
    struct hash<Point> {
        size_t operator()(const Point& p) const {
            return hash<int>()(p.x) ^ hash<int>()(p.y);
        }
    };
}

vector<Point> intersection(vector<Point>& a, vector<Point>& b) {
    unordered_set<Point> set(a.begin(), a.end());
    // ...其余逻辑相同
}

7. 扩展思考

7.1 多个数组的交集

扩展到k个数组的情况：

cpp复制vector<int> multiIntersection(vector<vector<int>>& arrays) {
    if (arrays.empty()) return {};
    
    unordered_map<int, int> count;
    for (const auto& arr : arrays) {
        for (int num : arr) {
            count[num]++;
        }
    }
    
    vector<int> res;
    int k = arrays.size();
    for (const auto& [num, cnt] : count) {
        if (cnt == k) {
            res.push_back(num);
        }
    }
    
    return res;
}

7.2 近似交集处理

有时我们需要模糊匹配：

cpp复制vector<pair<int,int>> fuzzyIntersection(
    vector<int>& a, vector<int>& b, int threshold) {
    
    sort(a.begin(), a.end());
    sort(b.begin(), b.end());
    
    vector<pair<int,int>> res;
    int i = 0, j = 0;
    
    while (i < a.size() && j < b.size()) {
        int diff = abs(a[i] - b[j]);
        if (diff <= threshold) {
            res.emplace_back(a[i], b[j]);
            i++;
            j++;
        }
        else if (a[i] < b[j]) {
            i++;
        }
        else {
            j++;
        }
    }
    
    return res;
}

在实际工程中，选择哪种方案需要根据具体场景权衡。我处理过一个用户行为分析系统，最初使用暴力搜索导致接口超时，后来改用哈希表方案使性能提升了40倍。关键是要理解每种方法的适用场景和限制条件。