Dallo heap per la coda con priorità a un nuovo algoritmo di ordinamento. Algoritmi e Laboratorio a.a Lezioni

Transcript

1 Università di Torino Facoltà di Scienze MFN Corso di Studi in Informatica Curriculum SR (Sistemi e Reti) Algoritmi e Laboratorio a.a Lezioni prof. Elio Giovannetti Parte 21 Heapsort versione 2/2/27 Quest' opera è pubblicata sotto una Licenza Creative Commons Attribution-NonCommercial-ShareAlike 2.5. Dallo per la coda con priorità a un nuovo algoritmo di ordinamento. Partiamo dal Selection sort (ordinamento per estrazione successiva del minimo), pessimo perché quadratico, e modifichiamolo come segue. Prima di iniziare il ciclo di estrazioni successive del minimo, trasformiamo l'array in uno, attraverso n inserimenti: ciascuno di essi ha complessità log i, con i che varia da 1 a n: log 1 + log log n < n log n Poi operiamo le estrazioni successive del minimo usando l'algoritmo di estrazione del minimo dello : abbiamo n estrazioni, con i che varia da n a 1, quindi di nuovo: log n log 2 + log 1 < n log n La complessità nel caso peggiore è quindi 2 n log n T worst (n) = Θ(n log n): è un algoritmo ottimale! 2/2/ E. Giovannetti - AlgELab Lez.2 I due cicli dell'algoritmo 1. Lo può essere costruito sullo stesso array da ordinare: ancora da esaminare Alla fine del ciclo l'intero array è diventato uno. 2. Ricorda: quando si estrae il minimo, lo si accorcia "dal fondo". Gli elementi successivamente estratti dallo possono perciò essere messi nello stesso array contenente lo, a partire dal fondo: ancora da svuotare parte già ordinata Estraendo ripetutamente il minimo e inserendolo nell'array a partire dal fondo si ottiene però l'ordine inverso. Come si può realizzare l'ordinamento solito? 2/2/ E. Giovannetti - AlgELab Lez.21 3 Ordinamento tramite (sort): soluzione. Basta usare uno a massimo invece di uno a minimo! In modo del tutto analogo a quanto illustrato nella slide precedente: 1. prima si trasforma, mediante inserimenti successivi, l'array in uno -a-massimo; 2. poi da esso si fanno successive estrazioni del massimo ognuna in tempo logaritmico, e i valori estratti vanno via via a riempire la parte di array liberata dallo, a partire dal fondo. Così l'ordine risultante è quello "giusto". 2/2/ E. Giovannetti - AlgELab Lez.21 4 Heapsort: caratteristiche. Complessità temporale del caso peggiore: Θ(n log n); non ha, come il quicksort, un caso peggiore quadratico, bensì è ottimale in ogni caso, come il mergesort. È un algoritmo che "lavora sul posto" (in place) cioè che, a differenza del mergesort, non ha bisogno di un array ausiliario della stessa dimensione dell'input. Inoltre, a differenza del quicksort, è un algoritmo iterativo, quindi il suo stack occupa solamente uno spazio massimo costante. Pertanto: Complessità spaziale (in ogni caso): Θ(1) Lo sort è dunque, dal punto di vista asintotico, l'algoritmo di ordinamento migliore fra quelli esaminati. Tuttavia nella maggior parte delle situazioni l'algoritmo di ordinamento più veloce, in media, risulta essere il quicksort! 2/2/ E. Giovannetti - AlgELab Lez.21 5 Heap in un array a partire dall'indice. Nota: Volendo usare lo per realizzare un algoritmo di ordinamento, lo stesso deve partire dall'indice invece che dall'indice 1. Il calcolo degl'indici del genitore e dei figli di un nodo deve essere cambiato di conseguenza: left(i) = 2i+1 right(i) = 2i+2 parent(i) = (i-1)/ /2/ E. Giovannetti - AlgELab Lez

