Tony Hoare: inventore del Quicksort.

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 9 Il Quicksort versione 10/01/2007 Quest' opera è pubblicata sotto una Licenza Creative Commons Attribution-NonCommercial-ShareAlike 2.5. Il quicksort: l'algoritmo di ordinamento più usato nel mondo. Tony Hoare: inventore del Quicksort E. Giovannetti - AlgELab Lez

2 Tony Hoare's interest in computing was awakened in the early fifties, when he studied philosophy (together with Latin and Greek) at Oxford University, under the tutelage of John Lucas. He was fascinated by the power of mathematical logic as an explanation of the apparent certainty of mathematical truth. During his National Service ( ), he studied Russian in the Royal Navy. Then he took a qualification in statistics (and incidentally) a course in programming given by Leslie Fox). In 1959, as a graduate student at Moscow State University, he studied the machine translation of languages (together with probability theory, in the school of Kolmogorov). To assist in efficient look-up of words in a dictionary, he discovered the well-known sorting algorithm Quicksort E. Giovannetti - AlgELab Lez.09 3 Il quicksort L'idea. Una possibile definizione induttiva di sequenza ordinata: una sequenza vuota o di un solo elemento è ordinata; una sequenza: u 1, u 2,..., u k, p, v 1, v 2,..., v h tale che: tutti gli u 1, u 2,..., u k sono minori di p; tutti gli v 1, v 2,..., v h sono maggiori o uguali a p; u 1, u 2,..., u k è ordinata; v 1, v 2,..., v k è ordinata; è una sequenza ordinata. Da questa definizione di che cosa è una sequenza ordinata si ricava immediatamente un algoritmo per trasformare una sequenza qualunque in una sequenza ordinata, cioè un algoritmo di ordinamento E. Giovannetti - AlgELab Lez

3 Quicksort: schema astratto dell'algoritmo void qsort(sequenza S) { if (lunghezza di S > 1) { togli un elemento p da S; ripartisci tutti gli altri elementi di S in due parti: una sequenza S1 contenente tutti gli elem. < p; una sequenza S2 contenente tutti gli elem. p; forma la sequenza S1 p S2; qsort(s1); qsort(s2); } } l'elemento p è detto pivot o perno della partizione E. Giovannetti - AlgELab Lez.09 5 Nota Bene Poiché viene "tolto" un elemento dalla (sotto-)sequenza S prima di farne la partizione, la lunghezza di S1 e la lunghezza di S2 sono certamente entrambe minori della lunghezza di S, anche nel caso in cui una delle due parti risulti vuota: lunghezza(s1) < lunghezza(s) lunghezza(s2) < lunghezza(s) Se così non fosse, si potrebbe avere una chiamata ricorsiva su una sottosequenza S1 (o S2) della stessa lunghezza di S e in tal caso la procedura in generale non terminerebbe E. Giovannetti - AlgELab Lez

4 Una versione leggermente diversa Una possibile definizione induttiva di sequenza ordinata: una sequenza vuota o di un solo elemento è ordinata; una sequenza: u 1, u 2,..., u k, v 1, v 2,..., v h tale che: sia p un elemento appartenente alla sequenza; tutti gli u 1, u 2,..., u k sono minori o uguali a p; tutti gli v 1, v 2,..., v h sono maggiori o uguali a p; u 1, u 2,..., u k è ordinata; v 1, v 2,..., v k è ordinata; è una sequenza ordinata. Anche da questa definizione si ricava subito un algoritmo di ordinamento, lievemente diverso dal precedente. A differenza di prima, gli eventuali elementi uguali al pivot non stanno necessariamente tutti da una parte, ma possono trovarsi da entrambi i lati del pivot E. Giovannetti - AlgELab Lez.09 7 Quicksort: schema astratto dell'algoritmo vers. 2 void qsort(sequenza S) { if (lunghezza di S > 1) { scegli un elemento p in S; ripartisci tutti gli elementi di S in due sequenze S1 ed S2 tali che: S1 contenga solo elementi p; S2 contenente solo elem. p; e contemporaneamente forma la sequenza S1 S2; qsort(s1); qsort(s2); } } 0.44 E. Giovannetti - AlgELab Lez

