Dipartimento di Elettronica, Informazione e Bioingegneria API 2013/4

Transcript

1 Dipartimento di Elettronica, Informazione e Bioingegneria API 2013/4 Heap sort; ordinamento senza G. Gini 2013

2 Ordinamento per confronti: complessita' Esistono altri algoritmi di ordinamento per confronto di complessita ottima O(nlog(n)) che operano sul posto? mergesort richiede memoria aggiuntiva QuickSort opera sul posto ma può essere Θ(n 2 ) Si', heapsort (ordinamento del mucchio) (Williams, 1964)

3 Idea di heapsort Modificando insertion sort, che e' di complessita' O(n 2 ), abbiamo ottenuto mergesort, di complessita' O(nlog(n)) abbiamo reso logaritmico, anziche' lineare, il costo di localizzare la posizione dove inserire il nuovo elemento nel sottovettore gia' ordinato. Consideriamo ora selection sort: cosa e' che lo rende quadratico? Il fatto che ad ogni iterazione il costo per identificare il nuovo elemento minimo e' lineare: sarebbe possibile renderlo logaritmico?

4 Verso heapsort nel primo ciclo di selection sort, tramite n-1 confronti, viene identificato l'elemento minimo del vettore cosa potremmo fare in alternativa con n-1 confronti? 1. dividiamo gli n elementi in coppie 2. con n/2 confronti si puo' stabilire l'elemento minimo di ogni coppia, ottenendo n/2 elementi 3. i passi (1) e (2) possono essere iterati fino ad ottenere l'elemento minimo del vettore, piu' un albero di relazioni tra gli elementi del vettore via via selezionati il tutto con n/2 + n/4 + n/ = n-1 confronti l'albero cosi' costruito ha altezza log(n)

5 HEAP come vettore per mantenere questa organizzazione degli elementi del vettore che ne riflette gli ordinamenti parziali e' necessario mantenere la struttura dati ad albero questa struttura dati e' chiamata heap. Il vettore stesso puo' essere utilizzato per rappresentare un albero binario. Un albero binario completo di n elementi puo' essere rappresentato in un array (con indici da 0 a n-1) dove i figli sinistro e destro del nodo i si trovano rispettivamente agli indici 2*i+1 e 2*i+2

6 Definizione di heap Un vettore, che può essere interpretato come albero binario B. Ogni nodo di B può anche rappresentare un elemento di una coda con priorità. C è un ordinamento parziale sui valori nei nodi Min-heap: i valori dei nodi sono minori dei valori sui nodi figli ovvero, A[Parent(i)] A[i] : heap crescente, cioè il padre contiene valore minore o uguale a quello dei figli. La radice contiene il valore minimo. Max-heap: i valori dei nodi sono maggiori dei valori sui nodi figli ovvero, A[Parent(i)] A[i] : heap descrescente, cioè il padre contiene un valore maggiore o uguale a quello dei figli. La radice contiene il valore massimo.

7 Esempio di min-heap e max-heap Min-heap Max-heap

8 Min-HEAP: esempio (con array da 0) vettore = [ 4, 12, 6, 14, 22, 18, 16, 44, 55, 23, 42, 94, 19, 26, 67 ] v[0]=4 v[1]=12 v[2]=6 v[3]=14 v[4]=22 v[5]=18 v[6]=16 v[7] =44 v[8] =55 v[9] =23 v[10] =42 v[11] =94 v[12] =19 v[13] =26 v[14] =67 i 0 i n/2-1 : v[i] v[2*i+1] v[i] v[2*i+2] - figlio sinistro e figlio destro i 0 i n-1 : v[0] v[i]

9 Esempio max (con array da 1) Un albero binario può essere rappresentato in un array, con # elementi heap # elementi array A[1] contiene la radice Parent (i) return _i/2_ Left (i) return 2*i Right (i) return 2*i + 1 In un max heap, A[Parent(i)] A[i] In un min heap A[Parent(i)] A[i]

10 HEAPSORT: idea dell ordinamento Se usiamo un max heap: 1. ogni volta estraiamo il massimo elemento (la radice) e la poniamo in fondo 2. Ripristiniamo un max heap con un elemento in meno 1. Max-heapify - mantiene la proprietà di maxheap 2. Build-Max-Heap, costruisce un max-heap da zero

11 max-heapify Heapify( A,i): ripristina la proprietà di Heap nel sottoalbero radicato in i assumendo che i suoi sottoalberi destro e sinistro siano già degli Heap Input Un array A e un indice i Gli alberi binari con radici Left(i) e Right(i) sono max-heap Ma l albero binario con radice i non è un max-heap Obiettivo Ripristinare la proprietà di max-heap sul sottoalbero con radice i Far scendere l'elemento A[i] nell'array fino alla posizione che gli compete

