(*
*   Fronta - funkcia QFull
*)

function QFull(Q:TQueue): Boolean;
begin
    QFull := (Q.Zac = 1) and (Q.Kon = Q.QMax) or ((Q.Zac - 1) = Q.Kon)
end;

(*
*   Fronta - funkcia Remove
*)

function Remove(Q:TQueue): Boolean;
begin
    if (Q.QZac <> Q.QKon) then
        begin
            Q.QZac = Q.Zac + 1;
            if (Q.QZac > Q.QMax) then
                Q.QZac := 1;
        end;
end;

(*
*   Rekurzívna ekvivalencia STRUKTUR dvoch binnarnych stromov
*)
function EQTS(Kor1, Kor2: Tuk): Boolean;
begin
    if (Kor1 = nil) or (Kor2 = nil) then
        EQTS := (Kor1 = Kor2)
    else
        EQTS := EQTS(Kor1^.LUk, Kor2^.LUk) and EQTS(Kor1^.PUk, Kor2^.PUk)
    end;


(*
*   Rekurzívna ekvivalencia dvoch binnarnych stromov
*)
function EQTS(Kor1, Kor2: Tuk): Boolean;
begin
    if (Kor1 = nil) or (Kor2 = nil) then
        EQTS := (Kor1 = Kor2)
    else
        EQTS := EQTS(Kor1^.LUk, Kor2^.LUk) and EQTS(Kor1^.PUk, Kor2^.PUk) and
            (Kor1^.Data = Kor2^.Data)
    end;

(*
*   PostDelete pre jednosmerný zoznam
*)
var PomUk: Tuk;
begin
    if (L.Act <> nil) then
        begin
            if (L.Act^.UkNasl <> nil) then
                begin
                    PomUk := PomUk^.UkNasl;
                    Dispose(PomUk);
                end;
        end;
end;

(*
*   Rekurzívny zápis CopyTree
*)
function CopyTree(KorOrig:TUk; var KorCopy: TUk);
begin
    if (KorOrig <> nil) then
        begin
            new(KorCopy);
            Kor.KorCopy^.Data := KorOrig^.Data;
            CopyTree(KorOrig^.LUk, KorCopy^.LUk);
            CopyTree(KorOrig^.PUk, KorCopy^.PUk);
        end;
    else
        KorCopy := nil;
end;


(*
*   QuickSort s optimalizovanym zasobnikom
*)
procedure NonRecQuicksort(left, right: integer);
var i,j: integer;
S: TStack;

begin
    SInt(S);
    Push(S, left);
    Push(S, right);

    while not S empty do
        begin
            Top(S, right);
            Pop(S);
            Top(S, left);
            Pop(S);

            while left < right do
                begin
                    Partition(A, left, right, i, j);
                    if ((right - i) > (j - left)) then
                        begin
                            Push(S, i);
                            Push(S, right);
                            right := j;
                        end;
                    else
                        begin
                            Push(S, left);
                            Push(S, j);
                            Left := i;
                        end;
                end;
        end;

(*
*   MacLarenov algoritmus
*)
i := 1;
Pom := first;

while i < Max do
    begin
        while Pom < i do
            Pom := Pole[Pom].Uk;
            Pole[i] := Pole[Pom];
            Pole[i].Uk := Pom;
            i := j + 1;
    end;

(*
*   SiftDown (stable) funkcia
*)
procedure SiftDown(var A:TArr; Left, Right: integer);
var i, j: integer;
Cont: Boolean; (* Řídicí proměnná cyklu *)
Temp: integer; (* Pomocná proměnná téhož typu jako položka pole *)

begin
    i := Left;
    j := 2 * i; (* Index levého syna *)
    Temp := A[i];
    Cont := j<=Right;

    while Cont do
        begin
            if (j < Right) then (* Uzel má oba synovské uzly *)
                if (A[j] < A[j+1]) then (* Pravý syn je větší *)
                    j := j + 1; (* nastav jako většího z dvojice synů *)
                    if (Temp >= A[j] ) then (* Prvek Temp již byl posunut na své místo; cyklus končí *)
                        Cont := false
                    else
                        begin (* Temp propadá níž, A[j] vyplouvá o úroveň výš *)
                            A[i] := A[j]; (* *)
                            i := j; (* syn se stane otcem pro příští cyklus"*)
                            j := 2 * i; (* příští levý syn *)
                            Cont := j<=Right; (* podmínka : "cyklus pokračuje" *)
                        end;
        end;
        A[i]:=Temp; (* konečné umístění prosetého uzlu *)
end;

(*
*   Post order
*)
procedure ​PostOrder​(var List:TList; UkTree:TUk);
var Zleva: Boolean;

begin
    SInitBool; (* inicializace zásobníku booleovských hodnot *)
    SInitUk; (* inicializace zásobníku ukazatelů *)
    InitList(List); 250
    InsertFirst(List,0); (* vytvoření hlavičky *)
    Nejlev(UkTree);

    while not SEmptyUk do
        begin
            TopBool(Zleva); PopBool;
            TopUk(UkTree);
            if Zleva then
                begin
                    PushBool(false); (* vložení příznaku "příště přijde zprava" *)
                    Nejlev(UkTree^.PUk);
                end;
            else
                begin
                    PopUk;
                    PostInsert(List, UkTree^.Data); (* postupné vkládání do seznamu *)
                    SuccList(List); (* postup aktivity *)
                end;
        end;
    DeleteFirst(List); (* zrušení nepotřebné hlavičky *)
end;


procedure DDeleteFirst (var DList:TDList);
var DPomUk:TDUk;
begin
     with DList do
        begin
            if (Zac <> nil) then
                begin
                    DPomUk := Zac;
                    if (Zac = Kon) then
                    begin
                        Zac := nil;
                        Kon := nil;
                        Act := nil;
                        MarkUsable := false;
                    end
                    else
                        begin
                            if Zac=Act then
                                Act:=nil;
                            if Zac = Mark then
                                MarkUsable := false;
                                Zac := DPomUk^.Puk;
                                Zac^.LUk := nil;
                        end;
                    dispose(DPomUk);
                end;
        end;
end;

procedure DeleteFirst(var L:TList);
var PomUk:TUk;
begin
    if (L.Zac <> nil) then
        begin
            PomUk := L.Zac;
            if (L.Zac = L.Act) then
                L.Act := nil;
                L.Zac := L.Zac^.Uk;
            if (L.Zac = nil) then
                L.Kon := nil;
            if (PomUk = L.Mark) then
                begin
                    L.MarkUsable := false;
                    L.Mark := nil
                end;
            dispose(PomUk);
        end;
end;