program scalaniepoprawne;

{$APPTYPE CONSOLE}

uses
  SysUtils,
  windows;

var
zakres,n,o,
q,i,z:longint;

   A,T,S:array[1..10000000] of Longint;
                  start1,stop1:Double;
                  timeEnd,TimeStart,freq,timestart1,timeend1:Int64;
                  czas:double;
F:textfile;

procedure insertionsort;
var
i,j,x:Longint;
Begin
    for j:=2 to n do
      Begin
       x:=A[j];
       i:=j-1;
        while x<a[i] do
          begin
           a[i+1]:=a[i];
           i:=i-1;
          end;
       a[i+1]:=x
      end;

end;
  //wybor
  procedure selectionsort;
var
i,j,k,x:Longint;
begin
 for i:=1 to n-1 do
  begin
    k:=i;
  
    for j:=i+1 to n do
      if a[j]<a[k] then
        Begin
          k:=j;
        end;
        x:=a[k];
      a[k]:=a[i];
      a[i]:=x;
   end;
end;

procedure heapSort;
 var
j,i,k,x,m:Longint;
begin {tworzenie kopca}
 for i:=2 to n do
    begin
       j:=i;
       k:=j div 2;
       x:=a[i];
    while (k >0 ) and (a[k]<x) do
        begin
        a[j]:=a[k];
        j:=k;
        k:=j div 2;
       end;
    a[j]:=x;
  end;

for i:=n downto 2 do
  begin                             // j przechowuje indeks przodka
  x:=a[1];                         // k przechowuje indeks lewego potomka.
  a[1]:=a[i];
  a[i]:=x;
  j:=1;
  k:=2;

  while k < i do
    begin
      if(k+1 < i) and (a[k+1] > a[k]) then
      m:=k+1
      else
      m:=k;
      if (a[m] <= a[j]) then break;
      x:=a[j];
      a[j]:=a[m];
      a[m]:=x;
      j:=m;
      k:=j+j;
   end;
  end;


end;


Procedure shellsort(n:longint);
var
h,t,x,k,i,j :longint;
B:array[1..19] of Longint;
Begin

   if (n <=100) then
    BEgin
      x:=n div 5;
      B[x]:=1;
      for k:=x-1 downto 1 do
      Begin
        B[k]:=3*B[k+1]+1;
      End;
    end;

    if n>100 then
       BEgin
        x:=17;
        B[x]:=1;
         for k:=x-1 downto 1 do
            B[k]:=3*B[k+1]+1;
       end;                    // generowanie tablicy przyrostow

    for k:=1 to x do
       if B[k]<n then
        begin
        h:=B[k]   ;
        
         for i:=n-h downto 1 do
            begin
                t:=a[i];     //zmienna pomocnicza
                j:=i+h;
                while (j<=n) and (t>a[j])  do
                  begin
                    a[j-h]:=a[j];
                    j:=j+h;
                  end;
             a[j-h]:=t;
             end;
       end;
end;








Procedure losowe;
begin
 AssignFile(f,'sortowanie2.txt');
Rewrite(f);
Close(f);

z:=0;
writeln('podaj n');
readln(n);
Writeln('podaj zakres');
readln(zakres);

AssignFile(f,'sortowanie2.txt');
Reset(F);
Append(f);
Writeln(F,'Liczba n    Heap                       ShellSort                   SelectionSort              InsertionSort');
CloseFile(F);

repeat
AssignFile(f,'sortowanie2.txt');
Reset(f);
Append(F);
Write(F,n,'  ');
z:=z+1;
       Writeln(n);
for i:=1 to n do
 begin
 S[i]:=random(zakres)+random(zakres);
 //Write(S[i],' ');
 A[i]:=S[i];
 end;
writeln;

if QueryPerformanceFrequency(Freq) then
QueryPerformanceCounter(TimeStart);
heapsort;
QueryPerformanceCounter(TimeEnd);
czas:=(TimeEnd-TimeStart)/Freq*1000;
writeln('heap :',czas);
Write(F,'  ',czas,'   ');
    for i:=1 to n do
  begin
  // write(A[i],' ');
  end;
