Laboratorio di Algoritmi e Strutture Dati II Semestre 2005/2006. Ordinamenti: mergesort e quicksort

Transcript

1 Laboratorio di Algoritmi e Strutture Dati II Semestre 2005/2006 Ordinamenti: mergesort e quicksort Marco Antoniotti Mergesort e Quicksort Due importantissimi algoritmi di ordinamento La conoscenza completa delle loro proprietà ha permesso la loro utilizzazione nelle applicazioni più disparate Occupano un posto di prominenza assoluta nell infrastruttura informatica mondiale Quicksort è stato definito come uno dei 10 algoritmi più importanti del XX secolo per la scienza l ingegneria Mergersort mergesort della libreria standard C Java system sort per array di oggetti (metodo Arrays.sort) Ordinamento stabile di Perl, Python ed altri linguaggi Quicksort Qsort della libreria standard C Ordinamento Java per array di tipi base (int, float, etc) II Semestre 2005/2006 Laboratorio Algoritmi - Marco Antoniotti 1/30 1

2 Mergesort Mergesort Si divide l array in due parti Le si ordinano usando mergesort (ricorsione) Le si ricombinano in un array ordinato ( merge ) II Semestre 2005/2006 Laboratorio Algoritmi - Marco Antoniotti 2/30 Mergesort: esempio II Semestre 2005/2006 Laboratorio Algoritmi - Marco Antoniotti 3/30 2

