Arbori binari (nonACE)
-
Upload
adrian-cornel -
Category
Documents
-
view
265 -
download
0
Transcript of Arbori binari (nonACE)
-
8/9/2019 Arbori binari (nonACE)
1/31
Arbori binari. Aplicaii
-
8/9/2019 Arbori binari (nonACE)
2/31
Arbori binari
Definiie. Un arbore binareste un arbore orientat cuproprietatea c pentru orice vrf v, od(v)e2. Dac od(v)=2,cei doi descendeni snt desemnai ca descendent stng (fiustnga) respectiv descendent drept (fiu dreapta). Pentru
vrfurile cu od(v)=1, unicul descendent este specificat fie cafiu stnga, fie ca fiu dreapta
Definiie. Se numete arbore strict binarun arbore binar cupoprietatea c pentru orice vrf v, od(v)1.
Definiie. Se numete nod terminal(sau frunz) orice vrfval arborelui cu od(v)=0. n caz contrar nodul vesteneterminal.
-
8/9/2019 Arbori binari (nonACE)
3/31
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
-
8/9/2019 Arbori binari (nonACE)
4/31
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;
-
8/9/2019 Arbori binari (nonACE)
5/31
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->infopreordine(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->ininordine(r->dr);
}}
-
8/9/2019 Arbori binari (nonACE)
6/31
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;
-
8/9/2019 Arbori binari (nonACE)
7/31
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);
}
-
8/9/2019 Arbori binari (nonACE)
8/31
Arbori de sortare (cutare)
Definiie. Un arbore de sortare este un arbore binar cuurmtoarele proprieti
fiecrui nod ial 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 nodurilejdin subarborele stng al arborelui curdcin i;
pentru fiecare nod i, INF(i) este mai mic dect INF(j),
pentru toate nodurilejdin subarborele drept al arborelui curdcin i;
pentru orice vrfuri iijdaca i{jatunci INF(i) { INF(j).
-
8/9/2019 Arbori binari (nonACE)
9/31
Arbori de sortare (cutare)
10
2
8
1 3
5
4
7 9
6
11
1512
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
-
8/9/2019 Arbori binari (nonACE)
10/31
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
1512
14 16
13
12,5
-
8/9/2019 Arbori binari (nonACE)
11/31
Arbori de sortare. tergere informaie
10
2
8
1 3
5
4
7 9
6
11
1512
14 16
13
7,2
7,37,1
10
2
8
3
4
9
5
1115
12
14 167,2
7,37,1
-
8/9/2019 Arbori binari (nonACE)
12/31
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;
}
-
8/9/2019 Arbori binari (nonACE)
13/31
Arbori de structur
Arbore de structur: arbore strict binar folosit pentru areprezenta expresiile aritmetice care conin numai operatoribinari. 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 ioperatorilor.
Parcurgerea arborelui n preordine => forma polonezdirect a expresiei
Parcurgere arborelui n inordine => refacerea expresiei (cusau fr paranteze).
-
8/9/2019 Arbori binari (nonACE)
14/31
Exemplu: a*(b+c) (d+e)/(f+g)
-
+
b c
a
*
ed
++
f g
/
Construire arbore:
1. Calculare prioriti pentru operanzi i operatori
2. Construire propriu-zis a arborelui
Arbori de structur
-
8/9/2019 Arbori binari (nonACE)
15/31
1. Calculare prioriti pentru operanzi i operatori
operatorii aditivi primesc prioritatea 1
operatorii multiplicativi primesc prioritatea 10
prioritatea fiecrui operator se mrete cu 10pentru fiecarepereche de paranteze care l include
fiecare operand primete prioritatea maxim (maxint)
Prioritile snt nscrise ntr-un vector.
p[i]= prioritatea elementului idin expresie (operator sauoperand, 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)
-
8/9/2019 Arbori binari (nonACE)
16/31
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 subarbore
l
e 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)
-
8/9/2019 Arbori binari (nonACE)
17/31
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)
-
8/9/2019 Arbori binari (nonACE)
18/31
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)
aa
**
--
b+c
(d+e)/(f+g)
( )
( )
( )
( )
b + c
(maxint,11, maxint)
b + c
(maxint,11, maxint)
aa ++
**
--
(d+e)/(f+g)
b c
-
8/9/2019 Arbori binari (nonACE)
19/31
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)
aa ++
bb cc
**
--
(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)
aa ++
bb cc
** //
--
f+gd+e
-
8/9/2019 Arbori binari (nonACE)
20/31
Parcurgerea arborelui npreordine => forma polonez direct aexpresiei:
- * a + b c / + d e + f g
Parcurgere arborelui n inordine => refacerea expresiei (cu saufr paranteze SRD sau (S)R(D) ):
a * b + c d + e / f + g
((a)*((b)+(c)))-(((d)+(e))/((f)+(g)))
Arbori de structur
-
8/9/2019 Arbori binari (nonACE)
21/31
Evaluare expresie: prin parcurgere npostordine.
Prelucrarea fiecrui nod rconst n
dac e nod frunz nu se schimb nimic
altfel se nlocuiete informaia r->infcu rezultatul expresieiss r->inf sd
unde ss i sdsnt informaiile din fiul stng respectiv drept alnodului curent
Arbori de structur
-
8/9/2019 Arbori binari (nonACE)
22/31
Arbori de structur
33 ++
44 66
++
1010 55
++
22 11
** //
--2525
a = 3, b = 4, c = 6, d = 10, e = 5, f = 2, g = 1
1010
3030
1515 33
55
-
8/9/2019 Arbori binari (nonACE)
23/31
Arbori de structur - implementare
#include #include #include #include #define MAXINT 10000
/* reprezentarea unei expresii prin arbore de structura sievaluarea eirestrictii:
- numai operatori aritmetici + - * /- identificatorii operanzilor formati din numai o litera- fara spatii
*/
typedef struct nod{ char inf;float v;struct nod *s,*d;
} TNOD;
-
8/9/2019 Arbori binari (nonACE)
24/31
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 prioritatil = strlen(s);for(i=j=crt=0; i
-
8/9/2019 Arbori binari (nonACE)
25/31
Arbori de structur - implementare
//eliminare paranteze
r=(char*)malloc(strlen(s));strcpy(r,s);i=0;
while(i
-
8/9/2019 Arbori binari (nonACE)
26/31
Arbori de structur - implementareTNOD* 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=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;
}
-
8/9/2019 Arbori binari (nonACE)
27/31
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);
}}
-
8/9/2019 Arbori binari (nonACE)
28/31
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;}
-
8/9/2019 Arbori binari (nonACE)
29/31
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);}
}
-
8/9/2019 Arbori binari (nonACE)
30/31
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 prioritatiefp=prioritati(expresie,p,&n);//construire arboreradacina_arbore_structura=construire_arbore(0,n-1,efp,p);//determinarea formei poloneze a expresieifpd=(char*)malloc(strlen(efp));fpd[0]='\0';
forma_poloneza(radacina_arbore_structura,fpd);printf("\nForma poloneza directa: %s",fpd);//evaluare expresieprintf("\nValorile operanzilor:\n");citire_valori_operanzi(radacina_arbore_structura);evaluare(radacina_arbore_structura);printf("\nValoare expresiei este: %7.3f\n",radacina_arbore_structura-
>v);
}
-
8/9/2019 Arbori binari (nonACE)
31/31
Arbori de structur - implementare
Atenie: Dac mai multe elemente au aceeai prioritate
minim, se alege ultimul pentru a fi rdcin
E
xemplu: 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