C++. Сборник рецептов

Когсуэлл Джефф

 random_shuffle(v.begin, v.end); // См. 7.2

 string* arr = new string[v.size];

 // Копируем элементы в массив

 copy(v.begin, v.end, &arr[0]);

 // Сортировка работает для любого типа диапазонов, но при условии, что

 // ее аргументы ведут себя как итераторы произвольного доступа.

 sort(&arr[0], &arr[v.size]);

 printRange(&arr[0], &arr[v.size]);

 // Создаем список с такими же элементами

 list<string> lst(v.begin, v.end);

 lst.sort; //

Самостоятельная версия sort работать не будет, здесь требуется

// использовать list::sort. Заметьте, что невозможно отсортировать

// только часть списка.

 printContainer(lst);

}

Запуск примера 7.6 может выглядеть вот так.

Введите набор строк: a z b y c x d w

^Z

– ----

a b c d w x y z

– ----

w b y c a x z d

– ----

a b c d w x y z

– ----

a b c d w x y z

Обсуждение

Сортировка — это очень часто выполняющаяся операция, и есть два способа отсортировать последовательность. Можно обеспечить хранение элементов в определенном порядке с помощью ассоциативного контейнера, но при этом длительность операции вставки будет иметь логарифмическую зависимость от размера последовательности. Либо можно сортировать элементы только по мере надобности с помощью

sort

, имеющей несколько опций.

Стандартный алгоритм

sort

делает именно то, что от него ожидается: он сортирует элементы диапазона в восходящем порядке с помощью

operator<

. Он объявлен вот так.

void sort(Rnd first, Rnd last);

void sort(Rnd first, Rnd last, BinPred comp);

Как и в большинстве других алгоритмов, если

operator<

не удовлетворяет вашим требованиям, можно указать собственный оператор сравнения. В среднем случае сложность имеет зависимость n log n. В худшем случае она может быть квадратичной.

Если требуется, чтобы одинаковые элементы сохранили свой первоначальный порядок, используйте

stable_sort

. Он имеет такую же сигнатуру, но гарантирует, что порядок эквивалентных элементов изменен не будет. Его сложность при наличии достаточного объема памяти в худшем случае составляет n log n. Если памяти недостаточно, то сложность может оказаться равной n(log n)².

Однако

sort

работает не для всех контейнеров. Он требует итераторов произвольного доступа, так что при использовании контейнера, не предоставляющего таких итераторов, он неприменим. Итераторы произвольного доступа предоставляют стандартные последовательные контейнеры

deque

,

vector

и

string

/

wstring

(которые не являются контейнерами, но удовлетворяют большинству требований к ним),

list

— это единственный, который такого итератора не предоставляет. Если требуется отсортировать список, используйте

list::sort

. Например, в примере 7.6 вы, вероятно, заметили, что

list::sort

не принимает никаких аргументов.

lst.sort;

Это отличает его от

std::sort

, с помощью которого можно отсортировать только часть последовательности. Если требуется отсортировать часть последовательности, то не следует использовать

list

.

Концепция сортировки очень проста, но есть несколько вариаций

на тему ее реализации в стандартной библиотеке. Следующий перечень описывает эти вариации.

partial_sort

Принимает три итератора произвольного доступа —

first

,

middle

и

last

— и (необязательно) функтор сравнения. Он имеет два постусловия: элементы диапазона (

first

,

middle

) будут меньше, чем элементы диапазона (

middle

,

last

), и диапазон (

first

,

middle

) будет отсортирован с помощью

operator<

или указанного функтора сравнения. Другими словами, он сортирует только первые n элементов.

partial_sort_сору

Делает то же, что и

partial_sort

, но помещает результаты в выходной диапазон. Он берет первые n элементов из исходного диапазона и в соответствующем порядке копирует их в результирующий диапазон. Если результирующий диапазон (n) короче, чем исходный диапазон (m), то в результирующий диапазон копируется только n элементов.

nth_element

Принимает три итератора произвольного доступа —

first

,

nth

и

last

— и необязательный функтор сравнения. Он помешает элемент, на который ссылается

nth

, в то место, где он находился бы, если бы весь диапазон был отсортирован. Следовательно, все элементы диапазона (

first

,

nth

) будут меньше, чем элемент в позиции

nth

(те, что находятся в диапазоне (

nth

,

last

) не сортируются, но больше, чем те, что предшествуют

nth

). Этот алгоритм следует использовать тогда, когда требуется отсортировать только один или несколько элементов диапазона и избежать затрат на сортировку всего диапазона.

Также можно разделить элементы диапазона в соответствии с каким-либо критерием (функтором), и это является предметом обсуждения рецепта 7.7.

Смотри также

Рецепт 7.7.

7.7. Разделение диапазона

Проблема

Имеется диапазон элементов, которые требуется каким-либо образом разделить на группы. Например, необходимо переместить в начало диапазона все элементы, которые меньше определенного значения.

Решение

Для перемещения элементов используйте стандартный алгоритм

partition

с предикатом-функтором. См. пример 7.7.

Пример 7.7. Разделение диапазона

#include <iostream>

#include <istream>

#include <string>

#include <vector>

#include <algorithm>

#include <functional>

#include <iterator>

#include "utils.h" // Для printContainer: см. рецепт 7.10

using namespace std;

int main {

 cout << "Введите набор строк: ";

 istream_iterator<string> start(cin);

 istream_iterator<string> end; // Здесь создается "маркер"

 vector<string> v(start, end);

 // Реорганизуем элементы в v так, чтобы те, которые меньше,