集合求交集中，vector, set ,unordered_set,的对比试验

集合求交集中，vector, set ,unordered_set,的对比试验

introduction： 对集合进行求交集，是我们常用的操作。STL 也给我们提供了对于常规容器(vector, set等)的intersection 操作

sort(a.begin(), a.end());
sort(b.begin(), b.end());
vector<int> res;
res.reserve(a.size() + b.size());
set_intersection(a.begin(), a.end(), b.begin() , b.end(), back_insert_iterator<vector<int>>(res));

用法如上所示，这里的 back_insert_iterator 仅仅对于具有push_back()操作的容器有效。

而在实际场合中，我们使用的数据容器多种多样，有具备随机访问的vector、 有基于红黑树的set，也有基于hashSet的unordered_set。下面将对这三中容器进行定量试验，测试在不同数据数量范围，不同容器的选择对求交集的影响。

Intersection Method for unordered_set

STL 是没有提供对于unordered_set 的求交集操作的。

因此在这里，我使用了一种简单的实现，时间复杂度为O(n);

vector<int> intertsect_hashset(vector<int> _a, vector<int> _b)
{
    unordered_set<int> a(_a.begin(), _a.end());
    unordered_set<int> b(_b.begin(), _b.end());
    vector<int> res;
    res.reserve(a.size() + b.size());
    for (int n : a){
        if (b.find(n) != b.end()){
            res.push_back(n);
            b.erase(n);
        }
    }
    return res;
}

Interseciton Method for vector & set

对于set_intersection函数来说，传入的迭代器对应的容器应该是有序的，内部实现原理类似如下：

template <typename InIt1, typename InIt2, typename OutIt>
OutIt unordered_set_intersection(InIt1 b1, InIt1 e1, InIt2 b2, InIt2 e2, OutIt out) {
    while (!(b1 == e1)) {
        if (!(std::find(b2, e2, *b1) == e2)) {
            *out = *b1;
            ++out;
        }

        ++b1;
    }

    return out;
}

于是在实现代码中，对于vector数组，需要进行额外的排序，当然，这也应该被统计在总的时间内。

Trials

实验的环境为 Intel Core i7-9700 @ 8x 4.7GHz 、Ubuntu 20.04 、Clang 6.0.0、 O3优化。

	_vector	_set	_hashset
10000	3.3	6.3	4.3
1000000	482.1	1707.3	610.2
100000000	60857.5	297929.7	103751.4

可以明显发现，在不同数据数量范围，均呈现线性增长。

对于基于红黑树实现的set容器，由于构造set是O(NlogN),求交为O(N)所以总体时间复杂度为O(NlogN)。

对于vector， 排序时间复杂度为O(NlogN),求交为O(N),因此时间复杂度也为O(NlogN)。

对于hashset，虽然其构造理论时间复杂度为O(1)，但是发生冲突的时候会衰减至O(N)，理想状态下，总时间复杂度为O(N).

对比试验可以发现，实际运行中，使用vector 的随机访问器的速度最快，而set的速度最慢，这是因为set不能随机访问，且访问的时间复杂度为O(logN). 相比之下, hashSet 的时间复杂度并不能达到最优，而是慢于vector， 如果改进hash函数，也许能够达到更好的效果。

Code

#include "timeTest.h"
#include <bits/stdc++.h>
#include <iostream>
using namespace std;

vector<int> intersect_vector(vector<int> a, vector<int> b)
{
    sort(a.begin(), a.end());
    sort(b.begin(), b.end());
    vector<int> res;
    res.reserve(a.size() + b.size());
    set_intersection(a.begin(), a.end(), b.begin() , b.end(), back_insert_iterator<vector<int>>(res));
    return res;
}


vector<int> intersect_set(vector<int> _a, vector<int> _b)
{
    set<int> a(_a.begin(), _a.end());
    set<int> b(_b.begin(), _b.end());
    vector<int> res;
    res.reserve(a.size() + b.size());
    set_intersection(a.begin(), a.end(), b.begin() , b.end(), back_insert_iterator<vector<int>>(res));
    return res;

}
vector<int> intertsect_hashset(vector<int> _a, vector<int> _b)
{
    unordered_set<int> a(_a.begin(), _a.end());
    unordered_set<int> b(_b.begin(), _b.end());
    vector<int> res;
    res.reserve(a.size() + b.size());
    for (int n : a){
        if (b.find(n) != b.end()){
            res.push_back(n);
            b.erase(n);
        }
    }
    return res;
}

int main()
{
    int sz1 = 100000000;
    vector<int> a, b;
    for (int i = 0; i < sz1 * 1.5; ++i)
    {
        if (i < sz1)
        {
            a.push_back(i);
        }
        else if (i > sz1 / 2)
        {
            b.push_back(i);
        }
    }
    random_shuffle(a.begin(), a.end());
    random_shuffle(b.begin(), b.end());
    vector<int> res1, res2, res3;
   {
        TestTimeVar
    TestTimeTic
    res1 = intersect_vector(a, b);
    TestTimeToc("intersect_vector")
   }
   {
        TestTimeVar
    TestTimeTic
    res2 = intersect_set(a, b);
    TestTimeToc("intersect_set")
   }
   {
        TestTimeVar
    TestTimeTic
    res3 = intertsect_hashset(a, b);
    TestTimeToc("intertsect_hashset")
   }
    return 0;
}