Bubble Sort. Facoltà di Ingegneria Corso di Studi in Ingegneria Informatica. Elaborato di Algoritmi e Strutture Dati. Anno Accademico 2011/2012

Transcript

1 Facoltà di Ingegneria Corso di Studi in Ingegneria Informatica Elaborato di Algoritmi e Strutture Dati Bubble Sort Anno Accademico 2011/2012 Professore Carlo Sansone Studente Lampognana Francesca M63/000144

2 Introduzione Il seguente elaborato illustrerà il funzionamento di un noto algoritmo di ordinamento: il Bubble Sort. Ne verranno mostrati i dettagli di funzionamento e il relativo pseudocodice. Si procederà dunque a verificarne la correttezza e ad effettuare l analisi asintotica per quanto riguarda la sua complessità temporale. Infine mostreremo un implementazione software dell algoritmo, effettuata tramite il linguaggio di programmazione C e, tramite tale software, provvederemo a testare la complessità temporale verificando l aderenza alla complessità temporale calcolata teoricamente mediante analisi asintotica. 2

3 Descrizione dell algoritmo Nome capitolo L algoritmo Bubble Sort fa parte della categoria degli algoritmi di ordinamento, ovvero esso risolve il problema dell ordinamento. Tale problema può essere formalmente descritto in questo modo: In input viene fornita una sequenza di n numeri <a 1,a 2, a n > In output si vuole ottenere una permutazione (riordinamento) < > della sequenza di input, tale che In particolare, Bubble Sort è un algoritmo di ordinamento basato su confronti e scambi. Bubble sort: funzionamento Mostriamo il principio di funzionamento su cui si basa l algoritmo, aiutandoci con un esempio. Data una sequenza di input di n elementi come quella in figura: Figura 1: Vettore in input Si effettua uno scorrimento della sequenza: ogni coppia di elementi adiacenti al suo interno viene comparata e, se l ordine relativo di questa coppia è errato, essi vengono invertiti. Alla fine del primo scorrimento si avrà che nella prima posizione del vettore 3

4 troveremo sicuramente l elemento più piccolo della sequenza e, nel successivo scorrimento, tale elemento sarà considerato come fisso. L algoritmo procede effettuato scorrimenti finchè non vengono eseguiti più scambi. Ciò significa che la sequenza fornita in input è stata correttamente ordinata. Vediamo nella successiva figura come funziona l algoritmo sulla sequenza di esempio. Figura 2: Funzionamento di Bubble Sort Si noti che abbiamo usato, per indicare i vari scorrimenti della lista gli indici di ciclo i e j. Con il colore azzurro sono stati indicati gli elementi della sequenza presi in considerazione, e eventualmente scambiati, in quel determinato passaggio. Con il colore grigio sono stati indicati gli elementi della sequenza correttamente ordinati. La figura aiuta anche a visualizzare il motivo alla base del nome di quest algoritmo. Infatti, grazie agli scambi, l elemento volta per volta più piccolo risale la sequenza riflettendo il comportamento di una bolla d aria all interno di un bicchiere d acqua frizzante. 4

5 Bubble sort: pseudocodice Una volta mostratone il funzionamento, scriviamo qui di seguito lo pseudocodice dell algoritmo. Come si poteva immaginare dalla descrizione del funzionamento, l algoritmo di Bubble Sort viene implementato mediante due cicli for innestati. Il ciclo interno è stato implementato in maniera discendente. Bubble sort: correttezza Mostriamo che l algoritmo Bubble Sort è corretto. Per farlo utilizzeremo la tecnica dell invariante di ciclo: ovvero definiremo per ciascuno dei due cicli di cui è composto l algoritmo delle proprietà che non variano durante tutte le loro iterazioni; per ciascun invariante dobbiamo analizzare i passi di inizializzazione, conservazione e conclusione. Per il ciclo interno, definiamo il seguente invariante: Prima dell inizio della j-esima iterazione, A[j] contiene il valore più piccolo del sottovettore A[j..n]. Passi: - Inizializzazione: Prima della prima iterazione j=n, quindi l invariante è valido. - Conservazione: Prima dell iterazione j, A[j] contiene l elemento più piccolo del sottovettore A[j..n]. Dopo tale iterazione, A[j-1] contiene l elemento più piccolo del sottovettore A[j-1..n]. L invariante è valido. 5

