Sunteți pe pagina 1din 13

Cozi i stive

1. Noiuni generale
Cozile i stivele sunt structuri de date logice (implementarea este fcut
utiliznd alte structuri de date) i omogene (toate elementele sunt de acelai tip).
Ambele structuri au dou operaii de baz: adugarea i extragerea unui element. n
afara acestor operaii se pot implementa i alte operaii utile: test de structur vid,
obinerea primului element fr extragerea acestuia, Diferena fundamental ntre
cele dou structuri este disciplina de acces. Stiva folosete o disciplin de acces de tip
LIFO (Last In First Out), iar coada o disciplin de tip FIFO (First In First Out).
2. Moduri de implementare
Stivele i cozile pot fi implementate n mai multe moduri. Cele mai utilizate
implementri sunt cele folosind masive i liste. Ambele abordri au avantaje i
dezavantaje:

Avantaje Dezavantaje
Masive implementare simpl
consum redus de memorie
vitez mare pentru operaii
numrul de elemente este
limitat
risip de memorie n cazul n
care dimensiunea alocat
este mult mai mare dect
numrul efectiv de elemente
Liste numr oarecare de elemente

consum mare de memorie
pentru memorarea legturilor

Pentru implementarea unei stive folosind masive avem nevoie de un masiv V
de dimensiune n pentru memorarea elementelor. Ultimul element al masivului va fi
utilizat pentru memorarea numrului de elemente ale stivei.

n cazul n care stiva este vid, atunci elementul V
n-1
va avea valoarea 0.
Folosind aceast reprezentare, operaiile de baz se pot implementa n timp constant
(O(1)).

Algoritmii pentru implementarea operaiilor de baz (n pseudocod) sunt:

adaugare( el em, V, n)
i f v[ n- 1] = n- 1 //verificam dac stiva nu e plin
r et ur n " st i va pl i na"
v[ v[ n- 1] ] = el em //adaugm elementul n masiv
v[ n- 1] = v[ n- 1] + 1 //incrementm numrul de elemente
r et ur n " succes"

stergere( V, n)

i f v[ n- 1] = 0 //verificam dac stiva nu e goal
r et ur n " st i va goal a"
el em= v[ v[ n- 1] - 1] //extragem elementul din masiv
v[ n- 1] = v[ n- 1] + 1 //decrementm numrul de elemente
r et ur n el em

Coada se poate implementa folosind un vector circular de dimensiune n (dup
elementul n-4 urmeaz elementul 0). Ultimele dou elemente conin indicii de start i
sfrit ai cozii, iar antepenultimul element este un marcaj folosit pentru a putea
diferenia cazurile de coad goal i coad plin.

Algoritmii care implementeaz operaiile de baz pentru o coad memorat in
forma prezentat sunt:

adaugare( el em, V, n)
v[ n- 2] = ( v[ n- 2] + 1) mod ( n- 2) //deplasm capul cozii
i f v[ n- 1] = v[ n- 2] //verificare coada plin
r et ur n " coada pl i na"
V[ V[ n- 1] ] = el em //adugm elementul
r et ur n " succes"

stergere( V, n)
i f v[ n- 1] = v[ n- 2] //verificare coad goal
r et ur n " coada goal a"
v[ n- 1] = ( v[ n- 1] + 1) mod ( n- 2) //deplasm indicele de sfrit
r et ur n V[ V[ n- 1] ] //ntoarcem elementul
Cea de-a doua modalitate de implementare a stivelor i cozilor este cea
folosind liste alocate dinamic.
n cazul stivei, vom folosi o list simplu nlnuit organizat ca n figura
urmtoare:

Fiecare nod este format din informaiile utile i o legtur ctre elementul
urmtor. Tipul informaiilor stocate n stiv este indicat de utilizator prin definirea
tipului TipStiva. Stiva vid este reprezentat printr-un pointer nul. Elementele sunt
adugate naintea primului element (cu deplasarea varfului stivei). Extragerea se face
tot din vrful stivei.
Codul surs pentru biblioteca care implementeaz operaiile pe stiva alocat
dinamic este:

#i f ndef STI VA_H
#def i ne STI VA_H

