1/32 Algoritmi e Strutture Dati HEAP Anno accademico 2004-05.

Presentazione sul tema: "1/32 Algoritmi e Strutture Dati HEAP Anno accademico 2004-05."— Transcript della presentazione:

1 1/32 Algoritmi e Strutture Dati HEAP Anno accademico 2004-05

2 2/32 Heap 128 64 72 87 12 30 1 6 3 A={ 128, 64, 72, 8, 7, 12, 30, 1, 6, 3 } 1 2 3 4 5 6 7 8 9 10 A(6) = 12

3 3/32 Heap: definizione formale Una Heap è un albero binario quasi completo. Quasi significa che possono mancare alcune foglie consecutive a partire dall’ultima foglia di destra. Per ogni nodo i Value(i) ≤ value(parent(i)) Nota 1: il massimo si trova nella radice Nota 2: non c’è nessuna relazione tra il valore di un nodo e quello di un suo fratello

4 4/32 Memorizzazione di un heap in un vettore 128 64 72 87 12 30 1 6 3

5 5/32 Memorizzazione di un heap in un vettore Radice posizione 1 Per ogni nodo in posizione i: left-child(i) posizione 2i right-child(i) posizione 2i+1 Parent(i) =  i/2 

6 6/32 i AB HeapsHeap i2i2i+1 parte del vettore già heapizzato elemento da aggiungere alla sotto heap (verde) Aggiunta di un elemento (heapify)

7 7/32 i AB IDEA: facciamo scendere il nodo i nell’albero fino a trovare la sua posizione. ? AB i

8 8/32 Heapify(A,i) l=left(i) r=right(i) if l≤heap-size(A) and A[l]>A[i] then largest=l else largest=i if r≤heap-size(A) and A[r]>A[largest] then largest=r if largest  i then Exchange(A[i],A[largest]) Heapify(A,largest)

9 9/32 Heapify: costo computazionale Caso pessimo: il nodo si sposta fino ad arrivare alle foglie. Heapify impiega tempo costante ad ogni livello per sistemare A[i], A[left(i)] e A[right(i)]. Esegue aggiustamenti locali al massimo height(i) volte dove height(i) = O(log(n))

10 10/32 Build-heap(A) heap-size(A)=length(A) for i=  length(A)/2  downto 1 do heapify(A,i) Analisi approssimativa: ogni chiamata a heapify costa O(log(n)). Chiamiamo heapify O(n) volte, quindi build-heap = O(nlog(n)) Domanda (esercizio): build-heap =  (nlog(n)) ?

11 11/32 PQ implementate con Heap Extract-max(A) if heap-size(A)<1 then "error" max=A[1] A[1]=A[heapsize(A)] heapsize(A)=heapsize(A)-1 Heapify(A,1) return max O(log(n))

12 12/32 PQ implementate con Heap max = max = ?? max = Heapify( )

13 13/32 PQ implementate con Heap Insert(A,x) heap-size(A)=heap-size(A)+1 i=heap-size(A) while i>1 and A[parent(i)]<x do A[i]=A[parent(i)] i=parent(i) A[i]=x O(log(n))

14 14/32 Heap Sort: l’idea. Heap Heapify Heap Heapify... avanti così...

15 15/32 Heap Sort Heap-Sort(A) build-heap(A) for i=length(A) downto 2 do exchange(A[1],A[i]) heap-size[A]=heap-size(A)-1 heapify(A,1) O(nlog(n)) È un metodo “in place”

16 16/32 Quicksort: l’idea Dividi: Dividi il vettore in due parti non vuote. Conquista: ordina le due parti ricorsivamente Combina: fondi le due parti ottenendo un vettore ordinato. A={10,5,41,3,6,9,12,26} mergesort quicksort A metà A 1 ={10,5,41,3} A 2 ={6,9,12,26} Intorno a un Pivot, es 12 A 1 ={10,5,3,6,9,12} A 2 ={41,26} Dividi

17 17/32 Quicksort Quicksort(A,p,r) if p<r then q=partition(A,p,r) Quicksort(A,p,q) Quicksort(A,q+1,r) Nota: Mergesort lavora dopo la ricorsione Quicksort lavora prima della ricorsione Partition è cruciale !!!

18 18/32 5 3 2 6 4 1 3 7 3 3 2 6 4 1 5 7 3 3 2 1 4 6 5 7 ij i i i i i j j j j j A(p,r) < 5≥ 5 Pivot  (n) in place

