Rappresentazione di alberi Lezione n°10 Prof.ssa Rossella Petreschi Lezione del 7/11/2013 del Corso di Algoritmica

Numeri di Catalano Il numero di alberi binari distinti con n nodi è pari al numero di Catalano di dimensione n: Cn = (2n su n)/(n+1), risultato dell’equazione ricorsiva Cn = ∑ Cs Cn-s-1, con 0 ≤ s ≤ n-1 e C0= C1=1 C2= 2 C3= 5 C4= 14 C5= 42 …………. 2

Quanti bit per un albero binario? Per rappresentare un qualunque albero binario con n nodi occorrono un numero di bit pari a log Cn= log[(2n su n)/ (n+1)] > > log[(22n)/ (2n(n+1))] per la (*) = 2n - O(logn) (*) (2n su n) = (2n)!/n! (2n-n)! = = (2n/2n) [2n (2n-1) (2n-2)…….1]/[n(n-1)(n-2)…1] [n(n-1)(n-2)…1]) = = (1/2n)[(2n2n)/(nn)][(2n-1)(2n-2)/(n-1)(n-1)]… [3x2/1] > > (1/2n)[(22n2/n2)][(2n-2)(2n-2)/(n-1)(n-1)]… [2x2/1] = = (1/2n) [22n2/n2] [22(n-1)2 /(n-1)2]… [22/12] = (1/2n) x (22n) 3

Alberi k-ari e ordinali alberi k-ari (o cardinali): ogni nodo ha k riferimenti ai figli, numerati da 0 a k (binari se da 0 a 2) alberi ordinali: ogni nodo memorizza solamente la lista dei figli, variabile da nodo a nodo. 4

Parentesi bilanciate . a b dd b e gg e hh a cc ff . Un albero ordinale può essere codificato da una sequenza di parentesi bilanciate nella seguente maniera: ogni nodo è codificato da una coppia di parentesi bilanciate e i suoi figli sono ricorsivamente codificati ciascuno con una sequenza bilanciata di parentesi. . a b dd b e gg e hh a cc ff . ( ( ( ( ) ) ( ( ) ) ( ) ) ( ) ( )) a c f b e h d g 5

Corrispondenza biunivoca Esiste una corrispondenza biunivoca tra Alberi binari (2-ari) di n nodi; Alberi ordinali di n+1 nodi ; Sequenze bilanciate di 2n parentesi E la cardinalità di questi tre insiemi è il numero di catalano di dimensione n : Cn = (2n su n)/(n+1) c . a b dd b e gg e hh a cc ff . ( ( ( ( ) ) ( ( ) ) ( ) ) ( ) ( ) ) NOTA: non si possono rappresentare direttamente alberi binari mediante parentesi perché non c’è modo di distinguere fs da fd a a c f b b e h d e f d g g h 6

Come rappresentare un albero binario Consideriamo che per ogni nodo u sia data la rappresentazione compressa del propria informazione u-info, quindi ci soffermiamo su come rappresentare le relazioni fra i nodi, ovvero su come rappresentare u-padre, u-fs e u-fd . Rappresentazione implicita: mantiene u-padre, u-fs e u-fd tramite una semplice regola matematica senza uso di memoria aggiuntiva. Esempio: rappresentazione dell’heap Utilizzabile solo per alcune classi di alberi binari Se pensiamo ad alberi binari qualunque, abbiamo: Rappresentazione esplicita:rappresentazione che impiega per ogni nodo u un numero di bits almeno pari a 3logn, dato che logn è il numero minimo di bits necessari per rappresentare un qualunque nodo. Rappresentazione succinta:rappresentazione che usa per rappresentare le relazioni fra i nodi dell’albero strutture dati che richiedono un totale di 2n + o(n) bits, ovvero una quantità di memoria pari a quanto si è dimostrato essere il minimo necessario. 7