5 Osservazione a differenza che nella prima versione, il pivot non viene "tolto" dalla sequenza prima di effettuare la partizione; pertanto, se una delle due parti S1 o S2 risulta vuota, l'altra è lunga quanto l'intera sequenza S; il procedimento con cui si effettua la partizione deve quindi essere tale da garantire che S1 ed S2 risultino in ogni caso non vuote, e quindi entrambe di lunghezza minore della lunghezza di S E. Giovannetti - AlgELab Lez.09 9 Analisi della complessità: introduzione. La partizione in due o tre (o in un numero fisso di) parti può essere effettuata in tempo lineare sia su liste che su array, e senza usare (nel caso di array) array ausiliari (ricorda la bandiera tricolore). Il tempo T(n) necessario per ordinare una sottosequenza di lunghezza n è quindi (per la seconda versione): n tempo necessario per effettuare la partizione; T(r) tempo necessario per ordinare S1, se r è la lunghezza di S1; T(n r) tempo necessario per ordinare S2, la cui lunghezza è ovviamente n-r (con la prima versione si avrebbe n-1 r invece di n-r) Il tempo T(1) o T(0) necessario per ordinare una porzione di lunghezza 1 o 0 è ovviamente costante (non si deve fare nulla), possiamo assumere che sia uno oppure zero: T(1) = T(0) = 1 oppure T(1) = T(0) = E. Giovannetti - AlgELab Lez

6 Analisi della complessità: equazioni di ricorrenza Abbiamo quindi ottenuto: T(1) = T(0) = 0 (oppure 1) T(n) = n + T(r) + T(n r) dove r può essere un valore distinto per ogni distinta chiamata ricorsiva. caso migliore = partizione sempre bilanciata: ad ogni chiamata ricorsiva, le due parti S1 ed S2 risultano sempre di ugual lunghezza fra di loro: T(n) n + T(n/2) + T(n/2) caso peggiore = partizione sempre sbilanciata al massimo: ad ogni chiamata ricorsiva, le due parti S1 ed S2 risultano sempre una di lunghezza 1 e l'altra di lunghezza n-1: T(n) n + T(n 1) + T(1) 0.44 E. Giovannetti - AlgELab Lez cioè: Caso migliore T(1) = 1 T(n) = n + T(n/2) + T(n/2) T(1) = 1 T(n) = 2T(n/2) + n è la stessa equazione del mergesort, studiata nel corso di Programmazione 2, con soluzione: T(n) = Θ(n log n) Come avevamo fatto a trovare la soluzione? (Ri)vediamolo nelle slides seguenti E. Giovannetti - AlgELab Lez

7 Caso migliore: rappresentazione grafica delle eq. di ricorrenza T(1) = 1 T(n) = n T(n/2) T(n/2) 0.44 E. Giovannetti - AlgELab Lez T(n) = n per semplicità sia n = 2 k T(n/2) T(n/2) 0.44 E. Giovannetti - AlgELab Lez

8 T(n) = n per semplicità sia n = 2 k n/2 n/2 T(n/4) T(n/4) T(n/4) T(n/4) 0.44 E. Giovannetti - AlgELab Lez T(n) = n per semplicità sia n = 2 k n/2 n/2 n/4 n/4 n/4 n/4 T(n/8) T(n/8) T(n/8) T(n/8) T(n/8) T(n/8) T(n/8) T(n/8) 0.44 E. Giovannetti - AlgELab Lez

9 livello 0 T(n) = n per semplicità sia n = 2 k 1 n/2 n/2 2 n/4 n/4 n/4 n/4 3 n/8 n/8 n/8 n/8 n/8 n/8 n/8 n/8 livello k T(1) T(1) T(1) T(1) T(1) 0.44 E. Giovannetti - AlgELab Lez livello 0 T(n) = n per semplicità sia n = 2 k 1 somma del livello: n/2 2 1 (n/2 1 ) = n n/2 2 n/4 n/4 2 2 (n/2 2 ) = n n/4 n/4 3 n/8 n/8 2 3 (n/2 3 ) = n n/8 n/8 n/8 n/8 n/8 n/8 livello k E. Giovannetti - AlgELab Lez

