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

93

我一直试图在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()方法会返回此类对象，

有没有更好的方法来找到std::setC ++中的两者的交集？最好是内置功能？

非常感谢！

c++  std  stl-algorithm  stdset 
— 我喜欢炸玉米饼
source
“我希望有一个新的套装（我们称它为s3）”，但是您没有，也没有。我不明白您希望结果如何。另外，您也没有阅读文档来确定要传递的参数。
— 轨道轻赛

Answers:

113

您尚未为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不支持这些操作。

— 卡尔提克
source
70
我想理解为什么对集合进行这样的基本操作需要如此奥秘的冗长咒语。为什么不使用一种简单的set<T>& set::isect(set<T>&)方法呢？（我要set<T>& set::operator^(set<T>&)的是桥，但那可能是一座桥太远了。）
— Ryan V. Bissell 2014年
3
@ RyanV.Bissell这是几乎所有算法的相似设计，<algorithm>即使没有其他问题也是如此。我认为，这种样式还可以为您提供灵活性。并允许将算法与多个容器一起使用，尽管此处可能不会发生这种情况。.同样，您的签名可能不起作用，您可能需要返回一个值。在我看来，在复制语义学之前的那一天将是双重复制。我已经有一段时间没有做过c ++了，所以
— 先吃
4
我仍然认为自己是STL的新手，因此盐粒的应用也适用。我的评论编辑窗口已过期，因此我无法更正按引用返回的假密码。我的评论不是抱怨一致性，而是一个诚实的问题，为什么这种语法必须尝起来这么苦。也许我应该将其作为一个SO问题。
— Ryan V. Bissell 2014年
3
实际上，大多数C ++ std库都是以这种晦涩的方式设计的。尽管设计的优雅是显而易见的（通用的，但不仅如此），但API的复杂性却具有毁灭性的影响（主要是因为人们不停地使用轮子，因为他们不能使用编译器附带的轮子）。在另一个世界中，设计师会因为喜欢他们的用户而不是他们的用户而被打败。在这个世界上……至少，我们拥有StackOverflow。
3
这是一种“通用语法”-您还可以在向量和列表上执行set_intersection并将结果存储到双端队列中，并且您甚至应该能够高效地执行此操作（当然，要确保两者都源容器在调用之前进行排序）。我并不觉得这很糟糕，我唯一有问题的是，可能还有一种set容器方法可以与另一组容器相交。传递容器而不是.begin()-的主题.end()是另一回事-一旦C ++具有概念，此问题将得到解决。
— Ethouris
6

参见std :: set_intersection。您必须添加一个输出迭代器，用于存储结果：

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

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

— 奥拉夫·迪斯特
source
3
请注意，如果您希望结果也为set，则back_inserter将不起作用，那么您需要使用类似于Karthik的std :: inserter。
— 约瑟夫·加文2015年
4

只是在这里评论。我认为是时候向集合接口添加联合，相交操作了。让我们在将来的标准中提出这个建议。我已经使用std很久了，每次我使用set操作时，我希望std会更好。对于一些复杂的集合操作（​​例如相交），您可以简单（容易吗？）修改以下代码：

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函数短，请继续进行操作。

如果要进行两个集合的并集，则只需setA.insert（setB.begin（），setB.end（））;即可。这比set_union方法简单得多。但是，这不适用于vector。

— 周克民
source
4

接受答案的第一个（经投票表决）注释抱怨现有std set操作缺少运算符。

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

  • operator *() 用于集合的交集
  • operator +() 集的联合。

样品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已经配备了move构造器/。

尽管我相信他，但我仍在思考如何检查（例如“令人信服”之类的东西）。实际上，这很容易。由于必须在源代码中提供模板，因此您可以简单地逐步调试程序。因此，我放置一个断点就在return s;的operator *()，并与单一步骤，其含铅我立即进行到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;
}

编译和测试：

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

$ ./test-set-assign-ops
s1: { 1, 2, 3, 4 }
s2: { 0, 1, 3, 6 }
s1I: { 1, 3 }
s2I: { 1, 3 }
s1U: { 0, 1, 2, 3, 4, 6 }
s2U: { 0, 1, 2, 3, 4, 6 }

$
— 舍夫
source
1
std::set已经实现了必要的move构造函数和赋值运算符，因此无需担心。同样，编译器最有可能采用返回值优化
— Olaf Dietsche
@OlafDietsche感谢您的评论。我检查了这个，并分别改善了答案。关于RVO，我已经与同事进行了一定的讨论，直到我在VS2013的调试器中向他们展示了这种情况不会发生（至少在我们的开发平台中）。实际上，除非代码对性能至关重要，否则它并不那么重要。在后一种情况下，我暂时不依赖RVO。（在C ++中实际上并不难...）
— Scheff
@Scheff好Scheff（不是Bose），很好的解释。
— JeJo
即使到现在，VS对C ++ 17保证的省略率的支持也是可悲的。
— Lightness Races in Orbit
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.