Rappresentazione succinta per ampiezza b a b c d e f 1 1 1 0 1 0 0 1 1 0 0 0 0 nodo[0,…,n-1] pieno[0,…,2n] c d e f Se un nodo occupa la posizione i nell’array nodo, allora i bit corrispondenti ai suoi due figli occupano le posizioni 2i+1 e 2i+2 nell’array pieno Se un nodo occupa la posizione i nell’array nodo, allora pieno[2i+1]=1(pieno[ 2i+2]=1) iff il riferimento al fs (fd) non è null Oltre all’array nodo, dobbiamo conteggiare 2n+1 bits necessari per l’array pieno + lo spazio per navigare fra i due array, mantenendo tempo costante 8

Come navigare: Rank,Select a b c d e f 1 1 1 0 1 0 0 1 1 0 0 0 0 nodo[0,…,n-1] pieno[0,…,2n]; a b c d Rank(pieno,i): numero di 1 presenti nel segmento pieno[0,i] 0<=i<=2n Select(pieno,i): posizione dell’(i+1)-esimo 1 in pieno 0<=i<=Rank(pieno,2n) e f Identificazione in nodo[] del fs(nodo[i]) o del fd(nodo[i]) : f = 2i+1 (o d = 2i+2 ):posizione del fs (o fd) di i in pieno[]; Se pieno(f) non 0 (o pieno(d) non 0), Rank(pieno,f (oppure d)): numero di 1 presenti nel segmento pieno[0,f]opure pieno[0,d]; nodo[Rank(pieno, f (oppure d)) -1]:fs[nodo(i)] oppure fd[nodo(i)]. Identificazione in nodo[] del padre(nodo[i]): p = Select (pieno,i): bit 1 corrispondente a nodo[i] in pieno[]; nodo(p-1)/2: padre[nodo(i)]. 9

Rappresentazione esplicita di Rank Nella rappresentazione esplicita del rank si hanno m (=2n+1) interi di logm bit ciascuno , da cui: Spazio: mlogm bit; Tempo: O(1) b(i) 1 1 1 0 1 0 0 1 1 0 0 0 0 0 0 0 ……… i 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 ……… ---------------------------------------------------------------------------------------- Rank 1 2 3 3 4 4 4 5 6 6 6 6 6 6 6 6 ………. Per ridurre lo spazio, si partiziona il vettore b in segmenti di dimensione k=logm/2 . Per ogni segmento si calcola un solo valore di rango, quindi avremo m/k= m/(logm/2) interi di logm bits ciascuno, da cui: Spazio: 2m bit; 10

Implementazione di Rank j 1 2 3 4 5 b(i) 1 1 1 0 1 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0…… i 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20…… ---------------------------------------------------------------------------------------- Rank 1 2 3 3 4 4 4 5 6 6 6 6 6 6 6 6 6 6 6 6 6… Tempo O(1) per conoscere il Rank (=Rank’) degli elementi campionati e per gli altri??? per gli elementi non campionati….. Rank(b,6) = Rank’[1] + #1nei primi 3 elementi di b[4,7] = 3 +1 =4 11

Numero degli 1 in un fissato intervallo di b C(h,2h): riporta il numero di 1 contenuti nelle prime h posizioni di tutti i possibili segmenti elementari  C(h,2h)= k2k = ((logm) /2)2(logm)/2 elementi di O(logk) bit ciascuno h=0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 h=1 0 0 0 0 1 1 1 1 1 1 1 1 2 2 2 2 h=2 0 0 1 1 1 1 2 2 1 1 2 2 2 2 3 3 h=3 0 1 1 2 1 2 2 3 1 2 2 3 2 3 3 4 Rank(b,6) = Rank’[1] + #1nei primi 3 elementi di b[4,7] = Rank’[1] + C[2,9] = 3 +1 =4 Dove Rank’[1] è il valore del Rank campionato più vicino a sinistra all’indice di cui si vuole calcolare il Rank; 9 è il numero decimale corrispondente al numero binario scritto in b nello intervallo [4,7] e la riga 2 indica che si debbono contare gli 1 nei primi 3 elementi in [4,7]. In generale Rank(b,i) = Rank’ [q] + C[r,s] dove q = ⎣i/k⎦ ed r = i-qk sono calcolabili in tempo O(1) e s??? 12

