Liste sortate Intr-o lista sortata elementele sunt dispuse in ordinea crescatoare (sau descrescatoare) a valorilor unor chei. In general, listele sortate se pot folosi in situatii similar celor in care se folosesc tablourile sortate. Avantajele listelor constau in : -viteza inserarii (nefiind necesare deplasari de elemente) -aceea ca o lista se poate extinde pana cand ocupa toata memoria disponibila, in t imp ce tabloul este limitat la o dimensiune dimensiune fixata. Dificultatea implementarii constituie un dezavantaj de luat in seama pentru listele inlantuite. O operatie des folosita este inserarea unui element intr-o lista ordonata – ea se face astfel:
e1
e2
……
ei-1
ei
ei+1
ei-1 ei ei+1 i=2,n-1 pentru lista ordonata crescator Daca se doreste inserarea unui element “e” se cauta pozitia de inserare, fie ea j, pentru care e j-1 e
e1
……
e j-1
e j
…….
en
e Functia de inserare intr-o lista ordonata crescator: LIST ∗insert_loc(LIST ∗l, int k) { LIST ∗aux, ∗capat ; aux=cons (k, NULL); if((!l)||(k<=l k)) { aux next=l; return (aux); } else { capat=l; while ((l next)&&(l next k
next;
O aplicatie des intalnita a listelor sortate sort ate este sortarea prin insertie intre lista ordonata crescator. Ex. 25
6
Plecam cu lista vida Pas 1 25 Pas 2 6 25
16
3
45
19
Pas 3 Pas 4 Pas 5 Pas 6
6 3 3 3
16 6 6 6
25 16 16 16
25 25 19
45 25
45
Functia de sortare prin insertie intr-o lista ordonata crescator: LIST ∗sortare_prin_insertie sortare_prin_insertie (LIST ( LIST ∗l) { LIST ∗aux; aux=NULL; if (!l)return(l); else { while (l) {aux=insert_loc(auxml k); l=l return (aux); } }
next;}
Eficienta listelor inlantuite ordonate -inserarea|stergerea unui element oarecare: O(N); a elementului minim: O(1); -cautarea elm. minim: O(1); elm. oarecare: O(N); -sortarea prin insertie: O(N2), dar se evita deplasarile de elemente care au loc in cazul tablourilor. Liste dublu inlantuite: elimina dezavantajul listei simplu inlantuite privind parcurgerea listei in sens invers. Ex. de folosire: o lista care pastreaza liniile de text introduse folosind un editor editor de texte. Cand cursorul este deplasat la linia urmatoare se poate trece usor urmand legatura “text”. Daca acesta este mutat in linia precedenta, se va urma pointerul “prev”. next prev
linia 1
linia 2
typedef struct celula_2lista { int k; struct celula_2lista celula_2lista ∗next, ∗prev; } LIST2; Pretul platit pentru cresterea in flexibilitate consta in: -fiecare celula de lista va ocupa ceva mai multa memorie datorita pointerului in plus “prev”; -la fiecare inserare|stergere trebuie modificate 4 legaturi in loc de 2. Functii de lucru cu liste dublu inlantuite: 1) LIST2 ∗cons_2inl(int cons_2inl(int k, LIST2 ∗l) { LIST2 ∗aux; aux=(LIST2∗)malloc(sizeof(LIST2)); aux k=k; aux next=l; aux prev=NULL; l prev=aux; return (aux); } 2) LIST2 ∗reverse_2inl(LIST ∗l) { LIST2 ∗pred, ∗salv; pred=NULL; while(l) { salv=l next; l next=pred; l prev=l next; pred=l; l=salv; } return(pred); }
3) Eliminarea unui element dintr-o lista dublu inlantuita LIST ∗out_2inl(LIST2 ∗l, int k) { LIST2 ∗capat, ∗p; if ((!l)||(k
csp ………… cs1
cd1 ……….. cdp
p
p
p=2 st
cs1
……
csp
x
dr
cd1
……
cdp
algoritm extractie *se initializeaza lista dublu inlantuita *se citeste numarul x de la tastatura *se cauta numarul in lista si daca se gaseste se intoarce adresa celulei in care a fost gasit *se construieste lista care contine celulele din stanga lui x cs 1,cs2 … csp *se construieste lista care contine celulele din dreapta lui x cd 1,cd2 … cdp *se construieste header-ul ca o structura cu 3 campuri: un pointer catre lista stanga, numarul x si un pointer catre lista dreapta *se afiseaza lista cu header stop
STIVE SI COZI Atat stivele cit si cozile sunt SD care modeleaza colectii de elemente pentru care doar un element este “vizibil” la un moment dat. Alegerea sa in vederea prelucrarii se face pe baza ordinii in care elementele au fost introduse in colectie: • Stiva: LIFO (Last In First Out) • Coada: FIFO (First In First Out) Obs.: TDA stiva este similar TDA lista cu exceptia ca in lista poate fi accesat, folosind operatorii specifici TDA, orice element. Ca urmare: *o stiva poate fi definita ca un tip particular de lista in care toate operatiile de inserare si stergere se fac la o extremitate: varful stivei inserare inserare iesire O(1) elemente elemente stergere
*o coada este un tip particular de lista in care inserarea se face la sfarsitul cozii, iar eliminarea la inceputul ei inserare O(1) stergere iesire elemente
inserare elemente
TDA stiva tip Stack [GenElm] Domenii GenElm: multimea elementelor generice care pot fi stivuite Bool: set de constant logice StackSet: multimea stivelor cu elemente din GenElm Operatori newStack: Stack Set // construieste stiva vida; este constructor de baza si apartine Conb push: StackSet x GenElm Stack Set // adauga un element in varful stivei; apartine Conb pop: StackSet Stack set // elimina varful st ivei gettop: StackSet GenElm // intoarce elm. din varful stivei isEmpty: StackSet Bool clearStack: StackSet StackSet // elimina toate intrarile din stiva Restrictii (pre-conditii) pop, gettop !isEmpty (s) clearStack !isEmpty (s) Axiome pentru oricare s StackSet si oricare e pop (push (s,e))=s gettop(push(s,e))=e isEmpty(newStack)=true isEmpty(push(s,e))=false clearStack(push(s,e))=newStack
GenElm
Implementari posibile •
Cu vector: 1
typedef struct stiva { int maxsize, top; GenElm StackArray [MaxSize]; }STACK;
top
maxsize StackArray •
(top)
Cu lista inlantuita s …….
typedef struct celula_stiva { GenElm StackElm; struct celula_stiva ∗next; } STACK; STACK ∗s;
Aplicatii simple pentru stive (in pseudocod) 1) Inversarea unui sir de caractere alg inversare_sir este *preluarea sirului de intrare, inputString, de la tastatura si afisarea sa / ∗ecou date de intrare ∗ / *construieste stiva vida s for (i=0; i
Program - PC (Program Counter) indica instructiunea curenta - varf stiva: functia curenta aflata in executie - AR(Activation Record): nume si argument functie, var. locale, o copie a PC Obs.: Acest exemplu ilustreaza elocvent de ce uneori se intampla ca stiva sa fie “depasita” (overflow) de multitudinea apelurilor recursive, care implica incarcarea in stiva a inregistrarilor de activare (AR) corespunzatoare functiilor apelate.
Aplicatie complexa pentru stiva: Evaluarea expresiilor aritmetice Scop: evaluarea expresiilor de forma (a+b)*c Deoarece evaluarea prin program a expresiilor in forma infixata, ca atare, este practic imposibila (ar trebui sa inglobeze toate cunostintele de matematica din primii ani de scoala :), se foloseste un artificiu: se transforma expresia din forma infixata in cea postfixata, numita si notatie poloneza inversa (ab+c*), dupa care se evalueaza expresia postfixata. Etapa 1. Conversia expresiilor din forma infixata
Ex.1: a+b∗c
Cand se intalneste un: -operator, el trebuie salvat pana se determina care-i sunt operanzii -operand, el se adauga la sfarsitul expresiilor postfixate partiale
Caracterul urmator in expresie a + b * c
postfixata
Expresia postfixata partiala a a ab ab abc abc* abc*+
Stiva operatorilor (varf spre stinga) vida + + *+ *+ + vida
Sa observam ca operatorul *a trebuie pus in stiva deoarece el avea prioritate (precedenta) mai mare decat + si, deci, b nu putea fi al II-lea operand al sumei. Ex.2: Operatori succesivi cu aceeasi precedent a) a-b+c (asociere st dr) + si - au aceeasi prioritate, se extrage “-“ din stiva si se adauga la sfarsitul expresiilor postfixate
a b + c
b) aˆbˆc (asoc.dr
st)
a a ab ababab-c ab-c+
vida vida + + vida
a a ab ab abc abcˆ abcˆˆ
vida ^ ^ ^^ ^^ ^ vida
aˆ(bˆc)
Desi ˆ care urmeaza dupa b are aceeasi prioritate cu cel din varful stivei, datorita asoc. dr st, va fi depus si el in stiva, pana i se stabileste al II-lea operand.
a ˆ b ˆ c
Ex.3: Daca expr. de evaluat contine paranteze acestea eludeaza regulile de precedenta ale operatorilor fortand evaluarea partilor de expresie din interiorul parantezelor. Cand se intalneste o paranteza deschisa ea este incarcata pe stiva. O data ajunsa acolo, ea va fi tratata ca un operator de precedent minima. Ca urmare, orice operator consecutiv ei va fi si el incarcat in stiva. Cand in sirul de
intrare se gaseste paranteza inchisa corespunzatoare (prima), se descarca toti operatorii gasiti pana la paranteza deschisa si sunt concatenati la sfarsitul expresiei partiale. a∗ (b+c) a a vida * a * ( a (* b ab (* + ab +(* c abc +(* ) abc+ (* abc+ * abc+* vida Ca urmare a celor reiesite din exemple rezulta algoritmul urmator: alg Conversie_infixata_in_postfixata este *se construieste operatorStack ca stiva vida *se initializeaza variabila “postfixata” cu sirul vid Se preiau operatori din stiva si se concateneaza la while * in expr. infixata mai sunt caractere de parcurs do “postfixata” pana cand stiva { next C urmatorul caracter non_blank din expr. infixata este vida sau varful sau este switch (nextC) precedenta < decat noul { case variabila: append (postfixata, nextC); break; operator. Apoi noul operator case ‘ˆ’: push (operator Stack, nextC); break; este depus in stiva. case ‘+’ or ‘-‘ or ‘*’ or ‘/’: while (!isEmpty(operator Stack) and precedence (nextC)<= precedence (gettop(operatorStack)) do {append (postfixata, gettop (operatorStack)); pop (operatorStack); Se preiau operatori din stiva }push (operatorStack, nextC); break; si se concateneaza la case ‘(‘: push (operatorStack, nextC); break; “postfixata” pana se descarca paranteza “(“ case ‘)’: if (!isEmpty(operatorStack)) { topO gettop (operatorStack); while (topO != ‘C’) { append(postfixata, topO); topO gettop (operatorStack); pop (operator Stack); /* se descarca si paranteza deschisa */ break; pop (operator Stack); }} default; break; } /* end switch */ } /* end while */ Ex: a/b*(c+(d-e))
next C a / b * ( c + ( d e ) )
postfixata a a ab ab/ ab/ ab/ ab/c ab/c ab/c ab/cd ab/cd ab/cde ab/cdeab/cdeab/cde-+ ab/cde-+ ab/cde-+*
operatorStack vida / / vida * (* (* +(* (+(* (+(* -(+(* -(+(* (+(* (+(* (* * vida
Etapa 2. Evaluarea expresiilor postfixate
-pleaca de la observatia ca de fiecare data cand se intalneste un operator el se aplica ultimilor 2 operanzi intilniti in parcurgerea de la stanga la dreapta. a*(b+c) abc+* (b+c)
Se va folosi o stiva in care daca intalnim un: -operand: se insereaza in stiva -operator: se extrag primii 2 operanzi si li se aplica operatorul in ordine inversa. Rezultatul se insereaza in stiva la randul sau.
TDA coada tip queue [GenElm] domeniu GenElm: multimea elementelor generice ale cozii Bool: set constant logice NatInt: multimea numerelor naturale queueSet: multimea cozilor cu elemente din GenElm operatori newQueue: queue Set // apartine Conb; construieste coada vida addQueue: queueSet x GenElm queueSet // apartine Conb; adauga un element la sfarsit remQueue: queueSet queueSet // elimina un element de la inceput getFront: queueSet GenElm intoarce elementele de la inceputul cozii isEmpty: queueSet Bool lengthQueue: queueSet NatInt // determina lungimea cozii restrictii newQueue (q), getFront (q) !isEmpty (q) axiome pentru orice q queueSet si orice e GenElm newQueue (addQueue(q,e))=if isEmpty (q) then q else addQueue (remQueue(q),e) getFront (addQueue(q,e))=if isEmpty (q) t hen e else getFront (q) isEmpty (addQueue(q,e))=false lengthQueue (newQueue)=0; lengthQueue (addQueue(q,e))=1+lengthQueue (q) Implementari posibile •
Cu vector “circular”:
rear
front
typedef struct coada { int front, rear max size; GenElm queueArray [MaxSize]; int empty Q;} QUEUE; QUEUE *q;
•
-se prefera lucrul cu pointeri catre cozi/stive pentru a evita transferul lor prin valoare, care ar presupune copierea lor pe stiva programului.
Cu lista cu header:
front
rear
……. Un caz particular de coada, deosebit de folosit in practica, este coada cu prioritati, in care elementele sunt ordonate (crescator/descrescator) dupa prioritati. Stergerile se fac tot la inceputul cozii, avand complexitatea in O(1). Inserarile se fac intr-o pozitie corespunzatoare prioritatii elementului inserat, deci in O(N), dupa se lucreaza cu vector sau lista. Se poate obtine o eficienta mai mare daca se foloseste o SD numita heap, care va fi prezentata in ultimul capitol. Ex. de folosire: cozile care se formeaza pentru resurse in SO de timp real, primul in coada fiind nu procesul cel mai vechi, ci acela care are prioritatea maxima. Cea mai flexibila implementare cu liste este cea de mai jos deoarece ofera acces facil la elemente, in ambele sensuri:
front
rear
Aplicatie: sortarea dupa ranguri Ex. 1 v:
vq:
0 1 2 3 4 5 6 7 8 9 10 1 1 0 2 1 0 0 1 2 1 0 0 1 2
Concatenare:
02 0 1 23 0
2
05 1 1 28 5
0
06 4 1
0
6
Chei simple (monolitice)
010 7 1
10
0
1
1
9
0
1
1
1
4
1
Ex. 2 v:
15 41 23 12 32 42 31 25 33
Chei compuse
Dupa rangul 1: vq 1 2 3 5 Dupa concatenare:
41 12 23 15
31 32 33 25
42
41 31 12 32 42 23 33 15 25
7
9
1
2
3
8
2
Dupa rangul 2: vq
1 2 3 4
12 23 31 41
15 25 32 42
33
Dupa concatenare: 12 15 23 25 31 32 33 41 42 #include
#include #include #include “coada.c” #include “cit_af_v.c” void Radix_sort (int n, int m, int v[ ]) /*n este numarul de elemente ale vectorului v, iar m nr de ranguri*/ { int i, j; QUEUE vq[10]; for (i=0; i #include void citire_v (int n, int v[ ]) { int i; printf (“\n Initializati vectorul:”); for (i=0; i
/*cit_af_v.c*/ void afisare_v (int n, int v[ ]) { int i; printf (“\n vectorul este:”); for (i=0; i
#include #include #inclide typedef struct lista { int k; struct lista *next; } LIST; typedef struct coada { LIST *front, *rear; } *QUEUE; void newq (QUEUE q) { q=(QUEUE*)malloc(sizeof(QUEUE)); q front=q rear=NULL; } int emptyq (QUEUE q) { if ((q front==q rear)&&(q front==NULL)) return (1); else return (0); void printq (QUEUE q) { LIST * 1; 1=q front; if (emptyq(q)) printf (“coada vida \n); else do { printf (“%d”, 1 k); 1= 1 next; } while ( 1); printf (“\n); } void addq (QUEUE q, int e) { LIST *aux, int f; if (emptyq(q))f=1; aux=(LIST*)malloc(sizeof(LIST)); aux k=e; aux next=NULL; if (f==1) /*e primul element*/ q front=q rear=aux; else { q rear next=aux; q rear=aux; } } void remq (QUEUE q) { LIST *out; if (! empty q(q)) { out=q front; if (q front next)q front=q front next; else q front=q rear=NULL; free (out); } else printf (“coada era vida!”); getch ( ); } int frontq (QUEUE q) { if (! empty q(q)) return (q front k); else printf (“\n coada este vida”); }
Arbori Arborii au aparut din necesitatea de a structura date ierarhice si, in plus, s-au dovedit a cumula avantajele oferite de tablouri ordonate (cautari rapide) si de listele inlantuite ( inserari/stergeri eficiente). Un arbore este, deci, o SD care furnizeaza o organizare ierarhica pentru datele pe care le reprezinta, spre deosebire de tablouri, liste, stive si cozi, care sunt structuri liniare. Non-liniaritatea arborilor este cheia proprietatilor lor speciale. Exemple de folosire a arborilor: •
Organigrama unei firme:
• • • • •
Arborele genealogic Sistemul de fisiere dintr-un sistem de operare Cuprinsul unei carti Reprezentarea structurii formulelor matematice Reprezentarea elementelor unei multimi
Terminologie Un arbore poate fi vazut ca un set de noduri care pot fi etichetate, conectate prin arce, care arata relatiile dintre acestea. Nodurile sunt asezate pe niveluri corespunzatoare pozitiei in ierarhie. Pe nivelul cel mai de sus se afla un singur nod, numit radacina. Nodurile de pe fiecare nivel sunt copiii(fiii) nodurilor de nivel precedent. Un nod care are fii este parintele (tatal) nodurilor descendente lui. Nodurile care au acelasi tata sunt frati, iar tatal este stramosul lor comun. Daca un nod nu are copii el se frunza. Nodurile care au copii se numesc noduri interioare (non-frunza). Orice nod are un parinte unic, cu exceptia radacinii, care nu are nici-un parinte. In general, fiecare nod dintr-un arbore poate avea un numar arbitrar de fii – un astfel de arbore se numeste arbore general (arbore “m”). Daca numarul de fii se reduce la maxim 2 arbore binar. Definitia matematica a unui arbore arata ca acesta este un graf orientat aciclic (DAG) Arb=(N,A), A⊆ NxN care satisface conditiile: noduri arce -exista si este unic un nod r ∈ N astfel incit i_grad(n)=0, numit radacina -oricare ar fi n ∈ N, n r, i_grad(n)=1, unde i_grad(n)=nr. de arce care intra in nodul n.
Se mai definesc si: • Frunzele ca nodurile n ∈ N astfel incit e_grad(n)=0 (e_grad(n)=nr. de arce care ies din nod) • Predecesorul unui nod n este n’ astfel incit (n’,n) ∈A • Succesorul unui nod n este n’’ astfel incit (n, n’’) ∈ A •
Nivel (n)=
•
Arborele vid ( ) ca arbore fara noduri
•
Inaltimea arborelui =
•
, adica numarul de noduri pe calea cea mai
lunga din arbore de la radacina la o frunza. Inaltimea unui nod oarecare = lungimea celui mai lung drum intre nodul respectiv si o frunza. Deci inaltimea arborelui este inaltimea radacinii. Ordinul unui nod ord(n)=e_grad(n), iar ordinul unui arbore Ord(ARB)=max{ord(n), n N}. Daca ordinul unui arbore este 1, atunci el degenereaza intr-o lista. Pentru ordin=2 avem de-a face cu arbori binari, iar pentru un ordin 3 avem de-a face cu arbore general (multicai)
Un subarbore al unui arbore dat se formeaza dintr-un nod si din toti descendentii sai in acel arbore, pana la frunze, inclusiv. Se spune ca un subarbore este dominat de un nod n, daca radacina sa este un successor direct al lui n. Un arbore este ordonat daca pentru oricare n ∈ N, exista o relatie de ordine unica in multimea subarborilor dominate de n. Fie un arbore Arb, de ordin m si fie K multimea cheilor din nodurile sale. Se spune ca Arb este arbore de cautare daca: -exista o relatie de ordine in multimea K, fie ea ∝ si k 1∝ k 2∝ k 3…∝ k m’-1, m’=1,n -arborele este ordonat -fiecare nod cu ordin m’ m contine exact (m’-1) chei -pentru oricare n ∈ Arb cu cheile k 1k 2…k m’-1 exista exact (m’) subarbori dominate de n astfel incit: -daca SAi exista => pentru ∀ k’∈ SAi: k’∝k i i=0,m-1 -daca SAi+1 exista => pentru ∀ k’’∈ SAi+1: k i∝k’’
K1∝K2 ... ∝Ki∝ ... Km'-1
Pentru m=2 se obtine un arbore binar de cautare, in care pentru orice nod n ∈ Arb, care nu este frunza si contine cheia k, se respecta conditiile: -daca exista SS n atunci pentru ∀ k’∈ SSn: k’∝k -daca exista SD n atunci pentru ∀ k’’∈ SDn: k ∝k’’, unde SSn, SS =subarborii dominati de n (stg/dr) Se spune ca un arbore este perfect echilibrat daca: • nivel(n’)=nivel(n”) oricare n’, n” frunze din arbore sau (def. echivalenta) =>h( )-h( )=0 • pentru ∀ n ∈ N si ∀ 2 subarbori dominati de n, Un arbore este numit echilibrat daca pentru oricare n ∈ N si ∀ care sint subarbori dominati de n => |h( )-h( )| 1
Obs.: Echilibrarea unui arbore este importanta pentru a creste eficienta operatiilor de cautare. Pentru arborii binari de cautare echilibrati se obtine O(log 2N) in timp ce pentru arbori dezechilibrati, care degenereaza spre liste, complexitatea este in O(N). h=0 h=1 h=2 h=3 …… h
arbore plin (full binary tree)
1 nod 1 1+2 noduri 1 2 1+2 +2 noduri 1 2 3 1+2 +2 +2 noduri 1
2
N=1+2 +2 +2
h
0
0 frunze=2 1 2 frunze=2 2 4 frunze=2 3 8 frunze=2 h
2 frunze
N= (complete binary tree) arbore complet
Arborii, in functie de proprietatile de cautare si echilibrare, se c lasifica in: • arbori binari de cautare • arbori binari de cautare echilibrati tip AVL Acesta este primul tip de arbori echilibrati descoperiti. Intr-un astfel de arbore in fiecare nod se memoreaza o informatie suplimentara, diferenta dintre inaltimea SS si a SD (aceasta trebuie sa fie 1). Dupa fiecare inserare se verifica radacina subarborelui aflat cel mai jos in arbore, in care s-a inserat noul nod. Daca diferenta dintre inaltimile celor 2 fii este mai mare decat 1 atunci se va executa o rotatie, simpla sau dubla, pentru a se egaliza cele 2 inaltimi. Procedeul se repeta, nivel cu nivel, ascendent, pana se ajunge la radacina. Cautarea intr-un arbore AVL se face in O(logN) insa o inserare/stergere presupune 2 parcurgeri, una descendenta (pentru determinarea locului de inserare/stergere) si una ascendenta pentru reechilibrare. • arbori binari de cautare echilibrati bicolori. Nodurile din acesti arbori sunt colorate si pe parcursul inserarilor/stergerilor se asigura pastrarea unor aranjamente prestabilite ale acestori culori, care conserva proprietatea de echilibrare ale arborelui. Acesti arbori sunt mai eficienti decat arborii AVL, deoarece elimina parcurgerea ascendenta pentru reechilibrare. Aceasta se face, descendent, in paralel cu cautarea locului de inserare, tot prin rotatii “locale”. • arbori TRIE (reTRIEval)=arbori multicai de cautare cu cheile dispersate pe caile din arbore. Cheile sunt secvente de caractere dintr-un alfabet oarecare (cifre, litere etc.). Se fol, in general pentru regasirea informatiei (dictionare, prefix matching, compresii samd). O(m_caractere_cheie): inserare, stergere, cautare • arbori B de grad g= arbori multicai de cautare perfect echilibrati in care: -radacina poate contine 1 2g chei -oricare n radacina contine g 2g chei Se folosesc, in general, pentru stocarea datelor pe un suport extern de informatii. Pentru optimizarea performantelor, de regula, fiecare nod dintr-un arbore B contine un bloc de date, de dimensiune egala cu blocul de disc. Intr-un arbore stocat in memorie legaturile intre noduri se pastreaza prin intermediul adreselor se memorie, insa pentru un arbore stocat pe disc se vor folosi adusele unor blocuri de disc. Intr-un arbore B este foarte important ca nodurile sa fie cat mai pline posibil, astfel ca in urma fiecarui acces la disc, facut pentru a citi informatia dintr-un nod, sa se acceseze o cantitate maxima de informatie. Inserarile si stergerile, care conduc la modificarea structurii nodurilor, vor respecta acest deziderat.
•
arbori 2-3-4 sunt arbori multicai de ordinul 4, in care: -un nod care contine o singura cheie are obligatoriu 2 fii -un nod care contine 2 chei are obligatoriu 3 fii -un nod care contine 3 chei are obligatoriu 4 fii Nu se permite existenta nodurilor vide si toate frunzele sunt pe acelasi nivel. Inserarile se fac intotdeauna in frunze, altfel ar fi implicat modificari mult prea diferite pentru a mentine numarul de fii corect pentru fiecare nod. Cand locul gasit pentru inserarea elementului curent este un nod deja plin, se va diviza acest nod in alte 2 noduri care vor include atat vechile elemente, cat si elementul nou inserat. Daca este necesar se vor face si alte divizari ascendente pentru a mentine structura 2-3-4.
Obs.: Arborii bicolori si arborii 2-3-4 sunt 2 TDA izomorfe. Ca urmare a acestei echivalente arborii 2-3-4 pot fi transformati in arbori bicolori. Prelucrarile frecvente ale arborilor sunt de 2 feluri:
-care NU modifica structura arborelui cautari de chei determinarea unei cai de la radacina la un nod remarcabil (care are anumite proprietati) traversari ale intregului arbore in scopul cunoasterii si prelucrarii intregului continut -care modifica structura arborelui inserari de chei cu conservarea proprietatilor arborelui eliminari de chei Parcurgeri ale arborilor binari – exemple
1. RSD (p. prefixata): radacina, subarbore sting (recursiv), subarbore drept (recursiv) 2. SDR (p. postfixata): subarbore sting (recursiv), subarbore drept (recursiv), radacina 3. SRD (p. infixata): subarbore sting (recursiv), radacina, subarbore drept Aceste parcurgeri pot fi generalizate pentru arborii oarecare de forma: n si se definesc recursiv astfel: -daca arborele este vid lista vida= parcurgerea sa pre/in/postfixata -daca arborele consta dintr-un nod lista formata din acel nod = parcurgerea sa pre/in/postfixata -daca arborele este oarecare (fig alaturata), atunci: 1. RSD incepe cu parcurgerea radacinii, dupa care se parcurg prefixat, recursiv, 2. SRD incepe cu parcurgerea infixata, recursiva, a continua cu parcurgerea infixata, recursiva a nodurilor d in 3. SDR parcurge postfixat, recursiv,
,
,…
,
,
, urmata de vizitarea radacinii, dupa care se ,… si se termina cu radacina
4. O alta parcurgere folosita in cazul arborilor oaracare este parcurgerea pe niveluri (in latime) (level_order, breadth_firstorder): Pas1. Se parcurg nodurile de pe nivelul radacinii Pas2. Se parcurg nodurile care sunt fii radacinii, de la stinga la dreapta Pas3. Se viziteaza tot de la stinga la dreapta nodurile nepoti ale radacinii, samd.
5.Arborii pot fi parcursi si nerecursiv, cu ajutorul unei st ive (de arbori!): alg RSD_nerecursiv este *se initializeaza S cu stiva vida cit timp*arborele a este nevid sau *stiva nu este vida executa cit timp *a este nevid { *tipareste cheia din radacina lui a (a k) *s=push(s,a sd) *a=a ss } executa { a=top(s); s=pop(s); } cit timp (! a && ! isEmpty(s)) sfarsit
Aplicatii simple cu arbori binari 1) Parcurgeri RSD, SDR, SRD
#include #include #include struct nod_arbore { int k; struct nod_arbore ∗ss, ∗sd; } ∗a; /* typedef struct nod_arbore { int k; struct nod_arbore ∗ss, ∗sd; } TREE; TREE ∗a; */ struct arbore ∗int_a_2( ) { struct arbore ∗aux; char nn, c1, int k; printf (“e nod NULL?”); scanf (“%c”, &nn); c1=getchar( ); if (nn==’n’)||(nn==’N’)) { printf (“cheie:”); scanf (“%d”, &k); c1=getchar( ); aux=(struct arbore∗)malloc(sizeof(struct arbore)); aux k=k; aux ss=int_a_2( ); aux sd=int_a_2( ); return (aux); } else return (NULL); } RSD (struct arbore ∗a) { if (a) { printf (“psrcurgere RSD: %d”, a k); RSD (a ss); RSD (a return 1; } main( ) {struct arbore ∗a; clrscr( ); a=int_a_2( ); RSD(a); getch( ); } SDR (struct arbore ∗a) { if (a) {SDR (a ss); SDR (a sd); printf (“%d \n”,a k); } return 1; } 2) Calcul inaltime arbore int max (int a, int b) { return (a>=b?a:b); } int h(struct arbore ∗a) { int h1; h2;
sd)}
if (!a) return (0); else { h1=h (a ss); h2=h (a sd); return (max(h1,h2)+1); } } 3) Parcurgere ne-recursiva RSD, folosind o stiva de arbori
struct astack; { struct arbore ∗a; struct astack ∗next; } ∗s; sfisare_stiva (struct astack ∗s) { struct astack ∗stv; /*pentru parcurgere nedistructiva a stivei*/ stv=s; while (stv) { printf (“\n un subarbore din stiva:”); RSD (stv a); stv=stv next; } printf (“NULL”); return (1); } struct astack ∗news ( ) { return (NULL); } struct astack ∗push (struct astack ∗s, struct arbore ∗a) { struct astack ∗stv; stv=(struct astack ∗)malloc(sizeof(struct astack)); stv a=a; stv next=s; return (stv); } struct arbore ∗top (struct astack ∗s) { struct arbore ∗arb; if (s) { arb=s a; return (arb); } else return (NULL); } struct astack ∗pop (struct stack ∗s) { struct astack ∗s; p=s) if (p) { s=p next; free (p); return (s); } else return (NULL); } emptys (struct astack ∗s) { if (!s) return(1); else return(0); } NER_RSD (struct arbore ∗a) { s=news ( ); while (a||!emptys(s)) { while (a) { printf (“%d”, a k); s=push (s,a do { a=top(s); s=pop(s); } while (!a && ! emptys(s)); } return (1); }
sd); a=a
ss; }
int depl_l=2, depl_c, col_init=40; PRSD (struct arbore ∗a, int col, int lin) { int harb; if (a) { harb=h(a); gotoxy (col, lin); printf (“%d\n”, a k); if (harb==hmax) depl_c=hmax+3; else depl_c=0) PRSD(a ss, col-1-depl_c, lin+1+depl_l); PRSD (a sd, col+1+depl_c, lin+1+depl_l); } return 1; } main ( ) { ……. hmax=h(a); PRSD (a, col_init, 1); ……. } /* parcurgerea in latime */ public void display Tree (TREE ∗a) { astack globalst=news ( ); int nBlanks=32; int isRowEmpty=0; push (globalst, a); while (!isRowEmpty) { astack localst=news( ); isRowEmpty=true; for (int j=0; j
TDA arbore binar tip 2 Tree este domenii GenElm, Bool, Int: SimilarArray 2treeSet: multimea tuturor arborilor binari cu elemente din GenElm operatori new2Tree: 2treeSet //apartine Conb
init2Tree: 2 treeSet x GenElm x 2treeSet 2treeSet //apartine Conb isEmpty: 2 treeSet Bool root: 2treeSet GenElm rootLeftsubtree, rootRightsubtree: 2treeSet 2treeSet restrictii root, rootLeftsubtree, rootRightsubtree (a) !isEmpty (a) axiome isEmpty (newTree)=true isEmpty (init2Tree(ss, r, sd))=false root(initTree (ss, r sd))=r rootLeftsubtree (ss, r, sd)=ss // Analog sd
TDA arbore oarecare tip m Tree este …………. operatori newmTree, initmTree (r, A1, A2, …, Am), isEmpty (A) root(A), label(n, A), Parent(n, A) firstChild (n, A), rightSibling(n, A)
Implementari posibile -se allege aceea care conduce la implementarea cea mai eficienta posibila pentru primitivele (operatorii) care se executa cel mai des in aplicatia de dezvoltat. 1) Cu vector “tata”
1 0
1
2
4
3
5
8
9
6
2 1
3 1
4 2
5 2
6 3
7 3
8 5
9 5
10 5
11
7
12
10
Pe linga tati vectorul poate include si etichetele nodurilor. Cautare nod tata=O(1); Parcurgere arbore din tata in tata =O(N); Ac. reprezentare NU faciliteaza: obtinerea informatiilor de filiatie, determinarea ordinii fiilor unui nod, implementarea first Child, right Sibling, determinarea inaltimii.
2) Cu liste de fii pentru fiecare nod
1
2
3
2
4
5
3
6
7
8
9
4 5
10
… 10 Cautare nod tata=O(N2); Parcurgere arbore=O(N); Faciliteaza obtinerea informatiilor despre fii; Faciliteaza determinarea ordinii fiilor nod n NU faciliteaza: implementarea first Child, right Sibling, determinarea inaltimii
3) Cu vector de pointeri la fii: pt. arbori multicai de cautare
20
2
5
14
7
9
18
40
21
25
28
26
27
30
struct nod_arbore { int m; /*numarul de fii*/ int k[mMax]; /*m-1 chei*/ struct nod_arbore *fii[mMax]; } ∗a; Cautare nod tata=O(logN); poate deveni O(1) dc se pastreaza si pointeri inapoi catre tatal fiecarui nod Parcurgere=O(N); Favorizeaza: obtinerea informatiilor de filiatie; determinarea ordinii fiilor; firstChild, rightSibling, determinarea inaltimii
4) Cu arbore binar a arborilor oarecare
struct nod_arbore { int k; struct nod_arbore ∗ss, ∗sd; } ∗a; 1
2
4
3
5
8
1
6
9
11
7
2
12
4
10
3
5
8
9
10
6
7
11
12
Ex. de folosire a arborilor binari •
Pentru reprezentarea expresiilor algebrice (expression trees)
a*b-c
*
a*(b-c)+d/e
+
c
a
*
b
a
/ -
b
d
e
c
alg evaluare_expresie_cu_arbore este if (arbore este vid) return 0 else firstOperand=evaluare_expresie_cu_arbore (leftSubtree(arbore)) secondOperand=evaluare_expresie_cu_arbore (rightSubtree(arbore)) operator=root (arbore) return (firstOperand operator secondOperand) sfarsit • Arbori de decizie (decision trees) o pot sta la baza sistemelor expert. o pot fi binari (Da/Nu) sau m-ari (multiple choice) Ex. SE in medicina este febril? Da
Nu
ii curge nasul? Da
Nu
are frisoane? Da
analizele indica o infectie? Nu Da
are dureri musculare?
are o raceala usoara
Da
Nu
este gripat
are guturai
Ex. de folosire a arborilor generali (oarecare) •
Arbore sintactic: a*(b+c)
-expresie algebrica=un termen sau 2 termeni separati de + sau -termen=un factor sau 2 factori separati de * sau / -factor= o variabila sau o expresie algebrica intre paranteze -variabila=o simpla litera
Nu
•
Arbori pentru jocuri: de ex. x si 0
x …….
x
……. x
……. x
……. 0
0
……..
……. 0
x x