//  writeln;
for i:=1 to n do
  begin
  a[i]:=S[i];
  //write(A[i],' ');
  end;
if QueryPerformanceFrequency(Freq) then
QueryPerformanceCounter(TimeStart);
shellsort(n);
QueryPerformanceCounter(TimeEnd);
czas:=(TimeEnd-TimeStart)/Freq*1000;
writeln('shell :',czas);
Write(F,'  ',czas,'  ');
//for i:=1 to n do
 //begin
// write(T[i],' ');
// end;

for i:=1 to n do
  begin
  a[i]:=S[i];
 // write(A[i],' ');
  end;
if QueryPerformanceFrequency(Freq) then
QueryPerformanceCounter(TimeStart);
selectionsort;
QueryPerformanceCounter(TimeEnd);
czas:=(TimeEnd-TimeStart)/Freq*1000;
writeln('selection :',czas);
Write(F,'  ',czas,'  ');

for i:=1 to n do
  begin
   a[i]:=S[i];
  //write(A[i],' ');
  end;
if QueryPerformanceFrequency(Freq) then
QueryPerformanceCounter(TimeStart);
insertionsort;
QueryPerformanceCounter(TimeEnd);
czas:=(TimeEnd-TimeStart)/Freq*1000;
writeln('insert :',czas);
Writeln(F,'  ',czas,'  ');
Closefile(F);

n:=n+5000;
until  n>50000;
//z=2;
//n>100000

  { TODO -oUser -cConsole Main : Insert code here }
end;


Procedure rosnaco;
begin
 AssignFile(f,'rosnaco.txt');
Rewrite(f);
Close(f);

z:=0;
writeln('podaj n');
readln(n);
AssignFile(f,'rosnaco.txt');
Reset(F);
Append(f);
Writeln(F,'Liczba n    Heap                       ShellSort                   SelectionSort              InsertionSort');
CloseFile(F);
repeat
AssignFile(f,'rosnaco.txt');
Reset(f);
Append(F);
Write(F,n,'  ');
z:=z+1;
Writeln(n);
for i:=1 to n do
 begin
 A[i]:=i;
//Write(A[i],' ');
 end;
writeln;
if QueryPerformanceFrequency(Freq) then
QueryPerformanceCounter(TimeStart);
heapsort;
QueryPerformanceCounter(TimeEnd);
czas:=(TimeEnd-TimeStart)/Freq*1000;
writeln('heap :',czas);
Write(F,'  ',czas,'  ');
for i:=1 to n do
 begin
// write(T[i],' ');
 end;
// shellsort
 for i:=1 to n do
 begin
 A[i]:=i;
//Write(A[i],' ');
 end;
writeln;
if QueryPerformanceFrequency(Freq) then
QueryPerformanceCounter(TimeStart);
shellsort(n);
QueryPerformanceCounter(TimeEnd);
czas:=(TimeEnd-TimeStart)/Freq*1000;
writeln('shell :',czas);
Write(F,'  ',czas,'  ');

for i:=1 to n do
 begin
// write(A[i],' ');
 end;
for i:=1 to n do
  begin
  a[i]:=i;
 // write(A[i],' ');
  end;
if QueryPerformanceFrequency(Freq) then
QueryPerformanceCounter(TimeStart);
selectionsort;
QueryPerformanceCounter(TimeEnd);
czas:=(TimeEnd-TimeStart)/Freq*1000;
writeln('selection :',czas);
Write(F,'  ',czas,'  ');

for i:=1 to n do
  begin
   a[i]:=i;
  //write(A[i],' ');
  end;
if QueryPerformanceFrequency(Freq) then
QueryPerformanceCounter(TimeStart);
insertionsort;
QueryPerformanceCounter(TimeEnd);
czas:=(TimeEnd-TimeStart)/Freq*1000;
writeln('insert :',czas);
Writeln(F,'  ',czas,'  ');
Closefile(F);





n:=n+5000;
until n>50000
end;