10 Abbiamo posto n = 2 k, quindi k = log 2 n. L'albero ha k+1 livelli, da 0 a k; per ciascun livello il tempo complessivo è n. Quindi: T best (n) = (k+1) n = n(1+log 2 n) = Θ(n log n) Assumendo T(1) = 0 invece di T(1) = 1 otteniamo 0 sull'ultimo livello, e quindi: T best (n) = k n = n log 2 n = Θ(n log n) 0.44 E. Giovannetti - AlgELab Lez livello 0 T(n) = n per semplicità sia n = 2 k 1 somma del livello: n/2 2 1 (n/2 1 ) = n n/2 2 n/4 n/4 2 2 (n/2 2 ) = n n/4 n/4 3 n/8 n/8 2 3 (n/2 3 ) = n n/8 n/8 n/8 n/8 n/8 n/8 livello k E. Giovannetti - AlgELab Lez

11 L'albero disegnato nelle slides precedente è l'albero delle chiamate ricorsive, o albero di ricorsione. In esso si vede bene che i due fattori dell'espressione della complessità temporale hanno i seguenti significati: log 2 n è il numero di livelli di ricorsione, cioè il massimo numero di chiamate ricorsive "annidate"; n, numero degli elementi, è il tempo impiegato nel partizionamento complessivamente da tutte le chiamate di uno stesso livello di ricorsione. Nota Bene: Nel quicksort tutto il lavoro dell'algoritmo viene effettuato dal partizionamento, così come nel mergesort veniva effettuato dalla fusione E. Giovannetti - AlgELab Lez Caso migliore: traduciamo il disegno in scrittura. cioè: T(1) = 1 T(n) = n + T(n/2) + T(n/2) T(1) = 1 T(n) = 2T(n/2) + n La seconda equazione vale per qualunque n > 1, allora riscriviamola con n/2 al posto di n (assumendo che n/2 > 1): T(n/2 n/2) ) = 2T((n/2) (n/2)/2) + n/2 cioè T(n/2) = 2T(n/2 2 ) + n/2 Ora per mezzo di essa espandiamo l'equazione originale: T(n) = 2T(n/2) 2 + n = 2( 2T(n/2 2 ) + n/2) ) + n = cioè T(n) = 2 2 T(n/2 2 ) + n + n = 2 2 T(n/2 2 ) + 2n 0.44 E. Giovannetti - AlgELab Lez

12 Continuiamo ad espandere: T(n/2 2 ) = 2T(n/2 3 ) + n/2 2 T(n) = 2 2 T(n/2 2 ) + 2n = 2 2 (2T(n/2 3 ) + n/2 2 ) + 2n = 2 3 T(n/2 3 ) + n + 2n = 2 3 T(n/2 3 ) + 3n... dopo h passi: T(n) = 2 h T(n/2 h ) + hn; se n = 2 k, si ha: T(n) = 2 k T(1) + kn se T(1) = 0 T(n) = nk = n log 2 n 0.44 E. Giovannetti - AlgELab Lez Caso migliore: complessità in spazio. Il quicksort opera la partizione "sul posto", cioè senza bisogno di un array aggiuntivo di lunghezza n (o dipendente da n). Tuttavia, essendo un algoritmo inerentemente ricorsivo, ha bisogno dello spazio per lo stack dei frames relativi alle chiamate ricorsive. Come abbiamo visto, l'altezza dell'albero di ricorsione è la massima profondità di chiamate ricorsive annidate, ed è quindi (proporzionale a) la massima profondità dello stack. Quindi: S best (n) = Θ(log n) 0.44 E. Giovannetti - AlgELab Lez

13 Caso peggiore T(1) = 0 T(n) = n + T(n 1) T(1) = 0 T(n) = n T(n-1) 0.44 E. Giovannetti - AlgELab Lez Espandendo, come nel caso migliore: T(n-1) = n-1 T(n) = n n-1 T(n-2) T(n-2) 0.44 E. Giovannetti - AlgELab Lez

14 Espandendo di nuovo: T(n-2) = n-2 T(n) = n T(n-3) n-1 n-2 T(n-3) 0.44 E. Giovannetti - AlgELab Lez Continuando a espandere: T(n) = n L'albero di ricorsione degenera in una sequenza. T(n) = n + (n 1) + (n 2) = n(n+1)/2 1 = (n 2 + n)/2 1 n-1 n-2 2 T(n) = Θ(n 2 ) T(1) 0.44 E. Giovannetti - AlgELab Lez

