Heap binomiali. Oltre alle precedenti operazioni fondamentali degli heap riunibili, sugli heap binomiali definiremo anche le due ulteriori operazioni:

Transcript

1 Heap binomiali Gli heap binomiali sono strutture dati su cui si possono eseguire efficientemente le operazioni: Make(H) : crea un heap vuoto. Insert(H, ) : aggiunge il nodo allo heap. Minimum(H) : ritorna il puntatore al nodo con chiave minima. EtractMin(H) : ritorna il puntatore al nodo con chiave minima dopo averlo tolto dallo heap. Union(H, H 2 ) : riunisce due heap in un unico heap. Oltre alle precedenti operazioni fondamentali degli heap riunibili, sugli heap binomiali definiremo anche le due ulteriori operazioni: DecreaseKe(H,, k) : cambia la chiave di con una minore. Delete(H, ) : toglie il nodo. Mucchi binomiali 2 Alberi binomiali Gli heap binomiali sono insiemi di alberi binomiali. Un albero binomiale B k di grado k è un albero ordinato (vi è un ordine tra i figli di ogni nodo) definito ricorsivamente nel seguente modo: L albero binomiale B k di grado k > 0 è costituito da due alberi binomiali di grado k - collegati tra loro ponendo la radice del primo come primo figlio della radice del secondo. Graficamente: B 0 B k L albero binomiale B 0 di grado 0 è costituito da un solo nodo, la radice. B k- B k- Alberi binomiali 3 B 0 B B 2 B 3 B Proprietà degli alberi binomiali. L albero binomiale B k : ) ha 2 k nodi; 2) ha altezza k; k 3) ha esattamente i nodi a livello i; ) la radice ha grado k e tutti gli altri nodi hanno grado minore; 5) se k-, k-2,..., 0 sono i figli della radice elencati per indice decrescente da sinistra a destra allora i è radice di un albero binomiale B i di grado i. 5

2 B k- B k-2 B k... B 2 B B 0 Dimostrazione. L albero binomiale B 0 : ) ha 2 0 = nodi; 2) ha altezza 0; 3) ha esattamente 0 0 = nodi a livello 0; ) la radice ha grado 0 e non ci sono altri nodi; 5) la radice non ha figli; Limiti conseguenti. Un albero binomiale di n = 2 k nodi ha sia altezza che grado uguali a k = log 2 n. quindi le cinque proprietà sono vere per k = 0. Assumiamole vere per k- e dimostriamole per k. 8 ) B k è costituito da due copie di B k- e quindi ha 2 k- + 2 k- = 2 k nodi; 2) l altezza di B k è uno in più dell altezza di B k-. Quindi B k ha altezza k-+ = k; 3) Sia D(k,i) il numero di nodi a livello i in B k. Allora D( k,0) = = k 0 D( k, k ) = D( k, k ) = k = k k k 9 Mentre per 0 < i < k i nodi a livello i sono i nodi a livello i di una delle due copie di B k- che formano B k più i nodi a livello i+ dell altra e pertanto D( k, i) = D( k, i) + D( k, i + ) = k = + k k i i i 0 ) la radice di B k ha un figlio più della radice di B k-. Essa ha quindi grado k-+ = k; 5) il primo figlio k- della radice di B k èradice di uno dei due B k- che lo formano mentre i figli successivi k-2,..., 0 sono i figli dell altro B k- e, per ipotesi induttiva, sono quindi radici di alberi binomiali B k-2,..., B 0. Definizione di heap binomiale Un heap binomiale H è un insieme di alberi binomiali tale che: ) Ogni albero binomiale di H è ordinato a min-heap: ad ogni nodo è associata una chiave e la chiave di ciascun nodo è maggiore della chiave del padre. 2) Gli alberi binomiali in H hanno gradi distinti. Def. mucchio binomiale 2 2

3 Proprietà degli heap binomiali. Sia H un heap binomiale con n nodi in totale. Allora: H contiene al più log 2 n + alberi. Dimostrazione. Sia H un heap binomiale con n nodi in totale e sia b k b k-...b 0 la rappresentazione binaria di n. Allora: * un albero binomiale B i in H contiene 2 i nodi e quindi n è somma di potenze di 2 distinte. Ma l unico modo in cui si può esprimere n come k somma di potenze di 2 distinte è n = = b 0 i 2 i i * Il numero di alberi è al numero di cifre nella rappresentazione binaria di n, ovvero log 2 n I nodi hanno i seguenti campi: ke : la chiave; parent : puntatore al padre child : puntatore al primo figlio sibling : puntatore al fratello destro degree : numero di figli. oltre ad eventuali altri campi per informazioni associate alla chiave sibling parent child Molte operazioni usano la funzione ausiliaria: Link(, z) > PRE: e z sono radici di alberi binomiali > dello stesso grado parent[] z sibling[] child[z] child[z] degree[z] degree[z] + Aggiunge come primo figlio di z. Richiede tempo costante O(). Link La funzione Minimum è: Minimum Minimum(H) > PRE: H non è vuoto, kmin ke[] while sibling[] nil do sibling[] if kmin > ke[] then kmin ke[] return kmin Siccome ci sono al più log 2 n + alberi essa richiede tempo O(log n). 8 3