6 - Conclusione: Alla fine del ciclo, j=i, quindi A[i] = A[j] contiene il valore più piccolo del sottovettore A[i..n] e quindi di A[j..n]. L invariante è valido. Per il ciclo esterno, definiamo invece il seguente invariante di ciclo: Prima dell inizio dell i-esima iterazione, il sottovettore A[1..i-1] contiene i primi i-1 elementi ordinati del vettore originario A. Passi: - Inizializzazione: Prima della prima iterazione, A[1..0] è un vettore vuoto quindi è banalmente ordinato. L invariante è valido. - Conservazione: Prima dell iterazione i, A[1..i-1] contiene i primi i-1 elementi ordinati di A. Alla fine di tale iterazione, A[1..i] ha i primi i elementi ordinati di A. Questo poiché alla fine del ciclo interno, A[i] contiene il valore più piccolo del sottovettore A[i..n]. L invariante è valido. - Conclusione: Alla fine del ciclo, i=n+1 e A[1..n] contiene i primi n elementi ordinati di A, ovvero l intero array. Quindi, la correttezza di entrambi gli invarianti prova la correttezza dell algoritmo Bubble Sort. Bubble sort: complessità In questo paragrafo mostriamo la complessità temporale dell algoritmo di ordinamento Bubble Sort, mediante lo strumento teorico dell analisi asintotica. In questo tipo di analisi non ci si preoccupa di come si comporta l algoritmo per un input n piccolo ma si vuole, piuttosto, verificare il tasso di crescita della funzione che definisce il tempo di esecuzione dell algoritmo. 6

7 E facile vedere come questa versione dell algoritmo abbia una complessità pari a Θ(n 2 ). Lo pseudocodice mostrato precedentemente è sostanzialmente formato da due cicli for innestati. La prima iterazione effettuerà n-1 confronti e scambi, la seconda ne farà n-2 e così via. Si utilizza la notazione Θ perché per come è fatto lo pseudocodice che stiamo prendendo in considerazione non vi è alcuna variazione della complessità conseguente a una diversa impostazione del vettore in input. Dunque caso migliore, peggiore e medio sono perfettamente equivalenti. Possono essere, tuttavia, realizzate delle ottimizzazioni dell algoritmo che ne possono migliorare in taluni casi le prestazioni. Per esempio: se per una determinata iterazione non sono stati fatti scambi, vuol dire che l intero vettore è già ordinato correttamente, dunque non sono necessarie ulteriori iterazioni. Questa modifica può portare a migliorie nel caso migliore ovvero nel caso in cui l array di input è già completamente ordinato; può non portare a nessun beneficio, anzi a peggioramenti nelle performance, nel caso peggiore ovvero in caso di array contrordinato. Questo a causa dell overhead introdotto per effettuare i controlli necessari alla realizzazione di questa ottimizzazione. Se viene introdotta questa ottimizzazione, la complessità deve essere indicata come O(n 2 ). Nel capitolo successivo, dedicato all analisi delle prestazioni del software realizzato, verificheremo la sua aderenza di questo risultato teorico. 7

8 Analisi del Software Nome capitolo In questo capitolo verranno illustrate le prestazioni del software realizzato. Esse verranno valutate mediante varie misure prese e si verificherà l effettiva aderenza al risultato formale relativo all algoritmo Bubble Sort mostrato nel precedente capitolo. E stato scelto un insieme di input e si è valutato il tempo di esecuzione del programma per tali input. I test sono stati ripetuti più volte per poter calcolare validi valori medi al fine di evitare anomalie dovute a caratteristiche hardware della macchina su cui si sono svolti tali test. I valori medi che abbiamo utilizzato sono riportati nelle seguenti tabelle, ove n rappresenta la dimensione del vettore fornito in input all algoritmo e y è il valore temporale ottenuto. n y n y

9 Una volta ottenuto il grafico di questa funzione si è provveduto a verificare l aderenza al risultato teorico. Tale risultato affermava che la complessità di Bubble Sort è Θ(n 2 ). Per dimostrare la validità di tale definizione, bisogna dimostrare che: Detta f(n) la funzione che rappresenta il tasso di crescita del tempo di esecuzione di Bubble Sort, bisogna trovare c1,c2 e n0 tali che: Mostriamo dunque di seguito il grafico relativo alle prestazioni ottenute con il software sviluppato fornendo in input i valori precedentemente citati. Figura 3: Prestazioni di Bubble Sort Il grafico mostra i tempi di esecuzioni espressi in microsecondi dell algoritmo che lavora su un vettore formato da numeri casuali di dimensione n. Le costanti c1 e c2 trovate valgono, rispettivamente: 6,8 * 10-3 e 4,49* n0 può essere identificato come 0.4*

