Implementation

Procedure InitStack;

Begin

S.uk:=0;

End;

Function FullStack;

Begin

FullStack:=S.uk=stacksize;

End;

Function EmptyStack;

Begin

EmptyStack:=S.uk=0;

End;

Procedure PutStack;

Begin

if not(FullStack(S)) then

begin

inc(S.uk);

S.buf[S.uk]:=el;

stackerror:=stackok;

end

else stackerror:=stackover;

End;

Procedure GetStack;

Begin

if not(EmptyStack(S)) then

begin

el:=S.buf[S.uk];

dec(S.uk);

stackerror:=stackok;

end

else stackerror:=stackover;

End;

End.

{------------------------------------------------------------------------------}

Unit UStackL;{стек на односвязном списке}

Interface

Const stackok=0;{успешное завершение операции}

stackover=1;{стек переполнен}

stackunder=2;{стек пуст}

Type BaseType=word;

Sv=^Zv;

Zv=Record

Data:BaseType;

Link:Sv

End;

Stack=Record

Start,Ptr:Sv

End;

Procedure InitStack(var S:Stack);{конструктор}

Function EmptyStack(S:Stack):boolean;{стек пуст?}

Function FullStack(S:Stack):boolean;{стек полон?}

Procedure PutStack(var S:Stack;El:BaseType);{помещение элемента в стек}

Procedure GetStack (var S:Stack; var El:BaseType);{удаление элемента из стека}

Implementation

Var StackError: 0..2;

Procedure InitStack;

Begin

New(S.Start);

S.Ptr:=S.Start;

S.Start^.Link:=nil;

StackError:=stackok;

End;

Function EmptyStack;

Begin

EmptyStack:=S.Start=nil

End;

Function FullStack;

Begin

FullStack:=maxavail<sizeof(Zv);

StackError:=StackUnder

End;

Procedure PutStack;

Begin

S.Ptr:=S.Start;

New(S.Start);

S.Start^.Data:=El;

S.Start^.link:=S.Ptr

End;

Procedure GetStack;

Begin

if not EmptyStack(s) then

begin

El:=S.Start^.data;

S.Ptr:=S.Start^.link;

Dispose(S.Start);

S.Start:=S.Ptr

end

End;

End.

{------------------------------------------------------------------------------}

unit UDeck; {дек на двусвязном списке}

Interface

uses UDList;

Const deckok=dlistok;{успешное завершение операции}

decknotmem=dlistnotmem;{не хватает памяти}

deckunder=dlistunder;{дек пуст}

Type Deck=DList;

Var deckerror:byte;

Procedure InitDeck(var D:Deck);{коструктор}

Function EmptyDeck(var D:Deck):boolean;{дек пуст?}

Procedure PutDStart(var D:Deck; e:BaseType);{помещение элемента в начало дека}

Procedure PutDEnd(var D:Deck; e:BaseType);{помещение элемента в конец дека}

Procedure GetDStart(var D:Deck;var e:BaseType);{удаление первого элемента}

Procedure GetDEnd(var D:Deck;var e:BaseType);{удаление последнего элемента}

Procedure DoneDeck(var D:Deck);{деструктор}

Implementation

Procedure InitDeck;

Begin

InitDList(D);

DeckError:=error

End;

Function EmptyDeck;

Begin

EmptyDeck:=Empty(D)

End;

Procedure PutDStart;

Begin

BeginPtr(D);

PutNext(D,e);

deckerror:=error

End;

Procedure PutDEnd;

Begin

EndPtr(D);

PutPrev(D,e);

deckerror:=error

End;

Procedure GetDStart;

Begin

BeginPtr(D);

GetNext(D,e);

deckerror:=error

End;

Procedure GetDEnd;

Begin

EndPtr(D);

GetPrev(D,e);

deckerror:=error

End;

Procedure DoneDeck;

Begin

DoneList(D);

deckerror:=error

End;

End.

{------------------------------------------------------------------------------}

unit UBTree; {бинарное дерево}