1

Cap.5 ARBORI CU RDCIN

1. Definirea arborilor cu rdcin
Definiie: Se numete arbore un graf conex i fr cicluri.
n continuare se vor lua n discuie arborii cu rdcin. n cazul arborilor cu rdcin se pune n eviden un
vrf special al su numit rdcin. Alegerea rdcinii duce la aezarea arborelui pe nivele astfel:
- se aeaz rcina pe nivelul 1 (acest nivel se noteaz n multe lucrri de specialitate cu 0)
- pe fiecare nivel k (k1) se plaseaz acele vrfuri pentru care lungimea lanurilor care le leag de rdcin
este k-1
- se traseaz muchiile arborelui
Putem da i o definiie recursiv a unui arbore cu rdcin: Se numete arborescen un arbore care are un vrf
special numit rdcin iar celelalte noduri pot fi repartizate n m mulimi disjuncte X1, X2,.,Xm, m0, astfel nct n
fiecare din aceste mulimi exist un nod adiacent cu rdcina, iar subgrafurile generate de acestea sunt la rndul
lor arborescene.
n particular, o arborescen cu un singur nod este format doar din nodul rdcin. Dac ordinea relativ a
arborescenelor generate de mulimile X1, X2,.,Xm din definie are importan, arborescena se numete arbore
ordonat.
n reprezentarea grafic a unei arborescene nodurile se deseneaz pe nivele, astfel: rdcina se afl pe primul
nivel, vrfurile adiacente cu rdcina pe urmtorul nivel, etc.
Nodurile adiacente cu rdcina se numesc descendenii rdcinii. Conceptul se aplic analog pentru nodurile de
pe un alt nivel. Descendenii aceluiai nod se numesc frai. Dac nodul x este descendentul unui nod y, l numim
pe acesta din urm printele nodului x.

Se numete nlimea unui arbore diferena dintre nivelul maxim din arbore i nivelul minim (nivelul rdcinii).
Pentru arborele de mai sus, nlimea este 4-1=3.
Observaie: ntr-un arbore orice nod este legat de rdcin printr-un lan unic de lungime minim (corespunztor
parcurgerii BF de la grafuri).

2. Reprezentarea arborilor oarecare

2
Nodurile unui arbore oarecare pot fi reprezentate sub forma unei zone de memorie alocat dinamic sau sub
forma unui tablou de date alocate static. Fie urmtorul arbore:

Reprezentarea unui arbore oarecare se poate face astfel:

a) Scrierea parantezat: Fiind dat un arbore cu vrfurile etichetate (numere sau caractere), definim scrierea
lui parantezat ca fiind scrierea parantezat a rdcinii sale. Ea const n scrierea etichetei ataat nodului
urmat, numai dac are descendeni, de scrierea parantezat a descendenilor cuprins ntre paranteze.
Pentru arborele de mai sus, scrierea parantezat este:
4(11(5,10),7,8(2,3,1(6)),9(12))
b) Pentru un nod oarecare putem folosi urmtoarea reprezentare cu informaiile alocate dinamic:
- informaia
- adresa primului descendent (fiu) stng
- adresa primului frate drept
Aceast structur poate fi reprezentat astfel:
typedef struct nod
int inf;
nod *fiu_stang, *frate_drept;
ARBORE;
c) Pentru fiecare nod se poate stoca:
- informaia
- numrul de descendeni
- adresa fiecrui descendent
Implementarea poate fi fcut astfel:
typedef struct nod
int inf;
int nr;
//numrul descendenilor
nod *fiu[NR_MAXIM_FII]; //tablou cu adresele descendenilor
ARBORE;

3. Parcurgerea arborilor oarecare

Prin parcurgere se nelege
vizitarea n mod sistematic a nodurilor arborelui n
scopul prelucrrii informaiei ataate nodurilor sau
a liniarizrii nodurilor.
Vom exemplifica metodele de parcurgere
pe urmtorul arbore:
Un arbore oarecare poate fi parcurs astfel:
a) n preordine: se viziteaz rdcina i
apoi descendenii direci ai fiecrui nod de
la stnga la dreapta

