1

Heap binomiali

Gli heap binomiali sono strutture dati su cui si possono eseguire efficientemente le operazioni:

Mucchi binomiali

Make(H) : crea uno heap vuoto

Insert(H, x) : aggiunge il nodo x allo heap

Minimum(H) : restituisce il puntatore al nodo con chiave minima

ExtractMin(H) : restituisce il puntatore al nodo con chiave minima dopo averlo tolto dallo heap

2

Union(H1, H2) : riunisce due heap in uno solo

DecreaseKey(H, x, k) : cambia la chiave di x con una minore;

Delete(H, x) : toglie il nodo x;

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

3

Alberi binomiali

Gli heap binomiali sono insiemi di alberi binomiali

Alberi binomiali

Un albero binomiale Bk di grado k è un albero ordinato (vi è un ordine tra i figli di ogni nodo) definito ricorsivamente nel seguente modo:

L’albero binomiale B0 di grado 0 consiste in un solo nodo (radice)

4

L’albero binomiale Bk di grado k > 0 consiste in due alberi binomiali di grado k - 1 legati ponendo la radice del primo come primo figlio della radice del secondo

Graficamente:

B0

Bk-1

Bk

Bk-1

5

B0 B1 B2 B3 B4

6

Proprietà degli alberi binomiali.L’albero binomiale Bk:

1) ha 2k nodi;2) ha altezza k;3) ha esattamente nodi a livello i;4) la radice ha grado k e tutti gli altri nodi hanno grado minore;5) se xk-1, xk-2, ..., x0 sono i figli della radice

elencati per indice decrescente da sinistra a destra allora xi è radice di un albero binomiale

Bi di grado i.

ik

7

Bk

Bk-1

Bk-2

B0

B2B1

.........

Limiti dimensionaliUn albero binomiale di n = 2k nodi ha altezza e grado massimo entrambi uguali a k = log2 n

8

DimostrazioneL’albero binomiale B0: 1) ha 20 = 1 nodi2) ha altezza 03) ha esattamente nodi a livello 04) la radice ha grado 0 e non ci sono altri nodi5) la radice non ha figli

10

k

Quindi le cinque proprietà sono vere per k = 0(la terza per ogni k e per i = 0)

Assumiamole vere per k-1 e dimostriamole per k

9

2) l’altezza di Bk è uno in più dell’altezza di

Bk-1. Quindi Bk ha altezza k-1+1 = k;3) Sia D(k,i) il numero di nodi a livello i in Bk

1) Bk è costituito da due copie di Bk-1 e quindi

ha 2k-1 + 2k-1 = 2k nodi;

Per 0 < i < k i nodi a livello i sono i nodi a livello i di una delle due copie di Bk-1 che formano Bk più i nodi a livello i-1 dell’altra e pertanto

i

k

i

k

i

k

ikDikDikD

1

11

)1,1(),1(),(

10

4) la radice di Bk ha un figlio più della radice di

Bk-1. Essa ha quindi grado k-1+1 = k;

5) il primo figlio xk-1 della radice di Bk è radice

di uno dei due Bk-1 che lo formano mentre i

figli successivi xk-2, ..., x0 sono i figli dell’altro

Bk-1 e, per ipotesi induttiva, sono quindi radici

di alberi binomiali Bk-2, ..., B0 .

11

Definizione di heap binomiale

Uno heap binomiale H è un insieme di alberi binomiali tale che:

Def. mucchio binomiale

1) Ogni albero binomiale di H ha la proprietà 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 e crescenti

12

1) H contiene l’albero binomiale Bi se e solo se bi = 1.

Proprietà degli heap binomialiSia H uno heap binomiale con n nodi in totale e sia bkbk-1...b0 la rappresentazione binaria di n. Allora:

2) H contiene al più log2 n +1 alberi.

13

Dimostrazione.Sia H uno heap binomiale con n nodi in totale e sia bkbk-1...b0 la rappresentazione binaria di n. Allora:

