Arbori binari (nonACE)

8/9/2019 Arbori binari (nonACE)

1/31

Arbori binari. Aplicaii


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.


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


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;


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

}}


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;


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/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).


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


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


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


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;

}


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


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


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



16/31



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



17/31



Arbori de structur


-

*

-

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


18/31



Arbori de structur


aa

**

--

b+c

(d+e)/(f+g)

( )

( )

( )

( )

b + c

(maxint,11, maxint)

b + c

(maxint,11, maxint)

aa ++

**

--

(d+e)/(f+g)

b c


19/31



Arbori de structur


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


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


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


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


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;


24/31


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


25/31


//eliminare paranteze

r=(char*)malloc(strlen(s));strcpy(r,s);i=0;

while(i


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;

}


27/31


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

}}


28/31


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;}


29/31


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);}

}


30/31


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

}


31/31


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

Documents

Arbori binari (nonACE)