17set相关算法

1、set相关算法

STL一共提供了四种与set（集合）相关的算法，分别是并集（union）、交集（intersection）、差集（difference）、对称差集（symmetric difference）。这四种算法所接受的set，必须是有序区间，元素允许重复，所以可以接受STL的set和mutiset容器作为输入区间。

2、set_union

算法set_union可构造S1、S2的并集。set_union是一种稳定操作，输入区间内的每个元素的相对顺序都不会改变。

在两区间内分别移动迭代器。首先将元素值较小者记录到目标区，较小者的迭代器前进，同时另一个区迭代器不动；如果元素相等，取S1者记录到目标区，并同时移动两个迭代器；最后目标区迭代器前进；继续循环直到两区中有一区到达尾端，将尚未到达尾端的区间的所有剩余元素拷贝到目标区。

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

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

3、set_intersection

算法set_intersection可构造S1、S2的交集。set_intersection是一种稳定操作，输入区间内的每个元素的相对顺序都不会改变。

在两区间内分别移动迭代器，元素值小的区迭代器前进，直到遇到元素值相等，将该元素值记录到目标区，并同时移动两个迭代器以及目标区迭代器，继续循环直到两区中有一区到达尾端结束。

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;
      ++first1;
      ++first2;
      ++result;
    }
  return result;
}

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

4、set_difference

算法set_difference可构造S1、S2的差集，即此集合内含出现于S1但不出现于S2的每一个元素。set_difference是一种稳定操作，输入区间内的每个元素的相对顺序都不会改变。

在两区间内分别移动迭代器，当第一区间的元素值小于第二区间元素值时，将第一区间该元素记录到目标区，并第一区间迭代器和目标区迭代器前进；当第一区间的元素值大于第二区间元素值时，第二区间迭代器前进；当第一区间的元素值等于第二区间元素值时，就让两个区间迭代器同时前进，继续循环直到两区中有一区到达尾端，将第一区间剩余元素拷贝到目标区间。

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

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

5、set_symmetric_difference

算法set_symmetric_difference可构造S1、S2的对称差集，即此集合内含出现于S1但不出现于S2以及出现于S2但不出现于S1的每一个元素。set_symmetric_difference是一种稳定操作，输入区间内的每个元素的相对顺序都不会改变。

在两区间内分别移动迭代器，当两区间内的元素不等，就记录较小元素值到目标区，并令较小元素所在区间和目标区间迭代器前进；当两区间内的元素相等，就让两区间迭代器同时前进；继续循环直到两区中有一区到达尾端，将两个区间剩余元素拷贝到目标区间。

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

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