Heap binomiali 1
Introduzione Heap-binomiali: un heap binomiale è un insieme di alberi binomiali. Alberi-binomiali: un albero binomiale è un albero ordinato definito ricorsivamente. 2
Proprietà degli alberi binomiali Sia B k un albero binomiale; allora valgono le seguenti proprietà: 1. I nodi dell albero sono 2 k 2. L altezza dell albero è k 3. I nodi a profondità i sono esattamente ( i k ), per i=0, 1,, k 4. La radice dell albero ha grado* k. Il grado della radice è maggiore del grado di ogni altro nodo; inoltre se k-1, k-2,, 0 è una enumerazione, da sinistra verso destra dei figli della radice, allora il figlio numero i è la radice di un sottoalbero binomiale B i. * numero dei figli 3
2 (=i Esempi di alberi binomiali (I) Profondità 0 1 B 0 B 1 B 2 B 3 3 k) = k! = 3! = 6/2 = 3 i i!*(k-i)! 2!*(3-2)! 4
Esempi di alberi binomiali (II) ottoalberi on radice B k-1 B k-2 B 2 B 1 B 0 B k 5
Heap binomiali Un heap binomiale H è un insieme di alberi binomiali che soddisfa le seguenti proprietà: 1. Ogni albero binomiale in H ha la proprietà di ordinamento parziale dello heap: la chiave di un nodo è maggiore o uguale della chiave del nodo padre (la radice di uno heap binomiale è la più piccola dello heap) 2. Non esistono due alberi binomiali in H le cui radici hanno lo stesso grado (uno heap binomiale con n nodi consiste al massimo di lgn + 1 alberi binomiali). 6
Esempi di heap binomiali (I) ead[h] 10 1 6 12 25 8 14 29 18 11 17 38 Heap costituito da 13 nodi, quindi n=13. Notare che in binario 13 è 1101 e H è costituito dall insieme di alberi binomiali con l ordinamento parziale dello heap B 3, B 2, B 0. L albero B 3 ha 8 (2 3 ) nodi, B 2 ha 4 (2 2 ) nodi e B 0 ha 1 (2 0 ) nodo. 27 key[x]>=key[father(x)]. Da sinistra a destra chiavi in ordine crescente (tranne radici). 7
Esempi di heap binomiali (II) iù in dettaglio: ad[h] / / / 10 1 0 2 / 6 3 / : link al padre p key 12 25 8 14 29 degree 1 0 2 1 0 child / / / / brother 18 11 17 38 0 1 0 0 / / / / / / gni albero è memorizzato usando la appresentazione figlio-sinistro, fratelloestro. 27 0 / / 8
Operazioni su heap binomiali (I) MAKE-HEAP(): crea e restituisce come risultato un nuovo heap che non contiene nessun elemento; INSERT(H, x): inserisce il nodo x, la cui chiave è già stata definita, nello heap H; MINIMUM(H): restituisce come risultato un puntatore al nodo dello heap la cui chiave è minima; EXTRACT-MIN(H): elimina dallo heap H l elemento di chiave minima e restituisce il puntatore a quel nodo; 9
Operazioni su heap binomiali (II) UNION(H1, H2): crea e restituisce un nuovo heap che contiene tutti i nodi degli heap H1 e H2; gli heap H1 e H2 vengono distrutti; DECREASE-KEY(H, x, k): assegna al nodo x dello heap H una nuova chiave k. Il valore della nuova chiave non deve essere più grande del vecchio valore; DELETE(H, x): elimina il nodo x dallo heap H. 10
Ricerca della chiave minima BINOMIAL-HEAP-MINIMUM(H){ y=null; x=head[h]; min=inf; while (x!=null){ if (key[x]<min){ min=key[x]; y=x; x=brother[x]; return y; Non esistono nello heap H chiavi più grandi di INF. Vengono esaminate al massimo lgn +1 radici, quindi tempo di esecuzione O(lgn). Un heap binomiale soddisfa la proprietà dell ordinamento heap, quindi la chiave minima deve essere associata ad un nodo radice. 11
Unione di due alberi binomiali BINOMIAL-LINK(y, z){ p[y]=z; brother[y]=child[z]; child[z]=y; degree[z]++; z 21 Collega due alberi binomiali B k-1 rispettivamente di radice y e z (z diventa il padre di y, quindi z diventa la radice dell albero B k ). y 1 z y 1 1 0 Tempo di esecuzione: O(1). 0 0 B k-1 B k-1 0 B k-1 B k-1 Il numero all interno ad ogn nodo non è la chiave, ma grado 12
Unione di due heap binomiali (I) BINOMIAL-HEAP-UNION(H 1, H 2 ){ H=MAKE-BINOMIAL-HEAP(); head[h]=binomial-heap-merge(h 1, H 2 ); if (head[h]==null) return H; prev-x=null; x=head[h]; next-x=brother[x]; 13
Unione di due heap binomiali (II) hile (next-x!=null){ if ( (degree[x]!=degree[next-x]) ((brother[next-x]!=null) && (degree[brother[next-x]]==degree[x])) ){ prev-x=x; x=next-x; else if (key[x]<=key[next-x]){ brother[x]=brother[next-x]; BINOMIAL-LINK(next-x, x); 14
Unione di due heap binomiali (III) else if (prev-x==null) head[h]=next-x; return H; else { brother[prev-x]=next-x; BINOMIAL-LINK(x, next-x); x=next-x; next-x=brother[x]; Tempo di esecuzione: O(lgn), dove n è il numero di nodi complessivo degli heap H 1 e H 2. 15
Inserimento di un nodo BINOMIAL-HEAP-INSERT(H, x){ H =MAKE-BINOMIAL-HEAP(); p[x]=null; child[x]=null; brother[x]=null; degree[x]=0; head[h ]=x; H=BINOMIAL-HEAP-UNION(H, H ) Tempo di esecuzione: O(lgn), dove n è il numero di nodi di H. 16
Estrazione del nodo con la chiave minima BINOMIAL-HEAP-EXTRACT-MIN(H){ trova la radice x con la chiave minima nella lista delle radici di H e la elimina H =MAKE-BINOMIAL-HEAP(); inverti l ordine della lista dei figli di x e assegna a head[h ] il puntatore al primo elemento della lista risultante H=BINOMIAL-HEAP-UNION(H, H ); return x; Tempo di esecuzione: O(lgn), dove n è il numero di nodi di H. 17
Decremento di una chiave INOMIAL-HEAP-DECREASE-KEY(H, x, k){ if (k>key[x]) return printf( ERRORE: k troppo grande ); key[x]=k; y=x; z=p[y]; while (z!=null && key[y]<key[z]){ scambia(key[y], key[z]); scambia anche le altre informazioni di y e z; z=p[y]; Tempo di esecuzione: O(lgn), dove n è il numero di nodi di H. 18
Eliminazione di una chiave INOMIAL-HEAP-DELETE(H, x){ BINOMIAL-HEAP-DECREASE-KEY(H, x, -INF); BINOMIAL-HEAP-EXTRACT-MIN(H); Lo heap non contiene chiavi il cui valore è minore o uguale a INF. Tempo di esecuzione: O(lgn), dove n è il numero di nodi di H. 19
ESERCIZIO 1 Si scrivano le istruzioni della procedura BINOMIAL-HEAP-MERGE, con rispettive figure che simulano l esecuzione della procedura passo passo; calcolarne la complessità, considerando che il numero degli alberi che costituiscono H 1 e H 2 sono rispettivamente n e m. BINOMIAL-HEAP-MERGE(H 1, H 2 ){ x=head[h 1 ]; y=brother[x]; while(y!=null){ x=brother[x]; y=brother[x]; brother[x]=head[h 2 ]; return Head[H 1 ]; Complessità computazionale: O(n) Manca l ordinamento dello heap generato. 20
ESERCIZIO 2 Si mostri lo heap binomiale che si ottiene come risultato dell operazione che inserisce il nodo con chiave di valore 24 nel seguente heap. ead[h] 25 12 6 37 18 10 8 14 29 41 16 28 13 11 17 38 26 23 77 27 42 21
ESERCIZIO 3 Si analizzino le relazioni esistenti tra l operazione che inserisce una chiave in uno heap binomiale e l operazione che incrementa un numero binario (si consideri l esercizio 2). 22
ESERCIZIO 4 Si mostri lo heap binomiale che si ottiene come risultato dell operazione che elimina il nodo con chiave di valore 28 dal seguente heap. ead[h] 25 12 6 37 18 7 8 14 29 41 10 28 13 11 17 38 16 23 77 27 42 23