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.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 |

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. |

Iterator to the first element of the second group.

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 predicateThe 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.

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

#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

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

© cppreference.com

Licensed under the Creative Commons Attribution-ShareAlike Unported License v3.0.

http://en.cppreference.com/w/cpp/algorithm/stable_partition