Сортировка вставками (InsertSort)

a[0] a[1] a[2] a[3] a[4]

исходный массив 5 2 4 7 3

обработка a[1]=2 2 5 | передвинуть 5 в поз.1, вставить 2 в поз.0

обработка a[2]=4 2 4 5 | передвинуть 5 в поз.2, вставить 4 в поз.1

обработка a[3]=7 2 4 5 7 | элемент 7 на месте

обработка a[4]=3 2 3 4 5 7 | сдвинуть хвост массива

| вправо, вставить 3 в поз.1

| массив отсортирован

Обменов в этой сортировке нет.

Вычислительная сложность сортировки вставками

Сортировка вставками требует фиксированного числа проходов - . В проходах включаются элементы В -м проходе включения производятся в часть массива и требуют в среднем сравнений. Общее число сравнений равно:

Сложность алгоритма измеряется числом сравнений. Наилучший случай – при уже отсортированном массиве. Тогда число сравнений равно . Наихудший случай – при пересортировке. Каждая вставка произойдет в точке , и в -м проходе требуется сравнений. Тогда общее число сравнений равно .

Быстрая сортировка (QuickSort)

индексы 0 1 2 3 4 5 6 7 8 9

исх. массив 80 15 30 60 55 65 40 35 45 70 l=0 m=(l+h)/2=4 h=9

a[m]=55 – центральный элемент

Все элементы массива разбиваются на 2 подмассива:

- нижний, - содержит элементы, меньшие или равные центральному;

- верхний, содержит элементы большие, чем центральный.

Поскольку известно, что будет последним в , то он меняется местами с . Затем сканируют с помощью двух индексов - и . Целью прохода является определение элементов для и .

Сначала перемещается . При индекс останавливается. Затем перемещается вниз и при останавливается. Элементы и находятся не в своих подмассивах, и поэтому они меняются местами: . Конечные положения и - они заходят друг за друга. При этом находится в подмассиве, элементы которого . Это точка разбиения подмассивов и позиция для центрального элемента. Поэтому - .

В результате первого просмотра массива (это первая фаза быстрой сортировки, - фаза сканирования) получим:

Затем подмассив (за исключением и подмассив обрабатываются точно так же, т.е. переходят к рекурсивной фазе обработки. Рекурсивный процесс прекращается на пустом или одноэлементном подмассивах.

//------------------------------------------------------------------------------------

void QuickSort(int l, int h)

{

int su, sd, m, p;

if(h-l==0) return; //если в массиве меньше 2-х элементов, вернуться

else if(h-l==1) //если в массиве 2 элемента

{ if(a[h]<a[l]) {swap(a[l], a[h]); obm++; }

sr++; return;

}

m=(l+h)/2; p=a[m]; swap(a[m], a[l]); obm++; su=l+1; sd=h;

do{

while(su<=sd&&a[su]<=p) {su++; sr++;}

while(p<a[sd]) { sd--; sr++; }

if(su<sd) {swap(a[su], a[sd]); obm++; }

} while(su<sd);

a[l]=a[sd]; a[sd]=p; obm++;

if(l<sd-1) QuickSort(l, sd-1);

if(sd+1<h) QuickSort(sd+1, h);

}

//--------------------------------------------------------------------------------------

Вызов функции - QuickSort(0, n-1).

Вычислительная сложность быстрой сортировки

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

Пусть размер массива , или , а центральный элемент располагается точно посередине массива и каждого подмассива.

При первом сканировании производится сравнений. В результате создаются 2 подмассива размером . При втором – обработка каждого из двух подмассивов потребует сравнений и т.д. Общее число сравнений:

.

Этот случай соответствует уже отсортированному массиву. Но практически то же происходит при пересортировке массива. Предположим, массив отсортирован по убыванию:

После первого прохода получим:

4 1 2 3 5 8 6 7

Массив почти отсортирован по возрастанию.

Наихудший случай: центральный элемент все время попадпет в одноэлементный подмассив, а все прочие элементы остаются во втором подмассиве. Это происходит тогда, когда центральным всегда является наименьший элемент. Например: 8 3 1 5 9.

Здесь в первом проходе производится сравнений, во втором - , и т.д. Общее число сравнений:

.

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