template< class RandomAccessIterator > void

sort( RandomAccessIterator first, RandomAccessIterator last );

template< class RandomAccessIterator, class Compare > void

sort( RandomAccessIterator first,

Алгоритм sort()

RandomAccessIterator last, Compare comp );

sort() переупорядочивает элементы в диапазоне [first,last) по возрастанию, используя оператор меньше , определенный для типа элементов контейнера. Во втором варианте порядок устанавливается операцией сравнения comip. (Для сохранения относительного порядка равных элементов пользуйтесь алгоритмом stable sort ().) М1 не приводим пример, специально иллюстрирующий применение алгоритма sort() , поскольку его можно найти во многих других программах, в частности в binary search(), equal range() и inplace merge().

template< class BidirectionalIterator, class Predicate BidirectionalIterator

stable partition( BidirectionalIterator first, BidirectionalIterator last,

Алгоритм stable partition()

Predicate pred );

stable partition() ведет себя так же, как partition(), но гарантированно сохраняет относительный порядок элементов контейнера. Вот та же программа, что и для алгоритма partition(), но с использованием

stable partition() .

#include <algorithm> #include <vector> #include <iostream.h>

/* печатается:

исходная последовательность:

29 23 20 22 17 15 26 51 19 12 35 40

устойчивое разбиение по четн элементам:

20 22 26 12 40 29 23 17 15 51 19

устойчивое разбиение по элементам, мень 25: 23 20 22 17 15 19 12 29 26 51 35 40

class even elem { public:

bool operator()( int elem ) { return elem%2 ? false : true;

int main()

int ia[] = { 29,23,20,22,17,15,26,51,19,12,35,40 }; vector< int, allocator > vec( ia, ia+12 );

ostream iterator< int > ofile( cout, );

cout << исходная последовательность:\n ;

copy( vec.begin(), vec.end(), ofile ); cout << \n;

stable partition( &ia[0], &ia[12], even elem() );

разбиение по четн элементам:\n ;

cout << устойчивое разбиение по четным copy( ia, ia+11, ofile ); cout << \n;

stable partition( vec.begin(), vec.end(),

bind2nd(less<int>(),25)

cout << устойвое разбиение по элементам, меньше 25:\n ; copy( vec.begin(), vec.end(), ofile ); cout << \n;

template< class RandomAccessIterator > void

stable sort( RandomAccessIterator first, RandomAccessIterator last );

template< class RandomAccessIterator, class Compare > void

stable sort( RandomAccessIterator first,

Алгоритм stable sort()

RandomAccessIterator last, Compare comp );

#include <algorithm> #include <vector> #include <iostream.h>

печатается:

исходная последовательность:

29 23 20 22 12 17 15 26 5l 19 12 23 35 40

устойчивая сортовка - по умолчана в порядке возрастания: 12 12 15 17 19 20 22 23 23 26 29 35 40 51 устойчивая сортовка: в порядке убания: 51 40 35 29 26 23 23 22 20 19 17 15 12 12

int main() 1

int ia[] = { 29,23,20,22,12,17,15,26,51,19,12,23,35,40 }; vector< int, allocator > vec( ia, ia+l4 ); ostream iterator< int > ofile( cout, );

cout << исходная последовательность:\n ; copy( vec.begin(), vec.end(), ofile ); cout << \n;

stable sort( &ia[0], &ia[l4] );

cout << устойчивая сортировка - по умолчанию

<< в порядке возрастания:\n ; copy( ia, ia+14, ofile ); cout << \n;

stable sort( vec.begin(), vec.end(), greater<int>() );

cout << устойвая сортовка: в порядке убания :\n ; copy( vec.begin(), vec.end(), ofile ); cout << \n;

элементы на основе заданной программистом операции сравнения comp.

template< class Type > void

Алгоритм swap()

swap ( Type &obl, Type &ob2 );

swap () обменивает значения объектов obl и ob2.

stable sort() ведет себя так же, как sort() , но гарантированно сохраняет относительный порядок равных элементов контейнера. Второй вариант упорядочивает