1. ALBERI
BINOMIALI
Dall’articolo:
“A Data Structure for Manipulating Priority Queues”
di Jean Vuillemin
dell’Università di Parigi-Sud

2. CODE DI PRIORITA’
Q = { <name1, label1>, …, <namen, labeln>}
EXTRACT
MIN
INSERT
DELETE
UNION
UPDATE

3. HEAP
1
2
3
4
5
6
7
8
9
10
A[PARENT(i)] < = A[i]
n operazioni
1
2
3
4
8
5
9
10
6
7
O(nlogn)

4. ALBERI E FORESTE BINOMIALI
•B0 è composto da un unico nodo;
•Bp+1 è composto da due sottoalberi Bp con la
radice di uno figlia dell’altra.
B0
Bp+1
Bp
Bp

5. ALBERI E FORESTE BINOMIALI
Ecco un esempio:
Questo è un albero B3:
•il numero totale di nodi è 23=8;
•l’altezza è log28=3;
3
nodi e
2
cioè: 3!/[2!(3-2)!] = 6/2 = 3;
•a profondità k=2 ci sono
()
•la radice ha 3 figli, mentre ad avere
un solo figlio ci sono 23-1-1 nodi, e
cioè 2.

6. ALBERI E FORESTE BINOMIALI
Decomposizione binaria di n:
∑ bi 2i
con bi Є{0; 1}
i>=0
Allora:
Fn ={Bi | i>=0, bi=1, n=∑ bi 2i }
i>=0
B0
F13=
B2
B3
quindi in Fn ci sono al più floor(log2n)+1 componenti.

7. CODE BINOMIALI
Q = { 503, 87, 512, 61, 908, 170, 897, 275, 653, 426}
61
426
653
170
275
897
87
908
503
512

8. COMPLESSITA’
All’interno di tale struttura la complessità
delle operazioni è pari al numero di confronti,
cioè delle operazioni di couplings, che
vengono effettuate durante la loro esecuzione.
Si indicherà con v(n) il numero di componenti
all’interno della foresta binomiale.

9. UNIONE
Caso semplice:
UNION(Fn , Fn’)
Se root(Bi’) < root(Bi):
con n=n’=2i
Se root(Bi) < root(Bi’):
COUPLINGS
Bi+1=
Bi
Bi’
Bi
Bi’

10. UNIONE
61
908
87
F5
512
503
+
170
275
154
897
509
426
F7
653
154
154
509
170
275
653
509
897
908
426
509
908
426
908
RIPORTO

11. UNIONE
61
154
=
170
275
509
897
908
426
87
512
F12
-
-
503
653
Complessità: O(log(n+n’)) = v(n’) + v(n) – v(n+n’)

12. INSERIMENTO
INSERT = UNION(Fn, 1)
Creazione di Fn = n INSERT
Complessità: O(n) = n - v(n)

13. EXTRACT MIN
Ricerca del minimo nella root di ogni componente della
foresta:
F13=
B0
B2
Complessità: O(logn) = v(n)-1
B3

14. EXTRACT MIN
Infatti considerando il caso pessimo, data una Fn questa
conterrà tutte le componenti possibili, che può avere:
F7 :
log2n

15. DELETE
Bisogna eliminare l’elemento m dalla coda
binomiale:
se m=root:
si rimuove Bi dalla Fn, posto m=root(Bi): Fn Fn1
EXTRACT-MIN(Bi): Bi Fn2
UNION(Fn1, Fn2)
Complessità: O(logn)

16. DELETE
se m è un nodo qualunque:
Si trova la componente Bi in cui è contenuto m
Si crea Fn1 dove n1 = n - 2i
Si considera la componente Bi:
Bi =
Bri-1
Bli-1

17. DELETE
•Se m si trova in Bli-1
Fn2 = {Bri-1} e si decompone Bli-1
•Se m si trova in Bri-1
Fn2 = {Bli-1} e si decompone Bri-1
L’operazione si ripete finché m non è root di una componente Bj
m viene tagliata via da Bj lasciando una F2i-1
F2i-1 viene aggiunta ad Fn2 e viene fatta la UNION(Fn1, Fn2)

18. UPDATE
UPDATE = DELETE
INSERT
Complessità: O(logn)

19. CASO PARTICOLARE
Con n operazioni di cui:
EXTRACT-MIN è eseguito meno delle altre;
UPDATE causa solo un incremento delle
priorità.
Allora le operazioni primitive si comportano in
modo differente:
UPDATE
DELETE
EXTRACT-MIN

20. CASO PARTICOLARE
In una sequenza arbitraria con :
n INSERT o UNION
u UPDATE
m EXTRACT-MIN
la complessità è:
O(nlogn) + O(u) + O(ulog(nm/u))

21. CONCLUSIONI
L’utilizzo di questo tipo di struttura dati comporta
diversi vantaggi:
la possibilità di gestire tutte le operazioni
primitive con una complessità logaritmica;
uno spreco di memoria contenuto rispetto ad
altre strutture dati: O(n);
la struttura tende a crescere all’aumentare di n,
tuttavia essa viene via via accorpata il più
possibile mantenendo il numero di componenti
assai minore rispetto al numero di elementi.