Pentru arborele de mai sus, succesiunea preordine a nodurilor este:

4,11,5,10,7,8,2,3,1,6,9,12
b) n postordine: se parcurg de la stnga la dreapta descendenii direci ai fiecrui nod i apoi se viziteaz
rdcina
Pentru arborele de mai sus, succesiunea postordine a nodurilor este:
5,10,11,7,2,3,6,1,8,12,9,4
c) pe nivele: se parcurg n ordine nodurile de pe fiecare nivel de la stnga la dreapta, ncepnd de la primul
nivel la ultimul nivel:
Pentru arborele de mai sus, succesiunea postordine a nodurilor este:
4,11,7,8,9,5,10,2,3,1,12,6
Dup cum se observ definirea celor trei moduri de parcurgere este recursiv.
Pentru parcurgerea n preordine procedm astfel: se viziteaz nodul rdcin i se apeleaz recursiv
funcia de parcurgere pentru fiecare descendent, de la stnga la dreapta.
Pentru parcurgerea n postordine se apeleaz recursiv funcia pentru parcurgerea tuturor descendenilor
i apoi se va afia informaia nodului rdcin.
Pentru parcurgerea pe nivele (orizontal) se utilizeaz o parcurgere de tip coad pentru c este o
parcurgere BF (n lime). Ct timp coada nu este vid se extrage nodul curent din coad i se adaug la captul
opus al cozii toi descendenii nodului.
Programul urmtor gestioneaz un arbore oarecare reprezentat prin metoda a treia descris n seciunea
anterioar: pentru fiecare nod se precizeaz informaia ataat, numrul de descendeni i tabloul cu adresele
acestor descendeni. Programul ilustreaz modul de creare a unui astfel de arbore, cele trei metode de
parcurgere descrise precum i tergerea din memorie a arborelui creat. Pentru tergere se va proceda astfel: se
terg mai nti toi descendenii unui nod, dup care se terge nodul tat. Ultimul nod ters va fi rdcina arborelui.
#include<iostream>
using namespace std;
#define NMAX 30 //numarul maxim de descendenti ai unui nod
typedef struct nod{
int inf;
int n;
//numarul de descendenti
nod *leg[NMAX]; //tabloul adreselor descendentilor
}ARB;
ARB *coada[100]; //coada pentru parcurgerea pe nivele
int prim,ultim;
//pentru gestionarea cozii
ARB* Creare() //creaza arborele oarecare si returneaza adresa radacinii
{
int info,nr,i; ARB *p;
cout<<"informatia nodului: "; cin>>info;
p=new ARB; p->inf=info;
cout<<"numarul descendentilor pentru "<<info<<": ";
cin>>nr; p->n=nr;
//se descriu in ordine descendentii de la stanga la dreapta si in adancime
for(i=0;i<p->n;i++) p->leg[i]=Creare();
//apelez recursiv functia pentru crearea descendentilor
return p; //radacina arborelui
}
void Preordine(ARB *p) //afiseaza nodurile in preordine
{
int i;
if(p)
{
cout<<p->inf<<" "; //afisez nodul tata
for(i=0;i<p->n;i++) Preordine(p->leg[i]); //afisez descendentii
}
}
void Postordine(ARB *p) //afiseaza nodurile in postordine
{

4
int i;
if(p)
{
for(i=0;i<p->n;i++)
if(p->leg[i]) Postordine(p->leg[i]);
cout<<p->inf<<" "; //afisez nodul tata

//afisez descendentii

}
}
void Adauga(ARB *p) //adauga un nod in coada
{
if(prim>ultim) cout<<"Coada este plina\n";
else coada[ultim++]=p;
}
ARB* Extrage_nod() //extrage un nod din coada
{
if(prim==ultim) return 0;
else return coada[prim++];
}
void Traversare_nivele(ARB *rad)
{
ARB *p; int i;
prim=ultim=0;
Adauga(rad); //in coada se introduce nodul radacina
do{
p=Extrage_nod(); //extrag un nod din coada
if(p)
{
cout<<p->inf<<" "; //afisez informatia nodului
for(i=0;i<p->n;i++)
Adauga(p->leg[i]); //adaug in coada descendentii nodului
}
}while(p);
cout<<"\n";
}
void Sterge(ARB *p) //stergerea unui nod din arbore
{
int i;
if(p)
for(i=0;i<p->n;i++) Sterge(p->leg[i]);
//mai intai sterg descendentii nodului
delete p; //sterg nodul tata
}
int main()
{
ARB *rad; //radacina arborelui oarecare
cout<<"\n\t\tIntroduceti arborele:\n";
rad=Creare(); //arborele a fost creat
cout<<"\n\t\tTraversarea in preordine:\n";
Preordine(rad);
cout<<"\n\t\tTraversarea in postordine:\n";
Postordine(rad);
cout<<"\n\t\tTraversarea pe nivele:\n";
Traversare_nivele(rad);
Sterge(rad); //stergerea arborelui din heap
return 0;
}

