P. 1
09 - Arbori binari

09 - Arbori binari

|Views: 233|Likes:
Published by mihai_cvi1191

More info:

Published by: mihai_cvi1191 on Apr 11, 2011
Copyright:Attribution Non-commercial

Availability:

Read on Scribd mobile: iPhone, iPad and Android.
download as PPT, PDF, TXT or read online from Scribd
See more
See less

11/28/2014

pdf

text

original

Arbori binari.

Aplica ii

Arbori binari
‡ Defini ie. Un arbore binar este un arbore orientat cu proprietatea c pentru orice vîrf v, od(v)e2. Dac od(v)=2, cei doi descenden i sînt desemna i ca descendent stîng (fiu stînga) respectiv descendent drept (fiu dreapta). Pentru vîrfurile cu od(v)=1, unicul descendent este specificat fie ca fiu stînga, fie ca fiu dreapta ‡ Defini ie. Se nume te arbore strict binar un arbore binar cu poprietatea c pentru orice vîrf v, od(v)1. ‡ Defini ie. Se nume te nod terminal (sau frunz ) orice vîrf v al arborelui cu od(v)=0. În caz contrar nodul v este neterminal.

Arbori binari. Subarbori
1 2 3

4 8

5 9

6 10

7

2 6

3 7

4 8

5 9

10 Subarbore drept

Subarbore stîng

Arbori binari. Reprezentare.
‡ Reprezentarea Fiu-Frate (N, R, Fiu, Frate, Inf) ‡ Cu structuri dinamice
± Structur nod: informa ie, adres fiu stîng / drept

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

‡ Pentru a cunoa te arborele: r d cina
TNOD* r;

Arbori binari. Parcurgere
‡ În l ime
± Pe niveluri Pe niveluri Preordine Postordine Inordine

‡ În adîncime
± A-Preordine ± A-Postordine ±

