15. Алгоритмы сортировки.
Пузырьковая сортировка.
Procedure Bubble(var A:ar);
var
I,j,tmp:int;
sort : Boolean;
begin
I:=lim;
sort:=false;
while (I>1)and not sort do
begin
sort:=true;
for j:=1 to I-1 do
if A[j]>A[j+1] then
begin
tmp:=A[j];A[j]:=A[j+1];
A[j+1]:=tmp;sort:=false;
End;
I:=I-1;
End;
end.
Число действий=n(n-1)/2
Сортировка выбора.
Procedure Choice(var A:ar);
Var
I,j,tmp:int;
Begin
for I:=1 to lim-1 do
For j:=i+1 to n do
If A[i]>A[j] then
begin
Tmp:=A[i];
A[i]:=A[j];
A[j]:=tmp;
end;
end.
Алгоритм быстрой сортировки.
Идея- найти опорный элемент (слева от него все элементы меньше по значению, а справа- все больше). Массив делится на 2 части этим элементом, после чего решается та же задача для половинок (рекурсивно). Массив будет упорядочиваться, если каждый элемент в своей части массива будет опорным.
Число сравнений
определяется по формуле:
Procedure Separate(var A:ar; L,r:int);Var I,j,tmp,d:int; flag:Boolean;
Begin I:=L;j:=r; d:=0;
Repeat
if (d=0) then repeat
Flag:=A[i]<A[j];
if flag then I:=I+1
until not flag;
if (d=1) then repeat
Flag:=A[j]>A[i]; if flag then j:=j-1
until not flag;
if (I>j) then begin
Tmp:=A[i];A[i]:=A[j];
A[j]:=tmp;end{begin};d:=d-1;
until I=j;
if (L<i-1) then Separate(A;L;i-1);
if (I+1<r) then Separate(A;I+1;r);
End{Separate};
Сортировка слиянием.
В ее основе лежит операция слияния 2-х массивов. Необходимо построить массив, в котором каждый элемент является элементом исходного массива. Результирующий массив должен быть упорядочен. Выделяется текущий элемент(вначале 1-й) и сравнивается с оставшимися. В результ. Массив попадает наименьший. В том массиве, откуда выбрали элемент в качестве текущего берется следующий, после чего сравнение повторяется. Если в результате описанных действий какой-то из массивов будет полностью просмотрен, то в результ. Массив полностью переносится остаток другого массива(это можно сделать, т.к. исходные массивы предполагаются упорядоченными). Алгоритм состоит в следующем: исходный массив делится примерно пополам. Каждая из частей сортируется по возрастанию. Этим же алгоритмом отсортировываются половинки и сливаются в уже отсортированный массив.
Program MergeSort;
Const lim=30;
Type ar=array[1..lim]of byte
Var I:byte; mas:ar;
Procedure Mering(s1,f1:byte
Var mas1:ar;s2,f2:byte; Var mas2:ar;f:byte Var mas:ar;);
Var I,j,k:byte
Begin I:=s1;j:=s2;
f:=(f1-s1+1)+( f2-s2+1);
for k:=1 to f do
if I>f1 then begin
mas[k]:=mas2[j]; inc(j);
end else if j>f2 then begin
mas[k]:=mas1[i]; inc(i);
end else if mas1[i]<=mas2[j] then begin mas[k]:=mas1[i];inc(i);
end else begin mas[k]:=mas2[j];
inc(j); end; end{mering};
{сортировка 2-х элементов}
procedure Align(s,f:byte; var mas:ar);var tmp:byte;
begin if mas[s]>mas[f] then
begin tmp:=mas[s];mas[s]:=mas[f]; mas[f]:=tmp;end; end{Align};
{сортировка слияния}
Procedure SorMerge(s,f:byte;var vas:ar);Var I,mid,ff:byte;rab:ar;
Begin mid:=(s+f)/2;
If mid-s>1 then SorMerge(s,mid,
mas) else Align(s, mid,mas);
If f-(mid+1)>1 then
SorMerge(mid+1,f,mas)else Align(mid+1, f,mas); Mering(1,mid,mas, mid+1,f,
mas,ff,rab);
for I:=s to f do mas[i]:=rab[I-s+1];end{ SorMerge } ;
{основная}
begin j:=0; randomize;
for I:=1 to lim do
mas[i]:=random(High(byte));
SorMerge(1,lim,mas);
For I:=1 to lim do Begin write(mas[i]:4); Inc(j);
if j mod 10=0 then Writeln; end;readln;End.
Время работы этого алгоритма хуже алгоритма быстрой сортировки, но по порядку сопоставимы.