4. Definirea arborilor binari

5
Definiie: Un arbore binar este o mulime finit de noduri care este fie vid, fie reprezint un arbore ordonat n
care fiecare nod are cel mult doi descendeni.
Un arbore binar conine cel mult doi subarbori, pe care i numim subarbore stng, respectiv subarbore
drept. Ei se pot obine prin suprimarea rdcinii i a nodurilor incidente cu aceasta. Un nod fr descendeni se
numete nod terminal sau frunz.

Un arbore binar n care fiecare nod are 0 sau 2 descendeni se numete arbore binar complet. Un astfel de
arbore apare n figura de mai jos.

Proprieti ale arborilor binari

1. Un arbore binar complet care are n noduri terminale, toate situate pe acelai nivel, are n total 2n-1 noduri.
n consecin, un arbore binar complet are un numr impar de noduri.
2. Numrul maxim de noduri de pe nivelul i al unui arbore este 2i.
3. Numrul maxim de noduri dintr-un arbore binar cu nlimea h este 2h+1-1.
4. Un arbore binar cu n noduri are nlimea mai mare sau egal cu [log2n].

5. Reprezentarea static a arborilor binari

Exist mai multe posibiliti de reprezentare a arborilor binari. n continuare sunt descrise trei metode de
reprezentare static a arborilor binari. Vom considera pentru exemplificare urmtorul arbore binar:

a) Reprezentarea standard se bazeaz pe urmtorul

principiu: pentru fiecare nod n parte se precizeaz, dac exist,
descendentul stng i descendentul drept. Dac un nod este terminal,
atunci acest lucru se precizeaz punnd 0 n locul descendenilor si.
Pentru aceast se utilizeaz fie doi vectori numii, de exemplu, S-pentru
descendenii din stnga i D-pentru descendenii din dreapta. Dac
pentru reprezentarea unui arbore binar cu n noduri se folosesc vectorii
S i D, atunci pentru fiecare nod i1,2,....n componenta S[i] conine
descendentul stng al nodului i, iar componenta D[i] conine
descendentul drept al nodului i.
De exemplu, pentru arborele binar de mai sus, cei doi vectori vor
avea urmtoarea structur:
Nodul i

S[i]
D[i]

2
3

4
5

0
0

0
0

6
7

0
0

8
9

0
0

0
0

Se observ c nu este important s se precizeze rdcina, deoarece ea nu este descendenta nici unui nod.
b) Legturi de tip tat. Se folosesc doi vectori: TATA i DESC. Pentru fiecare nod i, TATA[i] precizeaz
care nod i este ascendent (nodul printe). DESC[i] poate lua dou valori: -1 dac i este descendent stng pentru
TATA[i] i 1 dac este descendent drept pentru acesta. Pentru nodul rdcin, care nu are un nod printe asociat,
valoarea corespunztoare n cei doi vectori este 0. Pentru arborele binar de mai sus, configuraia celor doi vectori
este:
Nodul i
TATA[i]
DESC[i]