12 Esempio di Heapify(a,i) Assumiamo di avere due heap H 1 e H 2 con radici A[2i] e A[2i+1] e un nuovo elemento v in posizione i A[2i] A[i]= v A[2i+1] H 1 H 2

13 Esempio di Heapify(a,i) Assumiamo che il valore v in posizione i violi la proprietà di heap ovvero, v<a[2i] oppure v<a[2i+1] A[2i] = x A[i]= v A[2i+1] H 1 H 2

14 Esempio di Heapify(a,i) Scambia v in posizione i con la più grande delle radici Supponiamo ad esempio che A[2i] A[2i+1] A[i]= v A[2i] = x A[2i+1] H 1 H 2

15 Esempio di Heapify(a,i) Scambia A[i] con A[2i] A[2i]=v A[i]= x A[2i+1] H 1 H 2

16 Esempio di Heapify(A,i) Applica ricorsivamente la procedura Heapify sul sottoalbero la cui radice è stata scambiata In questo caso al sottoalbero di radice 2i, ovvero Heapify(A,2i) A[i]= x Heapify(A,2i) A[2i+1] H 1 H 2

17 Pseudocodice max-heapify max-heapify (A,i) l = left(i) //indirizzo sottoalbero sinistro r = right(i) //indirizzo sottoalbero destro if (l A.heapsize and A[l]>A[i]) // A.heap-size il numero di elementi dello heap then max = l else max = i if (r A.heapsize and A[r]>A[max]) then max = r if max i then swap(a, i, max) max-heapify (A, max)

18 Procedura build-max-heap() Principio generale Sia A[1..N] un array da ordinare I nodi A[ N/2 +1..N] sono foglie dell'albero e quindi heap di un elemento da cui iniziare La procedura build-max-heap() attraversa i restanti nodi dell'albero ed esegue max-heapify() build-max-heap(a) A.heapsize <-A.length //A.lenght numero elementi array for(i=a.length/2; i>=1; i--) max-heapify(a, i);

19 Heapsort con max heap Mettiamo l elemento più grande, che è il primo dell array, in fondo alla parte di array da ordinare, lo heap Lo heap si decrementa di 1, Chiama max-heapify( ) su n -1 elementi, per ricostruire un max heap heapsort (A, n) // array di n elementi build-max-heap(a) for (i=n; n>=2; i--) swap(a, 1, i) A.heapsize <- A.heapsize-1 max-heapify(a, 1)

20 esempio

21 Animazione Heapsort Animazione del heapsort da Wikipedia

22 Complessità di heapsort Max-heapify, è invocato n volte ed ogni sua chiamata, nel caso medio, è O(log n) Build-Max-Heap è O(n) Heapsort è quindi O(nlog n) è in place

23 Heap per gestire code Code di priorità Esempio: sistema operativo multitasking, in cui i job in esecuzione hanno diverse priorità Nello heap si memorizzano insiemi di oggetti a cui è associata una priorità Con la procedura max-heap si restituisce l elemento di priorità maggiore Implementazione: max-heap

24 Operazioni su Code di Max Priorità insert(s, x) inserisce l'elemento x nella coda maximum(s) restituisce l'elemento in S con priorità più alta extract-max(s): rimuove e restituisce l'elemento in S con priorità più alta increase-priority(s, x, k): aumenta la priorità di x al nuovo valore k, dove k>x.p

25 Sommario Heap: albero binario completo che soddisfa la heap property Due implementazioni Alberi binari Array Tre procedure principali (per max o min) Max-heapify: mantiene la proprietà di max-heap Build-Max-Heap: costruisce un max-heap da zero Heapsort: ordina un array sul posto Code di priorità Memorizzano insiemi di oggetti con una priorità Implementate tipicamente con una max-heap

26 Altri metodi di sorting È possibile fare sorting senza usare confronti? Se sì, è possibile migliorare la complessità? Abbiamo il limite inferiore teorico Ω(n log n) sugli algoritmi per confronto. Ma se non facciamo confronti, il limite teorico non si applica. Si applica comunque Ω(n). È possibile avere algoritmi Θ(n)?