15 Caso peggiore: traducendo il disegno in scrittura T(1) = 0 T(n) = n + T(n 1) + T(1) = n + T(n 1) espandiamo: T(n) = n + T(n 1) = = n + (n 1) + T(n 2) = = n + (n 1) + (n 2) + T(n 3) = = n + (n 1) + (n 2) + (n 3) T(1) = = n + (n 1) + (n 2) = = n(n+1)/2 1 T(n) = Θ(n 2 ) 0.44 E. Giovannetti - AlgELab Lez Caso peggiore: nota. Assumendo T(1) = 1 invece di T(1) = 0 il risultato non cambia: T(n) = n T(n 1) T(n) = n (n + T(n 2)) = = (n + 1) + n + (n 1) + T(n 3) = =... = (n + 1) + n + (n 1) = = Θ(n 2 ) 0.44 E. Giovannetti - AlgELab Lez

16 Caso peggiore: complessità in spazio. L'albero di ricorsione degenera in una sequenza di lunghezza n. Perciò: la profondità massima dello stack è (proporzionale a) n. S worst (n) = Θ(n) 0.44 E. Giovannetti - AlgELab Lez Caso peggiore: osservazione. Consideriamo il caso in cui il partizionamento produca sempre due parti di lunghezze k ed n-k, con k fisso; cioè due parti di cui una sempre di lunghezza k (assumiamo che le chiamate ricorsive su porzioni di lunghezza h k producano due parti di lunghezze h-1 e 1). È abbastanza facile vedere che anche in questo caso il comportamento asintotico di T(n) è lo stesso che nel caso peggiore (quadratico). Si ha infatti: T(k) c k 2 = C T(n) = n + T(k) + T(n-k) = n + C + T(n-k) Espandendo nel solito modo si ottiene: 0.44 E. Giovannetti - AlgELab Lez

17 n n-k C L'albero di ricorsione degenera in una quasi-lista di lunghezza proporzionale a n: n/k n-2k C n-3k C E. Giovannetti - AlgELab Lez Caso medio: intuizione In generale la partizione quasi mai sarà perfettamente bilanciata, ma anche quasi mai totalmente sbilanciata. Mediamente ognuna delle due parti della partizione avrà una lunghezza "non troppo lontana" da n/2; possiamo quindi intuire, in modo un po'vago, che il caso medio sia simile al caso migliore. Un esempio abbastanza istruttivo: assumiamo che il partizionamento produca sempre una partizione di 9 a 1 (cioè in cui le due parti siano sempre rispettivamente 1/10 e 9/10 della sequenza da ripartire). È questo un caso che si comporta come il caso peggiore? La risposta nelle prossime slides E. Giovannetti - AlgELab Lez

18 T(n) = Un esempio n Espandiamo l'albero come nei casi precedenti E. Giovannetti - AlgELab Lez Riscrivendo con (1/10)n al posto di n: = 0.44 E. Giovannetti - AlgELab Lez

19 Riscrivendo con (9/10)n al posto di n: = 0.44 E. Giovannetti - AlgELab Lez n 0.44 E. Giovannetti - AlgELab Lez

20 n n 10 h n (10/9) k log 10 n somma del livello: n n n log 10/9 n... livello h n livello k E. Giovannetti - AlgELab Lez Esempio: conclusione n log 10 n T(n) n n log 10/9 quindi T(n) = Θ(n log n) 10/9 n Un partizionamento che produca una partizione sempre sbilanciata di 9 a 1 si comporta asintoticamente come un partizionamente sempre perfettamente bilanciato! Il ragionamento si può ripetere invariato per partizionamento di 99 a 1, 999 a 1, ecc. Insomma ogni partizionamento che produca una ripartizione in una proporzione fissa in tutte le chiamate ricorsive determina un comportamento del quicksort asintoticamente uguale a quello del caso migliore! Ciò rafforza la nostra intuizione che il caso medio si comporti come il caso migliore... Dimostrazione rigorosa in lez E. Giovannetti - AlgELab Lez

