Code unificabili con alberi binomiali

1
Code unificabili con alberi binomiali

• Laboratorio di Algoritmi 02/03
• Prof. Ugo de Liguoro

2
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 lelemento 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?.

3
Alberi binomiali

• Gli alberi binomiali sono alberi finiti ordinati
  definiti induttivamente
• B0 ha un solo nodo
• Bk1 è formato da due alberi Bk di cui la radice
  del primo sia il figlio più a sinistra della
  radice del secondo

Bk1
Bk
Bk
Gli alberi binomiali si chiamano cosi perché, tra
le loro craratteristiche, vi è che il livello i
dellalbero Bk ha esattamente
nodi.
4
Esempi
Bo
B1
B2
B3
B4
5
Proprietà degli alberi binomiali

• Sia Bk lalbero binomiale di ordine k
• ha 2k nodi,
• ha altezza k,
• vi sono nodi al livello i,
• 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 Bi.

Dim. Vedi Cormen, cap. 20.
6
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 Bk è k.

7
Esempio
15
4
6
7
H
8
8
Rappresentazione
15
4
0
2
H
root-list
7
6
parent
1
0
key
degree
8
0
child
sibling
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.
9
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
• n2 b ?lg n? b ?lg n? -1 b0
• Visto che e
  che Bi ha 2i nodi, lalbero Bi occorre in H se e
  solo se bi 1 quindi di questi alberi ve ne
  sono al massimo ?lg n? 1.

10
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
lalbero il cui unico nodo è x, quindi unisce H
con il nuovo heap binomiale.
11
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?. BinHeapDecreas
eKey(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 questultimo abbia
chiave gt k.
12
Operazioni (3)
BinLink(Node x, Node y) Void rende lalbero
binomiale con radice in x figlio sinistro di
quello con radice in y funzione ausliaria di
BinHeapUnion. BinHeapUnion(BinHeap H1,H2)
BinHeap costruisce lunione di H1 ed H2
distruttivamente .
13
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 lalbero 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
14
Unione (pseudocodice)
BinHeapUnion(BinHeap H1, H2) H
MakeBinHeap() root-listH Merge(root-listH1
,root-listH2) // ordinando in modo non
decrescente sul grado if root-listH NIL then
return H else prev NIL x root-listH
next siblingx while next ? NIL do if
degreex ? degreenext or
(siblingnext ? NIL and
degreesiblingnext degreex) then prev
x x next else if keyx ? keynext
then siblingx siblingnext
BinLink(next,x) else if prev NIL then
root-listH next else
siblingprev next
BinLink(x,next) x next next
siblingx return H
15
Caso 1
siblingnext
prev
x
next
a
b
c
d
Bk
Bl
16
Caso 2
siblingnext
prev
x
next
a
b
c
d
Bk
Bk
Bk
17
Caso 3
siblingnext
prev
x
next
b ? c
a
b
c
d
Bk
Bk
Bl
18
Caso 4
siblingnext
prev
x
next
b gt c
a
b
c
d
Bk
Bk
Bl