Procedure malejaco;
begin
AssignFile(f,'malejaco.txt');
Rewrite(f);
Close(F);
z:=0;
writeln('podaj n');
readln(n);
AssignFile(f,'malejaco.txt');
Reset(F);
Append(f);
Writeln(F,'Liczba n    Heap                       ShellSort                   SelectionSort              InsertionSort');
CloseFile(F);


repeat
AssignFile(f,'malejaco.txt');
Reset(f);
Append(F);
Write(F,n,'  ');

 for i:=n downto 1 do
 begin
 A[i]:=(n-i)+1;
// Write(A[i],' ');
 end;
//for i:=1 to n do Write (A[i],' ');
writeln;

readln;
if QueryPerformanceFrequency(Freq) then
QueryPerformanceCounter(TimeStart);
heapsort;
QueryPerformanceCounter(TimeEnd);
czas:=(TimeEnd-TimeStart)/Freq*1000;
writeln('heap :',czas);
Write(F,'  ',czas,'  ');
{for i:=1 to n do
 begin
 write(T[i],' ');
 end;}

  //shellsort

  for i:=n downto 1 do
 begin
 A[i]:=(n-i)+1;
// Write(A[i],' ');
 end;
 writeln;

if QueryPerformanceFrequency(Freq) then
QueryPerformanceCounter(TimeStart);
shellsort(n);
QueryPerformanceCounter(TimeEnd);
czas:=(TimeEnd-TimeStart)/Freq*1000;
writeln('shell :',czas);
Write(F,'  ',czas,'  ');
{for i:=1 to n do
 begin
 write(T[i],' ');
 end;}
for i:=n downto 1 do
  begin
  a[i]:=(n-i)+1;
 // write(A[i],' ');
  end;
if QueryPerformanceFrequency(Freq) then
QueryPerformanceCounter(TimeStart);
selectionsort;
QueryPerformanceCounter(TimeEnd);
czas:=(TimeEnd-TimeStart)/Freq*1000;
writeln('selection :',czas);
Write(F,'  ',czas,'  ');

for i:=n  downto 1 do
 begin
  a[i]:=(n-i)+1;
 // write(A[i],' ');
  end;
 //for i:=1 to n do Write(a[i],' ');
if QueryPerformanceFrequency(Freq) then
QueryPerformanceCounter(TimeStart);
insertionsort;
QueryPerformanceCounter(TimeEnd);
czas:=(TimeEnd-TimeStart)/Freq*1000;
writeln('insert :',czas);
Writeln(F,'  ',czas,'  ');
// Writeln('po');
{  for i:=1  to n do
  begin
   write(A[i],' ');
  end;}
Closefile(F);
 n:=n+5000;
until  n>50000

end;

Procedure staly;
begin
AssignFile(f,'staly.txt');
Rewrite(f);
Close(F);
z:=0;
writeln('podaj n');
readln(n);
AssignFile(f,'staly.txt');
Reset(F);
Append(f);
Writeln(F,'Liczba n    Heap                       ShellSort                   SelectionSort              InsertionSort');
CloseFile(F);


repeat
AssignFile(f,'staly.txt');
Reset(f);
Append(F);
Write(F,n,'  ');

 for i:=n downto 1 do
 begin
 A[i]:=10;
// Write(A[i],' ');
 end;

writeln;


if QueryPerformanceFrequency(Freq) then
QueryPerformanceCounter(TimeStart);
heapsort;
QueryPerformanceCounter(TimeEnd);
czas:=(TimeEnd-TimeStart)/Freq*1000;
writeln('heap :',czas);
Write(F,'  ',czas,'  ');
{for i:=1 to n do
 begin
 write(T[i],' ');
 end;}

  //shellsort

  for i:=n downto 1 do
 begin
 A[i]:=10;
// Write(A[i],' ');
 end;
 writeln;

if QueryPerformanceFrequency(Freq) then
QueryPerformanceCounter(TimeStart);
shellsort(n);
QueryPerformanceCounter(TimeEnd);
czas:=(TimeEnd-TimeStart)/Freq*1000;
writeln('shell :',czas);
Write(F,'  ',czas,'  ');