21 Riassumendo: T worst (n) = Θ(n 2 ) T best (n) = Θ(n log n T medio (n) =Θ(n log n in place log n) log n) S worst (n) S best (n) S medio (n) = Θ(n) = Θ(log n) n =Θ(log n) n non stabile, perché basato su scambi. (vedremo che la complessità spaziale del caso peggiore e del caso migliore può essere diminuita con un'opportuna ottimizzazione) E. Giovannetti - AlgELab Lez Quicksort L'algoritmo concreto: differenti versioni E. Giovannetti - AlgELab Lez

22 Quicksort su array, versione 1 ("togliendo" il pivot): schema. sia a[inf..sup] la porzione di array da ordinare, con inf< sup: tolgo da essa un elemento, ad esempio il primo; partiziono il resto in due parti: < x e x inf x j < x x sup inserisco x fra le due parti, "spostando indietro di uno" la parte < x, cioè: scambia a[inf] con a[j] inf j x sup ordina a[inf..j-1]; ordina a[j+1..sup] 0.44 E. Giovannetti - AlgELab Lez Il partizionamento inf+1 a: j < x x i sup INVARIANTE a[inf+1.. j] < x a[j+1.. i-1] x i sup+1 j < i Corpo del ciclo (mantiene l'invariante) if(a[i] < x) { j++; scambia(a,i,j); // scambia a[i] con a[j] } i++; Inizializzazione (stabilisce l'invariante) la parte a[inf inf+1.. j] è vuota: j = inf; la parte a[j+1.. i-1] i è vuota: i = inf+1; 0.44 E. Giovannetti - AlgELab Lez

23 L'inserimento del pivot Test C'è ancora qualche elemento da esaminare: while(i sup) Quindi all'uscita dal ciclo è i > sup, quindi i = sup+1 inf j x < x x sup i Ora dobbiamo inserire il pivot fra le due porzioni. Attenzione: potremmo scambiarlo con a[j+1], cioè con il primo dei "gialli"? No, perché in tal modo in a[inf] ci andrebbe un elemento "giallo"; invece a[inf.. j-1] deve essere tutto "dell'altro colore" (cioè < x). Il pivot deve dunque essere scambiato con a[j], come indicato nella slide E. Giovannetti - AlgELab Lez Il partizionamento (continua) Test Osservazione Il ciclo può essere realizzato convenientemente con un for: int x = a[inf]; prende il primo elem. come pivot int j = inf; for(int i = inf+1; i <= sup; i++) { if(a[i] < x) { j++; scambia(a,i,j); } } inserisce il pivot fra le due parti scambia(a,inf,j); "spostando" la prima parte 0.44 E. Giovannetti - AlgELab Lez

24 Attenzione, come al solito, agl'indici! se il ciclo è fatto in modo tale che, all'uscita, j indichi il primo dei maggiori/uguali invece dell'ultimo dei minori: inf x j < x x sup per inserire x, attenzione: scambia a[inf] con a[j-1] inf j-1 x sup ordina a[inf..j-2]; ordina a[j..sup] 0.44 E. Giovannetti - AlgELab Lez Domande Cambia qualcosa se il test è a[i]<=x invece di a[i]<x, cioè se la partizione è fra minori-o-uguali e maggiori invece che fra minori e maggiori-o-uguali? Si realizzi una variante del quicksort del tutto analoga alle precedenti ma che prenda come pivot l'ultimo elemento invece del primo. Qual è o quali sono i casi peggiori nelle realizzazioni precedenti? 0.44 E. Giovannetti - AlgELab Lez

25 Una variante Come sappiamo dal problema della bandiera tricolore, il partizionamento può essere effettuato tenendo la parte da esaminare "in mezzo" invece che in fondo: a: x inf+1 i j < x x sup INVARIANTE a[inf inf+1.. i-1] i < x a[i+1.. sup] x i j+1 j > inf i sup Corpo del ciclo (mantiene l'invariante) if(a[i] < x) i++; else { scambia a[i] con a[j] j--; } 0.44 E. Giovannetti - AlgELab Lez a: x inf+1 i j < x x sup Inizializzazione (stabilisce l'invariante) la parte a[inf inf+1.. i-1] i è vuota: i = inf+1; la parte a[j+1.. sup] è vuota: j = sup; Test C'è ancora qualche elemento da esaminare: i j All'uscita dal ciclo vale quindi l'uguaglianza i = j+1: inf j i x < x x sup 0.44 E. Giovannetti - AlgELab Lez

26 Fine della variante. Come nella versione precedente: inf j i x < x x sup inserisco x fra le due parti, "spostando indietro di uno" la parte < x, cioè: scambia a[inf] con a[j] inf j x sup 0.44 E. Giovannetti - AlgELab Lez Quicksort: "randomizzazione". Nelle versioni precedenti il caso peggiore si verifica quando, ad ogni chiamata ricorsiva, gli elementi della porzione di array considerata sono o tutti minori o tutti maggiori/uguali del pivot. Ciò accade se l'array è già ordinato oppure ordinato al contrario: il che è molto spiacevole! Una buona soluzione consiste nello scegliere ogni volta il pivot a caso: in questo modo nessuna particolare istanza di input si comporta sempre da caso peggiore; l'utilizzatore "maligno" può produrre apposta un caso peggiore soltanto conoscendo l'algoritmo usato per la generazione dei numeri pseudo-casuali E. Giovannetti - AlgELab Lez

27 Generazione di un indice casuale. Vedere nella documentazione delle API la documentazione relativa alla classe Random. Fuori della procedura ricorsiva: Random generatore = new Random(); Nella procedura ricorsiva, per generare un naturale pseudo-casuale nel range [inf.. sup]: int ipivot = inf + generatore.nextint(sup - inf + 1); Si scambia l'elemento-pivot con il primo (o con l'ultimo) e ci si riporta così alla situazione di una delle realizzazioni precedenti, che viene pertanto seguita senza variazioni E. Giovannetti - AlgELab Lez Il pivot scelto come mediana di un certo numero di elementi Il verificarsi del caso peggiore quando l'array è ordinato (o ordinato al contrario) può essere evitato anche senza ricorrere alla randomizzazione: basta scegliere un elemento diverso dal primo e dall'ultimo. Osserva: la partizione è perfettamente bilanciata se il pivot è la mediana della sequenza da partizionare (vedi definizione di mediana nel corso di Probabilità). Non sapendo qual è la vera mediana, si può scegliere come pivot il mediano di un certo numero di elementi: ad es. il mediano di primo, ultimo, ed elemento centrale; oppure il mediano di nove elementi presi ad intervalli regolari. In questo modo il caso peggiore non è più l'array ordinato, ma è comunque una fissata configurazione dell'array, che si comporta sempre da caso peggiore E. Giovannetti - AlgELab Lez

