function template

std::partition

template <class BidirectionalIterator, class UnaryPredicate>  BidirectionalIterator partition (BidirectionalIterator first,                                   BidirectionalIterator last, UnaryPredicate pred);

template <class ForwardIterator, class UnaryPredicate>  ForwardIterator partition (ForwardIterator first,                             ForwardIterator last, UnaryPredicate pred);

Partition range in two

Rearranges the elements from the range [first,last), in such a way that all the elements for which pred returns true precede all those for which it returns false. The iterator returned points to the first element of the second group.

The relative ordering within each group is not necessarily the same as before the call. See stable_partition for a function with a similar behavior but with stable ordering within each group.

The behavior of this function template (C++98) is equivalent to:

template <class BidirectionalIterator, class UnaryPredicate>
  BidirectionalIterator partition (BidirectionalIterator first,
                                   BidirectionalIterator last, UnaryPredicate pred)
{
  while (first!=last) {
    while (pred(*first)) {
      ++first;
      if (first==last) return first;
    }
    do {
      --last;
      if (first==last) return first;
    } while (!pred(*last));
    swap (*first,*last);
    ++first;
  }
  return first;
}

Parameters

first, last: Bidirectional iterators to the initial and final positions of the sequence to partition. The range used is [first,last), which contains all the elements between first and last1, including the element pointed by first but not the element pointed by last.

Forward iterators to the initial and final positions of the sequence to partition. The range used is [first,last), which contains all the elements between first and last, including the element pointed by first but not the element pointed by last.
ForwardIterator shall point to a type for which swap is defined and swaps the value of its arguments.
pred: Unary function that accepts an element in the range as argument, and returns a value convertible to bool. The value returned indicates whether the element is to be placed before (if true, it is placed before all the elements for which it returns false).
The function shall not modify its argument.
This can either be a function pointer or a function object.

Return value

An iterator that points to the first element of the second group of elements (those for which pred returns false), or last if this group is empty.

Example

// partition algorithm example
#include <iostream>     // std::cout
#include <algorithm>    // std::partition
#include <vector>       // std::vector

bool IsOdd (int i) { return (i%2)==1; }

int main () {
  std::vector<int> myvector;

  // set some values:
  for (int i=1; i<10; ++i) myvector.push_back(i); // 1 2 3 4 5 6 7 8 9

  std::vector<int>::iterator bound;
  bound = std::partition (myvector.begin(), myvector.end(), IsOdd);

  // print out content:
  std::cout << "odd elements:";
  for (std::vector<int>::iterator it=myvector.begin(); it!=bound; ++it)
    std::cout << ' ' << *it;
  std::cout << '\n';

  std::cout << "even elements:";
  for (std::vector<int>::iterator it=bound; it!=myvector.end(); ++it)
    std::cout << ' ' << *it;
  std::cout << '\n';

  return 0;
}

Possible output:

odd elements: 1 9 3 7 5
even elements: 6 4 8 2

Complexity

Linear in the distance between first and last: Applies pred to each element, and possibly swaps some of them (if the iterator type is a bidirectional, at most half that many swaps, otherwise at most that many).

Data races

The objects in the range [first,last) are modified.

Exceptions

Throws if either an element swap or an operation on an iterator throws.
Note that invalid arguments cause undefined behavior.