10 Codice Nome capitolo Mostriamo qui di seguito il codice sorgente relativo all algoritmo Bubble Sort. Esso è stato scritto utilizzando il linguaggio di programmazione C. //Software che effettua l'ordinamento di un vettore mediante l'algoritmo Bubble Sort //Autore: Lampognana Francesca M63/144 #include <stdlib.h> #include <stdio.h> #include <windows.h> //necessaria per l'utilizzo di QueryPerformanceCounter //Dichiarazione delle variabili necessarie per il calcolo dei tempi d'esecuzione static LARGE_INTEGER frequency; // ticks per second static LARGE_INTEGER t1, t2; // ticks static double elapsedtime; //tempo trascorso /*INIZIO PROCEDURE*/ //Effettua lo scambio di due elementi dell'array void scambia(int *a, int *b){ int temp; temp=*a; *a=*b; *b=temp; //Generazione random di un vettore di input void generainput(long int n, int array[]){ int i=0; for(i=0;i<n;i++) array[i]=rand()%30000; //rand() inizializzata una sola volta nel main //Calcolo del tempo iniziale void starttime(){ static int first=1; if(first){ QueryPerformanceFrequency(&frequency); 10

11 first=0; QueryPerformanceCounter(&t1); //Calcolo del tempo finale void endtime(){ QueryPerformanceCounter(&t2); //Calcola la differenza tra i due tempi e la porta in microsecondi double eltime(){ return ((double)t2.quadpart - (double)t1.quadpart) * / (double)frequency.quadpart; //Procedura principale: implementa l'algoritmo void BubbleSort(long int n, int array[]){ long int i=0; long int j=0; for(i=0;i<n;i++) for(j=n;j>=i+1;j--){ if(array[j]<array[j-1]){ scambia(&array[j],&array[j-1]); /*FINE PROCEDURE*/ /*MAIN*/ int main(){ long int dim; int i=0,option=0,r=1,fine=0; printf("***\tbubble SORT\t***\n\n"); srand(time(0)); //Setta il seme della rand(). srand va eseguito una sola volta //Inizio del programma con visualizzazione del menù di scelta do { do{ printf("effettua una scelta tra le seguenti:\n"); printf("1 - Ordinamento di prova con vettore inserito manualmente e stampa a video\n"); printf("2 - Misura dei tempi con input generato casualmente e output su file\n"); printf("3 - Termina il programma\n"); printf("scelta: \t"); scanf("%d",&option); while((option<1) (option>3)); switch(option){ case 1: //Ordinamento con vettore inserito manualmente { //In questo caso non verranno calcolati i tempi printf("\ninserire la dimensione del vettore: \t"); scanf("%d",&dim); int vettore[dim]; for(i=0;i<dim;i++){ 11

12 printf("\nvettore [%d]:\t",i); scanf("%d",&vettore[i]); BubbleSort(dim,vettore); printf("vettore ordinato:\n"); for(i=0;i<dim;i++) printf("%d\t",vettore[i]); printf("\n"); break; case 2: //Ordinamento con misura dei tempi { //E' possibile effettuare misure ripetute printf("\ninserire la dimensione del vettore: \t"); scanf("%d",&dim); printf("\nripetizioni della misura:\t"); scanf("%d",&r); int array[dim]; for(i=0;i<r;i++){ generainput(dim,array); generiamo un input diverso starttime(); BubbleSort(dim,array); endtime(); elapsedtime = eltime(); //Per ogni ripetizione //Setta tempo iniziale //Ordina //Setta tempo finale //Calcolo differenza in us printf("\ntempo %d: %f us\n",i,elapsedtime); //Stampa dei tempi su file di testo FILE *pf1; char *nomefile1 = "bubblesort.txt"; pf1 = fopen(nomefile1, "a"); if(pf1){ fprintf(pf1, "%f\t%d\n", elapsedtime,dim); fclose(pf1); printf("\nmisurazione terminata. Output stampati sul file 'bubblesort.txt'"); printf("\n"); break; while(fine==0); return 0; case 3: { fine=1; break; //Terminazione del programma 12