14. Методы сортировок: сортировка массивов простыми включениями, сортировка массивов простым выбором, сортировка обменами. Анализ сложности алгоритмов сортировки.

Сортировка – процесс перегруппировки заданного множества объектов в некотором определенном порядке. Цель сортировки – облегчить  последующий поиск элементов в таком упорядоченном (отсортированном) множестве. Сортировку массивов называют внутренней сортировкой, т.к. массивы хранятся в быстрой, оперативной, внутренней памяти ЭВМ, допускающей случайный (прямой) доступ к элементам.

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

Сортировка обменами:

Производится последовательное упорядочение смежных пар элементов массива: x[1] и x[2], x[2] и x[3], …x[N-1] и x[N]. Если первый элемент больше второго, то элементы переставляются. В итоге, после N–1 сравнения максимальное значение переместится на место элемента X[N], т.е. "вверху" оказывается самый "легкий" элемент – отсюда аналогия с пузырьком. Следующий проход делается до второго сверху элемента (X[N–1]) , таким образом второй по величине элемент поднимается на правильную позицию и т.д. Таким образом, нужно выполнить данную процедуру N–1 раз.

При первом прохождении нужно сравнить N–1 пар элементов, при втором – N–2 пары, при k-м прохождении – N‑k пар.

Program Sort1;

Const N=10;

Type mas=array[1..N] of real;

Var x:mas;

i,k:integer;

a:real;

Begin

For i:=1 to N do {Ввод элементов массива}

read(x[i]);

For i:=1 to N-1 do {Сортировка}

For j:=1 to N-i do

If x[j]>x[j+1] then Begin

a:=x[j];

x[j]:=x[j+1];

x[j+1]:=a;

End;

For i:=1 to N do {Вывод элементов массива}

Write(x[i],’ ‘)

End.

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

Сортировка методом простого выбора

Обычно применяется для массивов, не содержащих повторяющихся элементов.

Алгоритм:

1) выбрать максимальный элемент массива;

2) поменять его местами с последним элементом (после этого самый большой элемент будет стоять на своём месте);

3) повторить пункты 1-2 с оставшимися n–1 элементами.

Программа сортировки методом простого выбора:

Const N=10

Var a:array[1..N] of integer;

i,j,k,n,m:integer;

begin

for i:=1 to N do {Ввод элементов массива}

read(a[i]);

for i:=n downto 2 do begin

k:=i; {Запоминаем номер и }

m:=a[i]; {значение текущего элемента}

for j:=1 to i-1 do {Поиск максимального элемента}

if a[j]>m then begin

k:=j;

m:=a[k]

end;

if k<>i then begin {Меняем местами с последним}

a[k]:=a[i];

a[i]:=m

end

end;

for i:=1 to N do {Вывод элементов массива}

write(a[i]:3)

end.

Сортировка методом простых вставок (метод прямого (простого) включения)

1. Начиная со 2-го элемента, каждый текущий элемент с номером k запоминается в промежуточной переменной.

2. Затем просматриваются предыдущие k–1 элемент и ищется место вставки k-го элемента таким образом, чтобы не нарушить упорядоченности, при этом все элементы, превышающие k-й, сдвигаются вправо.

3. На освободившееся место вставляется k-й элемент.

const NMAX=10;

type item=record

key: integer; {ключ, по которому сортируется массив}

{сопутствующие элементы структуры записей}

end;

TMassiv= array [0..NMAX] of item;

Proсedure Sort_Insert(n:word; Var a:TMassiv);

Var i,j:word;

x:item;

BEGIN

For i:=2 To n Do bеgin

x:=a[i]; {передвигаемый в левую часть элемент}

a[0]:=x; {фиктивный элемент – «барьер»,

установлен на тот случай, когда a[i]

должен переместиться на первое место}

j:=i-1; {правый край левой части}

While x.kеy<a[j].key Do bеgin

a[j+1]:=a[j]; j:=j-1; {продвижение «дырки» в

левой части массива справа налево до той

позиции, в которую должен быть включен

элемент a[i]}

end;

a[j+1]:=x {включение a[i] в «дырку» в левой

части}

еnd

END;

Сложность:

Количество элементарных операций зависит, в первую очередь, от размера сортируемого массива. Однако величина n не определяет это количество однозначно. Для различных массивов одного и того же размера тело цикла While x.key<a[j].key Do будет выполняться различное число раз. Поэтому необходимы три оценки сложности: минимальная, максимальная и средняя.

Минимальная сложность получается в том случае, когда элементы упорядочиваемого массива уже располагаются в нужном порядке. Тогда проверки x.key<a[j].key всегда будут давать отрицательный результат и тело цикла не выполнится ни разу. И выполнение процедуры сведется к выполнению следующих операторов:

For i:=2 To n Do bеgin

x:=a[i];

a[0]:=x;

j:=i-1;

а[j+1]:=x

еnd

Тело цикла For исполняется точно n-1 раз, и число пересылок записей (присваиваний): M_min=3(n-1).

Число сравнений ключей: C_min=n-1.

Максимальная сложность получается в том случае, когда элементы исходного массива расположены в порядке убывания. Тело цикла While выполняется до тех пор, пока элемент х не натолкнется на барьер, т.е. при i=2 один раз, при i=3 два раза; при i=n выполнится (n-1) раз.

Количество пересылок записей: M_max=3(n-1)+ =

=3(n-1)+(1+2+...+n-1)=3(n-1)+n(n-1)/2=(6n-6+n²-n)/2=

=(n²+5n-6)/2.

Количество сравнений: C_mах=2+3+…+n=(n+2)(n-1)/2=

=(n²-n+2n-2)/2=(n²+n-2)/2.

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

Структуру процедуры с точки зрения анализа сложности можно переписать так:

For i:=2 To n Do

begin