Dipartimento di Elettronica, Informazione e Bioingegneria API 2013/4

Transcript

1 Dipartimento di Elettronica, Informazione e Bioingegneria API 2013/4 G. Gini 2013

2 Alberi Alberi binari Rappresentazioni Proprietà Alberi n-ari attraversamento Alberi binari di ricerca Bilanciamento

3 Famiglia circa

4 The art of computer programming Donald Knuth, Enciclopedia dell informatica in 7 volumi TeX "Beware of bugs in the above code; I have only proved it correct, not tried it."

5 albero L albero e un tipo astratto di dati usato per rappresentare relazioni gerarchiche. - struttura del file system - -albero genealogico - organigramma - albero di decisione -.

6 Albero sintattico Input: Output: s=6*8+((2+42)*(5+12)+987*7*123+15*54) exp fact term fact term fact exp term fact fact exp term fact term term fact fact exp 6 * 8 + ( ( ) * ( ) * 7 * * 54 ) Osservazione: vale anche per il linguaggio naturale term fact fact term fact fact fact term fact

7 parsing di espressioni notazione algebrica normale (INORDER) (9+7)*(3-(4+1)) notazione polacca inversa - postfissa(postorder) *

8 Albero binario def ricorsiva Un albero è vuoto oppure è un nodo con due figli, sinistro e destro, chesonoa lorovoltaalberibinari. <albero-binario> ::= NIL <nodo> <albero-binario><albero-binario> Rappresentazione grafica: ogni nodo dell'albero contiene un elemento dell'insieme e due frecce, a figlio sinistro e a figlio destro. B A D C

9 primitive sugli alberi binari 1. vuoto? (cioè NULL) 2. radice 3. sinistro 4. destro 5. aggiungi-nodo 6. rimuovi-nodo Notazioni Nodo, arco Figlio, discendente, genitore,.. Radice, foglia, ramo