28 Richiamo di Probabilità e Statistica. La mediana di un insieme di valori è un valore (appartenente all'insieme) che "bipartisce" l'insieme; cioè è un valore (appartenente all'insieme) tale che metà degli elementi dell'insieme sono minori o uguali ad esso, e l'altra metà sono maggiori o uguali. La mediana è spesso una nozione statistica più significativa di quella di media: su un campione di 11 persone, di cui 5 guadagnano 2000 euro al mese, 5 guadagnano 3000 euro al mese, e uno guadagna euro al mese: la media è circa 11364, la mediana è La ricchezza media di coloro che hanno pubblicato un articolo scientifico sul quicksort è significativamente più alta di quella dei ricercatori in altri campi, la mediana non lo è (fra gli autori di un articolo sul quicksort vi è un certo William Gates, su Discrete Mathematics, 1979) E. Giovannetti - AlgELab Lez Combinazione dei due meccanismi precedenti. Si può scegliere il mediano di un certo numero di elementi di cui almeno alcuni scelti a caso. Ad esempio, il mediano di tre elementi: primo, ultimo, e un elemento di indice scelto a caso (escludendo primo e ultimo) E. Giovannetti - AlgELab Lez

29 Nota Nelle versioni precedenti alcuni elementi possono essere spostati due volte; ad esempio, se la parte da esaminare è "in mezzo": a: x inf+1 i < x x x x j sup Se a[i] ed a[j] sono entrambi x, il contenuto di a[j] viene prima spostato "a sinistra" (nello scambio con a[i]) e poi al passo successivo riportato "a destra". L'algoritmo mette al posto giusto un solo elemento alla volta (eventualmente spostandone un altro dalla parte sbagliata) E. Giovannetti - AlgELab Lez Quicksort: il problema degli elementi uguali al pivot Nelle versioni viste finora, se nel partizionamento vi sono molti elementi uguali al pivot (anche se scelto a caso) essi finiscono tutti "da una stessa parte", producendo così uno sbilanciamento. Un array di elementi tutti uguali, o quasi tutti uguali, costituirà quindi un caso peggiore, di complessità quadratica, anche con pivot scelto a caso. Per ovviare a tale inconveniente si può adottare una delle seguenti due strategie: originale di Hoare: fare in modo che gli elementi uguali al pivot possano stare da entrambe le parti (non del tutto facile una realizzazione corretta; vedi lez 9.3); tri-partizione: effettuare (adottando l'algoritmo della bandiera) una partizione in tre: minori, uguali, maggiori; le chiamate ricorsive vengono poi eseguite soltanto sulle due parti risp. dei minori e dei maggiori del pivot E. Giovannetti - AlgELab Lez

30 Vantaggi della tripartizione Poiché di elementi uguali al pivot ne esiste almeno uno, cioè il pivot stesso, le altre due parti della partizione sono entrambe sicuramente più corte della porzione partizionata. Poiché le chiamate ricorsive vengono fatte solo sulle parti consistenti di elementi diversi dal pivot, su un array di elementi tutti uguali non viene effettuata nessuna chiamata ricorsiva! Un array di elementi uguali costituisce quindi un molto particolare caso migliore di complessità temporale lineare (il tempo è infatti solo quello necessario alla partizione dell'intero array) e spaziale costante (la profondità dello stack non aumenta con n, bensì è costante): T best best (n) = Θ(n) S best best (n) = Θ(1) 0.44 E. Giovannetti - AlgELab Lez Svantaggi della tripartizione e rimedi. Il test è più complesso e quindi più dispendioso in tempo. Tenere gli elementi uguali al pivot "in mezzo" costringe ad effettuare uno scambio per ogni elemento diverso dal pivot; ma il caso "diverso dal pivot" si presume sia il caso più frequente: quindi si ha maggiore dispendio di tempo. Un rimedio al difetto precedente può essere tentato posizionando la parte degli uguali al pivot a sinistra o a destra invece che in mezzo, spostandola poi in mezzo solo alla fine del partizionamento. Oppure combinando la tripartizione con alcuni aspetti della versione "alla Hoare", come nella versione di Bentley-McIllRoy E. Giovannetti - AlgELab Lez

31 Confronto fra algoritmi e questioni di costanti. Il quicksort è asintoticamente molto più efficiente di algoritmi di ordinamento quadratici come l'insertion sort. Tuttavia la sequenza di operazioni che esso esegue per ciascun elemento dell'array è più complessa e quindi più dispendiosa in tempo. In termini matematici: se i tempi del caso medio rispettiv. per il quicksort e per l'insertion-sort sono T q medio(n) C q n log n + C q 'n + C q '' T i medio(n) C i n 2 + C i 'n + C i '' allora si ha C q > C i, ecc. Per piccoli valori di n (alcune decine) un algoritmo quadratico ma semplice, come l'insertion sort, è più efficiente di un algoritmo pseudolineare ma più complesso, come il quicksort E. Giovannetti - AlgELab Lez Grafici Per n < n 0 è più efficiente l'insertion sort. Si tratta di determinare sperimentalmente n 0. T isort T qsort g(n) n 0 n 0.44 E. Giovannetti - AlgELab Lez

32 Raffinamento del quicksort tramite l'insertion sort. Si confrontano sperimentalmente i tempi di calcolo del quicksort e dell'insertion sort, e si determina in modo approssimato il valore di n 0. All'interno della procedura del quicksort, quando la lunghezza della porzione da ordinare è inferiore a n 0 si esegue l'algoritmo di insertion-sort. In tal modo quando nelle successive chiamate ricorsive si scende sotto la lunghezza critica, l'algoritmo richiama l'insertion sort invece di continuare la ricorsione E. Giovannetti - AlgELab Lez Nota finale Attenzione: è facile sbagliare l'implementazione del quicksort! It is very easy to make errors when programming Quicksort. The basic idea is simple but the details of the manipulation of the "pointers" hi, lo, left, right, are very easily messed up - this is the voice of bitter experience! LLoyd Allison, Monash University 0.44 E. Giovannetti - AlgELab Lez