// Laboratoire mathématique. Réaliser du type insert et maxdelete.

program heapSortTest ;

const N = 7 ;

type Item = Cardinal ;

Tableau = array[1..N] of Item ;

procedure swap(var a,b : Item) ;

var tmp : Item ;

begin

tmp := a ;

a := b ;

b := tmp

end ;

procedure afficher(T : array of Item) ;

var k : cardinal ;

begin

for k := low(T) to high(T) do write(T[k]:4) ;

writeLn

end ;

procedure heapSort(var T : Tableau) ;

var k,j, dimFP : Cardinal ;

begin

// du tableau à la file de priorité : (N-1)insert

dimFP := 1 ;
 writeln('Insert :');

while dimFP < high(T) do

begin

inc(dimFP) ;

k := dimFP ;

while (k>1)and(T[k]>T[k div 2]) do

begin

swap(T[k],T[k div 2]) ;

k := k div 2;

afficher(T);

end

end ;

// de la file de priorité au tableau trié : (N-1)maxdelete

writeln('Maxdelete :');

while dimFP > 1 do

begin

swap(T[1],T[dimFP]) ;

afficher(t);

dec(dimFP) ;

k := 1 ;

while k <= dimFP div 2 do

begin

j := 2*k ;

if (j<dimFP)and(T[j]<T[j+1]) then inc(j) ;

if T[k]>=T[j] then break ;

swap(T[k],T[j]) ;

afficher(T);
 k := j

end

end

end ;

procedure generer(out T : Tableau) ;

var k : cardinal ;

begin

//randomize() ;

//for k := low(T) to high(T) do T[k] := random(100) ;

k:=1;

while (k<N+1) DO

begin

writeln('entre une valeur');

readln(T[k]);

inc(k);

end;

end ;

var T : Tableau ;

begin

generer(T) ;

afficher(T) ;

heapSort(T) ;

afficher(T)
end.