10 Es: contare le foglie contafoglie(x) - per x vuoto è zero, altrimenti è la somma delle foglie del sottoalbero sinistro e del sottoalbero destro int contafoglie ( tree-item x) if vuoto? (x) then return 0 if foglia(x) then return 1 else return (contafoglie (sinistro(x)) + (contafoglie (destro(x)) Funzione ausiliaria boolean foglia ( tree-item x) if vuoto? (x) then return false if vuoto?(sinistro(x)) AND vuoto?(destro(x)) then return true

11 Es: conta foglie (in C) int conta-f ( tree t ) { if ( t == NULL ) /*se vuoto*/ return 0; if ( t->left == NULL && t->right == NULL); /*se foglia*/ return 1; return conta-f( t->right ) + conta-f(t->left); }

12 Profondità e altezza Profondità = il numero di livelli dell albero A ha profondità 0. B e C sono a livello 1. Altezza = massima profondità + 1 L albero ha altezza altezza 4

13 Alcune definizioni Albero binario pieno (Full binary tree) - ogni nodo è una foglia oppure un nodo interno con 2 figli non vuoti Albero binario completo (Complete binary tree) -se l altezza dell albero è d, allora tutti i nodi tranne eventualmente quelli al livello d sono full.

14 Full Binary Tree TEOREMA: il numero di foglie in un full binary tree non vuoto è il numero dei nodi interni +1 Dimostrazione (per induzione matematica): Caso base: un full binary tree con 1 nodo interno ha due foglie Ipotesi induttiva: assumiamo che un full binary tree T con n-1 nodi interni ha n foglie Passo induttivo: dato l albero full binary tree T con n nodi interni, considera il nodo interno I con due figli foglia. Toglii figlidi I e ottieni l albero T. Per ipotesi induttiva, T è un full binary tree con n foglie. Riaggiungi i figli di I. Il numero dei nodi interni ora aumenta di 1 e diventa n. Il numero di foglie pure esso aumenta di 1.

15 Rappresentazioni per alberi Anche per gli alberi come per le liste si possono avere 2 rappresentazioni: 1. mediante array 2. a puntatori Per rappresentare un albero binario di profondità n basta un array in cui riservare memoria per ogni nodo; nel caso di alberi sbilanciati i nodi mancanti avranno un valore di default (-1). 7 / \ 3 9 / \ \

16 Dimensionare l array 1D profondità = il numero di livelli dell albero, ovvero il numero di archi da attraversare per andare dalla radice alla foglia più lontana (nell esempio 2) 7 / \ 3 9 / \ \ Un albero binario pieno (full) di profondità n ha: 1 nodo radice + 2 nodi primo livello + 4 nodi di secondo livello +... Quindi il numero dei nodi è: n = n Σ 2 i i=0

17 Implementazione in array 2D posizione genitore Figlio sinistro Figlio destro Fratello sinistro Fratello destro

18 Rappresentazione a puntatori Vediamo l albero binario come una lista di scatole di tre elementi: l informazione, il puntatore al sottoalbero sinistro, il puntatore al sottoalbero destro. B typedef struct Nodo { Tipo data; struct Nodo *left; struct Nodo *right; } nodo; A C D typedef nodo * tree;

19 nota Le foglie sono implementate come i nodi interni, quindi si spreca spazio per i puntatori nulli.

20 Ricerca elemento Restituisce NULL se non trova nell albero t il dato d, altrimenti restituisce il puntatore al primo nodo che lo contiene visita t in preordine sinistro tree trova ( tree t, d) if null(t) then return NULL if ( t->dato = d ) then return t; /*trovato*/ return (trova( t->left, d) trova( t->right, d ))

21 ricerca con assegnamenti (in C) tree trova ( tree t, int d) { tree temp; if ( t == NULL) return NULL; if ( t->dato == d ) return t; temp = trova( t->left, d ); if ( temp == NULL ) return trova( t->right, d ); else return temp; }

22 Es: calcolo della altezza int height ( tree t ) { if (t == NULL) return 0; return max ( heigth( t->left), heigth( t- >right )) + 1; } intmax( inta, intb ) { if (a >b) return a; else return b; }

23 Es: conteggio dei nodi - in C int contanodi ( tree t ) { if ( t == NULL ) return 0; else return (contanodi(t->left) + contanodi(t->right) } + 1); /* c è anche il nodo corrente */

24 Es: conta i nodi non-foglia int interni ( tree t ) { if ( t == NULL ) return 0; if ( t->left == NULL && t->right == NULL)) return 0; return 1 + interni( t->right ) + interni(t->left); } oppure int interni2 ( tree t ) { return contanodi( t ) conta-f( t ); } Si noti che la seconda versione scandisce due volte l'intero albero, impiegando circa il doppio del tempo (e lo stesso spazio in memoria)

25 Es: numero di nodi su livelli pari Consideriamo che il livello della radice, cioè 0, sia pari. Un albero col solo nodo radice ha 1 livello. int evencount ( tree t ) { if ( t == NULL ) return 0; if ( t->left == NULL ) && (t->right==null) return 1; return evencount( t->left->left) + evencount( t->left->right ) + evencount( t->right->left ) + evencount( t->right->right ) + 1; }

26 oppure con assegnamenti int evencount ( tree t ) { int n = 1; /* Il nodo corrente è sempre su livello pari, per ipotesi induttiva*/ if ( t == NULL ) return 0; if ( t->left!= NULL ) /* ci sono nodi a sinistra*/ n += evencount( t->left->left ) + evencount( t->left- >right ); if ( t->right!= NULL ) */ ci sono nodi a destra*/ n += evencount( t->right->left ) + evencount( t->right- >right ); return n; }

27 Es: numero di nodi su livelli dispari int oddcount ( tree t, int level ) { int n; if ( t == NULL ) return 0; n = oddcount( t->left, level+1 ) + oddcount( t->right, level+1 ); if ( level%2 == 1 ) /* == 0 per evencount */ n++; return n; } oppure oddcount (t) = contanodi (t) evencount(t)

28 numero di nodi su livelli dispari Si può vedere come il calcolo del numero dei nodi di livello pari partendo dal livello 1 invece che 0 int oddcount ( tree t) { if ( t == NULL ) return 0; /* vuoto*/ return evencount ( t->left ) + evencount (t->right) }

29 Albero n-ario ogni nodo ha un numero arbitrario di figli Si usa ad esempio per rappresentare tassonomie e organizzazioni gerarchiche definito ricorsivamente: <albero> =ε nodo seguito da un numero finito di alberi

30 Conversione in albero binario Il figlio di sinistra diventa sottoalbero sinistro; il sottoalbero destro contiene il primo fratello verso destra

31 Implementazioni sequenziali ad hoc Lista semplice con i nodi nell ordine di visita (ad esempio pre-order) Risparmio di spazio ma solo accesso sequenziale Occorre conservare la struttura dell albero per poterlo ricostruire esempi: se l albero è full, marca i nodi come foglie o come interni A B /DC E G/F HI usa un simbolo per marcare i NULL AB/D//CEG///FH//I//

32 Rappresentare solo foglie e struttura le liste in LISP sono alberi con l informazione (i simboli atomici) memorizzata nelle foglie. la lista (a (b c) d (e f g)) corrisponde all albero seguente In LISP è memorizzato come albero binario

33 con diverso numero di puntatori Ingestibile

34 Rappresentazione con 2 puntatori A B C D E F G H Il nodo è una struttura con 3 campi: 1. informazione, 2. puntatore al primo figlio, 3. puntatore al fratello a destra I A null Sottoalbero B B Sottoalbero C C null

35 Realizzazione con 3 puntatori / / / / / / / / / / / / / / / / Padre Nodo Primo Figlio Fratello

36 Attraversamento di albero Un processo per visitare i nodi di un albero in un dato ordine è detto attraversamento (tree traversal) Ogni attraversamento è una enumerazione dei nodi dell albero

37 Algoritmi di visita degli alberi per visitare tutti i nodi di un albero In profondità (depth-first search, a scandaglio, DFS) Vengono visitati i rami, uno dopo l altro Tre varianti in, pre, post-ordine In ampiezza (breadth-first search, a ventaglio, BFS) A livelli, partendo dalla radice

38 Modi di visita albero binario Pre-ordine, o pre-visita, o anticipato: visita ogni nodo prima di visitare i suoi figli Post-ordine, o post-visita, o posticipato: visita ogni nodo dopo aver visitato i suoi figli In-ordine, o simmetrico: visita il sottoalbero di sinistra, quindi il nodo, poi il sottoalbero di destra Si estende per albero n-ario

39 Esempi visita df Previsita Postvisita Simmetrica

40 df - ordine anticipato - preorder T a b e c d f g a b c d e f g void preorder (tree rt) { if (rt == NULL) return; // Empty visit(rt); preorder(rt->left); preorder(rt->right); }

41 df - ordine posticipato - postorder a T b e c d f g c d b f g e a void postorder(tree rt) { if (rt == NULL) return; // Empty postorder(rt->left); postorder(rt->right); visit(rt); }

42 df - ordine simmetrico - inorder T a b e c d f g void inorder(tree rt) { if (rt == NULL) return; // Empty inorder(rt->left); visit(rt); inorder(rt->right); } c b d a f e g

43 in ampiezza b a T e c d f g Sequenza: a b e c d f g

44 Albero binario programma in C typedef struct Tree { int data; struct Tree *left; struct Tree *right; } TREE; void insertnum(int i); void orderedinsert(tree *, int); void deepfirstvisit(tree *t); void breadthfirstvisit(tree *t); int search(tree *t, int i) ; TREE *root;

45 void main() { int i; do { printf("inserire un intero (-1 = fine):"); scanf("%d",&i); if(i==-1) break; insertnum(i); } while(i!=-1); deepfirstvisit(root); printf("\n"); breadthfirstvisit(root); } printf("\ninserire il valore da cercare: "); scanf("%d",&i); if(search(root,i)) printf("trovato\n"); else printf("niente da fare!\n");

46 void insertnum(int i) { if(root==null) { root=(tree *) malloc(sizeof(tree)); root->data=i; root->left=null; root->right=null; } else orderedinsert(root,i); } int search(tree *t, int numero) { if(t==null) return 0; if(numero==t->data) return 1; if(numero > t->data) return search(t->right,numero); else return search(t->left,numero); }

47 void orderedinsert(tree *nodo, int numero) { TREE *nuovo; if(numero == nodo->data) return; if(numero > nodo->data) { if(nodo->right == NULL) { nuovo=(tree *) malloc(sizeof(tree)); nuovo->data=numero; nuovo->left=null; nuovo->right=null; nodo->right=nuovo; } else orderedinsert(nodo->right, numero); } else { if(nodo->left == NULL) { nuovo=(tree *) malloc(sizeof(tree)); nuovo->data=numero; nuovo->left=null; nuovo->right=null; nodo->left=nuovo; } else orderedinsert(nodo->left, numero); }}

48 void deepfirstvisit(tree *t) { if(t==null) return; deepfirstvisit(t->left); deepfirstvisit(t->right); printf("%d - ",t->data); } = postorder void breadthfirstvisit(tree *t) { if(t==null) return; printf("%d - ",t->data); breadthfirstvisit(t->left); breadthfirstvisit(t->right); } = preorder

49 Alberi adatti per applicazioni di data base, di dizionari, etc

50 Alberi binari per rappresentare un insieme ordinato I valori nel sottoalbero di sinistra sono minori di quello del padre I valori nel sottoalbero di destra sono maggiori di quello del padre

51 Esempi rappresentare con alberi binari diversi l insieme ordinato dei numeri dispari da 1 a / \ / \ / \ / \ \ / \ / / \ \ 11

52 Ricerca in albero binario ordinato Ricerca del valore 4 66 T La radice contiene 6 4 < 6 4 sta nel sottoalbero sinistro di di

53 Ricerca del valore 4 66 T 4 > 2 4 sta nel sottoalbero destro di di

54 Ricerca del valore 4 66 T 4 = 4 trovato!

55 Pseudocodice per ricerca boolean element-of?(item x, tree-item tree) if vuoto?(tree) then return false if x = radice(tree) then return true if x < radice(tree) then return element-of(x, sinistro(tree)) if x > radice(tree) then return element-of(x, destro(tree))

56 Ricerca in C come predicato typedef struct Nodo { Tipo data; struct Nodo *left; struct Nodo *right; } nodo; typedef nodo * tree; int searchitem ( Tipo item, tree node) { if ( node == NULL) return 0; If (item == node -> data ) return 1; if ( item < node -> data ) return searchitem ( item, node -> left ); else return searchitem ( item, node -> right ); }

57 Vantaggi alberi binari ordinati Per vedere se un elemento x è contenuto basta confrontare x con radice: se x è minore basta cercare nel sottoalbero sinistro, se maggiore nel destro. Quanto è vantaggioso? Se l'albero è bilanciato i sottoalberi conterranno la metà degli elementi, quindi ad ogni passo dimezziamo il numero dei nodi da esaminare. Il numero dei passi crescerà quindi come log 2 n.

58 Dizionari Dizionario Insieme dinamico che implementa le seguenti funzionalità Cerca un item Inserisci un item Cancella un item Come implementarlo? Array (ordinato) Lista (non ordinata) Albero binario di ricerca

59 Alberi binari di ricerca (ABR) Definizione Ogni nodo u contiene una chiave u.key associata ad un valore u.value Le chiavi appartengono ad un insieme totalmente ordinato Proprietà 1. Le chiavi dei nodi del sottoalbero sinistro di u sono minori di u.key 2. Le chiavi dei nodi del sottoalbero destro di u sono maggiori di u.key 3. Tutti nodi i del sottoalbero sinistro di u sono tali che per tutti nodi r del sottoalbero destro di u, l.key <= r.key

60 Alberi binari di ricerca (ABR) Proprietà di ricerca Le proprietà 1. e 2. permettono di realizzare un algoritmo di ricerca dicotomica Proprietà di ordine Come visitare l'albero per ottenere la lista ordinata dei valori? Depth first inorder implementazione Ogni nodo deve mantenere Figlio sinistro, destro Padre Chiave Valore Figlio sinistro Padre Key, Value Figlio destro

61 Ricerca - chiave tree ricerca (item x, tree-item tree) if vuoto?(tree) then return NULL if x= tree.key then return tree if x < tree.key then return ricerca (x, left(tree)) if x > tree.key then return ricerca (x, right (tree))

62 Ricerca del minimo e del massimo Sottoalbero con radice 2: - minimo 1 - massimo 4 66 T Sottoalbero con radice 8: - minimo 8 - massimo

63 Ricerca minimo e massimo L elemento minimo è quello più a sinistra item MINIMUM (tree-item x) if x.left = NULL then return x return MINIMUM (x.left) L elemento massimo quello più a destra item MAXIMUM (tree-item x) if x.right = NULL then return x return MAXIMUM (x.right)

64 in forma iterativa Montresor usa notazione con.

65 Ricerca successore/predecessore Definizione Il successore di un nodo u èil più piccolo nodo maggiore di u PRIMO CASO u ha un figlio destro Il successore u' è il minimo del sottoalbero destro di u u 2 6 T Esempio: successore di 2 è u'

66 Ricerca successore/predecessore SECONDO CASO u non ha un figlio destro Il successore è il primo avo u' tale per cui u sta nel sottoalbero sinistro di u' 22 u' 66 T 88 Esempio: successore di 4 è u

67 Ricerca successore/predecessore

68 Ricerca: costo computazionale Le operazioni di ricerca sono confinate ai nodi posizionati lungo un singolo percorso dalla radice ad una foglia Tempo di ricerca: dipende dall altezza caso pessimo? L'albero è una sequenza lineare n passi caso ottimo? albero è completo, o bilanciato. L'altezza dell'albero con n nodi è log n h = altezza dell albero

69 Inserimento e rimozione Quando si inserisce o si rimuove un elemento la struttura dell albero cambia. L albero modificato deve mantenere le proprietà di un albero binario di ricerca. L inserimento risulta essere un operazione immediata. La rimozione di un elemento è più complicata, proprio perché bisogna essere certi che l albero rimanga un albero binario di ricerca. Dopo un certo numero di operazioni un albero si può sbilanciare

70 Inserimento Inserimento chiave 5 Dovrà essere nel sottoalbero sinistro Si inserisce sempre come foglia T 88 5 < 6 5 > 2 5 >

71 Inserimento Inserire z con key = y z

72 Inserimento - esempio Inserire la sequenza <5, 4, 7, 2, 6, 8>

73 Inserimento - esempio Inserire la sequenza <5, 4, 7, 2, 6, 8>

74 Inserimento - esempio Inserire la sequenza <8, 7, 6, 4, 5, 2> La struttura dell albero risulta diversa a seconda della sequenza di inserimento! L inserimento può portare ad avere alberi sbilanciati 2 5

75 Inserimento in C void orderedinsert(tree *nodo, int numero) { TREE *nuovo; if(numero == nodo->data) return; if(numero > nodo->data) { if(nodo->right == NULL) { nuovo=(tree *) malloc(sizeof(tree)); nuovo->data=numero; nuovo->left=null; nuovo->right=null; nodo->right=nuovo; } else orderedinsert(nodo->right, numero); } else { if(nodo->left == NULL) { nuovo=(tree *) malloc(sizeof(tree)); nuovo->data=numero; nuovo->left=null; nuovo->right=null; nodo->left=nuovo; } else orderedinsert(nodo->left, numero); }}

76 inserimento in C tree orderedinsert(tree nodo, int numero) { tree *nuovo;/* ritorna il puntatore all albero*/ if(numero == nodo->data) return nodo; if(numero > nodo->data) { /* va inserito a destra if(nodo->right == NULL) {/* non c è figlio destro*/ nuovo=malloc(sizeof(tree)); nuovo->data =numero; nuovo->left =NULL; nuovo->right =NULL; nodo->right =nuovo; return nodo; } else return orderedinsert(nodo->right, numero); } else { /* va inserito a sinistra*/ if(nodo->left == NULL) { nuovo=malloc(sizeof(tree)); nuovo->data=numero; nuovo->left=null; nuovo->right=null; nodo->left=nuovo; return nodo; } else return orderedinsert(nodo->left, numero); }}

77 Inserimento (Cormen) con notazione funzionale scendere nell'albero fino a che non si raggiunge il posto in cui il nuovo elemento deve essere inserito, ed aggiungerlo come foglia TREE-INSERT(T, z) 1 y := NIL //padre 2 x := root(t) //figlio 3 while x NIL //cerca dove inserire 4 do y := x //memorizza il padre 5 if key (z)< key(x) 6 then x := left (x) //scende a sinistra 7 else x := right(x) //scende a destra secondo il confronto 8 z.p := y // inserisci z come figlio di y 9 if y = NIL 10 then root(t) := z //l'albero T e' vuoto e z diventa la radice 11 else if key(z) < key(y) 12 then left(y) := z 13 else right(y) := z

78 Complessità inserimento Per inserire z si usano due puntatori y e x. Il puntatore a x scende l albero, y punta al padre di x. Nel ciclo while i due puntatori (x e y) scendono l albero. x scende al figlio sinistro o destro a seconda dell esito del confronto di key[z] con key[x]. Ci si ferma quando x = NIL e x occupa la posizione in cui z verrà inserito. I passi necessari per l inserimento sono non più del cammino massimo tra la radice e una foglia (cioè l altezza). Nel caso ricorsivo, il numero delle chiamate ricorsive dipende da h.

79 cancellazione Cancellare z, che ha chiave 14 Caso 1: z senza figli (foglia) si rimuove z

80 cancellazione Caso 2: cancellare z (che ha chiave 16) con 1 figlio si riattacca il figlio al padre di z z

81 cancellazione Caso 3: cancellare z (che ha chiave 12) con 2 figli z y Successore di z: Viene rimosso e va al posto di z

82 cancellazione Caso 3: z con 2 figli y z 12

83 cancellazione tre casi: 1. Se z non ha figli, allora si modifica puntatore a z, che punta non più a z ma a NIL. 2. Se z ha un unico figlio, allora si taglia fuori z dall albero, facendo puntare il puntatore a z all unico figlio di z. 3. Se z ha due figli, allora si individua il successore, ossia il minimo del suo sottoalbero destro. 1.Il successore y ha nessun figlio o 1 figlio. Quindi y prende il posto di z, riconducendosi al caso 1 e 2. Alla fine i dati in y vengono copiati in z.

84 Passi necessari L operazione di rimozione può richiede che SUCCESSOR(z) venga eseguito. SUCCESSOR(z) richiede tempo che dipende da h anche TREE-INSERT() e TREE-DELETE() richiedono tempo che dipende dall altezza

85 Cancellazione pseudocodice TREE-DELETE(T, z) 1 if left (z)= NIL or right(z) = NIL 2 then y := z // z ha 0 o 1 figlio, copialo in y 3 else y := TREE-SUCCESSOR(z) // z ha 2 figli, trova succ(z) 4 if left (y) NIL // y nodo da eliminare 5 then x := left(y) // x figlio di y 6 else x := right (y)

86 Cancellazione -continua 7 if x NIL then // se y ha il figlio 8 then p(x) := p(y) // taglia fuori y e aggiorna il padre 9 if p (y)= NIL 10 then root (T):= x // se y è la radice, x diventa radice 11 else if y = left(p(y)) // collega x al padre di y 12 then left(p(y)) := x 13 else right(p(y)) := x 14 if y z then // se y è il successore 15 key (z):= key(y) // ricopia i dati di y in z 16 return y

87 Cancellazione correttezza Caso 1 - nessun figlio Eliminare foglie non cambia la proprietà di ordine dei nodi rimanenti Caso 2 - solo un figlio (destro o sinistro) Se u è il figlio destro (sinistro) di p, tutti i i valori nel sottoalbero destro sono maggiori (minori) di p Quindi f può essere attaccato come figlio destro (sinistro) di p al posto di u Caso 3 - due figli Il successore s è sicuramente maggiore di tutti i nodi del sottoalbero sinistro di u è sicuramente minore di tutti i nodi del sottoalbero destro di u Quindi può essere sostituito a u

88 Modifica: costo computazionale Le operazioni di modifica sono confinate ai nodi posizionati lungo un singolo percorso dalla radice ad una foglia In tempo di ricerca dipende dall altezza dell albero Caso pessimo: l'albero è organizzato come una sequenza lineare - n Caso ottimo: l'albero è completo, o bilanciato. In questo caso, l'altezza dell'albero è log n h = altezza dell albero

89 bilanciamento Fattore di bilanciamento Il fattore di bilanciamento β(v) di un nodo v è la massima differenza di altezza fra i sottoalberi di v Esempio: albero perfetto: β(v)=0 per ogni nodo v In generale: Sono necessarie tecniche per mantenere bilanciato l'albero Vedremo alberi rosso-neri

90 Per approfondire Stanford Encyclopedia of philosophy Temi generali (Recursion, computer science,..) Autori

91 Esercizio 1 Sia data la seguente struttura per la memorizzazione di alberi binari etichettati con numeri interi: typedef struct nodo { int info; struct nodo *left, *right; } NODO; typedef NODO *tree; scrivere due funzioni ricorsive 1. int sommanodi(tree t), che somma i valori delle etichette nell'albero 2. int cercamax(tree t), che cerca il valore dell'etichetta massima dell'albero.

92 Soluzione 1 int sommanodi(tree t) { if (t==null) return 0; return t->info+sommanodi(t->left)+sommanodi(t->right);} int max(int a,int b) { if(a>b) return a; else return b;} int max3(int a,int b,int c) { return max(a,max(b,c));} int cercamax(tree t) { if (t==null) return 0; if (t->left==null && t->right==null) return t->info; if(t->left==null) return max(t->info, cercamax(t->right)); if(t->right==null) return max(t->info, cercamax(t->left)); return max3(cercamax(t->right), cercamax(t->left), t->info); }

93 Esercizio 2 Un albero binario si dice isobato se tutti i cammini dalla radice alle foglie hanno la stessa lunghezza Data la seguente definizione di albero typedef struct EL { int dato; struct EL *left; struct EL *right; } Node; typedef Node *tree; codificare una funzione che riceve in input un albero e restituisce 1 se l albero è isobato, 0 altrimenti.

94 Soluzione 2 Uso funzione ausiliaria int contaprofonditaseuguale(tree t) { int s, d; if(t==null) return 0; s=contaprofonditaseuguale(t->left); d=contaprofonditaseuguale(t->right); } if(d==-1 s==-1) return -1 if(d==s) return d+1; if(d==0) return s+1; if(s==0) return d+1; return -1;//d!=s int isobato(tree t) { if(contaprofonditaseuguale(t)==-1) return 0; else return 1; }

95 Esercizio 3 Si consideri la seguente definizione di un albero binario typedef struct EL { int dato; struct EL * left, right; } node; typedef node * tree; Definiamo un albero come "artussiano" se è composto solo da nodi foglia nodi con un solo figlio nodi con due figli aventi lo stesso numero di discendenti Codificare una funzione che riceve in input un albero e restituisce 1 se l albero è "artussiano", 0 altrimenti. Nel risolvere il problema è consigliato servirsi di opportune funzioni ausiliarie.

96 Soluzione 3 int contanodi ( tree t ) { if ( t == NULL ) return 0; else return (contanodi(t->left) + contanodi(t->right) + 1); } int artussiano(tree t) { if(t==null) return 1; if(t->left==null && t->right==null) return 1; if(t->left==null) return artussiano(t->right) if(t->right==null) return artussiano(t->left) if(contanodi(t->left)==contanodi(t->right) && artussiano(t->left) && artussiano(t->right)) return 1; return 0; }

97 Esercizio 4 Si consideri un albero binario in cui il valore dei nodi è sempre positivo. Supponiamo che percorrendo un cammino dalla radice alle foglie si totalizzi un punteggio pari alla somma dei valori contenuti nei nodi percorsi. - Scrivere una funzione maxpunti che calcola il punteggio massimo che possiamo totalizzare percorrendo un cammino dalla radice alle foglie. -Vogliamo percorrere l albero dalla radice ad una foglia totalizzando esattamente un certo punteggio. Scrivere una funzione esistecammino che dati un albero ed un intero k, dice se esiste un cammino dalla radice ad una foglia che permette di totalizzare esattamente k punti.

98 Soluzione 4 int maxpunti ( tree t ) { int D, S; if (t == NULL) return 0; S = maxpunti( t->left ); D = maxpunti( t->right ); if ( S > D ) return S + t->dato; else return D + t->dato; } int esistecammino ( tree t, int k ) { int D, S; if (t == NULL && k==0) return 1; if (t == NULL) return 0; if (k t->dato <0) return 0; return (esistecammino(t->left, k - t->dato) esistecammino(t->right, k - t->dato)); }

99 Esercizio 5 Si consideri la seguente definizione di un albero binario typedef struct EL { int dato; struct EL * left, right; } node; typedef node * tree; Scrivere una funzione che riceve il puntatore alla radice di un albero e lo scandisce interamente costruendo una lista tale che abbia tanti nodi quante sono le foglie dell albero e che ogni nodo della lista punti ad una diversa foglia dell albero. La funzione deve restituire al chiamante il puntatore all inizio della lista creata. typedef struct ELLista { tree foglia; struct ELLista * next; } nodelista; typedef nodelista * Lista; Si noti che esistono diversi modi di visitare l albero che originano diverse liste come risultato.

100 Soluzione 5 void crealista(tree t, Lista *lis) { Lista temp; if(t==null) return; if(t->left==null && t->right==null) { temp=*lis; *lis=(lista)malloc(sizeof(nodolista)); *lis->foglia=t; *lis->next=temp; } if(t->left!=null) crealista(t->left, lis); if(t->right!=null) crealista(t->right, lis); }

101 Esercizio 6 Si definisca una struttura dati adatta a rappresentare un albero N- ario. Per semplicità si consideri il caso in cui i nodi contengono, come dati utili, dei semplici numeri interi. Ogni nodo contiene, invece di una coppia di puntatori a nodi, come nel caso degli alberi binari, una lista di puntatori a nodo. Tale lista è una lista concatenata semplice, realizzata tramite la struttura Ramo. typedef Nodo * Albero; typedef struct Branch { Albero child; struct Branch * next; } Ramo; typedef struct Knot { int dato; struct Branch * rami; } Nodo; Si progetti la funzione int conta( ) che conta il numero di nodi di un albero N-ario.

102 soluzione 6 int contanodi ( Albero t ) { if ( t == NULL ) return 0; else return 1 + contarami( t->rami ); } int contarami ( Ramo * b ) { if ( b == NULL ) return 0; else return contanodi( b->child ) + contarami( b->next ); }