# std::stable_partition

From cppreference.com
< cpp‎ | algorithm

Defined in header `<algorithm>` |  |
template< class BidirIt, class UnaryPredicate > BidirIt stable_partition( BidirIt first, BidirIt last, UnaryPredicate p ); | (1) |
template< class ExecutionPolicy, class BidirIt, class UnaryPredicate > BidirIt stable_partition( ExecutionPolicy&& policy, BidirIt first, BidirIt last, UnaryPredicate p ); | (2) | (since C++17)

1) Reorders the elements in the range `[first, last)` in such a way that all elements for which the predicate `p` returns true precede the elements for which predicate `p` returns false. Relative order of the elements is preserved.
2) Same as (1), but executed according to `policy`. This overload only participates in overload resolution if std::is_execution_policy_v<std::decay_t<ExecutionPolicy>> is true.

### Parameters

first, last | - | the range of elements to reorder
policy | - | the execution policy to use. See execution policy for details.

p

-

unary predicate which returns ​true if the element should be ordered before other elements.

The expression p(v) must be convertible to bool for every argument `v` of type (possibly const) `VT`, where `VT` is the value type of `BidirIt`, regardless of value category, and must not modify `v`. Thus, a parameter type of VT&is not allowed, nor is VT unless for `VT` a move is equivalent to a copy (since C++11). ​

Type requirements
- `BidirIt` must meet the requirements of ValueSwappable and LegacyBidirectionalIterator.
- The type of dereferenced `BidirIt` must meet the requirements of MoveAssignable and MoveConstructible.
- `UnaryPredicate` must meet the requirements of Predicate.

### Return value

Iterator to the first element of the second group

### Complexity

Given `N = last - first`

1) Exactly `N` applications of the predicate and `O(N)` swaps if there is enough extra memory. If memory is insufficient, at most `N log N` swaps.
2) `O(N log N)` swaps and `O(N)` applications of the predicate

### Exceptions

The overload with a template parameter named `ExecutionPolicy` reports errors as follows:

- If execution of a function invoked as part of the algorithm throws an exception and `ExecutionPolicy` is one of the standard policies, std::terminate is called. For any other `ExecutionPolicy`, the behavior is implementation-defined.
- If the algorithm fails to allocate memory, std::bad_alloc is thrown.

### Notes

This function attempts to allocate a temporary buffer. If the allocation fails, the less efficient algorithm is chosen.

### Example

Run this code

    #include <iostream>
    #include <algorithm>
    #include <vector>

    int main()
    {
        std::vector<int> v{0, 0, 3, 0, 2, 4, 5, 0, 7};
        std::stable_partition(v.begin(), v.end(), [](int n){return n>0;});
        for (int n : v) {
            std::cout << n << ' ';
        }
        std::cout << '\n';
    }

Output:

    3 2 4 5 7 0 0 0 0

### See also

partition | divides a range of elements into two groups (function template)

Retrieved from "https://en.cppreference.com/mwiki/index.php?title=cpp/algorithm/stable_partition&oldid=103699"