1) un albero binomiale Bi in H contiene 2i nodi e quindi n è somma di potenze di 2 distinte. L’unico modo in cui si può esprimere n come somma di potenze di 2 distinte è

(pensateci con le potenze di 10)

k

i

iibn

02

2) Se lo heap contenesse Bk con 2k > n, eccederebbe il numero di nodi consentito. Quindi, al più usa tutti gli alberi da B0 a Bk con k = log2 n

14

10cima[H]

27

38

8 14 29

6

18

2512

1

11 17

I nodi hanno i seguenti campi:key : la chiave;parent : puntatore al padrechild : puntatore al primo figliosibling : puntatore al fratello destrodegree : numero di figli.oltre ad eventuali altri campi ausiliari

15

sibling

parent

child

cima[H] 10 0 1 2

12 1

18 0

25 0 8 2

11 1

27 0

17 0

6 3

14 1

18 0

29 0

16

Minimum(H) PRE: H non è vuoto

x cima[H], kmin key[x] while sibling[x] nil do x sibling[x] if kmin > key[x] then kmin key[x] return kmin

La funzione Minimum è:

Siccome ci sono al più log2 n +1 alberi essa richiede tempo O(log n).

Minimum

17

Link(y, z) PRE: y e z sono radici di alberi binomiali

dello stesso grado

parent[y] z sibling[y] child[z] child[z] y degree[z] degree[z] + 1

Link

La funzione ausiliaria Link è usata da molte altreAggiunge y come primo figlio di z. Richiede tempo costante O(1).

Nel seguito, assumiamo di avere una funzione Union() che fonde due heap in tempo O(log n).

18

Insert(H, x) parent[x] nil, sibling[x] nil child[x] nil , degree[x] 0 cima[H1] x Union(H,H1)

La funzione Insert è:

Siccome Union richiede tempo O(log n) anche Insert richiede tempo O(log n).

Insert

19

10cima[H]

27

38

8 14 29

6

18

2512

1

11 17

10cima[H]

27

38

8 14 29

6

18

2512

1

11 17

x

ExtractMin

20

10cima[H]

27

38

8 14 29

6

18

2512

1

11 17

x

10cima[H]

27

38

8 14 29

6

18

25 12

1

11 17

x

cima[H1]

21

10cima[H]

27

38

8 14 29

6

18

25 12

1

11 17

x

cima[H1]

cima[H]

27

38

8 14 29

6

18

12

1

11 17

x

25

10

22

ExtractMin(H) x cima[H], if x = nil then return nil z nil, kmin key[x], y sibling[x] while y nil do cerca la radice minima

if kmin > key[y] then z x, kmin key[y] x y, y sibling[x] if z = nil then la radice minima è la prima

x cima[H], cima[H] sibling[x] else la radice minima è quella che segue z

x sibling[z], sibling[z] sibling[x]

La funzione ExtractMin è: ExtractMin

23

cima[H1] nil costruisce un heap H1 con i figli di x

while child[x] nil do y child[x] child[x] sibling[y] parent[y] nil sibling[y] cima[H1] cima[H1] y Union(H,H1) unisce i due heap

return x

24

Il primo ciclo while percorre la lista delle radici ed ha quindi complessità O(log n).

Il secondo ciclo while 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 ExtractMin richiede tempo O(log n).

25

DecreaseKey(H, x, k) if k > key[x] then errore “la nuova chiave non è minore della vecchia” key[x] k y parent[x] while y nil and key[y] > key[x] do k key[x], key[x] key[y], key[y] k “scambia anche eventuali campi associati” x y, y parent[x]

La funzione DecreaseKey è:

Siccome l’altezza è O(log n) anche DecreaseKey richiede tempo O(log n).

DecreaseKey

26

Delete(H, x)

DecreaseKey(H, x, -) ExtractMin(H)

La funzione Delete è:

Siccome sia DecreaseKey che ExtractMin hanno complessità O(log n) anche Delete richiede tempo O(log n).

Delete

27

La logica è semplice (l’implementazione meno…)

