AlgoLab - Code unificabili Code unificabili con alberi binomiali Laboratorio di Algoritmi 02/03 Prof. Ugo de’ Liguoro

AlgoLab - Code unificabili ADT delle code unificabili Le code unificabili sono code di priorità che supportano le seguenti operazioni: MakeQueue(): crea una coda vuota; Enqueue(x,Q): aggiunge un elemento x alla coda Minimum(Q): ritorna l’elemento di chiave minima in Q (il minimo) Dequeue (Q): elimina da Q il minimo DecreaseKey(x,k,Q): ridefinisce la chiave di x in Q con il valore k, posto che essa fosse  k Union(Q,Q): costruisce una coda unificando distruttivamente Q e Q.

AlgoLab - Code unificabili Alberi binomiali Gli alberi binomiali sono alberi finiti ordinati definiti induttivamente: B 0 ha un solo nodo; B k+1 è formato da due alberi B k di cui la radice del primo sia il figlio più a sinistra della radice del secondo: B k+1 BkBk BkBk Gli alberi binomiali si chiamano cosi perché, tra le loro craratteristiche, vi è che il livello i dell’albero B k ha esattamente nodi.

AlgoLab - Code unificabili Esempi B4B4 BoBo B1B1 B2B2 B3B3

AlgoLab - Code unificabili Proprietà degli alberi binomiali Sia B k l’albero binomiale di ordine k: a)ha 2 k nodi, b)ha altezza k, c)vi sono nodi al livello i, d)la radice ha k figli i quali, se numerati da sinistra a destra con k  1, k  2, …, 0 allora il figlio i-esimo è un albero B i. Dim. Vedi Cormen, cap. 20.

AlgoLab - Code unificabili Heap binomiali Uno heap binomiale H è un insieme di alberi binomiali tale che: gli alberi siano degli heap minimi, ossia la chiave di un nodo è  di quella del padre (se esiste); per ogni k in H vi è al più un albero di grado k. Il grado di un nodo è il numero dei suoi figli; il grado (o arietà) di un albero è il massimo dei gradi dei suoi nodi. Si osservi che il grado della radice di B k è k.

AlgoLab - Code unificabili Esempio H =

AlgoLab - Code unificabili Rappresentazione H parent key degree childsibling Si osservi come la root-list sia ordinata in modo crescente rispetto al grado, mentre la lista dei fratelli di un nodo non radice sia decrescente sul grado. root-list

AlgoLab - Code unificabili Osservazioni Se H ha n nodi, allora H consta di al più  lg n  + 1 alberi binomiali:  lg n  + 1 è il numero dei bit nella rappresentazione binaria di n n 2 = b  lg n  b  lg n  -1 … b 0 Visto che e che B i ha 2 i nodi, l’albero B i occorre in H se e solo se b i = 1: quindi di questi alberi ve ne sono al massimo  lg n  + 1.

AlgoLab - Code unificabili Operazioni (1) MakeBinHeap (): BinHeap ritorna uno heap binomiale vuoto. BinHeapMin(BinHeap H): Node ritorna il puntatore al nodo con chiave minima in H: dato che gli alberi nella root- list di H sono heap, è sufficiente scandire la root-list (lunghezza   lg n  + 1). BinHeapInsert(Node x, BinHeap H): Void aggiunge un nodo precedentemente allocato x (di cui sia dunque definito il valore della chiave) allo heap binomiale H: crea uno heap vuoto, vi inserisce l’albero il cui unico nodo è x, quindi unisce H con il nuovo heap binomiale.

AlgoLab - Code unificabili Operazioni (2) BinHeapExtract(BinHeap H): Node ritorna il puntatore al nodo x con chiave minima in H, eliminandolo dalla coda: eliminato x dalla root-list di H, prima di deallocarlo forma uno heap binomiale H la cui root-list è la lista dei figli di x in ordine inverso (quindi con grado crescente); quindi unisce H ed H. BinHeapDecreaseKey(Node x, Key k, BinHeap H): Void ridefinisce la chiave del nodo x con il valore k (che si ipotizza sia minore del valore originario della chiave di x), ristrutturando la relativa componente di H: consiste nello scambio tra x e il padre di x ogni volta che quest’ultimo abbia chiave > k.

AlgoLab - Code unificabili Operazioni (3) BinLink(Node x, Node y): Void rende l’albero binomiale con radice in x figlio sinistro di quello con radice in y: funzione ausliaria di BinHeapUnion. BinHeapUnion(BinHeap H1,H2): BinHeap costruisce l’unione di H1 ed H2 distruttivamente ….

AlgoLab - Code unificabili Unione di heap binomiali BinHeapUnion (BinHeap H1, H2) H := la fusione ordinata sul grado delle root-list di H1 e H2 x := il puntatore al primo elemento della root-list di H while x ed il puntatore al fratello di x  NIL do if x ed il fratello hanno diverso grado or x è la prima di tre radici con lo stesso grado then x := il puntatore al successivo nella root-list else // x è la prima di due radici con lo stesso grado fondi l’albero con radice in x con quello successivo, facendo diventare radice del nuovo albero quella con la chiave minore x := il puntatore alla radice del nuovo albero return H

AlgoLab - Code unificabili BinHeapUnion(BinHeap H1, H2) H := MakeBinHeap(); root-list[H] := Merge(root-list[H1],root-list[H2]) // ordinando in modo non decrescente sul grado if root-list[H] = NIL then return H else prev := NIL; x := root-list[H]; next := sibling[x]; while next  NIL do if degree[x]  degree[next] or (sibling[next]  NIL and degree[sibling[next]] = degree[x]) then prev := x; x := next else if key[x]  key[next] then sibling[x] := sibling[next]; BinLink(next,x) else if prev = NIL then root-list[H] := next else sibling[prev] := next BinLink(x,next); x := next; next := sibling[x]; return H Unione (pseudocodice)

AlgoLab - Code unificabili Caso 1 abcd prevxnext sibling[next] BkBk BlBl abcd prevxnext BkBk BlBl

AlgoLab - Code unificabili Caso 2 abcd prevxnext sibling[next] BkBk BkBk BkBk abcd prevxnext BkBk BkBk BkBk

AlgoLab - Code unificabili Caso 3 abcd prevxnext sibling[next] BkBk BkBk BlBl b  c ab c d prev xnext BkBk BkBk B k+1 BlBl

AlgoLab - Code unificabili Caso 4 abcd prevxnext sibling[next] BkBk BkBk BlBl b > c ac b d prev xnext BkBk BkBk B k+1 BlBl