Question

我一直在尝试在C ++中找到两个std :: set之间的交集，但我一直收到错误。

我为此

创建了一个小样本测试

#include <iostream>
#include <vector>
#include <algorithm>
#include <set>
using namespace std;

int main() {
  set<int> s1;
  set<int> s2;

  s1.insert(1);
  s1.insert(2);
  s1.insert(3);
  s1.insert(4);

  s2.insert(1);
  s2.insert(6);
  s2.insert(3);
  s2.insert(0);

  set_intersection(s1.begin(),s1.end(),s2.begin(),s2.end());
  return 0;
}

后一个程序不生成任何输出，但我希望有一个新的集合（让我们称之为s3），其中包含以下值：

s3 = [ 1 , 3 ]

相反，我收到了错误：

test.cpp: In function ‘int main()’:
test.cpp:19: error: no matching function for call to ‘set_intersection(std::_Rb_tree_const_iterator<int>, std::_Rb_tree_const_iterator<int>, std::_Rb_tree_const_iterator<int>, std::_Rb_tree_const_iterator<int>)’

我从这个错误中理解的是，set_intersection中没有接受Rb_tree_const_iterator<int>作为参数的定义。

此外，我认为std::set.begin()方法返回这种类型的对象，

有没有更好的方法在C ++中找到两个std::set的交集？最好是内置功能？

非常感谢！

Answer 1

你没有为set_intersection

提供输出迭代器

template <class InputIterator1, class InputIterator2, class OutputIterator>
OutputIterator set_intersection ( InputIterator1 first1, InputIterator1 last1,
                                InputIterator2 first2, InputIterator2 last2,
                                OutputIterator result );

通过执行类似

的操作来解决此问题

...;
set<int> intersect;
set_intersection(s1.begin(),s1.end(),s2.begin(),s2.end(),
                  std::inserter(intersect,intersect.begin()));

您需要一个std::insert迭代器，因为该集合现在为空。我们不能使用back_或front_inserter，因为set不支持这些操作。

Answer 2

查看链接中的示例： http://en.cppreference.com/w/cpp/algorithm/set_intersection

您需要另一个容器来存储交叉点数据，在代码下面假设工作：

std::vector<int> common_data;
set_intersection(s1.begin(),s1.end(),s2.begin(),s2.end(), std::back_inserter(common_data));

Answer 3

见std::set_intersection。您必须添加输出迭代器，您将在其中存储结果：

#include <iterator>
std::vector<int> s3;
set_intersection(s1.begin(),s1.end(),s2.begin(),s2.end(), std::back_inserter(s3));

有关完整列表，请参阅Ideone。

Answer 4

请在这里发表评论。我认为是时候将set，intersect操作添加到set接口了。让我们在未来的标准中提出这个建议。我一直在使用std很长一段时间，每次我使用set操作我都希望std更好。对于一些复杂的集合操作，比如intersect，你可以简单地（更容易？）修改下面的代码：

template <class InputIterator1, class InputIterator2, class OutputIterator>
  OutputIterator set_intersection (InputIterator1 first1, InputIterator1 last1,
                                   InputIterator2 first2, InputIterator2 last2,
                                   OutputIterator result)
{
  while (first1!=last1 && first2!=last2)
  {
    if (*first1<*first2) ++first1;
    else if (*first2<*first1) ++first2;
    else {
      *result = *first1;
      ++result; ++first1; ++first2;
    }
  }
  return result;
}

从http://www.cplusplus.com/reference/algorithm/set_intersection/

复制

例如，如果输出是一个集合，则可以输出.insert（* first1）。此外，你的函数可能没有模板化。如果你的代码可以比使用std set_intersection函数更短，那就继续吧。

如果你想做两个联合，你可以简单地设置A.insert（setB.begin（），setB.end（））;这比set_union方法简单得多。但是，这不适用于矢量。

Answer 5

accepted answer的第一个（评选良好的）评论抱怨现有标准集操作缺少运算符。

一方面，我理解标准库中缺少此类运算符。另一方面，如果需要，可以很容易地添加它们（为了个人喜悦）。我超载了

operator *()用于集合的交集
operator +() for sets of sets。

示例test-set-ops.cc：

#include <algorithm>
#include <iterator>
#include <set>

template <class T, class CMP = std::less<T>, class ALLOC = std::allocator<T> >
std::set<T, CMP, ALLOC> operator * (
  const std::set<T, CMP, ALLOC> &s1, const std::set<T, CMP, ALLOC> &s2)
{
  std::set<T, CMP, ALLOC> s;
  std::set_intersection(s1.begin(), s1.end(), s2.begin(), s2.end(),
    std::inserter(s, s.begin()));
  return s;
}