27 Counting sort Ipotesi fondamentale: i valori da ordinare sono numeri naturali compresi tra 0 e una certa costante k Idea di base: se nell'array ci sono m e valori piu piccoli di un certo elemento e (il cui valore è v e ) nell'array ordinato l'elemento e sarà in posizione m e +1 quindi, basta contare quante "copie" dello stesso valore v e sono contenute nell'array usiamo questa informazione per determinare, per ogni elemento e (con 0 v e k), quanti elementi ci sono più piccoli di e dobbiamo tenere conto del fatto che nell'array ci possono essere elementi ripetuti

28 Algoritmo counting sort facciamo una scansione di A e riempiamo il vettore B, lungo k, del numero di occorrenze del valore A(i) per tutti gli n elementi di A. Poi scandiamo B per ogni i (da 1 a k), e scriviamo il valore i nel vettore A per B(i) volte.

29 Counting sort pseudocodice COUNTING-SORT (A[ ], k, n) //k è il massimo dei valori di A j <-1 crea B [1 k] //B conterrà gli elemeni contati for i <- 0 to k do B[i] := 0 // inizializza B for i := 1 to n do B[A[i]] := B[A[i]] + 1 //B[i] ora contiene il numero di elementi uguali a i for i := 1 to k do while B[i] >0 do A[j] <-i j<-j+1 B[i] := B[i] - 1

30 Esempio di counting sort A= [ ] ha lunghezza 8 B ha pure lunghezza 8 Counting-sort (A, 5, 8) Dopo il secondo for B contiene in ogni posizione il numero di volte che un valore da 0 a k compare in A B= [ ] Alla fine A = [ ]

31 Complessità di counting sort La procedura scandisce un vettore lungo n ed un vettore lungo k, quindi il tempo è O(n+k) La complessità è data dai cicli for (k volte uno, n volte l altro) e dal ciclo while eseguito k volte Se k è O(n), la complessità è O(n), cioè è lineare O(n) non è in contrasto con il limite inferiore Ω(n log(n)) sul numero dei confronti. Infatti counting sort non effettua confronti fra gli elementi di A. Counting sort ha complessità inferiore sia a mergesort che a heap-sort perché fa assunzioni sui valori da ordinare.

32 Ordinare per distribuzione Come si fa a ordinare un mazzo di carte? per prima cosa si separano cuori, fiori, quadri e picche, e per fare questo non si opera alcun confronto. I confronti entrano in gioco per ordinare tra loro carte dello stesso seme. utilizzando insertion sort e' possibile ordinare "per distribuzione". Vediamo radix sort

33 Ordinare per distribuzione L algoritmo: distribuisco le carte secondo il loro valore indipendentemente dal seme, in 13 pacchetti diversi e ordinati tra loro. Il pacchetto dei 2 segue quello degli assi e precede quello dei 3. Poi raccolgo i pacchetti mantenedo il loro ordine. Poi distribuisco le carte cosi' raccolte in base al seme, in 4 pacchetti diversi e ordinati tra loro. Poi raccolgo i pacchetti nel loro ordine: il mazzo risulta ordinato. Note: Per ottenere il mazzo ordinato devo distribuire prima in base alla cifra piu leggera (il numero), poi in base a quella piu pesante (il seme).

34 RADIX sort Abbiamo valori numerici da ordinare RADIX sort esegue gli ordinamenti per posizione delle cifre, partendo dalla cifra meno significativa. É stato usato per ordinare le schede perforate. Ora è usato per ordinare record di informazioni con più campi chiave.

35 Esempio su decimali 1 passo 2 passo 3 passo 4 passo risultato

36 RADIX SORT (Distribution Sort) radixsort (A, d) // A array di n elementi, d cifra di ordine più alto for i <- 1 to d do usa un ordinamento stabile pe ordinare A sulla cifra i

37 RADIXSORT: complessita Il tempo di esecuzione dipende dall algoritmo stabile che si utilizza Se ogni numero si trova fra 0 e k-1, e k non è troppo grande, counting sort è migliore. Ogni passagio su n numeri di d cifre richiede un tempo Θ(n+k); poichè ci sono d passate, il tempo di radix sort è Θ(d (n+k)) Se d è costante e k = O(n) radix sort è eseguito in tempo lineare. Radix sort è da preferire ad un algoritmo basato su confronti, come Quicksort? In realtà le costanti nascoste nella notazione asintotica contano. Radix sort ha meno passi ma più pesanti, Inoltre non è detto che ordini sul posto (dipende dall algoritmo scelto).

38 Altro metodo di distribuzione Bucket sort se l'intervallo dei valori da ordinare è noto a priori, è diviso in intervalli più piccoli, detti bucket (cesto). Ciascun valore dell array è quindi inserito nel bucket a cui appartiene, i valori all'interno di ogni bucket vengono ordinati l'algoritmo si conclude con la concatenazione dei valori contenuti nei bucket.