19 19/32 Partition(A,p,r) x=A[p] i=p-1 j=r+1 while true do repeat j=j-1 until A[j]<=x repeat i=i+1 until A[i]>=x if i<j then scambia(A[i],A[j]) else return j

20 20/32 Analisi di QS nel caso ottimo Caso ottimo: partizioni bilanciate T(n) = 2T(n/2) +  (n) quindi: T(n) =  (nlog(n))

21 21/32 Analisi di QS nel caso pessimo Caso pessimo: partizioni sbilanciate T(n) = T(n-1) +  (n) quindi: T(n) =  (n 2 ) ricorsione partition

22 22/32 Analisi di QS nel caso...... non buono ! 90% 10% T(n) ???

23 23/32 Albero di ricorsione n 1/10 n9/10 n 1/100 n9/100 n 81/100 n n +  (n log(n)) < n 81/1000 n729/1000 n log 10 n log 10/9 n

24 24/32 Analisi del caso medio di QS: una intuizione. Caso medio: a volte facciamo una buona partition a volte no... buona partition: cattiva partition:

25 25/32 Caso medio le buone e le cattive partition si alternano... cattiva 1 n-1 1(n-1)/2 dopo una cattiva e una buona partizione in successione siamo più o meno nella situazione in cui la cattiva partizione non è stata fatta ! buona

26 26/32 QS: distribuzione degli input Abbiamo assunto implicitamente che tutte le sequenze di numeri da ordinare fossero equiprobabili. Se ciò non fosse vero potremmo avere costi computazionali più alti. Possiamo “rendere gli input equiprobabili” ? mischiamo la sequenza casualmente prima di ordinare Scegliamo il pivot a caso. come procediamo

27 27/32 QS “randomizzato” QSR usa una versione randomizzata della procedura Partition. Randomized-partition(A,p,r) i=random(p,r) exchange(A[p],A[i]) return Partition(A,p,r) Un algoritmo randomizzato non ha un input pessimo, bensì ha una sequenza di scelte pessime di pivot.

28 28/32 Insertion sort Merge sort Heap sort Quick sort Caso pessimo n2n2 n log(n) n2n2 Caso medio n2n2 n log(n) Caso ottimo nn log(n) = in place

29 29/32 È possibile ordinare in meno di n log(n) ??? ovvero in o(n log(n))

30 30/32 Limite inferiore di complessità Insertion-sort Merge-sort Heap-sort Quick-sort “Comparison-sort” algoritmi basati su confronti Questi metodi calcolano una soluzione che dipende esclusivamentedall’esito di confronti fra numeri TEOREMA (Lower Bound per algoritmi Comparison-sort): Qualsiasi algoritmo “comparison-sort” deve effettuare nel caso pessimo  (n log(n)) confronti per ordinare una sequenza di n numeri.

31 31/32 lower bound per comparison sort IDEA: con n numeri ho n! possibili ordinamenti. Possiamo scegliere quello giusto tramite una sequenza di confronti. ≤> >> ≤ ≤ Ogni nodo rappresenta un confronto.

32 32/32 Esempio: n=3 {a 1,a 2,a 3 } a 1 :a 2 a 2 :a 3 a 1 :a 3 a 1,a 2,a 3 a 1 :a 3 a2,a1,a3a 2 :a 3 ≤> >> ≤ ≤ Ogni nodo bianco rappresenta un confronto. Ogni nodo rosso rappresenta una possibile soluzione. a 1,a 3,a 2 a 3,a 1,a 2 >≤ a 2,a 3,a 1 a 3,a 2,a 1 >≤ albero dei confronti

33 33/32 3! = 6 = numero di foglie dell’albero dei confronti. ogni (cammino dalla radice ad una) foglia rappresenta un ordinamento ci sono n! ordinamenti. quanto deve essere alto un albero per avere n! foglie ??? un albero binario alto h ha al massimo 2 h foglie dobbiamo avere 2 h ≥ n! Formula di Stirling: n! > (n/e) n e=2.17... h ≥ log[(n/e) n ] = nlog(n) - nlog(e) =  (nlog(n)) Limite inferiore al numero dei confronti

34 34/32 Il caso pessimo di un qualsiasi algoritmo comparison-sort eseguito su una sequenza di n numeri è dato dall’altezza dell’albero di decisione associato a quell’algoritmo. MA Un albero binario con n! foglie (ordinamenti) ha un altezza  (nlog(n)) QUINDI qualsiasi algoritmo comparison-sort, nel caso pessimo, esegue  (nlog(n)) confronti.