void inordine(TNOD* r) void preordine(TNOD* r) void postordine(TNOD* r) { { if(r!=NULL)if(r!=NULL) { if(r!=NULL) { inordine(r->st); { //prelucrare r->info { postordine(r->st); //prelucrare r->info preordine(r->st); postordine(r->dr); inordine(r->dr); preordine(r->dr); //prelucrare r->info } } } } } }

Arbori binari. Parcurgere
typedef struct nodc void niveluri(TNOD* r) { TNOD* info; { TNODC* c; struct nodc* next; TNOD* p; } TNODC; 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); } } }

Arbori binari. Calculul în l imii
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 (c utare)
‡ Defini ie. Un arbore de sortare este un arbore binar cu urm toarele propriet i ± fiec rui nod i al arborelui îi este ata at o informa ie INF(i) dintr-o mul ime ordonat de valori; ± pentru fiecare nod i, INF(i) este mai mare decît INF(j), pentru toate nodurile j din subarborele stîng al arborelui cu r d cin i; ± pentru fiecare nod i, INF(i) este mai mic decît INF(j), pentru toate nodurile j din subarborele drept al arborelui cu r d cin i; ± pentru orice vîrfuri i i j daca i { j atunci INF(i) { INF(j).

Arbori de sortare (c utare)
‡ Opera ii ± Parcurgeri (pe niveluri, preordine, inordine, postordine) ± Ad ugare informa ie ± tergere informa ie
10 6 4 2 1 3 5 7 8 9 11 12 14 13 15 16

‡ ‡ ‡ ‡

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

Arbori de sortare. Ad ugare informa ie
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; 10 }
6 4 2 1 3 5 7 8 9 11 12 12,5 14 13 15 16

Arbori de sortare. tergere informa ie
10 6 4 2 1 3 7,1 5 7 8 9 7,2 7,3 11 12 14 13 15 16

10 5 4 2 3 7,1 7,2 7,3 8 9 11 12 15 14 16

Arbori de sortare. tergere informa ie
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 con in numai operatori binari. Fiecare nod con ine ca informa ie util : ± un operand, dac este nod frunz ± un operator, dac nu e nod frunz ‡ Arborele se construie te acordînd priorit i operanzilor i operatorilor. ‡ Parcurgerea arborelui în preordine => forma polonez direct a expresiei ‡ Parcurgere arborelui în inordine => refacerea expresiei (cu sau f r paranteze).

Arbori de structur
Exemplu: a*(b+c) ±(d+e)/(f+g)
-

*

/

a

+

+

+

b

c

d

e

f

g

Construire arbore: 1. Calculare priorit i pentru operanzi i operatori 2. Construire propriu-zis a arborelui

Arbori de structur
Exemplu: a*(b+c) ±(d+e)/(f+g)
1. Calculare priorit i pentru operanzi i operatori ‡ ‡ ‡ ‡ ‡ operatorii aditivi primesc prioritatea 1 operatorii multiplicativi primesc prioritatea 10 prioritatea fiec rui operator se m re te cu 10 pentru fiecare pereche de paranteze care îl include fiecare operand prime te prioritatea maxim (maxint) p[i]= prioritatea elementului i din expresie (operator sau operand, în ordinea apari iei
a, *, b, +, c, -, d, +, e, /, f, +, g)

Priorit ile sînt înscrise într-un vector.

Elemente expr. =( Priorit i

=(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. =( Priorit i a, *, b, +, c, -, d, +, e, /, f, +, g) =(maxint,10,maxint,11,maxint,1,maxint,11,maxint,10,maxint,11,maxint)

Construire arbore: algoritm recursiv. 1. 2. 3. 4. dac expresia curent este vid , subarborele curent este vid (nil) altfel se caut elementul cu prioritate minim din expresia curent se creeaz un nod r d cin pentru subarborele curent fiul stîng este subarborele ob inut prin reprezentarea subexpresiei din stînga elementului curent fiul drept este subarborele ob inut prin reprezentarea subexpresiei din dreapta elementului curent

5.

Arbori de structur
Exemplu: a*(b+c) ±(d+e)/(f+g)
Elemente expr. =( Priorit i -, - d, +, e, /, f, +, g) =(maxint,10,maxint,11,maxint,1,maxint,11,maxint,10,maxint,11,maxint) 1 a, *, b, +, c,

a*(b+c) (d+e)/(f+g) a
a * b + c (maxint, 10, maxint, 11, maxint) a (maxint)

* b+c (d+e)/(f+g)

Arbori de structur
Exemplu: a*(b+c) ±(d+e)/(f+g)
Elemente expr. =( Priorit i a, *, b, +, c, -, d, +, e, /, f, +, g) =(maxint,10,maxint,11,maxint,1,maxint,11,maxint,10,maxint,11,maxint)

* a
() () () ()

(d+e)/(f+g) * a b + c (d+e)/(f+g)

b+c
b + c (maxint, 11, maxint)

Arbori de structur
Exemplu: a*(b+c) ±(d+e)/(f+g)
Elemente expr. =( Priorit i a, *, b, +, c, -, d, +, e, /, f, +, g) =(maxint,10,maxint,11,maxint,1,maxint,11,maxint,10,maxint,11,maxint)

* 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)

Arbori de structur
Parcurgerea arborelui în preordine => forma polonez direct a expresiei:

-*a+bc/+de+fg

Parcurgere arborelui în inordine => refacerea expresiei (cu sau f r 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 fiec rui nod r const în ‡ dac e nod frunz nu se schimb nimic ‡ altfel se înlocuie te informa ia r->inf cu rezultatul expresiei ss r->inf sd unde ss i sd sînt informa iile din fiul stîng respectiv drept al nodului curent

Arbori de structur
a = 3, b = 4, c = 6, d = 10, e = 5, f = 2, g = 1
25 -

30 * 3 4 10 + 6 10 + 15 5

5 / + 3 2 1

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 = break; case '-': rad->v = break; case '*': rad->v = break; case '/': rad->v = } return rad->v; }

evaluare(rad->s) + evaluare(rad->d); evaluare(rad->s) - evaluare(rad->d); evaluare(rad->s) * evaluare(rad->d); evaluare(rad->s) / evaluare(rad->d);

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
‡ Aten ie:
± Dac mai multe elemente au aceea i prioritate minim , se alege ultimul pentru a fi r d cin ± Exemplu:
± a-b*c+d ± a=100, b=2, c=5, d=10

‡ Probleme de rezolvat
± Eliminarea spa iilor ± Utilizarea altor operatori ± Utilizarea de identificatori mai lungi

You're Reading a Free Preview

Download
scribd
/*********** DO NOT ALTER ANYTHING BELOW THIS LINE ! ************/ var s_code=s.t();if(s_code)document.write(s_code)//-->