/ / Un el ement di n st i va
st r uct NodSt i va
{
Ti pSt i va Dat e; / / t i pul def i ni t de ut i l i zat or
NodSt i va *Ur mat or ; / / l egat ur a cat r e el ement ul ur mat or

/ / const r uct or pent r u i ni t i al i zar ea unui nod
NodSt i va( Ti pSt i va dat e, NodSt i va *ur mat or = NULL) :
Dat e( dat e) , Ur mat or ( ur mat or ) {}
};

/ / St i va est e memor at a ca un
/ / poi nt er cat r e pr i mul el ement
t ypedef NodSt i va* St i va;

/ / Cr eaza o st i va vi da
St i va St Cr ear e( )
{
r et ur n NULL;
}

/ / Ver i vi ca daca o st i va est e vi da
bool St EGoal a( St i va& st i va)
{
r et ur n st i va == NULL;
}

/ / Adauga un el ement i n st i va
voi d St Adauga( St i va& st i va, Ti pSt i va dat e)
{
st i va = new NodSt i va( dat e, st i va) ;
}

/ / I nt oar ce o copi e a var f ul ui st i vei
Ti pSt i va St Var f ( St i va& st i va)
{
/ / Caz 1: st i va vi da
i f ( St EGoal a( st i va) ) / / daca st i va e goal a, at unci
r et ur n Ti pSt i va( ) ; / / i nt oar cemval oar ea i mpl i ci t a pent r u
t i pul st i vei

/ / Caz 2: st i va nevi da
r et ur n st i va- >Dat e; / / i nt oar cemvar f ul st i vei
}

/ / Ext r age el ement ul di n var f ul st i vei
Ti pSt i va St Ext r age( St i va& st i va)
{
/ / Caz 1: st i va vi da
i f ( St EGoal a( st i va) ) / / daca st i va e goal a, at unci
r et ur n Ti pSt i va( ) ; / / i nt oar cemval oar ea i mpl i ci t a pent r u
t i pul st i vei

/ / Caz 2: st i va nevi da
NodSt i va *nodDeSt er s = st i va; / / sal vamo r ef er i nt a l a nodul de st er s
Ti pSt i va r ez = st i va- >Dat e; / / sal vamdat el e de r et ur nat

st i va = st i va- >Ur mat or ; / / avansamcapul l i st ei

del et e nodDeSt er s; / / st er gemnodul de st er s

r et ur n r ez; / / i nt oar cemr ezul t at el e
}

#endi f / / STI VA_H

Coada poate fi implementat folosind o list circular dublu nlanuit de
forma:
x
Capul cozii
Legtura ctre
elementul urmtor
Informaii
Legtura ctre
elementul anterior

Ca i n cazul stivei, tipul informaiilor stocate este indicat de ctre utilizator
prin definirea tipului de date TipCoada. Coada goal este reprezentat printr-un
pointer nul. Adugarea elementelor se face la sfritul listei, iar extragerea se face de
la nceputul acesteia.
Codul surs care implementeaz operaiile pe structura de date prezentat este:

#i f ndef COADA_H
#def i ne COADA_H

/ / Un el ement di n coada
st r uct NodCoada
{
/ / t i pul def i ni t de ut i l i zat or
Ti pCoada Dat e;

/ / l egat ur i l e cat r e el ement ul
/ / ur mat or si ant er i or
NodCoada *Ur mat or , *Ant er i or ;

/ / const r uct or pent ur i ni t i al i zar ea unui nod
NodCoada( Ti pCoada dat e,
NodCoada *ur mat or = NULL, NodCoada *ant er i or = NULL) :
Dat e( dat e) , Ur mat or ( ur mat or ) , Ant er i or ( ant er i or )
{}
};

/ / Coada est e memor at a ca un
/ / poi nt er cat r e pr i mul el ement
t ypedef NodCoada* Coada;

/ / Cr eaza o coada vi da
Coada CdCr ear e( )
{
r et ur n NULL;
}

/ / Test eaza daca o coada est e vi da
bool CdEGoal a( Coada& coada)
{
r et ur n coada == NULL;
}

