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)內的物件將被修改。
異常
如果任何元素比較、元素交換（或移動）或迭代器操作丟擲異常，則會丟擲異常。
請注意，無效引數會導致未定義行為。