La presentazione è in caricamento. Aspetta per favore

La presentazione è in caricamento. Aspetta per favore

1 Heap binomiali Gli heap binomiali sono strutture dati su cui si possono eseguire efficientemente le operazioni: Mucchi binomiali Make(H) : crea uno heap.

Presentazioni simili


Presentazione sul tema: "1 Heap binomiali Gli heap binomiali sono strutture dati su cui si possono eseguire efficientemente le operazioni: Mucchi binomiali Make(H) : crea uno heap."— Transcript della presentazione:

1 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 2 Union(H 1, H 2 ) : 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 3 Alberi binomiali Gli heap binomiali sono insiemi di alberi binomiali 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: Lalbero binomiale B 0 di grado 0 consiste in un solo nodo (radice)

4 4 Lalbero binomiale B k 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: B0B0 B k-1 BkBk

5 5 B0B0 B1B1 B2B2 B3B3 B4B4

6 6 Proprietà degli alberi binomiali. Lalbero binomiale B k : 1) ha 2 k 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 x k-1, x k-2,..., x 0 sono i figli della radice elencati per indice decrescente da sinistra a destra allora x i è radice di un albero binomiale B i di grado i.

7 7 BkBk B k-1 B k-2 B0B0 B2B2 B1B Limiti dimensionali Un albero binomiale di n = 2 k nodi ha altezza e grado massimo entrambi uguali a k = log 2 n

8 8 Dimostrazione Lalbero binomiale B 0 : 1) ha 2 0 = 1 nodi 2) ha altezza 0 3) ha esattamente nodi a livello 0 4) la radice ha grado 0 e non ci sono altri nodi 5) la radice non ha figli 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 9 2) laltezza di B k è uno in più dellaltezza di B k-1. Quindi B k ha altezza k-1+1 = k; 3) Sia D(k,i) il numero di nodi a livello i in B k 1) B k è costituito da due copie di B k-1 e quindi ha 2 k k-1 = 2 k nodi; Per 0 < i < k i nodi a livello i sono i nodi a livello i di una delle due copie di B k-1 che formano B k più i nodi a livello i-1 dellaltra e pertanto

10 10 4) la radice di B k ha un figlio più della radice di B k-1. Essa ha quindi grado k-1+1 = k; 5) il primo figlio x k-1 della radice di B k è radice di uno dei due B k-1 che lo formano mentre i figli successivi x k-2,..., x 0 sono i figli dellaltro B k-1 e, per ipotesi induttiva, sono quindi radici di alberi binomiali B k-2,..., B 0.

11 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 gradidistinti e crescenti

12 12 1) H contiene lalbero binomiale B i se e solo se b i = 1. Proprietà degli heap binomiali Sia H uno heap binomiale con n nodi in totale e sia b k b k-1...b 0 la rappresentazione binaria di n. Allora: 2) H contiene al più log 2 n +1 alberi.

13 13 Dimostrazione. Sia H uno heap binomiale con n nodi in totale e sia b k b k-1...b 0 la rappresentazione binaria di n. Allora: 1) un albero binomiale B i in H contiene 2 i nodi e quindi n è somma di potenze di 2 distinte. Lunico modo in cui si può esprimere n come somma di potenze di 2 distinte è (pensateci con le potenze di 10) 2) Se lo heap contenesse B k con 2 k > n, eccederebbe il numero di nodi consentito. Quindi, al più usa tutti gli alberi da B 0 a B k con k = log 2 n

14 14 10 cima[H] I nodi hanno i seguenti campi: key : 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 ausiliari

15 15 sibling parent child cima[H]

16 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ù log 2 n +1 alberi essa richiede tempo O(log n). Minimum

17 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 altre Aggiunge 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 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 19 10 cima[H] cima[H] x ExtractMin

20 20 10 cima[H] x 10 cima[H] x cima[H1]

21 21 10 cima[H] x cima[H1] cima[H] x 25 10

22 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 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 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 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 laltezza è O(log n) anche DecreaseKey richiede tempo O(log n). DecreaseKey

26 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 27 La logica è semplice (limplementazione meno…) Percorre le due liste delle radici e le fonde nella prima quando un albero B i cè e laltro no, lo aggiunge quando ci sono entrambi, aggancia uno allaltro, ottenendo un solo albero B i+1 se già esisteva un B i+1 aggancia un albero allaltro, ottenendo un solo albero B i+2 ripete gli accorpamenti finché necessario per eliminare i doppioni Union

28 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 H2 Procediamo 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 29 xxp y x y Caso 1. Finché lalbero 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 30 Caso 2. x xp y x 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 lalbero in y è più piccolo di quello in x, lo aggancio fra xp e x

31 31 else caso 3: degree[y] = degree[x] ys sibling[y] Caso 3 Se i due alberi sono uguali, vanno fusi Intanto, prepariamo il successivo valore di y…

32 32 Caso 3.1. x xp y 7 4 x y 7 4 ys if key[x] > key[y] then caso 3.1 xs sibling[x] Link(x,y) if xp = nil then cima[H1] y else sibling[xp] y sibling[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 33 Caso 3.2. x xp y 7 4 x 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 34 xs sibling[x] while xs nil and degree[x] = degree[xs] do II° while Dopo la fusione, lalbero 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 35 x xp 47 xs Caso 3.4. Caso 3.3. x xp 74 xs x xp 7 4 xs if key[x] > key[xs] then caso 3.3 Link(x,xs) if xp = nil then cima[H1] xs else sibling[xp] xs x xs else caso 3.4 sibling[x] sibling[xs] Link(xs,x) xs sibling[x]

36 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è qualcosaltro, va direttamente appeso ad H1 (due sottocasi, secondo che H1 sia vuota o no)

37 37 Siccome m 1, m 2 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ù m 1 + m 2 - m volte. Siano m 1 ed m 2 il numero di alberi contenuti nei due heap da unire, m quello dello heap risultante Il ciclo while più esterno si esegue al più m 1 + m 2 volte

38 38

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


Scaricare ppt "1 Heap binomiali Gli heap binomiali sono strutture dati su cui si possono eseguire efficientemente le operazioni: Mucchi binomiali Make(H) : crea uno heap."

Presentazioni simili


Annunci Google