/ / Adauga un el ement l a sf ar si t ul cozi i
voi d CdAdauga( Coada& coada, Ti pCoada dat e)
{
i f ( CdEGoal a( coada) )
{
/ / Cazul 1: Coada vi da
coada = new NodCoada( dat e) ;
coada- >Ant er i or = coada- >Ur mat or = coada;
}
el se
{
/ / Cazul 2: Coada cu cel put i n un el ement
coada- >Ant er i or - >Ur mat or = new NodCoada( dat e, coada, coada- >Ant er i or ) ;
coada- >Ant er i or = coada- >Ant er i or - >Ur mat or ;
}
}

/ / Obt i ne o copi e a pr i mul ui el ement di n coada
Ti pCoada CdVar f ( Coada& coada)
{
/ / Caz 1: coada vi da
i f ( CdEGoal a( coada) ) / / daca coada e goal a, at unci
r et ur n Ti pCoada( ) ; / / i nt oar cemval oar ea i mpl i ci t a pent r u
t i pul st i vei

/ / Caz 2: coada nevi da
r et ur n coada- >Dat e; / / i nt oar cemvar f ul cozi i
}

/ / Ext r age pr i mul el ement di n coada
Ti pCoada CdExt r age( Coada& coada)
{
Ti pCoada r ez;

/ / Caz 1: coada vi da
i f ( CdEGoal a( coada) )
r et ur n Ti pCoada( ) ;

/ / Caz 2: coada cu un si ngur el ement
i f ( coada- >Ant er i or == coada)
{
r ez = coada- >Dat e;
del et e coada;
coada = NULL;

r et ur n r ez;
}

/ / Caz 3: coada cu mai mul t e el ement e
NodCoada *nodDeSt er s = coada;
r ez = coada- >Dat e;

coada = coada- >Ur mat or ;
coada- >Ant er i or = coada- >Ant er i or - >Ant er i or ;
coada- >Ant er i or - >Ur mat or = coada;
del et e nodDeSt er s;

r et ur n r ez;
}

#endi f / / COADA_H
3. Aplicaie Evaluarea expresiilor aritmetice
Pentru exemplificarea utilizrii structurilor de tip stiv i coad vom construi o
aplicaie pentru evaluarea expresiilor aritmetice. Expresiile acceptate pot conine
numere naturale, operaii aritmetice de baz (adunare, scdere, nmulire, mprire) i
paranteze.
Pentru evaluarea expresiei vom folosi forma polonez postfixat. Aceast
form de scriere a expresiei permite o evaluarea rapid ntr-o singur parcurgere.
Evaluarea expresiei primite sub forma unui ir de caractere se face n trei faze:
1. Se transform irul primit ntr-o coad de elemente numite atomi care conin
informaiile necesare transformrii i evalurii expresiei (tip, prioritate i
valoare).
2. Expresia stocat ca o coad de atomi este rescris n forma polonez
postfixat.
3. Se evalueaz expresia.
Structurile folosite pentru memorarea expresiei sunt:

/ / Ti pur i l e de at omi accept at e de apl i cat i e
enumTi pAt om
{
Ter men, / / un numar
Deschi der ePar ant eza, / / )
I nchi der ePar ant eza, / / (
Pl us, / / +
Mi nus, / / -
I nmul t i r e, / / *
I mpar t i r e / / /
};

/ / I nf or mat i i l e r ef er i t oar e l a un at om
st r uct At om
{
Ti pAt omTi p;
i nt Pr i or i t at e;
doubl e Val oar e;

/ / Const r uct or ul pent r u i ni t i al i zar ea
/ / unui at om
At om( Ti pAt omt i p = Ter men,
i nt pr i or i t at e = 0, doubl e val oar e = 0)
{
Ti p = t i p;
Pr i or i t at e = pr i or i t at e;
Val oar e = val oar e;
}
};
Algoritmii folosesc bibliotecile pentru manipularea stivelor i cozilor
prezentate n seciunea precedent:

/ / St i vel e si cozi l e f ol osi t e vor
/ / avea ca i nf or mat i e ut i l a at omi
t ypedef At omTi pSt i va;
t ypedef At omTi pCoada;