4 La funzione Union percorre le due liste delle radici riunendole nella prima delle due. Union(H,H2), p nil head[h2], head[h2] = nil while nil and nil do > I while p Caso. deg[] < deg[] p In dipendenza dei gradi di e di si possono presentare i seguenti casi: Union 9 20 if degree[] > degree[] then > caso p, sibling[] p Caso 2. deg[] < deg[] p s 2 22 else if degree[] < degree[] then > caso 2 s sibling[] if p = nil then else sibling[p] sibling[], p s else s sibling[] > caso 3: degree[] = degree[] p Caso 3.. ke[] > ke[] p s 23 2

5 else s sibling[] > caso 3: degree[] = degree[] if ke[] > ke[] then > caso 3. s sibling[] Link(,) if p = nil then else sibling[p] sibling[] s, s p Caso 3.2. ke[] > ke[] p s 2 else > caso 3.2 Link(,) s p Caso 3.3. s s sibling[] while s nil and degree[] = degree[s] do > II while p Caso 3.. s p s 28 if ke[] > ke[s] then > caso 3.3 Link(,s) if p = nil then s else sibling[p] s s else > caso 3. sibling[] sibling[s] Link(s,) s sibling[] if nil then if p = nil then else sibling[p]

6 Siano m ed m 2 il numero di alberi contenuti nei due heap da unire ed m quello dello heap ottenuto. Il ciclo while più esterno viene eseguito al più m +m 2 volte. Ad ogni esecuzione del ciclo while interno il numero totale di alberi diminuisce di uno. Quindi esso viene eseguito al più m + m 2 - m volte. Siccome m, m 2 ed m sono tutti O(log n) anche Union richiede tempo O(log n). La funzione Insert è: Insert(H, ) parent[] nil, sibling[] nil child[] nil, degree[] 0 Union(H,H) Siccome Union richiede tempo O(log n) anche Insert richiede tempo O(log n). Insert 3 32 EtractMin La funzione EtractMin: idea EtractMin EtractMin(H) radice con chiave minima - elimina dalla lista delle radici di H - crea uno heap H tale che head[h ] punta alla lista concatenata dei figli di, invertita Union(H,H) > unisce i due heap

7 La funzione EtractMin è: EtractMin EtractMin(H) if = nil then return nil p nil, kmin ke[] while sibling[] nil do > p radice che precede if kmin > ke[sibling[]] then > quella minima kmin ke[sibling[]], p sibling[] if p = nil then > la radice minima è la prima, sibling[] else > la radice minima è quella che segue p sibling[p], sibling[p] sibling[] 3 buildheap(h, ) > costruisce un heap H con i figli di Union(H,H) > unisce i due heap return dove la procedura buildheap è: buildheap(h, ) > costruisce un heap H con i figli di nil while child[] nil do child[] child[] sibling[] parent[] nil sibling[] Il primo ciclo while percorre la lista delle radici ed ha quindi complessità O(log n). buildheap percorre la lista dei figli di una radice. Siccome il grado è O(log n) anche tale ciclo ha complessità O(log n). Infine Union richiede tempo O(log n) e quindi anche EtractMin richiede tempo O(log n) La funzione DecreaseKe è: DecreaseKe DecreaseKe(H,, k) if k > ke[] then errore la nuova chiave non è minore della vecchia ke[] k parent[] while nil and ke[] > ke[] do k ke[], ke[] ke[], ke[] k scambia anche eventuali campi associati, parent[] Siccome l altezza è O(log n) anche DecreaseKe richiede tempo O(log n). Delete La funzione Delete è: Delete(H, ) DecreaseKe(H,, - ) EtractMin(H) Siccome sia DecreaseKe che EtractMin hanno complessità O(log n) anche Delete richiede tempo O(log n). 2

8 Operazione Complessità Make Θ() Insert O(log n) Minimum O(log n) EtracMin O(log n) Union O(log n) DecreaseKe O(log n) Delete O(log n) Esercizio 2. Supponiamo che non esista una rappresentazione della chiave -. Riscrivere al funzione Delete per gli heap binomiali in modo che essa non usi la chiave -. Assicurarsi che la complessità rimanga O(log n). 3 Esercizio. Nella funzione EtractMin abbiamo dovuto percorrere tutta la lista dei figli del nodo estratto per invertirne l ordine. Questo perché la lista delle radici è ordinata per grado crescente mentre le liste dei figli sono ordinate per grado decrescente. Cosa succede se ordiniamo le due liste in modo concorde? 5 Esiste una struttura dati, gli heap di Fibonacci, in cui le stesse operazioni si eseguono con le seguenti complessità ammortizzate. Operazione Complessità ammortizzata Make Θ() Insert Θ() Minimum Θ() EtractMin O(log n) Union Θ() DecreaseKe Θ() Delete O(log n) Esercizio 28. Dimostrare che non esiste nessuna struttura dati che permetta di eseguire le tre operazioni Make, Insert ed EtractMin in tempo costante (sia caso pessimo che ammortizzato). 8