Как найти пересечение двух std:: set в С++?

Ответ 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 не поддерживает эти операции.

Ответ 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));

Ответ 3

См. Std :: set_intersection. Вы должны добавить выходной итератор, где вы сохраните результат:

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

См. " Идеал" для полного списка.

Ответ 4

Просто прокомментируй здесь. Я думаю, что пришло время добавить объединение, пересечь операцию в установочный интерфейс. Предложите это в будущих стандартах. Я использую std в течение длительного времени, каждый раз, когда я использовал заданную операцию, мне хотелось, чтобы 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/

Например, если ваш выход является набором, вы можете output.insert(* first1). Кроме того, вы можете не использовать шаблоны. Если код может быть короче, чем использовать функцию std set_intersection, то продолжайте его.

Если вы хотите сделать объединение двух наборов, вы можете просто установитьA.insert(setB.begin(), setB.end()); Это намного проще, чем метод set_union. Однако это не будет работать с вектором.

Ответ 5

Первый (хорошо проголосовавший) комментарий принятого ответа жалуется на отсутствующий оператор для существующих операций установки std.

С одной стороны, я понимаю отсутствие таких операторов в стандартной библиотеке. С другой стороны, легко добавить их (для личной радости), если это необходимо. Я перегружен

• 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 уже оснащен конструктором/присваиванием перемещения.

Хотя я ему верил, я думал, как это проверить (для чего-то вроде "самоуверенного" ). На самом деле, это довольно легко. Поскольку шаблоны должны быть предоставлены в исходном коде, вы можете просто перейти к отладчику. Таким образом, я поставил точку разрыва прямо на return s; в operator *() и продолжил с одним шагом, который сразу же перевел меня на std::set::set(_myt&& _Right): et voilà – конструктор перемещения. Спасибо, Олаф, за (мое) просвещение.

Для полноты я реализовал также соответствующие операторы присваивания

• 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 }

$