Dati e Algoritmi 1: A. Pietracaprina. Alberi Generali

Transcript

1 Dati e Algoritmi 1: A. Pietracaprina Alberi Generali 1

2 Alexander Calder, Arc of Petals, Peggy Guggenheim Collection, Venice. 2

3 Cos è un albero? root$ Albero Informalmente: collezione di nodi; collegamenti: minimali (che garantiscano la connessione); di tipo padre-figlio struttura gerarchica (lista = caso estremo di albero) 3

4 Campi Applicativi 1 strutture dati: dizionari; code con priorità 2 esplorazione risorse: filesystem; siti di e-commerce; 3 sistemi distribuiti e reti di comunicazione: sincronizzazione, broadcast, gathering 4 analisi di algoritmi: albero della ricorsione 5 classificazione: alberi di decisione 6 compressione di dati (codici di Huffman) 7 biologia computazionale: alberi filogenetici 4

5 Alberi (Tree) (Capitolo 8 [GTG14]) Definizione di Albero radicato (rooted tree) Un albero radicato T è una collezione di nodi che, se non è vuota, soddisfa le seguenti proprietà: un nodo speciale r T (r. = radice) v T, v r :!u T : u è padre di v (v è figlio di u) v T, v r : risalendo di padre in padre si arriva a r (= ogni nodo è discendente dalla radice.) r" u" v" 5

6 Nota Nel libro la terza condizione: v T, v r : risalendo di padre in padre si arriva a r manca. Senza di questa, la seguente collezione r" u" v" con u padre di v e v padre di u sarebbe un albero... che ha poco senso. Questa collezione piuttosto è una foresta di alberi. 6

7 Alberi: altre definizioni r" u" v" w" z" Antenati x è antenato di y se x = y oppure x è antenato del padre di y (es: u è antenato di w Discendenti x è discendente di y se y è antenato di x Nodi interni Nodi con 1 figli 7

8 Alberi: altre definizioni (continua) r" u" v" w" z" Nodi esterni (= foglie) Nodi senza figli. Sottoalbero con radice v T v = albero formato da tutti i discendenti di v Albero ordinato T è un albero ordinato se per ogni nodo interno v T è definito un ordinamento lineare tra i figli u 1, u 2,..., u k di v. 8

9 Definizione Ricorsiva Definizione ricorsiva di albero radicato Un albero radicato T è una collezione di nodi che, se non è vuota, risulta partizionata in questo modo: per un qualche k 0, dove: r è radice T = {r} T 1 T 3 T k, i, 1 i k: T i è un albero non vuoto la cui radice (chiamiamola u i ) è figlia di r r" u 1" u 2" u k" " T 1" T 2" T k" 9

10 Alberi: ancora definizioni 10 Profondità (depth) di un nodo v in un albero T Definizioni alternative: 1 profondità depth T (v) di v = antenati(v) - 1; 2 se v = r radice depth(v) = 0 altrimenti depth(v) = 1 + depth(padre(v)) Livello i Insieme dei nodi a profondità i ( i 0) Altezza (height) di un nodo v in un albero T se v è foglia height(v) = 0 altrimenti height(v) = 1 + max w:w figlio di v (height(w))

11 Alberi: ancora definizioni... e una proposizione 11 Altezza di un albero T Altezza height(t ) di T = height(r), r è radice di T Proposizione (Proposition 8.3 [GTG14]) Dato un abero T, height(t ) = max v T :v foglia (depth(v))

12 Esempio 12 DEPTH& 0& 1& h=2& h=2& h=4& h=3& LIVELLO& 0& 1& 2& h=0& h=1& h=1& h=0& h=2& h=0& 2& 3& h=0& h=0& h=1& h=0& h=0& 3& 4& h=0& altezza& 4&

13 13 Proposizione (Proposition 8.3 [GTG14]) Dato un albero T, height(t ) = max v T :v foglia (depth(v)) Dimostrazione (Esercizio R-8.2 [GTG14]) Induzione su n = numero di nodi di T base: n=1 OK passo induttivo: fisso n 1. Come hp. induttiva assumiamo che la proprietà valga per qualsiasi albero con m nodi, per 1 m n. Consideriamo un albero T con n + 1 nodi. Dato che n + 1 > 1, si ha che T è del tipo: r" u 1" u 2" " u k" k 1 " T 1" T 2" T k"