#i ncl ude " st i va. h"
#i ncl ude " coada. h"
Prima faz a aplicaiei este transformarea expresiei ntr-o coad de atomi.
Funcia care implementeaz operaia este:

/ / Tr ansf or ma expr esi a i nt r - o coada de at omi
Coada Par sar eSi r ( char *expr esi e)
{
Coada coada = CdCr ear e( ) ;

whi l e ( *expr esi e ! = ' \ 0' )
{
swi t ch( *expr esi e)
{
case ' +' : CdAdauga( coada, At om( Pl us, 1) ) ; br eak;
case ' - ' : CdAdauga( coada, At om( Mi nus, 1) ) ; br eak;
case ' *' : CdAdauga( coada, At om( I nmul t i r e, 2) ) ; br eak;
case ' / ' : CdAdauga( coada, At om( I mpar t i r e, 2) ) ; br eak;
case ' ( ' : CdAdauga( coada, At om( Deschi der ePar ant eza, 0) ) ; br eak;
case ' ) ' : CdAdauga( coada, At om( I nchi der ePar ant eza, 0) ) ; br eak;
def aul t :
/ / t er men ( numar i nt r eg)
i f ( *expr esi e > ' 0' && *expr esi e <= ' 9' )
{
/ / const r ui mt er menul
doubl e val oar e = 0;
whi l e ( *expr esi e >= ' 0' && *expr esi e <= ' 9' )
{
val oar e = val oar e*10 + ( *expr esi e - ' 0' ) ;
expr esi e++;
}

/ / t r ebui e sa r eveni ml a pr i mul car act er
/ / de dupa numar
expr esi e- - ;

/ / adaugamt er menul i n coada
CdAdauga( coada, At om( Ter men, 0, val oar e) ) ;
}
}

/ / avansaml a ur mat or ul car act er di n expr esi e
expr esi e++;
}

r et ur n coada;
}
Transformarea expresiei din forma normal infixat n forma polonez
postfixat se face folosind algoritmul lui Dijkstra. Acest algoritm utilizeaz o stiv n
care sunt pstrai operatorii i din care sunt eliminai i transferai n scrierea
postfixat (o coad).
Algoritmul este:
1. se iniializeaz stiva i scrierea postfixat;
2. att timp ct nu s-a ajuns la sfritul expresiei matematice:
a. se citete urmtorul element din expresie;
b. dac este valoare se adaug n scrierea postfixat;
c. dac este ( se introduce n stiv;
d. dac este ) se transfer elemente din stiv n scrierea postfixat pn la(
e. altfel:
i. att timp ct ierarhia operatorului din vrful stivei este mai
mare ierarhia operatorului curent, se trece elementul din vrful
stivei n scrierea postfixat;
ii. se introduce operatorul curent n stiv.
3. se trec toi operatorii rmai pe stiv n scrierea postfixat.
Algoritmul este implementat folosind urmtoarea funcie:

/ / Tr ansf or ma o expr esi e di n f or ma nor mal a
/ / i nf i xat a i n f or ma pol oneza post f i xat a
Coada For maPol oneza( Coada& expr esi e)
{
/ / st i va f ol osi t a pent r u st ocar ea t empor ar a
St i va st i va = St Cr ear e( ) ;

/ / coada pent r u st ocar ea r ezul t at ul ui ( f or ma pol oneza)
Coada f or maPol oneza = CdCr ear e( ) ;

At omat omSt i va;

/ / par cur gemexpr esi a i ni t i al a
whi l e ( ! CdEGoal a( expr esi e) )
{
At omat om= CdExt r age( expr esi e) ;

swi t ch ( at om. Ti p)
{
case Ter men:
/ / se adauga di r ect i n si r ul r ezul t at
CdAdauga( f or maPol oneza, at om) ;
br eak;

case Deschi der ePar ant eza:
/ / se adauga i n st i va
St Adauga( st i va, at om) ;
br eak;

case I nchi der ePar ant eza:
/ / se mut a di n st i va i n r ezul t at t ot i oper at or i i
/ / pana l a deschi der ea par ant ezei
at omSt i va = St Ext r age( st i va) ;
whi l e ( at omSt i va. Ti p ! = Deschi der ePar ant eza)
{
CdAdauga( f or maPol oneza, at omSt i va) ;
at omSt i va = St Ext r age( st i va) ;
}
br eak;
def aul t : / / oper at or
whi l e ( ! St EGoal a( st i va) && St Var f ( st i va) . Pr i or i t at e >
at om. Pr i or i t at e)
CdAdauga( f or maPol oneza, St Ext r age( st i va) ) ;

St Adauga( st i va, at om) ;
}
}

/ / mut amt oat e el ement el e r amase i n r ezul t at
whi l e ( ! St EGoal a( st i va) )
CdAdauga( f or maPol oneza, St Ext r age( st i va) ) ;

r et ur n f or maPol oneza;
}
Evaluarea expresiei n forma polonez se face folosind stiv pentru operanzi
dup algoritmul urmtor:
1. se iniializeaz stiva;
2. att timp ct nu s-a ajuns la sfritul scrierii postfixate:
a. se citete urmtorul element;
b. dac este valoare se depune pe stiv;
c. altfel, respectiv cazul n care este operator:
i. se extrage din stiv elementul y;
ii. se extrage din stiv elementul x;
iii. se efectueaz operaia x operator y;
iv. se depune rezultatul pe stiv;
3. ultima valoare care se afl pe stiv este rezultatul expresiei.
Funcia care implementeaz algoritmul este:

/ / Eval uaeaza o expr esi e af l at a i n
/ / f or ma pol oneza post f i xat a
doubl e Eval uar e( Coada& f or maPol oneza)
{
/ / st i va de t er meni f ol osi t a pent r u eval uar e
St i va st i va = St Cr ear e( ) ;

/ / par cur gemexpr esi a i n f or ma pol oneza
whi l e ( ! CdEGoal a( f or maPol oneza) )
{
At omat om= CdExt r age( f or maPol oneza) ;

i f ( at om. Ti p == Ter men)
/ / daca avemun t er men at unci i l adaugami n st i va
St Adauga( st i va, at om) ;
el se
{
/ / daca avemun oper at or at unci scoat em
/ / ul t i mi i doi t er meni di n st i va, ef ect uamoper at i a
/ / si punemr ezul t at ul pe st i va
At omt er men1 = St Ext r age( st i va) ;
At omt er men2 = St Ext r age( st i va) ;

swi t ch ( at om. Ti p)
{
case Pl us:
St Adauga( st i va, At om( Ter men, 0, t er men1. Val oar e +
t er men2. Val oar e) ) ;
br eak;
case Mi nus:
St Adauga( st i va, At om( Ter men, 0, t er men2. Val oar e -
t er men1. Val oar e) ) ;
br eak;
case I nmul t i r e:
St Adauga( st i va, At om( Ter men, 0, t er men1. Val oar e *
t er men2. Val oar e) ) ;
br eak;
case I mpar t i r e:
St Adauga( st i va, At om( Ter men, 0, t er men2. Val oar e /
t er men1. Val oar e) ) ;
br eak;
}
}
}

/ / r ezul t at ul expr esi ei est e val oar ea
/ / ul t i mul ui t er men r amas i n st i va
r et ur n St Ext r age( st i va) . Val oar e;
}
Codul surs complet al aplicaiei este:

#i ncl ude <i ost r eam>
usi ng namespace st d;

const i nt DI M_MAX_EXPRESI E = 1024;

/ / Ti pur i l e de at omi accept at e de apl i cat i e
enumTi pAt om
{
Ter men, / / un numar
Deschi der ePar ant eza, / / )
I nchi der ePar ant eza, / / (
Pl us, / / +
Mi nus, / / -
I nmul t i r e, / / *
I mpar t i r e / / /
};

/ / I nf or mat i i l e r ef er i t oar e l a un at om
st r uct At om
{
Ti pAt omTi p;
i nt Pr i or i t at e;
doubl e Val oar e;

/ / Const r uct or ul pent r u i ni t i al i zar ea
/ / unui at om
At om( Ti pAt omt i p = Ter men,
i nt pr i or i t at e = 0, doubl e val oar e = 0)
{
Ti p = t i p;
Pr i or i t at e = pr i or i t at e;
Val oar e = val oar e;
}
};

/ / St i vel e si cozi l e f ol osi t e vor
/ / avea ca i nf or mat i e ut i l a at omi
t ypedef At omTi pSt i va;
t ypedef At omTi pCoada;

#i ncl ude " st i va. h"
#i ncl ude " coada. h"

/ / Tr ansf or ma expr esi a i nt r - o coada de at omi
Coada Par sar eSi r ( char *expr esi e)
{
Coada coada = CdCr ear e( ) ;

whi l e ( *expr esi e ! = ' \ 0' )
{
swi t ch( *expr esi e)
{
case ' +' : CdAdauga( coada, At om( Pl us, 1) ) ; br eak;
case ' - ' : CdAdauga( coada, At om( Mi nus, 1) ) ; br eak;
case ' *' : CdAdauga( coada, At om( I nmul t i r e, 2) ) ; br eak;
case ' / ' : CdAdauga( coada, At om( I mpar t i r e, 2) ) ; br eak;
case ' ( ' : CdAdauga( coada, At om( Deschi der ePar ant eza, 0) ) ; br eak;
case ' ) ' : CdAdauga( coada, At om( I nchi der ePar ant eza, 0) ) ; br eak;
def aul t :
/ / t er men ( numar i nt r eg)
i f ( *expr esi e > ' 0' && *expr esi e <= ' 9' )
{
/ / const r ui mt er menul
doubl e val oar e = 0;
whi l e ( *expr esi e >= ' 0' && *expr esi e <= ' 9' )
{
val oar e = val oar e*10 + ( *expr esi e - ' 0' ) ;
expr esi e++;
}

/ / t r ebui e sa r eveni ml a pr i mul car act er
/ / de dupa numar
expr esi e- - ;

/ / adaugamt er menul i n coada
CdAdauga( coada, At om( Ter men, 0, val oar e) ) ;
}
}

/ / avansaml a ur mat or ul car act er di n expr esi e
expr esi e++;
}

r et ur n coada;
}

/ / Tr ansf or ma o expr esi e di n f or ma nor mal a
/ / i nf i xat a i n f or ma pol oneza post f i xat a
Coada For maPol oneza( Coada& expr esi e)
{
/ / st i va f ol osi t a pent r u st ocar ea t empor ar a
St i va st i va = St Cr ear e( ) ;

/ / coada pent r u st ocar ea r ezul t at ul ui ( f or ma pol oneza)
Coada f or maPol oneza = CdCr ear e( ) ;

At omat omSt i va;

/ / par cur gemexpr esi a i ni t i al a
whi l e ( ! CdEGoal a( expr esi e) )
{
At omat om= CdExt r age( expr esi e) ;

swi t ch ( at om. Ti p)
{
case Ter men:
/ / se adauga di r ect i n si r ul r ezul t at
CdAdauga( f or maPol oneza, at om) ;
br eak;

case Deschi der ePar ant eza:
/ / se adauga i n st i va
St Adauga( st i va, at om) ;
br eak;

case I nchi der ePar ant eza:
/ / se mut a di n st i va i n r ezul t at t ot i oper at or i i
/ / pana l a deschi der ea par ant ezei
at omSt i va = St Ext r age( st i va) ;
whi l e ( at omSt i va. Ti p ! = Deschi der ePar ant eza)
{
CdAdauga( f or maPol oneza, at omSt i va) ;
at omSt i va = St Ext r age( st i va) ;
}
br eak;
def aul t : / / oper at or
whi l e ( ! St EGoal a( st i va) && St Var f ( st i va) . Pr i or i t at e >
at om. Pr i or i t at e)
CdAdauga( f or maPol oneza, St Ext r age( st i va) ) ;

St Adauga( st i va, at om) ;
}
}

/ / mut amt oat e el ement el e r amase i n r ezul t at
whi l e ( ! St EGoal a( st i va) )
CdAdauga( f or maPol oneza, St Ext r age( st i va) ) ;

r et ur n f or maPol oneza;
}

/ / Eval uaeaza o expr esi e af l at a i n
/ / f or ma pol oneza post f i xat a
doubl e Eval uar e( Coada& f or maPol oneza)
{
/ / st i va de t er meni f ol osi t a pent r u eval uar e
St i va st i va = St Cr ear e( ) ;

/ / par cur gemexpr esi a i n f or ma pol oneza
whi l e ( ! CdEGoal a( f or maPol oneza) )
{
At omat om= CdExt r age( f or maPol oneza) ;

i f ( at om. Ti p == Ter men)
/ / daca avemun t er men at unci i l adaugami n st i va
St Adauga( st i va, at om) ;
el se
{
/ / daca avemun oper at or at unci scoat em
/ / ul t i mi i doi t er meni di n st i va, ef ect uamoper at i a
/ / si punemr ezul t at ul pe st i va
At omt er men1 = St Ext r age( st i va) ;
At omt er men2 = St Ext r age( st i va) ;

swi t ch ( at om. Ti p)
{
case Pl us:
St Adauga( st i va, At om( Ter men, 0, t er men1. Val oar e +
t er men2. Val oar e) ) ;
br eak;
case Mi nus:
St Adauga( st i va, At om( Ter men, 0, t er men2. Val oar e -
t er men1. Val oar e) ) ;
br eak;
case I nmul t i r e:
St Adauga( st i va, At om( Ter men, 0, t er men1. Val oar e *
t er men2. Val oar e) ) ;
br eak;
case I mpar t i r e:
St Adauga( st i va, At om( Ter men, 0, t er men2. Val oar e /
t er men1. Val oar e) ) ;
br eak;
}
}
}

/ / r ezul t at ul expr esi ei est e val oar ea
/ / ul t i mul ui t er men r amas i n st i va
r et ur n St Ext r age( st i va) . Val oar e;
}

voi d mai n( )
{
/ / al ocar e spat i u pent r u expr esi a ci t i t a
char *si r = new char [ DI M_MAX_EXPRESI E] ;

/ / ci t i r e expr esi e de l a t ast at ur a
cout << " Expr esi a: " ;
ci n. get l i ne( si r , 10000) ;

/ / Faza 1: Const r ui r ea cozi i de at omi
Coada expr esi e = Par sar eSi r ( si r ) ;

/ / Faza 2: Tr ansf or mar ea i n f or ma pol oneza
Coada f or maPol oneza = For maPol oneza( expr esi e) ;

/ / Faza 3: Eval uar ea expr esi ei
doubl e r ezul t at = Eval uar e( f or maPol oneza) ;

/ / af i sar ea r et zul t at ul ui
cout << " Val oar e: " << r ezul t at << endl ;
}
4. Probleme
1. S se scrie funcia de inversare a unui ir folosind o stiv alocat dinamic.
2. S se scrie funcia de adugare pentru o stiv alocat ca vector.
3. S se scrie funcia de extragere a unui element dintr-o stiv alocat ca
vector.
4. S se descrie modul de organizare a unei cozi alocate ca vector i s se
scrie funcia de adugare a unui element.
5. S se descrie modul de organizare a unei cozi alocate ca vector i s se
scrie funcia de tergere a unui element.
6. S se scrie funcia de concatenare a dou stive alocate dinamic S
1
i S
2
folosind doar operaiile de baz (adugare, extragere, testare stiv vid).
Rezultatul trebuie s conin elementele din cele dou stive n ordinea
iniial.
Indicaie: Se va folosi o stiv temporar.
7. S se scrie funcia de conversie a unei stive n list simplu nlnuit.
8. Se consider un ir de numere ntregi. S se scrie funcia care construiete
dou stive (una cu numerele negative i una cu cele pozitive) ce conin
numerele n ordinea iniial folosind doar structuri de tip stiv.
Indicaie: Se adaug toate elementele ntr-o stiv temporar dup care se
extrag elementele din aceasta i se introduc n stiva corespunztoare.
9. Scriei funcia recursiv pentru tergerea tuturor elementelor dintr-o stiv
alocat dinamic.
10. Scriei funcia pentru tergerea tuturor elementelor dintr-o coad alocat
dinamic.