39 Bucket sort BucketSort(A, n) //A array di n elementi, ognuno fra 0 e 1 for i 1 to length[a] do inserisci A[i] nella lista B(n(A[i]) //B array ausiliario di liste concatenate dei bucket for i 1 to n-1 do ordina(b[i]) con insertion sort return concatena(b[0], B[1],..B[n-1]) // restituisce la concatenazione dei bucket

40 esempio (a) l array (b) l array di liste concatenate dopo il secondo ciclo for

41 Bucket sort - complessità La complessità del bucket sort è O(n) per tutti i cicli, a parte l'ordinamento dei singoli bucket. Resta da valutare il tempo dovuto alle chiamate di insertion sort nel secondo for Considerando la variabile casuale n i che è il numero di elementi del bucket B[i], poiché insertion sort è quadratico abbiamo T(n) = Θ(n) + Σ O(n i2 ) Si dimostra che questa equazione vale Θ(n) + n O( 2-1/n) = Θ(n) Quindi il tempo di esecuzione è lineare

42 RankSort e sorting parallelo Strategia dell algoritmo di Rank Sort: Conta il numero di elementi minori di a nell array Hai quindi la posizione di a nell array ordinata Ripeti per tutti gli elementi dell array Complessità risulta n*(n-1), O(n 2 ).

43 RankSort Versione sequenziale void ranksort(int a[],int sorted[], int n) { /* works well only if there are no repetitions of the numbers in the array */ for (int i=0; i<n; i+=1) { int rank = 0; for (int j=0; j<n; j+=1) if (a[i] > a[j]) rank += 1; sorted[rank] = a[i]; } }

44 RankSort - parallelo utilizzando n processori: void ranksort(int a[],int sorted[], int n) { /* works well only if no repetitions */ forall (int i=0; i<n; i+=1) { /* l istruzione parallela forall distribuisce * l esecuzione su n processori */ int rank = 0; for (int j=0; j<n; j+=1) if (a[i] > a[j]) rank += 1; sorted[rank] = a[i]; } } Complessità parallela O(n)

45 Sorting esterno Grandi quantità di dati i dati si trovano su un file ad accesso sequenziale Occorrono 3 files su cui distribuire le sottosequenze durante l ordinamento fusione diretta (ispirato a mergesort) si divide la sequenza a da ordinare in due meta, b e c; si fa il merging fra b e c combinando gli elementi semplici in coppie ordinate; si chiama questa sequenza a e si ricomincia facendo il merging delle coppie per ottenere gruppi di 4, e cosi via fino ad ordinare l intera sequenza.

46 Esempio Sorting per fusione diretta a = volta b = c = a = volta b = c = a = volta b = c = a =

47 Pseudocodice fusione diretta Ordinaperfusione su<-t p<-1 repeat if su then i<-1, j<-n, k<-n+1,l<-2*n else k<-1, l<-n, i<-n+1,j<-2*n fondi sequenze i e j in k Copia coda di i in k Copia coda j in k su <- not su p <- 2*p until p = n

48 Complessità fusione diretta La lunghezza p della sequenza ordinata viene raddoppiato ad ogni passata Ordinamento termina se p n Servono log(n) passate Il numero totale di spostamenti è n log(n)

49 Alcuni confronti

50 Heapsort vs quicksort

51 riassunto Nome Migliore Medio Peggiore Memoria Stabile In place Bubble sort O(n) O(n 2 ) O(n 2 ) O(1) Sì Sì Bucket sort O(n+m) O(n+m) O(n+m) O(m) Si No Counting sort O(n+k) O(n+k) O(n+k) O(n+k) Sì No Heap sort O(nlog n) O(nlog n) O(nlog n) O(1) No Sì Insertion sort O(n) O(n + d) O(n 2 ) O(1) No Sì Merge sort O(nlog n) O(nlog n) O(nlog n) O(n) Sì No Quicksort O(nlog n) O(nlog n) O(n 2 ) O(log n) No Sì Radix sort O(n k/s) O(n k/s) O(n k/s) O(n) Sì Selection sort O(n 2 ) O(n 2 ) O(n 2 ) O(1) No Sì Shell sort O(n 1.5 ) O(1) No Sì Stupid sort O(1) O(n n!) illimitato O(1) No Sì

52 Esercizi da fare su heap Considerare i seguenti valori memorizzati in un vettore, Rappresenta una heap? (motivare opportunamente la risposta) Implementare una coda FIFO utilizzando un heap.