template <class T, class CMP = std::less<T>, class ALLOC = std::allocator<T> >
std::set<T, CMP, ALLOC> operator + (
  const std::set<T, CMP, ALLOC> &s1, const std::set<T, CMP, ALLOC> &s2)
{
  std::set<T, CMP, ALLOC> s;
  std::set_union(s1.begin(), s1.end(), s2.begin(), s2.end(),
    std::inserter(s, s.begin()));
  return s;
}

// sample code to check them out:

#include <iostream>

using namespace std;

template <class T>
ostream& operator << (ostream &out, const set<T> &values)
{
  const char *sep = " ";
  for (const T &value : values) {
    out << sep << value; sep = ", ";
  }
  return out;
}

int main()
{
  set<int> s1 { 1, 2, 3, 4 };
  cout << "s1: {" << s1 << " }" << endl;
  set<int> s2 { 0, 1, 3, 6 };
  cout << "s2: {" << s2 << " }" << endl;
  cout << "I: {" << s1 * s2 << " }" << endl;
  cout << "U: {" << s1 + s2 << " }" << endl;
  return 0;
}

编译并测试：

$ g++ -std=c++11 -o test-set-ops test-set-ops.cc 

$ ./test-set-ops     
s1: { 1, 2, 3, 4 }
s2: { 0, 1, 3, 6 }
I: { 1, 3 }
U: { 0, 1, 2, 3, 4, 6 }

$

~~我不喜欢的是运算符中返回值的副本。可能是，这可以通过移动分配来解决，但这仍然超出了我的技能。~~

由于我对这些“新奇”移动语义的了解有限，我担心操作员返回可能导致返回集的副本。 Olaf Dietsche指出这些问题是不必要的，因为std::set已经配备了移动构造函数/赋值。

虽然我相信他，但我正在考虑如何解决这个问题（对于像“自我说服”这样的事情）。实际上，这很容易。由于模板必须在源代码中提供，因此您可以简单地使用调试器。因此，我在return s;的{{1}}处设置了一个断点，然后单步执行，立即将我引入operator *()：etvoilà - 移动构造函数。谢谢，奥拉夫，（我的）启发。

为了完整起见，我还实现了相应的赋值运算符

std::set::set(_myt&& _Right)用于“破坏性”交集
operator *=()用于“破坏性”联合集。

示例operator +=()：

test-set-assign-ops.cc

编译并测试：

#include <iterator>
#include <set>

template <class T, class CMP = std::less<T>, class ALLOC = std::allocator<T> >
std::set<T, CMP, ALLOC>& operator *= (
  std::set<T, CMP, ALLOC> &s1, const std::set<T, CMP, ALLOC> &s2)
{
  auto iter1 = s1.begin();
  for (auto iter2 = s2.begin(); iter1 != s1.end() && iter2 != s2.end();) {
    if (*iter1 < *iter2) iter1 = s1.erase(iter1);
    else {
      if (!(*iter2 < *iter1)) ++iter1;
      ++iter2;
    }
  }
  while (iter1 != s1.end()) iter1 = s1.erase(iter1);
  return s1;
}

template <class T, class CMP = std::less<T>, class ALLOC = std::allocator<T> >
std::set<T, CMP, ALLOC>& operator += (
  std::set<T, CMP, ALLOC> &s1, const std::set<T, CMP, ALLOC> &s2)
{
  s1.insert(s2.begin(), s2.end());
  return s1;
}

// sample code to check them out:

#include <iostream>

using namespace std;

template <class T>
ostream& operator << (ostream &out, const set<T> &values)
{
  const char *sep = " ";
  for (const T &value : values) {
    out << sep << value; sep = ", ";
  }
  return out;
}

int main()
{
  set<int> s1 { 1, 2, 3, 4 };
  cout << "s1: {" << s1 << " }" << endl;
  set<int> s2 { 0, 1, 3, 6 };
  cout << "s2: {" << s2 << " }" << endl;
  set<int> s1I = s1;
  s1I *= s2;
  cout << "s1I: {" << s1I << " }" << endl;
  set<int> s2I = s2;
  s2I *= s1;
  cout << "s2I: {" << s2I << " }" << endl;
  set<int> s1U = s1;
  s1U += s2;
  cout << "s1U: {" << s1U << " }" << endl;
  set<int> s2U = s2;
  s2U += s1;
  cout << "s2U: {" << s2U << " }" << endl;
  return 0;
}

如何在C ++中找到两个std :: set的交集？

5 个答案: