Quicksort. Quicksort: idea di base. Riprendiamo il problema dell'ordinamento di n oggetti.

Transcript

1 Riprendiamo il problema dell'ordinamento di n oggetti. Quicksort Per questo problema abbiamo già visto gli algoritmi insertion-sort e mergesort. Il tempo di esecuzione di insertion-sort è (n 2 ). Il tempo di esecuzione di mergesort è (n log n), ma mergesort non ordina in loco. 1 2 Studieremo ora l'algoritmo quicksort che, se opportunamente implementato, risulta essere il più veloce algoritmo di ordinamento general purpose. Lo studio del quicksort ci farà imparare delle tecniche algoritmiche molto importanti. Quicksort: idea di base Per ordinare un array: scegli un elemento (detto ) metti a sinistra gli elementi metti a destra gli elementi ordina ricorsivamente la parte destra e la parte sinistra. 3 4 Esempio: dobbiamo ordinare se prendiamo come 19, otteniamo Quicksort Quicksort La ricorsione termina quando dobbiamo ordinare un array di un solo elemento. Rimane da specificare la procedura che usiamo per mettere gli elementi sulla sinistra, e gli elementi sulla destra. Nel seguito indicheremo tale procedura con il nome

2 Partition: idea di base. Facciamo crescere contemporaneamente la regione con gli elementi sulla sinistra, e la regione con gli elementi sulla destra. Esempio. =17 Avanziamo i due puntatori, facendo crescere le due regioni, fino a quando è possibile Quando entrambi i puntatori non possono avanzare scambiamo gli elementi A questo punto i due puntatori possono riprendere ad avanzare È possibile che i due puntatori si fermino nella stessa posizione se essa contiene il. Esempio. Supponiamo che il sia La procedura termina quando i due puntatori si incrociano Nell'implementazione della procedura ci sono due scelte fondamentali da fare: come scegliere il ; come trattare gli elementi uguali al durante la scansione. Nella nostra prima versione prendiamo come il primo elemento dell'array (vedremo che si tratta di una pessima scelta), e fermiamo la scansione quando incontriamo elementi uguali al. Mostriamo ora una prima semplice implementazioni della procedura. La procedura prende in input un array A[ ], e due interi p e r (p<r) e partiziona gli elementi A[p]... A[r]. Viene restituito un intero q tale che gli elementi in A[p]... A[q] sono minori o uguali di quelli in A[q+1]... A[r]

3 int Partition(Item A[], int p, int r) Item t; int i= p-1; int j= r+1; Item x = A[p]; // // Quicksort: ordina A[p]...A[r] (p<=r) void quicksort(item A, int p, int r) int q; if(p<r) while(1) while(a[--j]>x) ; // esce se A[j]<=x q = Partition(A,p,r); while(a[++i]<x) ; // esce se A[i]>=x quicksort(a,p,q); if(i<j) quicksort(a,q+1,r); // scambia A[i] <-> A[j] t=a[i]; A[i]=A[j]; A[j]=t; else break; // per ordinare A[0]...A[n-1] return j; quicksort(a,0,n-1) Prime osservazioni Quicksort ordina in loco La strategia di ordinamento è simile a quella del mergesort: la procedura di fusione (merge) è stata sostituita dal partizionamento. Analisi quicksort Vogliamo ora analizzare il tempo di esecuzione dell'algoritmo quicksort. Trattandosi di un algoritmo di ordinamento basato sui confronti, analizziamo il numero di confronti in funzione della numero n di oggetti da ordinare Osserviamo che: tutti i confronti sono eseguiti nella procedura. quando è eseguita su un sottoarray di lunghezza m vengono eseguiti m confronti (ogni elemento è confrontato una volta con il ). Se l'array da ordinare viene partizionato in due array di dimensione r e n-r abbiamo che il numero di confronti C(n) soddisfa alla ricorrenza: C(n) = 0 se n = 1 C(r)+ C(n-r) + n se n >

4 Questa ricorrenza non è del tipo che si può studiare mediante il teorema principale anche perché il parametro r cambia ad ogni chiamata della procedura! Studieremo il caso peggiore e il caso migliore, e cercheremo di farci un'idea del caso medio. 19 Quicksort: caso peggiore Il caso peggiore si verifica quando ad ogni passo l'array viene partizionato in due regioni di cui una contiene un solo elemento. Abbiamo allora: C(n) = C(n-1) + n = C(n-2) + (n-1) + n = C(1) (n-2) + (n-1) + n = (n 2 ) 20 Sfortunatamente, con la nostra scelta del il caso peggiore si presenta quando l'array è già ordinato (sia in ordine crescente che decrescente). Questo è uno dei motivi per cui è opportuno cambiare la scelta del! Quicksort: caso migliore Il caso migliore si verifica quando ad ogni passo l'array viene partizionato in due regioni uguali. Abbiamo allora: C(n) = 0 se n = 1 2C(n/2) + n se n > 1 21 Per il teorema principale C(n) = (n log n) 22 Ancora una volta il caso peggiore e il caso migliore risultano molto diversi tra loro. Abbiamo ora che C(n) soddisfa alla ricorrenza: È naturale chiedersi se dobbiamo aspettarci più di frequente un tempo (n 2 ) o un tempo (n log n) o qualcosa di intermedio. C(n) = 0 se n = 1 C(n/10) + C(9n/10) + n se n > 1 Per farci un'idea sul caso medio studiamo il caso (altamente improbabile) che la procedura crei sempre due regioni di cui una sia 9 volte più grande dell'altra. 23 Analizzando l'albero di ricorrenza si ottiene che anche in questo caso C(n) = (n log n) 24

5 Esempio albero di ricorrenza, n=1000: Analisi albero di ricorrenza: n/10 n 9n/10 (n) (n) n/100 9n/100 9n/100 81n/100 (n) Per scendere di un livello nell'albero di ricorrenza si paga un costo pari alla somma delle dimensioni dei problemi cioè (n) Dopo log 10 n livelli alcuni sottoproblemi raggiungono dimensione 1 e non sono più suddivisi. Dopo log 9/10 n livelli tutti i sottoproblemi hanno raggiunto dimensione 1 e sono stati risolti direttamente. Il costo totale è dato dal costo di ogni livello per il numero dei livelli quindi risulta (n log 9/10 n) cioè (n log n). Studiamo ora il caso in cui si alternano una partizione cattiva e una buona. Nei livelli dispari il problema viene spezzato in [1,n-1], nei livelli pari in [n/2,n/2]. Possiamo ripetere l'analisi sull'albero di ricorrenza Esempio: albero di ricorrenza n=103 Analisi albero di ricorrenza: n n-1 (n) (n-1) (n-1)/2 (n-1)/2 (n-1) Per scendere di un livello nell'albero di ricorrenza si paga un costo che è sempre al più (n) L'altezza dell'albero è 2log n quindi il costo complessivo è (n log n). 30

6 Riassumendo. Se le partizioni sono spesso molto sbilanciate, il costo può risultare molto alto. Se le partizioni non sono troppo sbilanciate si ha un costo (n log n) cioè asintoticamente uguale al caso ottimo. Un simile comportamento si ha anche per altri algoritmi ricorsivi che suddividono un problema in sottoproblemi di dimensione non necessariamente uguale. Bilanciare il lavoro solitamente riduce il costo complessivo dell'algoritmo Introduciamo il Quicksort perché: Test di autovalutazione A. Ha una complessità asintotica minore rispetto al mergesort. B. A differenza del mergesort nel caso migliore ha un costo (n). C. Non necessita di memoria ausiliaria Il Quicksort: La procedura : A. È un algoritmo ricorsivo, ma non è basato sul divide et impera. B. È basato sul divide et impera e quindi ha un costo (n log n). C. Ha un costo (n log n) sono quando divide l array in parti uguali. A. Garantisce che ogni partizione contenga almeno n/10 elementi. B. È una procedura ricorsiva. C. Divide l array in parti uguali quando l'array è già ordinato

7 La procedura (2): A. Deve evitare di creare una partizione con un solo elemento altrimenti Quicksort non termina. B. Deve evitare di creare una partizione con zero elementi altrimenti Quicksort non termina. C. Deve evitare di accedere ad elementi al di fuori di A[p]...A[r]. Un piccolo trucco... Nella versione base Quicksort è chiamato ricorsivamente fino a quando non arriviamo ad un array di dimensione 1. È stato però osservato che gli array piccoli sono ordinati più velocemente da Insertion-Sort. Questo fatto suggerisce una semplice modifica del Quicksort per affidare all'insertion-sort l'ordinamento degli array piccoli // ordina A[p]... A[r] (deve essere p<=r) #define soglia 10 void quicksort(item A, int p, int r) int q; Quicksort: scelta del if(p+soglia>r) // ordina array di dim <= soglia // con insertion_sort insertion_sort(a+p,r-p+1); else q = Partition(A,p,r); quicksort(a,p,q); quicksort(a,q+1,r); Abbiamo visto che scegliere come il primo elemento dell'array comporta un costo (n 2 ) se l'array è già ordinato o è quasi ordinato. Questo non è accettabile quindi studiamo strategie alternative per la scelta del. Tutte le strategie che vedremo possono comportare un costo (n 2 ), ma non quando l'array è già ordinato. Random ing Abbiamo visto che otteniamo un costo asintoticamente superiore a (n log n) soltanto se scegliamo male il numerose volte durante l'algoritmo. Questo suggerisce di affidare la scelta al caso, nella speranza che non saremo sfortunati troppo spesso

8 Supponiamo quindi di avere una procedura che dati due interi i,j con i<j, restituisce un intero scelto casualmente nell'intervallo [i,j]. Esempio: (7,16) restituisce un numero scelto a caso tra 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 ognuno di questi numeri ha la stessa probabilità di essere scelto. Ad ogni esecuzione della procedura usiamo per scegliere casualmente il tra i valori A[p], A[p+1],...,A[r-1], A[r]. Una volta scelto il lo mettiamo in A[p] perché è usato dall'algoritmo come sentinella int RandPartition(Item A[], int p, int r) Item t, x; int i,j; i = Random(p,r); // posizione random x = A[i]; // // scambia A[i]<->A[p] t=a[i];a[i]=a[p];a[p]=t; i= p-1; j= r+1; // inizializza indici while(1) // codice per il partizionamento // come per Partition() Si può dimostrare matematicamente che il tempo di esecuzione di Quicksort basato su è (n log n) con probabilità molto vicina ad 1. In altre parole, devo essere molto sfortunato per avere un tempo di esecuzione asintoticamente superiore a (n log n). return j; Osserviamo che il tempo di esecuzione non dipende più dall'input, ma dalle scelte eseguite dalla procedura. In altre parole, non esistono più sequenze buone o cattive, ma scelte casuali fortunate o sfortunate. Pivot medio di 3 La generazione dei numeri causali rallenta la procedura e quindi tutto l'algoritmo Quicksort. Per questo motivo sono state proposte altre strategie di selezione del che in pratica risultano leggermente più veloci

9 La strategia medio di 3 consiste nel considerare gli elementi che sono nella prima e ultima posizione dell'array, e l'elemento che si trova in posizione mediana. Esempio: Di questi tre valori viene preso quello intermedio (nell'esempio qui sopra 31). 49 Item Median3(Item A[],int Left,int Right) int Center = ( Left + Right )/2; if( A[ Left ] > A[ Center ] ) Swap( &A[ Left ], &A[ Center ] ); if( A[ Left ] > A[ Right ] ) Swap( &A[ Left ], &A[ Right ] ); if( A[ Center ] > A[ Right ] ) Swap( &A[ Center ], &A[ Right ] ); // ora A[Left]<= A[Center] <= A[Right] // metto il in A[Right-1] Swap( &A[ Center ], &A[ Right - 1 ] ); return A[ Right - 1 ]; // Return 50 Array iniziale: Dopo aver ordinato i 3 elementi: Al termine di Median3: Questa scelta del permette di realizzare una procedura più sofisticata che usa gli elementi estremi come sentinelle. Per semplicità mostriamo questa procedura incorporata all'interno del quicksort Valore restituito come : void Qsort(Item A[], int p, int r) Item x, t; int i,j; Esempio Qsort. Situazione dopo Median3 if(p+3<r) x = Median3(A, p, r); i = p; j=r-1; while(1) while(a[--j]>x) ; // esce se A[j]<=x while(a[++i]<x) ; // esce se A[i]>=x if(i<j) Swap(&A[i],&A[j]); else break; Inizio la scansione: Swap(&A[i],&A[r-1]); Qsort(A,p,i-1); Qsort(A,i+1,r); else InsertionSort(A+p,r-p+1); 53 54

10 Scambio gli elementi: Scambio gli elementi: riprendo la scansione: riprendo la scansione: Gli indici si sono incrociati quindi la scansione termina. A questo punto scambio il con A[i] e chiamo ricorsivamente l'algoritmo sulle porzioni azzurra e gialla Come tutte le implementazioni efficienti del quicksort anche questa è delicata. Esempio. Se sostituiamo il codice a sinistra con quello a destra... i = p; j=q-1; while(1) while(a[--j]>x) ; while(a[++i]<x) ; if(i<j) Swap(&A[i],&A[j]); else break; i = p+1; j=q-2; while(1) while(a[j]>x) j--; while(a[i]<x) i++; if(i<j) Swap(&A[i],&A[j]); else break;...il programma entra in loop infinito se A ha tutti gli elementi uguali. 58 Elementi uguali al Una scelta molto importante nell'implementazione del quicksort è cosa fare quando, durante la scansione incontriamo elementi uguali al. Fino ad ora abbiamo sempre interrotto la scansione con il vantaggio che il faceva da sentinella. È una buona scelta? 59 Per minimizzare gli scambi, posso continuare la scansione anche quando incontro elementi uguali al. Questo richiede che durante la scansione controlliamo che gli indici i e j non superino i limiti degli array. Se i controlli sono fatti in maniera corretta l'algoritmo funziona, cioè ordina qualsiasi sequenza. 60

11 Sfortunatamente questo metodo porta ad un costo (n 2 ) se tutti gli elementi sono uguali. Esempio. Se inizio muovendo l'indice di destra, ottengo la situazione: Dato che ad ogni esecuzione di ho una suddivisione [1,n-1], il costo complessivo diventa (n 2 ). Ho quindi un programma che in generale funziona benissimo, ma che per alcune sequenze di input misteriosamente risulta molto lento. La cosa è grave anche perché le sequenze su cui il programma è lento sono facili da ordinare La strategia di fermare la scansione ogni volta che si incontra un elemento uguale al spezza a metà gli array contenenti un unico valore Abbiamo quindi che la nostra versione del quicksort ordina un array di elementi uguali in (n log n). In realtà non è un risultato di cui andare fieri: vedremo che esistono algoritmi (n) per ordinare interi in un range piccolo. Osservazione: è giusto preoccuparsi delle sequenze in cui ci sono pochi valori distinti perché tali sequenze saltano fuori anche quando non ce le aspettiamo. 64 Esempio. Supponiamo di dover ordinare una sequenza di 10 6 interi, di cui 10 3 sono uguali a 2 (rappresentati da in figura). Situazione iniziale: Considerazioni sullo spazio Abbiamo visto che uno dei principali motivi che possono farci preferire il quicksort al mergesort è il non richiedere spazio ausiliario. Ma è veramente così? Dopo un certo numero di chiamate ricorsive quicksort lavora su una partizione contenente molti

12 Ricordiamo che lo stack contiene il record di attivazione di ogni chiamata di procedura non ancora conclusa. Di conseguenza, un algoritmo ricorsivo occupa (sullo stack) una quantità di spazio proporzionale alla massima profondità dell'albero di ricorsione. Nel caso in cui le partizioni siano molto sbilanciate, il quicksort può avere un albero di profondità massima (n). Esempio. Se il partizionamento risulta sempre del tipo [n-1,1] avremo sullo stack i record di attivazione delle chiamate: quicksort(a,0,n-1) quicksort(a,0,n-2) quicksort(a,0,n-3) quicksort(a,0,1) Se questo fenomeno si verifica, lo spazio occupato sullo stack può essere molto maggiore dell'array ausiliario richiesto dal mergesort. Questo inconveniente si può verificare con tutte le versioni di quicksort che abbiamo visto in quanto per ognuna di esse possiamo avere partizioni sbilanciate. Fortunatamente c'è una tecnica generale che garantisce che lo stack non contenga mai più di log n record di attivazione. La tecnica consiste nell'eseguire la chiamata ricorsiva sulla partizione più piccola e di sostituire la ricorsione sulla partizione più grande con una iterazione // Quicksort: versione con stack O(log n) void quicksort(item *A, int p, int r) int q; while(p<r) q = Partition(A,p,r); if((q-p+1)<(r-q)) // la prima meta' e + piccola quicksort(a,p,q); // ricorsione p=q+1; // iterazione else // la seconda meta' e + piccola Dato ogni chiamata ricorsiva viene fatta su di un sottoproblema di dimensione al più la metà del problema precedente, abbiamo che l'i-esimo record di attivazione sullo stack si riferisce ad un problema di dimensione al più n/2 i. Quindi deve essere 2 i < n e di conseguenza i < log n, cioè lo stack contiene al più log n record di attivazione. quicksort(a,q+1,r); // ricorsione r=q; // iterazione 92 93

13