1
0
0

2
1
-1

3
1
1

4
2
-1

5
2
1

6
5
-1

7
5
1

8
7
-1

9
7
1

c) Reprezentarea cu paranteze (parantezat). Pentru a obine o reprezentare a arborelui folosind

paranteze, se procedeaz n felul urmtor:
1) se scrie nodul rdcin
2) fiecare nod al arborelui va fi urmat de:
o parantez rotund deschis
o descendent stng
o virgul
o descendent drept
o parantez rotund nchis
Pentru arborele din figura anterioar, reprezentarea parantezat este: 1( 2 (4 , 5 ( 6 , 7 ( 8 , 9 ) ) ) , 3)
Prin parcurgerea arborilor binari se nelege, ca i la grafurile obinuite, examinarea n mod sistematic a
nodurilor astfel nct fiecare nod s fie atins o singur dat. Aceast procedur se mai numete i vizitare a
nodurilor arborelui n scopul prelucrrii informaiei coninut de fiecare dintre acestea. Deoarece arborii sunt o
structur neliniar de date, rolul traversrii este tocmai obinerea unei aranjri liniare a nodurilor, pentru ca trecerea
de la unul la altul s se realizeze ct mai simplu posibil. Exist trei modaliti de parcurgere a arborilor binari, toate
utiliznd modul standard de reprezentare (sau alocarea dinamic): n preordine (Rdcin-Stnga-Dreapta), n
inordine (Stnga-Rdcin-Dreapta) i n postordine (Stnga-Dreapta-Rdcin). Aceste trei sunt definite
recursiv i parcurgerea se face n trei etape:
a) Traversarea n preordine (RSD)
se viziteaz rdcina
traverseaz subarborele stng
traverseaz subarborele drept
b) Traversarea n inordine (SRD)
se traverseaz subarborele stng
se viziteaz rdcina
se traverseaz subarborele drept
c) Traversarea n postordine (SDR)
se traverseaz subarborele stng
se traverseaz subarborele drept
se viziteaz rdcina
Pentru arborele binar din figura de mai sus, avem urmtoarele rezultate ale parcurgerilor:
metoda RSD: 1, 2, 4, 5, 6, 7, 8, 9, 3
metoda SRD: 4, 2, 6, 5, 8, 7, 9, 1, 3
metoda SDR: 4, 6, 8, 9, 7, 5, 2, 3, 1
Programul care implementeaz cele trei metode de parcurgere (bazate pe o strategie DEI) este prezentat n
continuare:
#include<iostream>
using namespace std;
#define N 30
int S[N],D[N],rad,n;
void SRD(int k) //parcurgere inordine

7
{
if(S[k]) SRD(S[k]);
cout<<k<<" ";
if(D[k]) SRD(D[k]);

}
void RSD(int k) //parcurgere preordine
{
cout<<k<<" ";
if(S[k]) RSD(S[k]);
if(D[k]) RSD(D[k]);
}
void SDR(int k) //parcurgere postordine
{
if(S[k]) SDR(S[k]);
if(D[k]) SDR(D[k]);
cout<<k<<" ";
}
int main()
{
int i;
cout<<"numar varfuri, n=";
do{
cin>>n;
}while(n<1||n>N);
cout<<"radacina arborelui: ";
do{
cin>>rad;
}while(rad<1||rad>n);
//memorarea arborelui prin vectorii S,D
for(i=1;i<=n;i++)
{
cout<<"descendentii stanga,dreapta ("<<i<<"): ";
cin>>S[i]>>D[i];
}
cout<<"\n\tParcurgerea in preordine:\n";
RSD(rad);
cout<<"\n\n\tParcurgerea in inordine:\n";
SRD(rad);
cout<<"\n\n\tParcurgerea in postordine:\n";
SDR(rad);
cout<<"\n";
return 0;
}

6. Alocarea dinamic a arborilor binari

n acest mod de alocare, fiecare nod este o structur cu trei cmpuri: informaia ataat nodului, adresa
fiului stng i adresa fiului drept. Absena unui fiu este marcat cu pointerul nul. Se observ c acest mod de
reprezentare este similar cu reprezentarea standard de la alocarea static a arborilor binari. Pentru descrierea unui
nod putem folosi declaraiile:
typedef struct nod
int inf;
//sau orice alt tip pentru informaie
nod *st,*dr; //adresele fiilor
ARB;
Crearea unui arbore binar alocat dinamic se realizeaz cel mai uor aplicnd metoda DEI astfel:
- se genereaz un nod, adic se aloc spaiu n heap i se ncarc informaia
- pentru fiecare nod se construiete subarborele su stng, apoi subarborele su drept i se completeaz
adresele descendenilor nodului cu adresele acestor subarbori

8
-

un descendent vid trebuie marcat printr-o proprietate stabilit asupra informaiei (spre exemplu apariia
valorii 0 drept coninut informaional al nodului curent)
Spre exemplu, pentru arborele binar urmtor
irul datelor furnizat la intrare va arta astfel: 1 2 4 0 0
5 7 0 0 0 3 0 6 8 0 0 9 0 0
ceea ce
corespunde unei liste n preordine a nodurilor.
Funcia care creaz un arbore binar furnizat ca mai sus
este:

typedef struct nod{

int inf;
nod *st,*dr;
}ARB;
void Creare(ARB* &r)
{
int x;
cin>>x;
if(!x) //urmeaza subarbore vid
r=0;
else
{
r=new ARB; r->inf=x;
//creare nod curent si memorare informatie
Creare(r->st); Creare(r->dr); //crearea subarborilor
}
}
Funcia Creare() se poate proiecta astefel nct s ntoarc adresa rdcinii arborelui. n acest caz, funcia
va avea antetul: ARB* Creare(ARB* &r).
Parcurgerea arborilor binari poate fi fcut:
- n adncime (pe subarbori) n trei moduri: preordine (RSD), inordine (SRD), postordine(SDR)
- n lime (pe niveluri, ca la arborii oarecare)
Programul urmtor realizeaz crearea unui arbore binar i afieaz listele nodurilor obinute pein cele trei metode
de parcurgere n adncime.
#include<iostream>
using namespace std;
typedef struct nod{
int inf;
nod *st,*dr;
}ARB;
void Creare(ARB* &r)
{
int x;
cin>>x;
if(!x) //urmeaza subarbore vid
r=0;
else
{
r=new ARB; r->inf=x;
//creare nod curent si memorare informatie
Creare(r->st); Creare(r->dr); //crearea subarborilor
}
}

9
void SRD(ARB *r) //parcurgere inordine
{
if(r)
{
SRD(r->st); cout<<r->inf<<" "; SRD(r->dr);
}
}
void RSD(ARB *r) //parcurgere preordine
{
if(r)
{
cout<<r->inf<<" "; RSD(r->st); RSD(r->dr);
}
}
void SDR(ARB *r) //parcurgere postordine
{
if(r)
{
SDR(r->st); SDR(r->dr); cout<<r->inf<<" ";
}
}
void Sterge(ARB *r)
{
if(r)
{
Sterge(r->st); Sterge(r->dr); delete r;
}
}
int main()
{
ARB *rad;
//adresa radacinii arborelui
cout<<"Introduceti nodurile : ";
Creare(rad); //crearea arborelui binar
cout<<"\nNodurile in inordine:
"; SRD(rad);
cout<<"\nNodurile in preordine: "; RSD(rad);
cout<<"\nNodurile in postordine: "; SDR(rad);
cout<<"\n";
Sterge(rad); //stergerea arborelui din heap
return 0;
}

7. Forma polonez a expresiilor aritmetice

Se mai numete notaia fr paranteze a expresiilor aritmetice i de studiul acestei probleme s-a ocupat
matematicianul polonez J. Lukasiewicz. Deoarece ntr-o expresie aritmetic, un operator se aplic unui operand
sau unei perechi de operanzi, s-a ajuns la ideea de a asocia unei expresii aritmetice un arbore binar. Presupunem
c se noteaz cu E1 respectiv cu E2 dou expresii aritmetice crora li se aplic operatorul notat op. Operatorii pe
care i vom accepta sunt doar operatorii binari, i anume: adunarea (+), scderea (-), nmulirea (*), mprirea (/) i
ridicarea la putere (^). Pentru a asocia unei expresii aritmetice fr paranteze un arbore binar se folosesc
urmtoarele reguli:
unei expresii aritmetice format dintr-un singur operand i se asociaz un arbore binar format doar din nodul
rdcin n care se pune operandul respectiv
dac expresia aritmetic E este de forma E1 op E2, atunci arborele binar complt asociat are ca rdcin
operatorul op, ca subarbore stng are arborele binar asociat expresiei aritmetice E1, iar ca subarbore drept
are arborele binar asociat expresiei aritmetice E2
Exemplu: Fie expresiile cele mai simple care se pot forma cu operatorii binari
cunoscui: a+b, a-b, a*b, a/b i ab. Considernd op unul dintre operatorii binari
+,-,*,/,, arborele binar asociat este cel din figura urmtoare:

10

Exemplu: Fie expresia E=a*b+c/d-e. Ne propunem s determinm arborele binar asociat. Se observ c,
deoarece nu este stabilit modul de asociere a termenilor, se pot obine doi arbori binari, dup cum se consider
E1=a*b+c/d i E2=e, sau E1=a*b i E2=c/d-e. Se obin corespunztor arborii din figura de mai jos.

Aceti arbori binari se pot parcurge folosind

oricare din cele trei metode. Se obine
astfel:
RSD: -+*ab/cde respectiv
RSD: +*ab-/cde
SRD: a*b+c/d-e respectiv
SRD: a*b-c/d-e
SDR: ab*cd/+e- respectiv
SDR: ab*cd/e-+
irul obinut prin parcurgerea n preordine a arborelui binar ataat expresiei aritmetice se numete forma polonez
prefixat asociat expresiei, iar irul obinut prin prin parcurgerea n postordine se numete forma polonez
postfixat asociat expresiei aritmetice.
Observaii: Se poate construi arborele binar asociat i pentru o expresie aritmetic care conine paranteze
rotunde. n forma polonez nu apar parantezele, acestea nemaifiind necesare pentru a marca prioritile de calcul.
Programul urmtor citete o expresie aritmetic care conine paranteze rotunde, operanzi de o liter i
operatori binari +,-,*,/ i construiete forma polonez prefixat. Pentru a construi n memorie arborele binar ataat
pornind de la expresia aritmetic (citit ca ir de caractere) se acord prioriti operatorilor i operanzilor astfel:
prioritatea iniial a operatorilor +,- este 1
prioritatea iniial a operatorilor *,/ este 10
la prioritatea unui operand se adaug zece uniti pentru fiecare pereche de paranteze ntre care se
gsete
prioritatea unui operand este 1000
Construirea prioritilor se realizeaz astfel:
se citete expresia aritmetic n irul de caractere e
se utilizeaz o variabil j care indic ce valoare se adaug la prioritatea iniial a unui operator (la ntlnirea
unei paranteze deschise j crete cu 10, iar la ntlnirea unei paranteze nchise scade cu 10)
se parcurge expresia caracter cu caracter i se memoreaz n vectorul p prioritile operatorilor i
operanzilor
n vectorul efp se construiete expresia aritmetic fr paranteze, iar n pfp se obine vectorul prioritilor
din care, spre deosebire de epf, lipsesc componentele corespunztoare parantezelor
utiliznd vectorii efp i pfp funcia Creare() construiete n heap arborele binar ataat expresiei aritmetice.
Conform tehnicii Divide Et Impera, funcia Creare() lucreaz astfel:
de la limita superioar (ls) ctre cea inferioar (li), limite corespunztoare irurilor din efp, se caut
operandul sau operatorul cu prioritate minim, reinndu-se i poziia acestuia
n situaia n care limita superioar este diferit de cea inferioar, pentru completarea adresei subarborelui
stng, respectiv drept, se reapeleaz funcia Creare()
#include<iostream>
#include<string.h>
using namespace std;
#define MAX 100
typedef struct nod{
char inf;
nod *st,*dr;
}ARB;
char e[MAX],efp[MAX];
int p[MAX],pfp[MAX];
ARB *rad;

11
void Creare(ARB* &c,int li,int ls,char epf[],int pfp[])
{
int i,j,min;
min=pfp[ls]; i=ls;
for(j=ls;j>=li;j--)
if(pfp[j]<min) { min=pfp[j]; i=j; }
c=new ARB; c->inf=efp[i];
if(li==ls)
c->st=c->dr=0;
else
{
Creare(c->st,li,i-1,efp,pfp);
Creare(c->dr,i+1,ls,efp,pfp);
}
}
void Parcurgere(ARB *c)
{
if(c)
{
cout<<c->inf;Parcurgere(c->st); Parcurgere(c->dr);
}
}
int main()
{
int i,j=0;
cout<<"introduceti expresia: "; gets(e);
for(i=0;e[i];i++)
switch(e[i])
{
case ')': j-=10; break;
case '(': j+=10; break;
case '+':
case '-': p[i]=j+1; break;
case '*':
case '/': p[i]=j+10; break;
default: p[i]=1000;
}
j=-1;
for(i=0;e[i];i++)
if(e[i]!=')'&&e[i]!='(')
{
j++; efp[j]=e[i]; pfp[j]=p[i];
}
Creare(rad,0,j,efp,pfp);
cout<<"\nForma poloneza prefixata este: ";
Parcurgere(rad); cout<<"\n";
return 0;
}
Modul n care se folosete forma polonez prefixat pentru evaluarea expresiei aritmetice asociate este
urmtorul: se parcurge forma polonez prefixat de la dreapta la stnga utilizndu-se o stiv pentru memorarea
operanzilor. Dac simbolul curent este un operand, el se introduce n vrful stivei. Dac simbolul citit este un
operator, se aplic acest operator primilor doi operanzi din vrful stivei obinndu-se un rezultat. Cei doi operanzi
sunt eliminai din stiv i n locul lor se trece rezultatul obinut. Se trece apoi la urmtorul simbol care conine forma
polonez prefixat asociat expresiei aritmetice.
Programul urmtor ilustreaz aceast modalitate de evaluare a expresiilor aritmetice. Operanzii sunt
identificai printr-o singur liter, iar operatorii sunt binari din mulimea +,-,*,/.
#include<iostream>
#include<string.h>
using namespace std;

12
char e[100];
float s[100],x,y; //s este stiva
int n,i,p;
int main()
{
cout<<"\tIntroduceti expresia aritmetica in forma prefixata\n";
gets(e); n=strlen(e);
for(i=n-1;i>=0;i--)
if(e[i]=='+'||e[i]=='-'||e[i]=='*'||e[i]=='/')
{
x=s[p--]; y=s[p];
switch(e[i])
{
case '+': s[p]=x+y; break;
case '-': s[p]=x-y; break;
case '*': s[p]=x*y; break;
case '/': s[p]=x/y; break;
}
}
else
s[++p]=e[i]-'0';
cout<<"\nvaloarea expresiei este "<<s[1]<<endl;
return 0;
}