Percorre le due liste delle radici e le fonde nella prima• quando un albero Bi c’è e l’altro no, lo aggiunge• quando ci sono entrambi, aggancia uno all’altro,

ottenendo un solo albero Bi+1

• se già esisteva un Bi+1 aggancia un albero all’altro,ottenendo un solo albero Bi+2

• ripete gli accorpamenti finché necessario per eliminare i doppioni

Union

Union

28

Union(H1,H2) x cima[H1], xp nil y cima[H2], cima[H2] = nil while x nil and y nil do I° while

Sia x la radice corrente in H1 e y quella in H2Procediamo scorrendo H1 con x e sganciando via via y finché non abbiamo scorso interamente le due liste

Union

xp è la radice che precede x (per manipolare la lista H1) ys è la radice che segue y (per scorrere H2 dopo aver sganciato y

29

xxp

y

xxp

y

Caso 1.

Finché l’albero in y è più grosso di quello in x sposto avanti x…

if degree[y] > degree[x] then caso 1

xp x, x sibling[x]

30

Caso 2.

xxp

y

xxp

y ys

else if degree[y] < degree[x] then caso 2 ys sibling[y] if xp = nil then cima[H1] y else sibling[xp] y sibling[y] x, xp y y ys

Quando l’albero in y è più piccolo di quello in x, lo aggancio fra xp e x

31

else caso 3: degree[y] = degree[x]

ys sibling[y]

Caso 3

Se i due alberi sono uguali, vanno fusiIntanto, prepariamo il successivo valore di y…

32

Caso 3.1.

xxp

y

7

4

xxp

y

7

4

ys

if key[x] > key[y] then caso 3.1xs sibling[x]Link(x,y)if xp = nil then cima[H1] yelse sibling[xp] ysibling[y] xs x y, y ys

Se x ha chiave più alta, aggancio x a y e inserisco y nella lista della radici(due casi secondo che sia in cima alla lista o no)

33

Caso 3.2.

xxp

y

7

4

xxp

y

4

7

ys

else caso 3.2

Link(y,x)y ys

Se x non ha chiave più alta, aggancio y a x

34

xs sibling[x] while xs nil and degree[x] = degree[xs] do II° while

Dopo la fusione, l’albero in x e quello in xs possono essere di ugual dimensione. Finché è così, li fondo

Ancora una volta, abbiamo due casi: 1. chiave di x più alta di quella di xs

(caso 3.3: aggancio di xs a x e inserimento di x nella lista)2. chiave di x non più alta di quella di xs

(caso 3.4: semplice aggancio di x a xs)

35

xxp4 7

xs

Caso 3.4.

Caso 3.3.

xxp7 4

xs

xxp

7

4

xs

if key[x] > key[xs] then caso 3.3Link(x,xs)if xp = nil then cima[H1] xselse sibling[xp] xsx xs

else caso 3.4sibling[x] sibling[xs]Link(xs,x)

xs sibling[x]

36

if y nil then if xp = nil then cima[H1] y else sibling[xp] y

Arrivati in fondo ad H1, se in H2 c’è qualcos’altro, va direttamente appeso ad H1(due sottocasi, secondo che H1 sia vuota o no)

37

Siccome m1, m2 ed m sono tutti O(log n) anche Union richiede tempo O(log n).

Ad ogni esecuzione del ciclo while interno il numero totale di alberi diminuisce di uno. Quindi esso viene eseguito al più m1 + m2 - m volte.

Siano m1 ed m2 il numero di alberi contenuti nei due heap da unire, m quello dello heap risultante

Il ciclo while più esterno si esegue al più m1 + m2 volte

38

Operazione Complessità Make (1) Insert O(log n) Minimum O(log n) ExtracMin O(log n) Union O(log n) DecreaseKey O(log n) Delete O(log n)

39

Operazione Complessità ammortizzata Make (1) Insert (1) Minimum (1) ExtractMin O(log n) Union (1) DecreaseKey (1) Delete O(log n)

Esiste una struttura dati, i mucchi di Fibonacci, in cui le stesse operazioni si eseguono con le seguenti complessità ammortizzate.