Calcolo di s in O(1) Rank’ 3 5 6 6 6 m/k = 2m/logm j 1 2 3 4 5 b’(j) 14 9 8 0 0 0≤ b’(j) < m1/2 b(i) 1 1 1 0 1 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0…… k=1/2 logm i 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20…… ---------------------------------------------------------------------------------------- Rank 1 2 3 3 4 4 4 5 6 6 6 6 6 6 6 6 6 6 6 6 6… Da cui Rank(b,i) = Rank’ [q] + C[r,b’[q+1]] Rank(b,6) = Rank’[1] + C[r,b’[q+1]] = Rank’[1] + C[2,b’[2]] = 3 +1 =4 13

2m è ancora troppo Dato un array di 256 bits i 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20…… 32 interi di 8 bit ciascuno: b(i) 1 1 1 0 1 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0… mlogm Rank 1 2 3 3 4 4 4 5 6 6 6 6 6 6 6 6 6 6 6 6 6 i 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20…… 8 interi di 8 bit ciascuno: b(i) 1 1 1 0 1 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0… 2m (k=logm/2) Rank’ 3 5 6 6 6 i 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20…… 4 interi di 8 bit ciascuno: b(i) 1 1 1 0 1 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0… O(m/logm)(k=(log2m)/8) Rank” 5 6 14

..di conseguenza L’operazione di Rank(b,i) si esegue in tempo costante con l’aggiunta di o(m) bit ai bit richiesti dal vettore b Infatti: Lo spazio occupato da Rank” è O(m/logm)bit Lo spazio occupato da Rank’ è O(mloglogm/logm)bit Si partiziona b in blocchi da k = (log2m)/8 bit e per ciascuno di questi blocchi si costruisce l’array Rank’ relativo (così è garantito che ogni elemento di Rank’ richiede O(loglogm) bit dato che le somme parziali all’interno di ogni singolo blocco Rank’ possono aver valore al più k) Lo spazio occupato da C è O( m1/2 logm) O(log(logm/2)) bit Quindi aggiungiamo o(m) ai bit richiesti da b’ aggiungiamo Rank”(8i/log2m) al calcolo del Rank(b,i) Esempio: Rank(b,12) = Rank”(1) + Rank’(3) + C[0,b’[4]] = Rank”(1) + Rank’(3) + C[0,0] = 5 + 1 + 0 = 6 15

La funzione Match Rank (parentesi,l) = i Select (parentesi,i) = l . a b dd b e gg e hh a ee ff . ( ( ( ( ) ) ( () ) () ) () () ) .abdeghcf 1 1 1 10 0 1 10 0 10 0 10 10 0 nodi parentesi Ovvero le parentesi aperte (chiuse) sono identificate con 1 (0) Ogni nodo di indice i è posto in corrispondenza con l’indice della propria parentesi sinistra (left) tramite le funzioni rank e select: Rank (parentesi,l) = i Select (parentesi,i) = l Per individuare anche la parentesi destra (right), dobbiamo introdurre una nuova funzione Match Match (parentesi,l) = r Match (parentesi,r) = l 16

Rappresentazione succinta tramite parentesi bilanciate tramite parentesi bilanciate si può, in tempo costante, con 2n +o(n) bit in totale, fornire informazioni basiche sull’albero tipo: calcolo della dimensione di un sottoalbero Select (parentesi, i) = l Match (parentesi, l) = r size (i) = Rank(parentesi, r) - Rank(parentesi,l) + 1 Rappresentazione succinta fondamentale per rappresentare in forma compatta alberi statici 17