2 Heap a massimo di elementi interi. realizzato in modo tradizionale non a oggetti. Inserimento. static void addtoheap(int newelem, int[], int lastindex) { aggiunge un nuovo elemento allo -in-array, parzialmente riempito con numero di elementi indiciati da a lastindex; Nota In tutte le procedure seguenti potrebbe essere conveniente usare come parametro la dimensione invece dell'indice dell'ultimo elemento; si è preferita la prima soluzione per ragioni didattiche di comprensibilità del programma. poiché useremo lo solo per realizzare l'ordinamento, l'indice dell'ultimo elemento (o, equivalentemente, la dimensione) non viene mantenuto in un campo o in una variabile: sarà il programma utilizzatore stesso che dovrà "conoscerlo" ad ogni istante; ad esempio, dopo aver fatto k inserimenti a partire dallo vuoto, si sa che la dimensione dello è k, e quindi l'indice dell'ultimo elemento è k-1; ecc. 2/2/ E. Giovannetti - AlgELab Lez /2/ E. Giovannetti - AlgELab Lez.21 8 Inserimento (addtoheap) int i = lastindex+1; la posizione iniziale del posto vuoto è alla prima cella libera (si crea virtualmente una nuova foglia al fondo dell'albero) int j; sarà l'indice del genitore del posto vuoto; while(i > && [j = (i-1)/2] < newelem) { il posto vuoto non è la radice e il suo genitore è minore dell'elemento da inserire; allora: [i] = [j]; faccio scendere il genitore nel posto vuoto i = j; faccio salire il posto vuoto (cioè sposto il suo indice uguagliandolo a quello del genitore) all'uscita dal while il posto vuoto o è la radice oppure il suo genitore è maggiore o uguale del valore da inserire; è quindi il posto giusto per effettuare l'inserimento: [i] = newelement; 2/2/ E. Giovannetti - AlgELab Lez.21 9 Estrazione del massimo static int extractmax(int[], int lastindex) { int max = []; estrae il massimo [] = [lastindex]; mette nella radice il valore dell'ultima foglia lastindex--; taglia la foglia movedown(,, lastindex); fa scendere al posto giusto la radice (il nodo di indice ) return max; 2/2/ E. Giovannetti - AlgELab Lez.21 1 Procedura movedown o fixheap Nell'algoritmo di ordinamento evidentemente non si vuole creare un oggetto separato di una classe PriorityQueue, ma realizzare lo direttamente nell'array da ordinare. Occorre quindi modificare il metodo movedown, facendolo diventare statico. L'array degli elementi e l'indice dell'ultimo elemento, che erano campi della classe PriorityQueue, diventano quindi parametri espliciti del metodo. Il parametro i è, come nella versione originale, l'indice della radice del sotto- da aggiustare (cioè del nodo da far scendere). static void movedown(int[], int i, int lastindex) Procedura fixheap o movedown i, inizialmente indice del nodo da far scendere, è poi l'indice del "posto vuoto" che viene via via fatto scendere; int node = [i];valore nodo iniziale da far scendere; int ichild; indice del maggiore dei figli del nodo di indice i i 8 ichild 6 5 2/2/ E. Giovannetti - AlgELab Lez /2/ E. Giovannetti - AlgELab Lez

3 Procedura fixheap o movedown while((ichild = 2*i+1) <= lastindex) { il posto vuoto ha almeno un figlio (il sinistro) j = ichild + 1; if(j <= lastindex && [j] > [ichild]) se ha anche il figlio destro, ed esso è maggiore del sinistro: ichild++; allora il più grande dei figli è il destro; in ogni caso ichild è l'indice del maggiore dei figli if(node < [ichild]) { se il valore da far scendere è minore almeno del maggiore dei figli [i] = [ichild]; i = ichild; faccio salire tale figlio scambiandolo con il posto vuoto else break; se il valore è maggiore di entrambi i figli, posto ok il posto vuoto o non ha figli, o ha figli tutti minori del valore [i] = node; 2/2/ E. Giovannetti - AlgELab Lez Procedura di ordinamento (sort) Esercizio 1. Si scriva per esercizio la procedura di ordinamento public static void sort(int[] a) richiamando le procedure addtoheap e extractmax in due rispettivi cicli for. Primo ciclo for: Secondo ciclo for: ancora da svuotare ancora da esaminare parte già ordinata 2/2/ E. Giovannetti - AlgELab Lez Raffinamento. L'array può essere trasformato in uno, invece che per mezzo di n inserimenti successivi (tempo totale Θ(n log n)), applicando ripetutamente movedown ai nodi a partire dal basso (vedremo che ciò richiede solo un tempo Θ(n)). Infatti: un albero costituito da una foglia è uno ; un albero quasi completo i cui sottoalberi sinistro e destro sono degli (e in cui quindi solo la radice può essere "fuori posto") diventa uno se si applica movedown alla sua radice: void trasformainheap(subarray) { if(subarray non è vuoto e non è una foglia) { trasformainheap(left(subarray)); trasformainheap(right(subarray)); movedown nel subarray la radice del subarray Raffinamento (continua) Con l'utilizzo dell'algoritmo lineare (vedi dimostrazione più avanti) di trasformazione diretta dell'array in, la complessità asintotica non cambia, perché il ciclo di estrazioni successive del massimo rimane n log n, e si ha quindi: T(n) = n + n log n = Θ(n log n) Tale tempo è tuttavia migliore di quello della versione iniziale, espresso da 2 n log n. 2/2/ E. Giovannetti - AlgELab Lez /2/ E. Giovannetti - AlgELab Lez Realizzazione della procedura trasformainheap (in inglese ify, cioè "ifica") static void ify(int[] a, int i) { int lastindex = a.length - 1; int j; if((j = 2*i+1) <= lastindex) { se la radice del sottoalbero ha almeno il figlio sinistro ify(a,j); ifica il figlio sinistro ify(a,j+1); ifica il figlio destro movedown(a,i,lastindex); fa scendere la radice Nota: se il figlio destro è inesistente, esso non ha a sua volta figli, quindi la procedura invocata su di esso ritorna senza errori e senza fare nulla (come nel caso di una foglia). 2/2/ E. Giovannetti - AlgELab Lez Le foglie sono già banalmente degli. indice /2/ E. Giovannetti - AlgELab Lez

4 Allora basta ificare dapprima tutti i sottoalberi di loro volta ificare; di radice di indice ). Allora basta ificare dapprima tutti i sottoalberi di loro volta ificare; di radice di indice ) /2/ E. Giovannetti - AlgELab Lez /2/ E. Giovannetti - AlgELab Lez.2 Allora basta ificare dapprima tutti i sottoalberi di loro volta ificare; di radice di indice ) /2/ E. Giovannetti - AlgELab Lez.21 Basta cioè ificare su tutti i nodi percorrendo l'albero per livelli dal basso verso l'alto, a partire dal primo nodo non-foglia, cioè dal genitore dell'ultima foglia: static void ify(int[] a) { int lastindex = a.length - 1; for(int j = (lastindex-1)/2; j >= ; j--) movedown(a,j,lastindex); Nota: (lastindex-1)/2 è l'indice del genitore dell'ultima foglia, cioè l'indice dell'ultimo nodo interno. Iniziando da esso e andando all'indietro, si esegue movedown su tutti i nodi interni. Si vede facilmente che la procedura iterativa e quella ricorsiva eseguono esattamente le stesse chiamate di movedown; esse hanno quindi la stessa complessità temporale, ma naturalmente la procedura iterativa è più efficiente e ha bisogno solo di uno spazio costante. 2/2/ E. Giovannetti - AlgELab Lez.22 Calcolo della complessità di ify Il tempo di esecuzione ify è la somma dei tempi di tutte le esecuzioni di movedown, quindi è la somma di tutte le altezze dei sottoalberi non-foglie (nel caso peggiore). Assumiamo per semplicità che l'albero sia completo: Quanti sono gli alberi di altezza 1 (radici arancioni)? Sono n foglie /2. 2/2/ E. Giovannetti - AlgELab Lez.23 Calcolo della complessità di ify Quanti sono gli alberi di altezza 2 (radici viola)? Sono n foglie /2 2. La somma delle altezze è quindi 2 n foglie /2 2. Quanti sono gli alberi di altezza 3? Sono n foglie /2 3. La somma delle loro altezze è 3 n foglie /2 3. Quanti sono gli alberi di altezza h? Sono n foglie /2 h. La somma delle loro altezze è h n foglie /2 h. La somma delle altezze dei sottoalberi non-foglie è quindi: n foglie /2 + 2 n foglie / n foglie / h n foglie /2 h k n foglie /2 k = n foglie (1/2 + 2/ / k/2 k ) con n foglie = 2 k Ma è 1/2 + 2/ / k/2 k < 2 (vedi slide seguente) Quindi T worst (n) < 2n foglie =Θ(n) (vedi slide seguente) Abbiamo dimostrato che ify ha complessità lineare. 2/2/ E. Giovannetti - AlgELab Lez.24 4

5 Calcolo della complessità di ify Dimostrazione di 1/2 + 2/ / k/2 k < 2 : Osservazione preliminare: 1/2 + 1/ / = (,111...) binario < 1 Allora: 1/2 + 2/ / k/2 k = 1/2 + 1/ / /2 k < 1 + 1/2+ 1/ / /2 k < 1-1/2 = 1/2 + 1/2 + 1/ / /2 k < 1 1/2 1/2 2 = 1/ /2 + 1/ / /2 k <... ma 1 + 1/2 + 1/ / /2 k < = 2 Dimostrazione di 2n foglie = O(n): Ricorda che il numero dei nodi di un albero completo è n = k = 2 k+1 1 = 2n foglie 1 Quindi 2n foglie = n 1 = Θ(n). 2/2/ E. Giovannetti - AlgELab Lez.25 Altro calcolo della complessità di ify (solo da leggere). Ricaviamo le equazioni di ricorrenza: T(1) = 1 T(n) = 2T(n/2) + T fixheap = 2T(n/2) + log n per n > 1 2 Usiamo, come al solito, il metodo delle successive espansioni, assumendo n = 2 k : T(m) = 2T(m/2) + log 2 m T(n) = = 2T(n/2) + log n 2 = 2(2T(n/2 2 ) + log (n/2)) + log 2 2 n = 2 2 T(n/2 2 ) + 2 log 2 (n/2) + log 2 n = 2 2 (2T(n/2 3 ) + log (n/2 2 2 )) + 2 log (n/2) + log 2 2 n = 2 3 T(n/2 3 ) log (n/2 2 2 ) + 2 log (n/2) + log 2 2 n =... = 2 k T(1) log (n/2 3 2 ) log (n/2 2 2 ) + 2 log (n/2) + log 2 2 n = n log (n/2 3 2 ) log (n/2 2 2 ) + 2 log (n/2) + log 2 2 n 2/2/ E. Giovannetti - AlgELab Lez.26 Altro calcolo della complessità di ify (continua) n + 2 k-1 log 2 (n/2k- 1 ) log 2 (n/2 2 ) + 2 log 2 (n/2) + log 2 n = n + 2 k-1 log 2 (2) + 2k-2 log 2 (2 2 ) + 2 k-3 log 2 (2 3 ) log 2 (2 k ) = n + 2 k k k k = n + n(1/2 + 2/ / k/2 k ) < n + n 2 = 3n = Θ(n) perché 1/2 + 2/ / k/2 k < 2 (vedi slide precedente)... ma 1 + 1/2 + 1/ / /2 k 2 (osserva: 1/2 + 1/ / = (, ) binario 1 ) binario Riassunto sort. È per selezione successiva del massimo, analogo al pessimo selection sort, ma usa uno -a-massimo (brevemente max-) perché da esso si estrae il massimo in modo più efficiente (logaritmico). Trasforma l'array in uno "partendo dal basso" tramite la procedura ify che usa ripetutamente movedown. Estrae ripetutamente il massimo dallo, usando ogni volta la procedura movedown per riaggiustare lo. Attenzione ai nomi: non confondere fixheap, che è un altro nome di movedown, con ify! Per aumentare la confusione, alcuni testi scambiano i nomi! 2/2/ E. Giovannetti - AlgELab Lez.27 2/2/ E. Giovannetti - AlgELab Lez.28 Esercizio 2 Definire la versione migliorata di Sort utilizzando la procedura ify illustrata nelle slides precedenti. Definire una classe contenente un main di prova che permetta di provare lo sort e di confrontarne i tempi con quelli del quicksort. 2/2/ E. Giovannetti - AlgELab Lez.29 5