function template
<algorithm>
std::stable_partition
template <class BidirectionalIterator, class UnaryPredicate> BidirectionalIterator stable_partition (BidirectionalIterator first, BidirectionalIterator last, UnaryPredicate pred);
Partition range in two - stable ordering
Rearranges the elements in 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, and, unlike function partition, the relative order of elements within each group is preserved.
This is generally implemented using an internal temporary buffer.
参数
- 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 last, including the element pointed by first but not the element pointed by last.
BidirectionalIterator shall point to a type for which swap is defined (and swaps the value of its arguments) and which is both move-constructible and move-assignable.
- 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).
该函数不得修改其参数。
This can either be a function pointer or a function object.
返回值
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.
示例
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
|
// stable_partition example
#include <iostream> // std::cout
#include <algorithm> // std::stable_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::stable_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;
}
|
输出
odd elements: 1 3 5 7 9
even elements: 2 4 6 8
|
复杂度
If enough extra memory is available, linear in the distance between first and last: Applies pred exactly once to each element, and performs up to that many element moves.
Otherwise, up to linearithmic: Performs up to N*log(N) element swaps (where N is the distance above). It also applies pred exactly once to each element.
数据竞争
范围[first,last)内的对象将被修改。
异常
如果任何元素比较、元素交换（或移动）或迭代器操作抛出异常，则会抛出异常。
请注意，无效参数会导致未定义行为。