Алгоритм adjacent_find()

template < class ForwardIterator >

ForwardIterator

adjacent_find( ForwardIterator first, ForwardIterator last );

template < class ForwardIterator, class BinaryPredicate >

ForwardIterator

adjacent_find( ForwardIterator first,

ForwardIterator last, Predicate pred );

adjacent_find() ищет первую пару одинаковых соседних элементов в диапазоне, ограниченном итераторами [first,last). Если соседние дубликаты найдены, то алгоритм возвращает однонаправленный итератор, указывающий на первый элемент пары, в противном случае возвращается last. Например, если дана последовательность {0,1,1,2,2,4}, то будет найдена пара [1,1] и возвращен итератор, указывающий на первую единицу.

#include <algorithm>

#include <vector>

#include <iostream.h>

#include <assert.h>

class TwiceOver {

public:

bool operator() ( int val1, int val2 )

{ return val1 == val2/2 ? true : false; }

};

int main()

{

int ia[] = { 1, 4, 4, 8 };

vector< int, allocator > vec( ia, ia+4 );

int *piter;

vector< int, allocator >::iterator iter;

// piter указывает на ia[1]

piter = adjacent_find( ia, ia+4 );

assert( *piter == ia[ 1 ] );

// iter указывает на vec[2]

iter = adjacent_find( vec.begin(), vec.end(), TwiceOver() );

assert( *iter == vec[ 2 ] );

// пришли сюда: все хорошо

cout << "ok: adjacent-find() завершился успешно!\n";

return 0;

}

Алгоритм binary_search()

template < class ForwardIterator, class Type >

bool

binary_search( ForwardIterator first,

ForwardIterator last, const Type &value );

template < class ForwardIterator, class Type >

bool

binary_search( ForwardIterator first,

ForwardIterator last, const Type &value,

Compare comp );

binary_search() ищет значение value в отсортированной последовательности, ограниченной парой итераторов [first,last). Если это значение найдено, возвращается true, иначе – false. В первом варианте предполагается, что контейнер отсортирован с помощью оператора “меньше”. Во втором варианте порядок определяется указанным объектом-функцией.

#include <algorithm>

#include <vector>

#include <assert.h>

int main()

{

int ia[] = {29,23,20,22,17,15,26,51,19,12,35,40};

vector< int, allocator > vec( ia, ia+12 );

sort( &ia[0], &ia[12] );

bool found_it = binary_search( &ia[0], &ia[12], 18 );

assert( found_it == false );

vector< int > vec( ia, ia+12 );

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

found_it = binary_search( vec.begin(), vec.end(),

26, greater<int>() );

assert( found_it == true );

}

Алгоритм copy()

template < class InputIterator, class OutputIterator >

OutputIterator

copy( InputIterator first1, InputIterator last,

OutputIterator first2 )

copy() копирует последовательность элементов, ограниченную парой итераторов [first,last), в другой контейнер, начиная с позиции, на которую указывает first2. Алгоритм возвращает итератор, указывающий на элемент второго контейнера, следующий за последним вставленным. Например, если дана последовательность {0,1,2,3,4,5}, мы можем сдвинуть элементы на один влево с помощью такого вызова:

int ia[] = {0, 1, 2, 3, 4, 5 };

// сдвинуть элементы влево на один, получится {1,2,3,4,5,5}

copy( ia+1, ia+6, ia );

copy() начинает копирование со второго элемента ia, копируя 1 в первую позицию, и так далее, пока каждый элемент не окажется в позиции на одну левее исходной.

#include <algorithm>

#include <vector>

#include <iterator>

#include <iostream.h>

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

0 1 1 3 5 8 13

сдвиг массива влево на 1:

1 1 3 5 8 13 13

сдвиг вектора влево на 2:

1 3 5 8 13 8 13

*/

int main()

{

int ia[] = { 0, 1, 1, 3, 5, 8, 13 };

vector< int, allocator > vec( ia, ia+7 );

ostream_iterator< int > ofile( cout, " " );

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

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

// сдвиг влево на один элемент

copy( ia+1, ia+7, ia );

cout << "сдвиг массива влево на 1:\n";

copy( ia, ia+7, ofile ); cout << '\n';

// сдвиг влево на два элемента

copy( vec.begin()+2, vec.end(), vec.begin() );

cout << "сдвиг вектора влево на 2:\n";

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

}