14 14 Dimostrazione (continua) r" u 1" u 2" " u k" k 1 " T 1" T 2" T k" height(t ) (def ) = 1 + max 1 i k (height(u i)) (hp.ind.) = 1 + max ( max (depth Ti (v))) 1 i k v T i v foglia = max ( max (1 + depth Ti (v))) 1 i k v T i v foglia = max max 1 i k v T i v foglia = max depth T (v) v T v foglia depth T (v)

15 15 Implementazione di un albero generale Nodo (Position<E>) (Struttura linkata) parent& element& children& Albero (Tree<E>) numelements$ root$

16 16 Complessità Nell analisi degli algoritmi che usano i metodi dell interfaccia, assumeremo che gli iteratori abbiano complessità lineare nel numero di oggetti scansionati, e che gli altri metodi abbiano complessità costante. È facile sviluppare implementazioni che soddisfino questi requisiti.

17 Calcolo della profondità di un nodo (Algoritmo ricorsivo) 17 Algoritmo: depth(t,v) Input: v T Output: profondità di v in T if (T.isRoot(v)) then return 0; else return 1+depth(T,T.parent(v)); Osservazione [GTG14] definisce il metodo depth dentro una classe astratta che implementa l interfaccia Tree

18 18 Complessità di depth La complessità di depth è espressa dalla seguente relazione di ricorrenza in funzione della profondità d del nodo { c 1 d = 0 t(d) = t(d 1) + c 2 d > 0 c 1, c 2 > 0 costanti Esercizio: Dimostrare per induzione su d che t(d) = c 2 d + c 1, per ogni d 0 t(d) = Θ (d + 1) N.B.: [GTG14] è meno formale e non usa una relazione di ricorrenza

19 Calcolo della profondità di un nodo (Algoritmo iterativo) 19 Algoritmo: iter-depth(t,v) Input: v T Output: profondità di v in T d 0 ; while!(t.isroot(v)) do v T.parent(v); d d + 1 return d Complessità Θ (d + 1)

20 Calcolo dell altezza di un nodo 20 Algoritmo: height(t,v) Input: v T Output: altezza di v in T h 0; foreach w T.children(v) do h max{h, 1+height(T,w)} ; return h Osservazione La complessità dell algoritmo può essere espressa tramite una relazione di ricorrenza, in funzione della taglia (= numero di nodi) del sottoalbero T v. Tuttavia l utilizzo della relazione di ricorrenza risulta complicato dal fatto che il numero di chiamate ricorsive e la taglia dei sottoproblemi risolti da queste chiamate sono variabili che dipendono dalla istanza. In questo caso, per l analisi facciamo un argomento ad hoc (pag. 287 [GTG14]).

21 21 Complessità di height Analizziamo la complessità di height(t, v) per step successivi: 1 Come per qualsiasi algoritmo ricorsivo, la complessità può essere determinata sommando il numero di operazioni eseguite da ciascuna chiamata dell algoritmo, escludendo quelle dalle chiamate ricorsive al suo interno. 2 L algoritmo viene invocato esattamente una volta su ogni nodo u T v. (La dimostrazione per induzione sull altezza di T v è lasciata come esercizio.) 3 Per ogni u T v, il costo attribuito alla chiamata height(t, u) è Θ (c u + 1), dove c u è il numero di figli di u. 4 (Proposizione 8.4 [GTG14]) Se T v contiene n nodi (n = T v ), si ha che u T v c u = n 1. Si dimostra osservando che ogni nodo di T v tranne la radice ha un padre (unico) in T v e contribuisce 1 alla sommatoria.

22 22 Complessità di height (continua) Dai punti 1-4 deduciamo che la complessità di height(t, v) è Θ (c u + 1) = Θ (2n 1) = Θ (n), u T v dove n = T v. Osservazione È facile verificare che le complessità determinate per depth e height sono tight (da qui l uso di Θ ( )). Inoltre, tutte le istanze della stessa taglia (profondità d del nodo v per depth e numero di nodi n in T v per height) hanno la stessa complessità.

23 Visite di Alberi 23 Visita Accedere a tutti i nodi dell albero eseguendo una qualche operazione ad ogni nodo ( visita ). Preorder Prima il padre e poi (ricorsivamente) i sottoalberi radicati nei figli. Postorder Prima (ricorsivamente) i sottoalberi radicati nei figli, poi il padre.

24 24 Algoritmo preorder(t,v) Input: nodo v T Output: visita di tutti i nodi di T v visita v; foreach w T.children(v) do preorder(t,w) Chiamata iniziale preorder(t,t.root()) Visita in Preorder Nota Se l albero è ordinato la visita tocca i figli di un nodo A nell ordine dato. B B A C C D E F G E F G D A(B(E(F(C(D(G( A(B(E(F(C(D(G(

25 25 Algoritmo postorder(t,v) Input: nodo v T Output: visita di tutti i nodi di T v foreach w T.children(v) do postorder(t,w) visita v; Chiamata iniziale postorder(t,t.root()) Visita in Postorder Nota Se l albero è ordinato la visita tocca i figli di un nodo A nell ordine dato. B B A C C D D Osservazione L algoritmo height è un esempio di visita in postorder, in cui la visita di un nodo è il calcolo della sua altezza date quelle dei suoi figli. E F G E F G E(F(B(C(G(D(A( E(F(B(C(G(D(A(

26 26 Complessità delle visite Determiniamo la complessità di preorder(t,t.root()) e postorder(t,t.root()), in funzione del numero di nodi n di T. L analisi è simile a quella dell algoritmo height Ciascuna chiamata su un nodo u T esegue un numero di operazioni (escluse quelle fatte dalle chiamate riscorsive al suo interno) che è Θ (c u t u ), dove c u è il numero di figli di u e t u è il costo della visita di u Dato che l algoritmo viene invocato esattamente una volta per ogni nodo u T, la complessità totale è ( ) ( Θ (c u t u ) = Θ n + t u ). u T u T Nel caso in cui t u = O (1) per ogni u, la complessità della visita in preorder o postorder risulta essere Θ (n).

27 Esempio di visita in preorder 27 Albero: struttura di un libro in sezioni (capitoli, paragrafi, ecc.) Visita di un nodo: stampa nome sezione. La visita dell albero produce quindi l indice del libro: Book: Chapter1, Section 1.1., Section 1.2, Section 1.2.1, Section 1.2.2, Chapter 2, Section 2.1, Section 2.2, Section 2.2.1, Section Altro esempio: modo in cui spesso i file system presentano la sequenza di cartelle e file.

28 28 Esercizio Progettare un algoritmo che dato un albero T, per ciascun nodo v T memorizzi la sua profondità in un campo v.depth, e analizzarne la complessità in funzione del numero di nodi n dell albero. (Suggerimento: modificare la visita in preorder.)

29 29 Svolgimento Idea: se il nodo è la radice, la sua profondità viene impostata a 0, altrimenti si imposta la profondità a 1+la profondità del padre, che si assume già impostata. Lo pseudocodice è il seguente (prima invocazione con v = T.root()): Algoritmo alldepths(t,v) Input: nodo v T (il padre, se esiste, ha depth impostato) Output: tutti i nodi di T v con campo depth impostato if (T.isRoot(v)) then v.depth 0; else v.depth 1+T.parent(v).depth; foreach w T.children(v) do alldepths(t,w); Complessità: Θ (n), dato che l algoritmo ha la stessa struttura della visita in preorder e la visita di un nodo (impostazione del campo depth) richiede O (1) operazioni.

30 Esempio di visita in postorder 30 Albero: struttura del file system Nodi: directory (nodi interni) o file (nodi foglia). Inizialmente ogni nodo v ha un campo v.size che rappresenta lo spazio occupato dal nodo. Tuttavia, se il nodo è una directory tale spazio non include quello dei file o directory in esso contenuti. Visita di un nodo: memorizzazione nel campo size dello spazio complessivo associato al nodo (che include anche quello dei file e directory in esso contenuti). La visita dell albero determina quindi lo spazio occupato da tutti i file e directory.

31 31 Esempio 1K# 1K# 3K# 1K# 10K# 5K# 4K# 8K# 3K# 1K# 36K# 1K# 3K# 1K# 20K# 3K# 12K# 10K# 5K# 4K# 8K# 3K# 10K# 5K# 4K# 8K# 3K#

32 32 Lo pseudocodice dell algoritmo è il seguente (prima invocazione con v = T.root()): Algoritmo diskspace(t,v) Input: nodo v T Output: spazio aggregato di T v + aggiornamento di u.size u T v con lo spazio aggregato di T u s 0; foreach w T.children(v) do s s+diskspace(t,w); v.size v.size +s; return v.size; Complessità: Θ (n) (dove n è il numero di nodi dell albero), dato che l algoritmo ha la stessa struttura della visita in postorder e la visita di un nodo (impostazione del campo size) richiede O (1) operazioni.

33 33 Definizione Sia T albero ordinato e siano u, v T due nodi allo stesso livello. Diciamo che u è a sinistra di v ( v è a destra di u) se u viene prima di v nella visita in preorder. NB: si assume che nella visita in preorder i figli di un nodo siano visitati secondo l ordine a loro assegnato Osservazione La definizione è coerente con il modo di disegnare gli alberi.

34 Esercizi 34 Esercizio (simile a R-8.19 di [GTG14]) Si supponga che la visita in preorder di un albero ordinato di 6 nodi incontri i nodi nell ordine ABCDEF. 1 Dire quali delle seguenti sequenze può rappresentare la visita in postorder dello stesso albero (motivando la risposta): BAFECD, CDBFEA, CDAEFB. 2 Disegnare l albero compatibile con le due sequenze di preorder e postorder.

35 35 Svolgimento 1 Dall ordine preorder si deduce che A è radice e quindi deve essere visitato per ultimo in postorder. Quindi l unica sequenza compatibile è CDBFEA 2 Osservazioni: B deve essere il primo figlio di A (da preorder); C e D devono essere figli di B (da preorder e postorder); E deve essere il secondo figlio di A (da preorder); ed F deve essere il figlio di E (da postorder). Il disegno è lasciato come esercizio.

36 Esercizio Si supponga di calcolare l altezza di un albero T di n nodi invocando l algoritmo depth(t, v) da ciascuna foglia v di T e restituendo come altezza la massima profondità ottenuta. Dimostrare che tale strategia ha una complessità al caso pessimo Ω ( n 2). (È l algoritmo heightbad decritto in [GTG14]. Si veda anche l esercizio C-8.27 del testo.) Svolgimento Dato che il calcolo della profondità d v di un nodo v richiede Θ (d v + 1) operazioni, la complessità della strategia indicata è Ω (1 + d v ) v:v foglia Gli esempi nel prossimo lucido mostrano che per ogni n esiste un albero di n nodi in cui v:v foglia (1 + d v ) Ω ( n 2). 36

37 37

38 38 Esercizio 4 (C-8.50 [GTG14]) Sia T un albero. Dati due nodi v, w T si definisce il Lowest Common Ancestor di v e w (LCA(v, w)) come l antenato comune più profondo. Progettare un algoritmo efficiente per trovare LCA(v, w), analizzandone la complessità. Svolgimento L idea dell algoritmo è di risalire dal più profondo dei due nodi passati in input sino all antenato che sta alla stessa profondità dell altro, e da qui risalire da entrambi sino a trovare il primo antenato comune. (Si osservi che un antenato in comune esiste sicuramente ed è la radice.) Per determinare la profondità di un nodo si utilizza l algoritmo depth visto a lezione.

39 39 Lo pseudocodice dell algoritmo è il seguente: Algoritmo LCA(v, w) input v, w T output LCA(v, w) d v depth(v); d w depth(w) if (d v > d w ) then for i 1 to d v d w do v T.parent(v) else for i 1 to d w d v do w T.parent(w) while (v w) do { v T.parent(v) w T.parent(w) } return v

40 40 Complessità: Le invocazioni di depth hanno complessità proporzionale alle profondità di v e w. I cicli for e il ciclo while eseguono, ciascuno, un numero di iterazioni limitato superiormente dalla massima profondità dei due nodi, e in ciascuna iterazione eseguono un numero costante di operazioni. Dato che la profondità di un nodo è limitata superiormente dall altezza dell albero, concludiamo che la complessità dell algoritmo è O (h), con h altezza di T. Esercizio: Dimostrare che la complessità è Θ ( ). Osservazione Le complessità di algoritmi su alberi si esprimono spesso in funzione del numero di nodi n o dell altezza h. Si noti che una complessità espressa in funzione di h può essere anche espressa in funzione di n usando il fatto che 0 h < n.

41 41 Esercizio Progettare un algoritmo che dato un albero T, per ciascun nodo v T memorizzi la sua altezza in un campo v.height, e analizzarne la complessità in funzione del numero di nodi n dell albero.

42 Errata 42 Cambiamenti rispetto alla prima versione dei lucidi: Lucido 16: aggiunta osservazione