3 Merging L operazione finale di merging combina due array (o liste) ordinate in un array (o lista) restituita come risultato L operazione viene fatta utilizzando un array ausiliario static void merge(int a[], int aux[], int l, int m, int r) { int k = l; int i = l; int j = m; for (; k < r; k++) aux[k] = a[k]; for (k = l; k < r; k++) { if (i >= m) a[k] = aux[j++]; else if (j >= r) a[k] = aux[i++]; else if (aux[j] < aux[i]) a[k] = aux[j++]; else a[k] = aux[i++]; II Semestre 2005/2006 Laboratorio Algoritmi - Marco Antoniotti 4/30 Mergesort Il codice per una funzione mergesort di libreria potrebbe essere il seguente static void do_mergesort(int a[], int aux[], int l, int r) { int mid; if (r <= l + 1) return; mid = (r + l) / 2; do_mergesort(a, aux, l, mid); do_mergesort(a, aux, mid + 1, r); merge(a, aux, l, mid, r); void sorting_mergesort(int a[], int n_elements) { int* aux = (int*) malloc(n_elements * sizeof(int)); do_mergesort(a, aux, 0, n_elements); free(aux); II Semestre 2005/2006 Laboratorio Algoritmi - Marco Antoniotti 5/30 3

4 Analisi: memoria Quanta memoria richiede mergesort? Array iniziale: N Array ausiliario: N Variabili locali: costante Profondità dello stack di chiamate: lg(n) Totale: 2N + O(lg(N)) Quanta memoria richiedono gli altri algoritmi di ordinamento? Array iniziale: N + O(1) (ad esempio bubblesort e selectionsort) L ordinamento avviene in-place N + O(lg(n)) Per i più audaci ed annoiati Come si fa a fare l operazione di merge in-place? [Kronrud 1969] II Semestre 2005/2006 Laboratorio Algoritmi - Marco Antoniotti 6/30 Analisi: tempo Quanto tempo richiede mergesort? Definizione sia T(N) il numero di confronti La funzione di ricorrenza per mergesort è T (N) = T N /2 0 se N =1 ( ) +T ( N /2 ) + N altrimenti L equazione di ricorrenza per mergesort è della forma canonica prevista dal Master Theorem (cfr. Cormen, Leiserson e Rivest) T (N) = a T (N /b)+ f (N) Siccome f (N) = Θ( N lg(2) ) la soluzione è ( ) = Θ(N lg(n)) T (N) = Θ N lg(2) lg(n) II Semestre 2005/2006 Laboratorio Algoritmi - Marco Antoniotti 7/30 4

5 Analisi: tempo Prova con albero di ricorsione II Semestre 2005/2006 Laboratorio Algoritmi - Marco Antoniotti 8/30 Mergesort: considerazioni pratiche e generalizzazione dell interfaccia L interfaccia presentata è molto semplice e non generica L interfaccia generica (e l implementazione) per mergesort dovrebbe essere la seguente void sorting_merge(void* a, int n, size_t s, sorting_cmp_fun_t compare) { void* aux = (void*) malloc(n * s); do_sorting(a, aux, compare, s, 0, n); free(aux); static void do_sorting(void* a, void* aux, sorting_cmp_fun_t compare, size_t s, int l, int r) { int mid; if (r <= l + 1) return; mid = (l + r) / 2; do_sorting(a, aux, compare, s, l, mid); do_sorting(a, aux, compare, s, mid + 1, r); merge(a, aux, compare, s, l, mid, r); II Semestre 2005/2006 Laboratorio Algoritmi - Marco Antoniotti 9/30 5

6 Mergesort: considerazioni pratiche e generalizzazione dell interfaccia La funzione generica merge diventa: void merge(void* a, void* aux, sorting_cmp_fun_t compare, size_t s, int l, int m, int r) { int k; int i = l; int j = m; for (k = l; k < r; k++) memcpy(aux + k * s, a + k * s, s); for (k = l; k < r; k++) { if (i >= m) memcpy(a + k * s, aux + (j++) * s, s); else if (j >= r) memcpy(a + k * s, aux + (i++) * s, s); else if (0 > compare(aux + j * s, aux + i * s)) memcpy(a + k * s, aux + (j++) * s, s); else memcpy(a + k * s, aux + (i++) * s, s); II Semestre 2005/2006 Laboratorio Algoritmi - Marco Antoniotti 10/30 Mergesort: ottimizzazioni Alcune ottimizzazioni pratiche Codice più complicato Sentinelle L uso di sentinelle ci permette di evitare due test sui limiti degli array Usare insertion sort su (sotto)array di piccole dimensioni Mergesort fa troppo lavoro extra per (sotto)array di piccole dimensioni Di solito si passa a insertion sort per (sotto)arrays di lunghezza 6 o 7 Stop se l array è già ordinato Ovvero se l elemento più grande dell array di sinistra è più piccolo del più piccolo elelmento dell array di destra Utile per arrays di input (quasi) ordinati Eliminare la copia dell array ausiliario Si scambia il ruolo dei due array ad ogni chiamata Si riduce il tempo richiesto (di una costante) ma non la memoria II Semestre 2005/2006 Laboratorio Algoritmi - Marco Antoniotti 11/30 6

7 Quicksort II Semestre 2005/2006 Laboratorio Algoritmi - Marco Antoniotti 12/30 Quicksort Si mischia l array Si partiziona l array L elemento a[i] è nella sua posizione finale per un dati i Nessun elemento a sinistra di i è più grande di a[i] Nessun elemento a destra di i è più piccolo di a[i] Si ordinano le due parti delimitate da i ricorsivamente Problema: Come si può partizionare l array in maniera efficiente? II Semestre 2005/2006 Laboratorio Algoritmi - Marco Antoniotti 13/30 7

8 Partizione in Quicksort II Semestre 2005/2006 Laboratorio Algoritmi - Marco Antoniotti 14/30 Quicksort: esempio II Semestre 2005/2006 Laboratorio Algoritmi - Marco Antoniotti 15/30 8

9 Quicksort: implementazione in C (1) void do_quicksort(int a[], int l, int r) { int p; if (r <= l) return; p = partition(a, l, r); do_quicksort(a, l, p - 1); do_quicksort(a, p + 1, r); void sorting_quicksort(int a[], int n) { shuffle(a, n); do_quicksort(a, 0, n - 1); II Semestre 2005/2006 Laboratorio Algoritmi - Marco Antoniotti 16/30 Quicksort: implementazione in C (1) void shuffle(int a[], int n) { int k; for (k = 0; k < n; k++) { exchange(&(a[rand() % n]), &(a[rand() % n])) II Semestre 2005/2006 Laboratorio Algoritmi - Marco Antoniotti 17/30 9

10 Quicksort: implementazione in C (1) void partition(int a[], int l, int r) { int i = l - 1; int j = r; while (1) { /* Cerca l elemento da scambiare a destra. */ while (a[++i] < a[r]) if (i == r) break; /* Cerca l elemento da scambiare a sinistra. */ while (a[r] < a[--j]) if (j == l) break; if (i >= j) break; exchange(&(a[i]), &(a[j])); exchange(&(a[i]), &(a[r])); return i; II Semestre 2005/2006 Laboratorio Algoritmi - Marco Antoniotti 18/30 Quicksort: dettagli implementativi Partizione in loco Usare un array ausiliario semplifica l operazione ma non ne vale la pena Terminazione del ciclo Controllare quando i due puntatori si incrociano è più complicato di quanto sembri Controllo sui limiti Il test (i == r) è ridondante, ma il test (l == j) non lo è Casualità dell input Questo passo è necessario per garantire le prestazioni dell algoritmo Elementi duplicati In presenza di elementi duplicati, sebbene controintuitivo, è meglio fermarsi quando si trova un elemento uguale all elemento di partizione (il pivot) II Semestre 2005/2006 Laboratorio Algoritmi - Marco Antoniotti 19/30 10

11 Quicksort: caratteristiche di prestazioni Caso peggiore Il numero di confronti è quadratico La probabilità di questo evento è molto bassa Attenzione Molti libri di testo riportano implementazioni potenzialmente quadratiche se L input è ordinato L input è in ordine inverso L input contiene molti elementi duplicati II Semestre 2005/2006 Laboratorio Algoritmi - Marco Antoniotti 20/30 Quicksort: caso medio Tempo medio Circa N lg(n) confronti Assunzione: l input è in ordine casuale Note Circa il 39% più confronti di mergesort In pratica più veloce di mergesort, dato che molte altre istruzioni sono più veloci Attenzione: molti libri di testo hanno implementazioni quadratiche in presenza di elementi duplicati anche con input casuale II Semestre 2005/2006 Laboratorio Algoritmi - Marco Antoniotti 21/30 11

12 Quicksort: miglioramenti pratici Mediana del campione La miglior scelta del pivot è la mediana Ma come calcoliamo la mediana? Si stima la mediana calcolando la mediana del campione Usare insertion sort per input di piccole dimensioni Parametri ottimizzati Mediana di 3 elementi Limite per il cambio ad insertion sort: circa 10 elementi Versione semi ricorsiva Ultima chiamata è in posizione tail-ricorsiva Versione non ricorsiva Gestione esplicita di uno stack (profondità garantita O(lg(N)) Si ordina per prima la partizione più piccola II Semestre 2005/2006 Laboratorio Algoritmi - Marco Antoniotti 22/30 Elementi duplicati Elementi uguali: sempre presenti in tutte le applicazioni in cui è necessario aggregare gli elementi uguali Ordinare una popolazione per età Trovare punti collineari Rimuovere i duplicati da una lista di posta Applicazione tipica Input molto grande Numero di classi di equivalenza basso Soluzione: quicksort a 3 vie II Semestre 2005/2006 Laboratorio Algoritmi - Marco Antoniotti 23/30 12

13 Partizione a 3 vie Partizione a 3 vie Gli elementi tra i e j sono uguali al pivot v Nessun elemento più grande del pivot alla sinistra di i Nessun elemento più piccolo del pivot alla destra di j Noto anche come il problema della bandiera olandese Non usato prima della metà degli anni 90 Incorporato in Java ed in alcune implementazioni della libreria C Quicksort con partizione a 3 vie è ottimale La prova richiede nozioni di teoria dell informazione II Semestre 2005/2006 Laboratorio Algoritmi - Marco Antoniotti 24/30 Soluzione del problema della bandiera olandese Soluzione Si partiziona l array in 4 parti Nessun elemento più grande del pivot alla sinistra di i Nessun elemento più piccolo alla destra di j Elementi uguali alla sinistra di p Elementi uguali alla sinistra di q Infine si muvono gli elementi uguali al centro Tutte le proprietà più utili sono verificate In loco Non molto codice Lineare anche se molti elementi sono uguali Poche operazioni extra se non ci sono elementi uguali II Semestre 2005/2006 Laboratorio Algoritmi - Marco Antoniotti 25/30 13

14 Implementazione void q3sort(int a[], int l, int r) { int i, j, p, q, k; if (r <= l) return; i = p = l - 1; j = q = r; while (1) { while (a[++i] < a[r]); Partizione a 4 vie while (a[r] < a[--j]) if (j == l) break; if (i >= j) break; exchange(a, i, j); if (a[i] == a[r]) exchange(a, ++p, i); if (a[j] == a[r]) exchange(a, --q, j); exchange(a, i, r); j = i - 1; i = i + 1; for (k = l; k <=p; k++) exchange(a, k, j--); for (k = r - 1; k >=q; k--) exchange(a, k, i++); q3sort(a, l, j); q3sort(a, i, r); Scambio degli elementi uguali a destra o sinistra Spostamento degli elementi uguali al centro II Semestre 2005/2006 Laboratorio Algoritmi - Marco Antoniotti 26/30 Selezione Selezione: trovare il k-esimo elemento Min: k = 1 Max: k = N Mediana: k = N/2 Facile minimo o massimo com O(N) confronti Mediana con O(N lg(n)) Sfida Mediana in tempo lineare II Semestre 2005/2006 Laboratorio Algoritmi - Marco Antoniotti 27/30 14

15 Quickselect Soluzione Partizione dell input in modo da L elemento a[i] è nella sua posizione finale per un dati i Nessun elemento a sinistra di i è più grande di a[i] Nessun elemento a destra di i è più piccolo di a[i] Si ripete in uno dei sotto-array in dipendenza da i void quickselect(int a[], int n, int k) { int l, r; shuffle(a, n); l = 0; r = n - 1; while (r > l) { int i = partition(a, l, r); if (i > k) r = i - 1; else if (i < k) l = i + 1; else return; Al termine a[k] contiene il (k+1)-esimo elemento II Semestre 2005/2006 Laboratorio Algoritmi - Marco Antoniotti 28/30 Quickselect: analisi Quickselect richiede, in media, tempo lineare Intuitivamente, ogni partizione divide l input a metà N + N/2 + N/4 + < 2N confronti L analisi formale è simile a quella per quicksort: la prova è che la media del numero di confronti è 2N + k ln N N + (N k)ln k N k Caso peggiore Il caso peggiore è Ω(N 2 ) confronti, ma il riordino iniziale lo rende estremamente improbabile II Semestre 2005/2006 Laboratorio Algoritmi - Marco Antoniotti 29/30 15

16 Sommario Algoritmi ottimi di ordinamento con confronti: O(N lg(n)) Mergesort 2N memoria Quicksort Operazione di partizione è fondamentale Assunzione di input casuale pure fondamentale Quicksort con partizione a 3 vie ottimo Quickselect Selezione del k-esimo elemento in tempo lineare sfruttando l operazione di partizione II Semestre 2005/2006 Laboratorio Algoritmi - Marco Antoniotti 30/30 16