{for i:=1 to n do
 begin
 write(T[i],' ');
 end;}


 for i:=1 to n do
  begin
  a[i]:=10;
 // write(A[i],' ');
  end;
if QueryPerformanceFrequency(Freq) then
QueryPerformanceCounter(TimeStart);
selectionsort;
QueryPerformanceCounter(TimeEnd);
czas:=(TimeEnd-TimeStart)/Freq*1000;
writeln('selection :',czas);
Write(F,'  ',czas,'  ');

for i:=1 to n do
  begin
   a[i]:=10;
  //write(A[i],' ');
  end;
if QueryPerformanceFrequency(Freq) then
QueryPerformanceCounter(TimeStart);
insertionsort;
QueryPerformanceCounter(TimeEnd);
czas:=(TimeEnd-TimeStart)/Freq*1000;
writeln('insert :',czas);
Writeln(F,'  ',czas,'  ');
Closefile(F);


n:=n+5000;
until  n>50000

end;




Procedure aksztaltny;
Begin

AssignFile(f,'aksztaltny.txt');
Rewrite(f);
Close(F);
q:=1;
writeln('podaj n');
readln(n);
AssignFile(f,'aksztaltny.txt');
Reset(F);
Append(f);
Writeln(F,'Liczba n    Heap                       ShellSort                   SelectionSort              InsertionSort');
CloseFile(F);

repeat
AssignFile(f,'aksztaltny.txt');
Reset(f);
Append(F);
Write(F,n,'  ');

z:=1;                //tworzenie tablicy a-ksztaltny
q:=1;
for i:=1 to (n div 2) do
  Begin
   A[i]:=q;
   q:=q+2;
   T[i]:=A[i];
  // write(a[i],' ');
 End;
 q:=(q+1)*2;
 for i:=(n div 2)+1 to n do
  Begin
   A[i]:=q;
   q:=q-2;
   T[i]:=A[i];
  // Write(a[i],' ');

 End;
 writeln;
 readln;
//heapsort
 if QueryPerformanceFrequency(Freq) then
QueryPerformanceCounter(TimeStart);
heapsort;
QueryPerformanceCounter(TimeEnd);
czas:=(TimeEnd-TimeStart)/Freq*1000;
writeln('heap :',czas);
Write(F,'  ',czas,'  ');
{ for i:=1 to n do
 begin
 write(A[i],' ');
 end;}

            writeln;
//shellsort
for z:=1 to n do
  Begin
    A[z]:=T[z];
    //Write(A[z],' ');
  end;
 if QueryPerformanceFrequency(Freq) then
QueryPerformanceCounter(TimeStart);
shellsort(n);
QueryPerformanceCounter(TimeEnd);
czas:=(TimeEnd-TimeStart)/Freq*1000;
writeln('shell :',czas);
Write(F,'  ',czas,'  ');
{for i:=1 to n do
 begin
 write(A[i],' ');
 end;}

 for z:=1 to n do
  begin
  a[z]:=T[z];
  //write(A[z],' ');
  end;
if QueryPerformanceFrequency(Freq) then
QueryPerformanceCounter(TimeStart);
selectionsort;
QueryPerformanceCounter(TimeEnd);
czas:=(TimeEnd-TimeStart)/Freq*1000;
writeln('selection :',czas);
Write(F,'  ',czas,'  ');

for z:=1 to n do
  begin
   //write(A[z],' ');
   a[z]:=T[z];
  //write(A[i],' ');
  end;
if QueryPerformanceFrequency(Freq) then
QueryPerformanceCounter(TimeStart);
insertionsort;
QueryPerformanceCounter(TimeEnd);
czas:=(TimeEnd-TimeStart)/Freq*1000;
writeln('insert :',czas);
Writeln(F,'  ',czas,'  ');
Closefile(F);
  for z:=1 to n do
  begin
   //write(A[z],' ');
  end;

n:=n+5000;
until    n>50000;

end;








Begin
aksztaltny;
//losowe;
//rosnaco;
//malejaco;
//staly;
readln;
End.