Реализации алгоритмов/Сортировка/Пирамидальная: различия между версиями

м (Добавлена ссылка на Википедию к Rust)
 
<source lang="pascal">
procedure SortHeapSort (var Arrsequence: array of SomeTypeT; Countcount: IntegerWord);
 
procedure DownHeapSiftDown (index, Countcount: integerWord; Currentcurrent: SomeTypeT);
{
Функция пробегает по пирамиде восстанавливая ее
Процедура пробежит по всем потомкам и найдет нужное место для следующего элемента
}
var Childchild: IntegerWord;
begin
while index < Countcount div 2 do begin
Child := (index+1)*2-1;begin
ifchild := (Childindex <+ Count-1) and* (Arr[Child]2 <- Arr[Child+1]) then;
if (child < count - 1) and (sequence[child] < sequence[child + 1]) then
Child:=Child+1;
if Current > child := Arr[Child]child + then1;
if current >= sequence[child] then
break;
Arrsequence[index] := Arrsequence[Childchild];
index := Childchild
end;
Arrsequence[index] := Currentcurrent
end;
 
{ Основная функция }
var i: integerInteger;
Currentcurrent: SomeTypeT;
begin
{ Собираем пирамиду }
for i := (Countcount div 2) - 1 downtodownTo 0 do
DownHeapSiftDown(i, Countcount, Arrsequence[i]);
{ Пирамида собрана. Теперь сортируем }
for i := Countcount - 1 downtodownTo 0 do
begin
Currentcurrent := Arrsequence[i]; { перемещаем верхушку в начало отсортированного списка }
Arrsequence[i] := Arrsequence[0];
DownHeapSiftDown(0, i, Currentcurrent) { находим нужное место в пирамиде для нового элемента }
end
end;
===Вариант № 2===
Примечание:
myarray = array[1..Size] of integer;
N — количество элементов массива
 
<source lang="pascal">
procedure HeapSort (var msequence: myarrayarray of T; N: integerInteger);
var i: integerInteger;
{ Выполняет обмен значениями двух элементов массива sequence с указанными индексами }
procedure Swap(var a,b:integer);
procedure SwapItems (index_1, index_2: Word);
var tmptemp: integerT;
begin
tmptemp := asequence[index_1];
asequence[index_1] := bsequence[index_2];
bsequence[index_2] := tmptemp
end;
 
procedure Sort (Ns: integer);
var i, tmpchild, pos, mid: integerInteger;
begin
mid := Ns div 2;
for i := mid downtodownTo 1 do
begin
pos := i;
while pos <= mid do
begin
tmpchild := pos * 2;
if tmpchild < Ns then
begin
if msequence[tmpchild + 1] <m sequence[tmpchild] then
tmpchild := tmpchild + 1;
if msequence[poschild]>m < sequence[tmppos] then
begin
SwapSwapItems(m[pos], m[tmp]child);
pos := tmpchild
end
else
pos := Ns
end
else if msequence[poschild]>m < sequence[tmppos] then
begin
SwapSwapItems(m[pos], m[tmp]child);
pos := Ns
end
begin
Sort(i);
SwapSwapItems(m[1], m[i])
end
end;
 
{ Процедура приведения массива к пирамидальному виду (to heap) }
procedure toHeapToHeap (var data: TArray; n: integer); { n - размер массива }
var i: integer;
begin
 
{ Процедура для сдвига массива влево }
procedure leftShiftLeft (var data: TArray; n: integer);
var i: integer;
temp: integer;
for i := n downTo 1 do
begin
toHeapToHeap(a, i);
leftShiftLeft(a, n);
end
END.
Анонимный участник