2.2. Сортировка

Двоичный поиск работает только в том случае, если элементы отсор­тированы. Если по одному и тому же набору данных планируется не­однократный повторный поиск, то выгоднее один раз отсортировать данные, а затем использовать двоичный поиск. Если набор данных из­вестен заранее, то он может быть отсортирован при написании програм­мы и проинициализирован.во время компиляции. Иначе придется сор­тировать его во время выполнения программы.

Один из самых лучших алгоритмов сортировки — быстрая сортиров­ка (quicksort), которая была придумана в 1960 году Чарльзом Хоаром (С. A. R. Ноаге). Быстрая сортировка — замечательный пример того, как можно избежать лишних вычислений. Она работает при помощи разде­ления массива на большие и маленькие элементы:

выбрать один элемент массива ("разделитель");

разбить оставшиеся элементы на две группы:

"маленькие", то есть меньшие, чем разделитель,

"большие", то есть большие или равные разделителю,

рекурсивно отсортировать обе группы.

Когда этот процесс закончится, то массив будет отсортирован. Быстрая сортировка работает быстро, потому что, как только мы узнаем, что эле­мент меньше, чем разделитель, нам уже не нужно его сравнивать с боль­шими элементами; аналогично, большие элементы не сравниваются с маленькими. Поэтому данный алгоритм существенно быстрее, чем та­кие простые методы сортировки, как сортировка вставкой или пузырь­ком, когда каждый элемент сравнивается напрямую со всеми остальными.

Алгоритм быстрой сортировки практичен и эффективен; он хорошо изучен, и существует множество его вариаций. Версия, которую мы здесь представим, является одной из самых простых реализаций, но, ко­нечно, далеко не самой быстрой.

Наша функция quicksort сортирует массив целых чисел:

/* quicksort: сортирует v[0]..v[n-1] по возрастанию */

void quicksort(int v[], int n)

{

int i, last;

if (n <= 1) /* ничего не делать */

return;

swap(v, 0, rand() % n); /* поместить разделитель в v[0] */

last = 0;

for (i = 1; i < n; i++) /* разделить */

if (v[i] < v[0j)

swap(v, ++last, i);

swap(v, 0, last); /* сохранить разделитель */

quicksort(v, last); /* рекурсивно отсортировать */

quicksort(v+last+1, n-last-1); /* каждую часть */

Операция swap, которая меняет местами два элемента, встречается в quicksort трижды, поэтому лучше всего вынести ее в отдельную функцию:

/* swap: поменять местами v[i] и v[j] */

void swap(int v[], int i, int j)

{

int temp;

temp = v[i];

v[i] = v[j];

v[j] = temp;

}

При разделении прежде всего случайным образом выбирается элемент-разделитель, который временно переставляется в начало массива, затем просматриваются остальные. Элементы, меньшие разделителя ("маленькие" элементы), перемещаются ближе к началу массива (на по-зюцию last), а "большие" элементы — в сторону конца массива (на позицию I). В начале процесса, сразу после перемещения разделителя в нача-ло, last = 0 и элементы с i = 1 по n-1 еще не исследованы:

В начале 1-й итерации элементы с первого по last строго меньше разделителя, элементы с last+1. по i-1 больше или равны разделителю, а эле-менты с i по n-1 еще не рассмотрены. Пока не выполнилось первый раз условие v[i] >=v[0], алгоритм будет переставлять элемент v[i] сам с со-бой; это, конечно, занимает дополнительное время, но не столь страшно.

Когда все элементы просмотрены, нулевой элемент переставляется на позицию last, чтобы разделитель занял свою окончательную пози­цию; тогда порядок элементов будет правильным. Теперь массив вы­глядит так:

Та же самая операция применяется к левой и правой частям массива; после окончания этого процесса весь массив будет отсортирован.

Насколько быстро работает быстрая сортировка? В наилучшем случае

• первый проход делит массив из п элементов на две группы пример­ но по тг/2 элементов;

• второй проход разделяет две группы по п/2 элементов на 4 группы, в каждой из которых примерно по п/4 элементов;

• на следующем проходе четыре группы по п/4 делятся на восемь групп по (примерно) и/8 элементов;

• и т. д.

Данный процесс продолжается примерно Iog₂ n раз, поэтому общее время работы в лучшем случае пропорционально n + 2 * n/2 + 4 * n/4 + 8 * n/8 ... (Iog₂ п слагаемых), что равно

п Iog₂ п. В среднем алгоритм работает совсем не намного дольше. Обычно принято использовать именно двоичные логарифмы, поэтому мы можем сказать, что быстрая сортировка работает пропорционально п log п.

Эта демонстрационная реализация быстрой сортировки наиболее прозрачна, но у нее есть одна слабина. Если каждый выбор разделите­ля разбивает массив на две примерно одинаковые группы, то наш ана­лиз корректен, однако если разделение слишком часто происходит неровно, то время работы будет расти скорее как п¹. В нашей реали­зации в качестве разделителя берется случайный элемент, чтобы уменьшить шанс того, что плохие входные данные приведут к слиш­ком большому количеству неровных разбиений массива. Но если все входные значения одинаковы, то наша реализация за каждый проход будет отделять только один элемент, поэтому время работы будет ра­сти как п².

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