Question

我的矢量很少。例如4

std::vector1 <CMyClass>;
std::vector2 <CMyClass>;
std::vector3 <CMyClass>;
std::vector4 <CMyClass>;

我想要一个结果向量，它将具有存在于所有向量中的对象。例如。如果

Vector1 has C1, C2, C3;
Vector2 has C1, C2;
Vector3 has C1, C4;
Vector has  C1, C5;

我希望结果向量具有C1。

我可以运行循环并比较并找出结果向量，但我想知道是否有任何直接的方法。像一些运营商或数据结构。

Answer 1

这是交集，而不是超集（这意味着联合或四个向量中包含的所有元素的集合）。

如果您可以对矢量进行排序，直接的方法是使用std::set_intersection。

你必须使用它三次，得到中间结果 A =十字路口（v1，v2）和 B =十字路口（3,4） 交集（A，B）的最终结果。

使用此linked answer将更有效（跳过两个中间容器），但需要更多手动编码（和测试）。

Answer 2

这个怎么样？您必须在类中添加运算符＆lt;（）（以及辅助运算符＆lt;＆lt;（））。从每个向量形成std :: set，然后计算这些集合的交集。再次 - 从结果集中制作矢量。

#include <iostream>
#include <vector>
#include <algorithm>
#include <iostream>
#include <set>

class CMyClass
 {
 public:
     CMyClass(int n){_n=n;}
     ~CMyClass(){}
     bool operator<(const CMyClass a) const{return _n <a._n;}
     friend std::ostream& operator<<(std::ostream& s,const CMyClass& a){s<<a._n;return s;}
 private:
     int _n;
 };
vector<CMyClass> find_intersect(vector<vector<CMyClass>>& vecs)
{
    vector<CMyClass> res;
    if (vecs.empty()) return res;
    set<CMyClass> S;
    for_each(vecs[0].begin(),vecs[0].end(),[&S](const CMyClass& e){S.insert(e);});
    for(auto &vec:vecs)
    {
        set<CMyClass> s,tmp;
        for_each(vec.begin(),vec.end(),[&s](const CMyClass& e){s.insert(e);});
        set_intersection(S.begin(),S.end(),s.begin(),s.end(),std::inserter(tmp,tmp.begin()));
        S=tmp;
        if (S.empty()) break;
    }
    for_each(S.begin(),S.end(),[&res](const CMyClass& e){res.push_back(e);});
    return res;
}

int main()
{
    vector<CMyClass> v1={1,2,3};
    vector<CMyClass> v2={1,2};
    vector<CMyClass> v3={1,4};
    vector<CMyClass> v4={1,5};
    vector<vector<CMyClass>> vectors;
    vectors.push_back(v1);
    vectors.push_back(v2);
    vectors.push_back(v3);
    vectors.push_back(v4);
    auto res = find_intersect(vectors);
    cout<<"[";
    for(auto &elem:res)
        cout<<elem<<",";
    cout<<"]"<<endl;
}

输出： [1，]

Answer 3

对矢量进行排序。
使用std::set_intersection()三次（你有多少个矢量 - 1）。

时间复杂性分析：

4 * O（nlogn）= O（nlogn）
线性2 *（firstSize + secondSize） - 1
2 *中的线性（firstSecondInterSize + thirdSize） - 1
2 *中的线性（firstSecondThirdInterSize + fourthSize） - 1

以O（nlogn）为界，意味着排序是算法的瓶颈。

完整代码示例：

#include <iostream>     // std::cout
#include <algorithm>    // std::set_intersection, std::sort
#include <vector>       // std::vector

int main () {
  std::vector<int> first = {5,10,15,20,25};
  std::vector<int> second = {50,40,30,20,10};
  std::vector<int> third = {10,20,3,4,0};
  std::vector<int> fourth = {4,20,10,3,6};
  std::vector<int> v(first.size() + second.size() + third.size() + fourth.size());
  std::vector<int>::iterator it;

  std::sort (first.begin(),first.end());
  std::sort (second.begin(),second.end());
  std::sort (third.begin(),third.end());
  std::sort (fourth.begin(),fourth.end());

  it=std::set_intersection (first.begin(), first.end(), second.begin(), second.end(), v.begin());
  it=std::set_intersection (v.begin(), v.end(), third.begin(), third.end(), v.begin());
  it=std::set_intersection (v.begin(), v.end(), fourth.begin(), fourth.end(), v.begin());
  v.resize(it-v.begin());

  std::cout << "The intersection has " << (v.size()) << " elements: ";
  for (it=v.begin(); it!=v.end(); ++it)
    std::cout << ' ' << *it;
  std::cout << '\n';

  return 0;
}

输出：

交叉路口有2个元素：10 20

矢量的交叉点

3 个答案: