Arbori binari.

Aplicaii
Arbori binari
Definiie. Un arbore binar este un arbore orientat cu
proprietatea c pentru orice vrf v, od(v)2. Dac od(v)=2,
cei doi descendeni snt desemnai ca descendent stng (fiu
stnga) respectiv descendent drept (fiu dreapta). Pentru
vrfurile cu od(v)=1, unicul descendent este specificat fie ca
fiu stnga, fie ca fiu dreapta

Definiie. Se numete arbore strict binar un arbore binar cu
poprietatea c pentru orice vrf v, od(v)1.

Definiie. Se numete nod terminal (sau frunz) orice vrf v
al arborelui cu od(v)=0. n caz contrar nodul v este
neterminal.

Arbori binari. Subarbori
1
2 3
4 5 6 7
8 9 10
2
4 5
8
3
6 7
9 10
Subarbore stng Subarbore drept
Arbori binari. Reprezentare.
Reprezentarea Fiu-Frate (N, R, Fiu, Frate, Inf)

Cu structuri dinamice
Structur nod: informaie, adres fiu stng / drept

typedef struct nod { int info;
struct nod* st,*dr;
} TNOD;

Pentru a cunoate arborele: rdcina

TNOD* r;

Arbori binari. Parcurgere
n lime
Pe niveluri Pe niveluri
n adncime
A-Preordine Preordine
A-Postordine Postordine
Inordine
void preordine(TNOD* r)
{ if(r!=NULL)
{ //prelucrare r->info
preordine(r->st);
preordine(r->dr);
}
}
void postordine(TNOD* r)
{ if(r!=NULL)
{ postordine(r->st);
postordine(r->dr);
//prelucrare r->info
}
}
void inordine(TNOD* r)
{ if(r!=NULL)
{ inordine(r->st);
//prelucrare r->info
inordine(r->dr);

}
}
Arbori binari. Parcurgere
void niveluri(TNOD* r)
{ TNODC* c;
TNOD* p;
int er;
if(r != NULL)
{ c = NULL;
c = push(c,r);
while(c != NULL)
{ c=pop(c,&p,&er);
// prelucrare p->info
if(p->st!=NULL) c = push(c,p->st);
if(p->dr!=NULL) c = push(c,p->dr);
}
}
}
typedef struct nodc
{ TNOD* info;
struct nodc* next;
} TNODC;

Arbori binari. Calculul nlimii
int inaltime(TNOD* r)
{ int i,j,k;
if(r == NULL) i = 0;
else
{ j = inaltime(r->st);
k = inaltime(r->dr);
i = 1 + (j>k ? j : k);
}
return(i);
}
Arbori de sortare (cutare)
Definiie. Un arbore de sortare este un arbore binar cu
urmtoarele proprieti
fiecrui nod i al arborelui i este ataat o informaie INF(i)
dintr-o mulime ordonat de valori;
pentru fiecare nod i, INF(i) este mai mare dect INF(j),
pentru toate nodurile j din subarborele stng al arborelui cu
rdcin i;
pentru fiecare nod i, INF(i) este mai mic dect INF(j),
pentru toate nodurile j din subarborele drept al arborelui cu
rdcin i;
pentru orice vrfuri i i j daca i j atunci INF(i) INF(j).
Arbori de sortare (cutare)
10
2
8
1 3
5
4
7 9
6
11
15 12
14 16
13
Operaii
Parcurgeri (pe niveluri, preordine, inordine, postordine)
Adugare informaie
tergere informaie
Preordine : 10, 6, 4, 2, 1, 3, 5, 8, 7, 9, 13, 12, 11, 15, 14, 16
Inordine : 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16
Postordine: 1, 3, 2, 5, 4, 7, 9, 8, 6, 11, 12, 14, 16, 15, 13, 10
Pe niveluri: 10, 6, 13, 4, 8, 12, 15, 2, 5, 7, 9, 11, 14, 16, 1, 3
TNOD* inserare(TNOD* r, int a, int* er)
{ *er=0;
if(r==NULL)
{ r=(TNOD*)malloc(sizeof(TNOD));
r->info=a;
r->dr=NULL;
r->st=NULL;
}
else if(r->info==a) *er=1;
else if(r->info>a) r->st=inserare(r->st, a, er);
else r->dr=inserare(r->dr,a,er);
return r;
}
Arbori de sortare. Adugare informaie
10
2
8
1 3
5
4
7 9
6
11
15 12
14 16
13
12,5
Arbori de sortare. tergere informaie
10
2
8
1 3
5
4
7 9
6
11
15 12
14 16
13
7,2
7,3 7,1
10
2
8
3
4
9
5
11
15
12
14 16 7,2
7,3 7,1
Arbori de sortare. tergere informaie
TNOD* sterge(TNOD* r, int a, int*er)
{ TNOD* p, *q;
*er=0;
if(r == NULL) *er=1;
else if(r->info > a) r->st = sterge(r->st,a,er);
else if(r->info < a) r->dr = sterge(r->dr,a,er);
else if(r->st == NULL)
{ p = r; r = r->dr; free(p); }
else if(r->st->dr==NULL)
{ r->info = r->st->info; p = r->st; r->st = r->st->st;
free(p);
}
else
{ p = r->st;
while(p->dr != NULL)
{ q = p;
p = p->dr;
}
r->info = p->info;
q->dr = p->st;
free(p);
}
return r;
}
Arbori de structur
Arbore de structur: arbore strict binar folosit pentru a
reprezenta expresiile aritmetice care conin numai operatori
binari. Fiecare nod conine ca informaie util:
un operand, dac este nod frunz
un operator, dac nu e nod frunz

Arborele se construiete acordnd prioriti operanzilor i
operatorilor.
Parcurgerea arborelui n preordine => forma polonez
direct a expresiei
Parcurgere arborelui n inordine => refacerea expresiei (cu
sau fr paranteze).
Exemplu: a*(b+c) (d+e)/(f+g)
-
+
b c
a
*
e d
+ +
f g
/
Construire arbore:
1. Calculare prioriti pentru operanzi i operatori
2. Construire propriu-zis a arborelui
Arbori de structur
1. Calculare prioriti pentru operanzi i operatori
operatorii aditivi primesc prioritatea 1
operatorii multiplicativi primesc prioritatea 10
prioritatea fiecrui operator se mrete cu 10 pentru fiecare
pereche de paranteze care l include
fiecare operand primete prioritatea maxim (maxint)
Prioritile snt nscrise ntr-un vector.
p[i]= prioritatea elementului i din expresie (operator sau
operand, n ordinea apariiei
Elemente expr. =( a, *, b, +, c, -, d, +, e, /, f, +, g)
Prioriti =(maxint,10,maxint,11,maxint,1,maxint,11,maxint,10,maxint,11,maxint)
Arbori de structur
Exemplu: a*(b+c) (d+e)/(f+g)
Elemente expr. =( a, *, b, +, c, -, d, +, e, /, f, +, g)
Prioriti =(maxint,10,maxint,11,maxint,1,maxint,11,maxint,10,maxint,11,maxint)
Construire arbore: algoritm recursiv.
1. dac expresia curent este vid, subarborele curent este vid (nil)
2. altfel se caut elementul cu prioritate minim din expresia curent
3. se creeaz un nod rdcin pentru subarborele curent
4. fiul stng este subarborele obinut prin reprezentarea subexpresiei din stnga
elementului curent
5. fiul drept este subarborele obinut prin reprezentarea subexpresiei din dreapta
elementului curent

Arbori de structur
Exemplu: a*(b+c) (d+e)/(f+g)
Elemente expr. =( a, *, b, +, c, -, d, +, e, /, f, +, g)
Prioriti =(maxint,10,maxint,11,maxint,1,maxint,11,maxint,10,maxint,11,maxint)
Arbori de structur
Exemplu: a*(b+c) (d+e)/(f+g)
-
*
-
-
1
a * b + c
(maxint, 10, maxint, 11, maxint)
a * b + c
(maxint, 10, maxint, 11, maxint)
a
(maxint)
a
(maxint)
a*(b+c) (d+e)/(f+g)
a b+c
(d+e)/(f+g)
Elemente expr. =( a, *, b, +, c, -, d, +, e, /, f, +, g)
Prioriti =(maxint,10,maxint,11,maxint,1,maxint,11,maxint,10,maxint,11,maxint)
Arbori de structur
Exemplu: a*(b+c) (d+e)/(f+g)
a
*
-
b+c
(d+e)/(f+g)
( )
( )
( )
( )
b + c
(maxint, 11, maxint)
b + c
(maxint, 11, maxint)
a +
*
-
(d+e)/(f+g)
b c
Elemente expr. =( a, *, b, +, c, -, d, +, e, /, f, +, g)
Prioriti =(maxint,10,maxint,11,maxint,1,maxint,11,maxint,10,maxint,11,maxint)
Arbori de structur
Exemplu: a*(b+c) (d+e)/(f+g)
a +
b c
*
-
(d+e)/(f+g)
d + e / f + g
(maxint,11,maxint,10,maxint,11,maxint)
d + e / f + g
(maxint,11,maxint,10,maxint,11,maxint)
a +
b c
* /
-
f+g d+e
Parcurgerea arborelui n preordine => forma polonez direct a
expresiei:
- * a + b c / + d e + f g


Parcurgere arborelui n inordine => refacerea expresiei (cu sau
fr paranteze SRD sau (S)R(D) ):
a * b + c d + e / f + g
((a)*((b)+(c)))-(((d)+(e))/((f)+(g)))
Arbori de structur
Evaluare expresie: prin parcurgere n postordine.

Prelucrarea fiecrui nod r const n

dac e nod frunz nu se schimb nimic

altfel se nlocuiete informaia r->inf cu rezultatul expresiei
ss r->inf sd
unde ss i sd snt informaiile din fiul stng respectiv drept al
nodului curent
Arbori de structur
Arbori de structur
3 +
4 6
+
10 5
+
2 1
* /
- 25
a = 3, b = 4, c = 6, d = 10, e = 5, f = 2, g = 1
10
30
15 3
5
Arbori de structur - implementare
#include <stdio.h>
#include <malloc.h>
#include <string.h>
#include <math.h>
#define MAXINT 10000

/* reprezentarea unei expresii prin arbore de structura si
evaluarea ei
restrictii:
- numai operatori aritmetici + - * /
- identificatorii operanzilor formati din numai o litera
- fara spatii
*/

typedef struct nod{ char inf;
float v;
struct nod *s,*d;
} TNOD;
Arbori de structur - implementare
char* prioritati(char *s, int p[], int* n)
{ int i,j,crt,l;
char* r;
//i - caracterul curent
//j - proritatea curenta
//crt - elementul curent
//r - expresia fara paranteze
//calcul prioritati
l = strlen(s);
for(i=j=crt=0; i<l; i++)
switch(s[i])
{ case ')': j-=10;break;
case '(': j+=10;break;
case '+': ;
case '-': p[crt]=j+1;crt++;break;
case '*': ;
case '/': p[crt]=j+10;crt++;break;
default : p[crt++]=MAXINT;
}
Arbori de structur - implementare
//eliminare paranteze

r=(char*)malloc(strlen(s));
strcpy(r,s);
i=0;
while(i<l)
if( (r[i]==')') || (r[i]=='(') )
{ for(j=i+1; j<l; j++)
r[j-1]=r[j];
r[l]='\0';
l--;
}
else i++;
*n=crt;
return r;
}
Arbori de structur - implementare
TNOD* construire_arbore(int p, int u, char *r, int pr[])
{ TNOD *a;
int min, poz;
min = pr[p];
poz = p;
for(int i=p+1; i<=u; i++)
if(min >= pr[i])
{ min=pr[i];
poz=i;
}
a=(TNOD*)malloc(sizeof(TNOD));
a->inf = r[poz];
if(p == u)
a->s = a->d = NULL;
else
{ a->s = construire_arbore(p,poz-1,r,pr);
a->d = construire_arbore(poz+1,u,r,pr);
}
return a;
}
Arbori de structur - implementare
void forma_poloneza(TNOD* rad, char* exp)
{ int l;
if(rad)
{ l = strlen(exp);
exp[l] = rad->inf;
exp[l+1] = '\0';
forma_poloneza(rad->s, exp);
forma_poloneza(rad->d, exp);
}
}
Arbori de structur - implementare
float evaluare(TNOD* rad)
{ if(rad)
if(rad->s)
switch (rad->inf)
{ case '+': rad->v = evaluare(rad->s) + evaluare(rad->d);
break;
case '-': rad->v = evaluare(rad->s) - evaluare(rad->d);
break;
case '*': rad->v = evaluare(rad->s) * evaluare(rad->d);
break;
case '/': rad->v = evaluare(rad->s) / evaluare(rad->d);
}
return rad->v;
}
Arbori de structur - implementare
void citire_valori_operanzi(TNOD* rad)
{ if(rad)
if(rad->s == NULL)
{ printf("%c=", rad->inf);
scanf("%f",&(rad->v));
}
else
{ citire_valori_operanzi(rad->s);
citire_valori_operanzi(rad->d);
}
}
Arbori de structur - implementare
void main()
{ char expresie[100], *efp, *fpd;
int p[100],n;
TNOD* radacina_arbore_structura;
printf("\nExpresia de analizat (corecta, conform restrictiilor):\n");
gets(expresie);
radacina_arbore_structura=NULL;
//calcul prioritati
efp=prioritati(expresie,p,&n);
//construire arbore
radacina_arbore_structura=construire_arbore(0,n-1,efp,p);
//determinarea formei poloneze a expresiei
fpd=(char*)malloc(strlen(efp));
fpd[0]='\0';
forma_poloneza(radacina_arbore_structura,fpd);
printf("\nForma poloneza directa: %s",fpd);
//evaluare expresie
printf("\nValorile operanzilor:\n");
citire_valori_operanzi(radacina_arbore_structura);
evaluare(radacina_arbore_structura);
printf("\nValoare expresiei este: %7.3f\n",radacina_arbore_structura-
>v);
}
Arbori de structur - implementare
Atenie:
Dac mai multe elemente au aceeai prioritate
minim, se alege ultimul pentru a fi rdcin
Exemplu:
a-b*c+d
a=100, b=2, c=5, d=10

Probleme de rezolvat
Eliminarea spaiilor
Utilizarea altor operatori
Utilizarea de identificatori mai lungi