是否存在以以下方式对两个范围进行排序和划分的标准算法？

Question

I wonder whether a standard approach for the following algorithm exists. I want to sort and partition two ranges x and y . Both x and y should be partitioned using a binary predicate that takes an element from x and y . The signature of the function would be something along the lines of:

template<typename ForwardIt1, typename ForwardIt2, typename Compare, typename BinaryPredicate>
std::pair<ForwardIt1, ForwardIt2> sort_and_partition(ForwardIt1 first1, ForwardIt1 last1, ForwardIt2 first2, ForwardIt2 last2, Compare comp, BinaryPredicate p);

Here comp is forwarded to std::sort . The binary predicate p is used for the partitioning. Then, for example:

std::vector<T> x;
std::vector<T> y;

auto [xm, ym] = sort_and_partition(x.begin(), x.end(), y.begin(), y.end(), std::less<T>{}, std::equal_to<T>{});

This would result in four ranges:

• x1: [x.begin(), xm)
• x2: [xm, x.end())
• y1: [y.begin(), ym)
• y2: [ym, y.end())

Where both x1 and y1 are sorted and contain equivalent elements (according to the binary predicate p ). Effectively x1 and y1 contain the sorted intersection for x and y in the example. x2 and y2 are sorted as well, and contain all elements unique to x and y respectively.

Am I missing an obvious approach to implement such an algorithm by combining existing algorithms in the STL? I am planning now to write a custom implementation for this but wanted to check here first before starting on the implementation. What would be a good name for this algorithm?

Update , I've implemented the following algorithm that satisfies my requirements. The algorithm requires that the input ranges are sorted.

/// Takes two sorted input ranges, and partitions both ranges such that all
/// elements that occur in both ranges precede those elements that only occur in
/// one of the two ranges.
template<typename ForwardIt1, typename ForwardIt2, typename Compare>
std::pair<ForwardIt1, ForwardIt2> frc::binary_partition(
    ForwardIt1 first1, ForwardIt1 last1, ForwardIt2 first2, ForwardIt2 last2, Compare comp)
{
  auto equals = [&](const auto& x, const auto& y) { return !comp(x, y) && !comp(y, x); };

  // Invariant: first1 and last1 point to the first mismatch.
  std::tie(first1, first2) = std::mismatch(first1, last1, first2, last2, equals);

  while (first1 != last1 && first2 != last2)
  {
    // Iterators to the next matching elements.
    auto fm1{first1};
    auto fm2{first2};

    // Find next matching elements in both ranges.
    while (comp(*fm1, *fm2) || comp(*fm2, *fm1))
    {
      if (comp(*fm1, *fm2))
      {
        ++fm1;
      }
      else
      {
        ++fm2;
      }

      if (fm1 == last1 || fm2 == last2)
      {
        return std::pair(first1, first2);
      }
    }

    // Find the end of the matching subsequence.
    auto [lm1, lm2] = std::mismatch(fm1 + 1, last1, fm2 + 1, last2, equals);

    // In case matching elements are found, move the mismatching subrange behind
    // the matching subrange.
    first1 = std::rotate(first1, fm1, lm1);
    first2 = std::rotate(first2, fm2, lm2);
  }

  return std::pair(first1, first2);
}

Answer 1

No, and I can think of two reasons:

1. You're actually demanding two algorithms: std::sort and std::stable_partition (or std::partition and std::sort of both partitions of each range). You can compose that yourself.

2. Algorithms implement their semantics in terms of iterators - that's where the extra part to make it work with two ranges should be implemented. In other words, if an algorithm's semantics can be defined with one input range, there won't be overloads for multiple ones.

   You have to use a custom iterator, which will internally manipulate two iterators of distinct ranges (containers). I think boost::zip_iterator is what you're looking for.

Answer 2

There is no such function in STL as far as I know.

Maybe what you could do is make use of the following functions provided by STL:

• sort x
• sort y
• use mismatch on x and y with a binary predicate

It returns a pair of iterators pointing to the first unmatched element of both sequences.

template <class InputIterator1, class InputIterator2, class BinaryPredicate>
  pair<InputIterator1, InputIterator2>
    mismatch (InputIterator1 first1, InputIterator1 last1,
              InputIterator2 first2, BinaryPredicate pred);

Answer 3

In the case where we can synthesize p from comp , this is roughly

template<typename ForwardIt1, typename ForwardIt2, typename Compare>
std::pair<ForwardIt1, ForwardIt2> sort_and_partition(ForwardIt1 first1, ForwardIt1 last1, ForwardIt2 first2, ForwardIt2 last2, Compare comp)
{
    // We don't strictly need copies of the two ranges, but it makes things easier. 
    // We do want them sorted, using an ordered set here gives that for free
    std::multiset<typename std::iterator_traits<ForwardIt1>::value_type, Compare> set1{ first1, last1, comp };
    std::multiset<typename std::iterator_traits<ForwardIt2>::value_type, Compare> set2{ first2, last2, comp };

    // Copy back into a partitioned [first1, last1)
    auto mid1 = std::set_intersection(set1.begin(), set1.end(), set2.begin(), set2.end(), first1, comp);
    std::set_difference(set1.begin(), set1.end(), set2.begin(), set2.end(), mid1, comp);

    // Copy back into a partitioned [first2, last2)
    auto mid2 = std::set_intersection(set2.begin(), set2.end(), set1.begin(), set1.end(), first2, comp);
    std::set_difference(set2.begin(), set2.end(), set1.begin(), set1.end(), mid2, comp);

    // And return our midpoints
    return { mid1, mid2 };
}

In the more general case, you will need to decide how many pairs of elements to compare in the partition step, as different choices will lead to different outcomes.