4.2. Простые методы сортировки

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

4.2.1. Сортировка выбором

О дним из простейших алгоритмов сортировки является алгоритм сортировки выбором. Его суть в следующем. Пусть первые (i-1) элементов массива уже содержат правильные значения. Тогда на следующем шаге найдём в оставшейся части массива минимальный элемент и поменяем его местами с i-м – в результате правильные значения будут содержать уже i первых элементов массива.

		i
3	4	7	8	5	6

Рис 4.2 Иллюстрация работы сортировки выбором.

Минимальный элемент 5 меняем местами с текущим.

Приведем текст функции, выполняющей сортировку выбором:

void sort(int a[], int n)

{ for(int i=0; i<n; i++)

{//определяем индекс мин.элемента и ставим его на i-е место

int indMin=i;

for(int j=i+1; j<n; j++)

if (a[j]<a[indMin]) indMin=j;

int tmp = a[i]; a[i] = a[indMin]; a[indMin] = tmp;

}

}

Как видим, алгоритм выполняет O(n²) операций независимо от исходных данных, даже если массив изначально был отсортирован или почти отсортирован. Из-за этого недостатка он достаточно редко применяется даже для сортировки небольшого числа элементов.

4.2.2. Сортировка алгоритмом пузырька

Алгоритм пузырьковой сортировки уже рассматривался в разделе 1._. Хотя данный алгоритм также не отличается эффективностью, но у него есть большой плюс – он допускает различные улучшения.

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

Чтобы ещё более улучшить алгоритм, можно запоминать не только сам факт обмена, но и индекс места, где произошёл последний обмен. Если в нём участвовали элементы a_k и a_k+1, то, значит, часть массива от 1 до k уже отсортирована и дальше изменяться не будет. (Действительно, раз не было ни одного обмена в этой части массива, значит, она отсортирована. Кроме того, в оставшейся части массива нет элементов, меньших a_k, поскольку a_k был минимальным из них).

Ещё одно улучшение вытекает из следующего наблюдения. Представим следующую ситуацию. Пусть имеется почти отсортированный массив, за исключением того, что в конце его стоит маленький элемент. За один проход этот элемент поднимется в начало массива, после чего на следующем проходе обменов выполнено не будет, и алгоритм остановится. Если же, наоборот, в начале почти отсортированного массива стоит большой элемент, то на каждом проходе он будет сдвигаться вправо всего лишь на одну позицию. Отсюда вытекает следующее улучшение – менять направление следующих один за другим проходов. Полученный алгоритм иногда называют шейкер-сортировкой. Приведем пример реализации алгоритма со всеми этими модификациями:

void sheiksort(int a[], int n)

{

int l=0; //индекс элемента, левее которого уже всё готово

int r=n-1; //индекс элемента, правее которого уже всё готово

int i,t,j;

while (l<r)

{ //двигаемся слева направо

j = -1;

for(i=l; i<r; i++)

if (a[i]>a[i+1])

{

t = a[i+1]; a[i+1] = a[i]; a[i] = t;

j=i; //запоминаем позицию обмена

}

if (j==-1) return; //ни одного обмена - завершение

r=j; //всё, что правее, уже отсортировано и не изменится

//теперь двигаемся справа налево

j=-1;

for(i=r; i>l; i--)

if (a[i-1]>a[i])

{

t = a[i-1]; a[i-1] = a[i]; a[i] = t;

j = i; //запоминаем позицию обмена

}

if (j==-1) return; //ни одного обмена - сортировка завершена

l=j; //всё, что стоит левее, уже отсортировано и не изменится

}

}

	l	i			R
1	2	3	2	4	4	7	9

Рис. 4.3. Иллюстрация к алгоритму шейкер-сортировки (показан проход слева направо, уже готовые части выделены серым)

К сожалению, сложность данного алгоритма в худшем случае (можно показать, что и в среднем тоже) осталась O(n²), но, по крайней мере, поведение алгоритма стало естественным – почти отсортированный массив будет «досортирован» за линейное время.