Il problema dell'ordinamento. Algoritmi e Laboratorio a.a Lezioni. Proprietà degli algoritmi di ordinamento: stabilità.

Transcript

1 Il problema dell'ordinamento 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 22 Riassunto algoritmi di ordinamento. Ordinamento lineare. Data una sequenza (ad es. array o lista) di elementi, ordinarla rispetto ad una relazione d'ordine definita sugli elementi (di solito su un particolare campo o componente di tali elementi); ad es. ordinare un insieme di oggetti di una classe Studente rispetto al numero di matricola (costituente la chiave identificativa dell'oggetto), oppure rispetto al cognome, ecc. Gli algoritmi che risolvono tale problema, cioè gli algoritmi di ordinamento, sono classificabili secondo diversi criteri, quali la complessità asintotica oppure il fatto che godano o no di certe proprietà interessanti. Quest' opera è pubblicata sotto una Licenza Creative Commons Attribution-NonCommercial-ShareAlike /02/2007 E. Giovannetti - AlgELab Lez.22 2 Proprietà degli algoritmi di ordinamento: stabilità. Un algoritmo di ordinamento si dice stabile se non altera l'ordine relativo di oggetti distinti che sono uguali rispetto alla relazione d'ordine, ad es. l'ordine relativo di elementi con chiavi uguali. Cioè, se nella sequenza da ordinare vi sono due elementi A e B di uguali chiavi, e A si trova prima di B in tale sequenza, anche nella sequenza ordinata A deve trovarsi prima di B. Se una sequenza di elementi già ordinata secondo un certo criterio viene ordinata secondo un altro criterio per mezzo di un algoritmo stabile, elementi uguali secondo il nuovo criterio risultano ordinati secondo il precedente criterio. Esempio: Se una sequenza di persone individuate da nome e cognome è ordinata per nome, ordinandola per cognome con un algoritmo stabile si ottiene una sequenza in cui le persone dello stesso cognome sono ordinate per nome. 19/02/2007 E. Giovannetti - AlgELab Lez.22 3 Stabilità Naturalmente la stabilità non ha alcuna importanza se gli elementi coincidono con le chiavi o, più in generale, se elementi uguali rispetto alla relazione d'ordine non sono distinguibili (ad esempio un array di interi). 19/02/2007 E. Giovannetti - AlgELab Lez.22 4 Proprietà degli algoritmi di ordinamento: ordinamento sul posto (in place, in loco) Un algoritmo di ordinamento su array si dice sul posto (o in loco, o in place) se in ogni istante al più un numero costante di elementi viene memorizzato al di fuori dell'array; cioè se l'algoritmo riordina l'array senza usare un array ausiliario o comunque uno spazio proporzionale al numero di elementi. Definizione di fatto equivalente: Un algoritmo di ordinamento si dice sul posto se la sua complessità spaziale è al più O(log n). Ricorda che la complessità spaziale comprende anche lo spazio usato dallo stack. Concludendo: un algoritmo di ordinamento è sul posto se usa solo una quantità "piccola" di spazio aggiuntivo. 19/02/2007 E. Giovannetti - AlgELab Lez.22 5 Classificazione degli algoritmi di ordinamento selection sort:sul posto, anzi spazio O(1); non stabile; tempo O(n 2 ) in tutti i casi; insertion sort: sul posto, anzi spazio O(1); stabile; tempo O(n 2 ) nei casi peggiore e medio, O(n) nel caso migliore; mergesort: non sul posto, spazio O(n); stabile; tempo O(n log n) nei casi peggiore e medio; quicksort: sul posto, spazio O(log n); non stabile; tempo O(n 2 ) nel caso peggiore, O(n log n) nei casi migliore e medio; heapsort: sul posto, anzi spazio O(1); non stabile; tempo O(n log n) in tutti i casi; Nota: il mergesort è stabile purché implementato opportunamente; ne esiste anche una versione sul posto, estremamente complicata e poco usata. 19/02/2007 E. Giovannetti - AlgELab Lez

2 Esercizio 1. Spiegare perché il selection sort, il quicksort e lo heapsort non sono stabili. Spiegare perché l'insertion sort è stabile. Spiegare perché il mergesort non è sul posto, mentre tutti gli altri dell'elenco lo sono. Spiegare in che modo deve essere realizzato il mergesort affinché esso sia stabile. Algoritmi di ordinamento non basati sui confronti: ordinamento in tempo lineare. 19/02/2007 E. Giovannetti - AlgELab Lez /02/2007 E. Giovannetti - AlgELab Lez.22 8 Problema 1.1: ordinare un array di n elementi aventi chiavi intere tutte diverse comprese fra 0 e n-1. Riprendiamo un esempio illustrato nella Lezione 10, slide 3. Si vuole ordinare un array di 50 oggetti "Articolo" distinti, contenenti ciascuno un numero di codice da 0 a 49 (articoli distinti hanno codici distinti). Per farlo è sufficiente: disporre di un array ausiliario b della stessa lunghezza; percorrere l'array di partenza andando a mettere nell'array ausiliario ogni elemento al suo posto, cioè l'articolo di codice h nell'elemento b[h]; ovviamente ciò richiede un tempo Θ(n); l'ordinamento è stato effettuato senza operare nessun confronto. 19/02/2007 E. Giovannetti - AlgELab Lez.22 9 Problema 1.2: ordinare un array di n elementi aventi chiavi intere senza ripetizioni e comprese nel range m.. m+n-1 (con m intero) Vogliamo ordinare per numero di matricola un array di 1000 studenti di matricola compresa nel range (con matricole non duplicate). È sufficiente: disporre di un array ausiliario b di 1000 elementi percorrere l'array di partenza andando a mettere nell'array ausiliario ogni elemento al suo posto, cioè l'articolo di codice h nell'elemento b[h-42000]; ovviamente ciò richiede un tempo Θ(n); l'ordinamento è stato effettuato senza operare nessun confronto. 19/02/2007 E. Giovannetti - AlgELab Lez Problema 2: ordinare un array contenente la sequenza degli n interi compresi fra m ed m+n-1. Vogliamo ordinare una sequenza di 1000 elementi costituiti da interi "nudi" compresi fra e 42999, senza elementi ripetuti. Per elemento intero "nudo" intendiamo un elemento costituito da un semplice intero senza altri dati ad esso associati. Elementi di chiavi uguali sono quindi identici (indistinguibili). In tal caso non serve alcun array ausiliario, anzi non serve neppure conoscere l'array di input! Basta semplicemente riempire ordinatamente l'array con tutti i numeri compresi fra e 42999: for(int i = 0; i < 1000; i++) a[i] = i; È ovviamente T(n) = Θ(n). 19/02/2007 E. Giovannetti - AlgELab Lez Problema 3 integer sort: ordinare un array di n interi compresi nel range 0.. k-1, con possibili ripetizioni. Nota: Se è n > k, vi sono sicuramente elementi ripetuti. Anche in questo caso non serve un array ausiliario per il risultato, ma per ognuno dei k possibili valori bisogna contare il numero di volte in cui tale valore compare nell'array. Occorre quindi un array ausiliario di contatori, di lunghezza k. Si percorre una volta l'array da ordinare A, incrementando, per ogni elemento A[i], il contatore C[A[i]] corrispondente a quell'elemento. Si percorre l'array dei contatori, depositando nell'array da ordinare il numero corretto di elementi uguali a ciascuno dei k valori. 19/02/2007 E. Giovannetti - AlgELab Lez

3 Integer sort: realizzazione public static void intsort(int k, int[] a) { int[] counters = new int[k]; // contatori int n = a.length; // inizializzo a zero i contatori (in Java non necessario): for(int i=0; i < k; i++) counters[i] = 0; //se a[j] contiene il valore v, incremento il v-esimo contatore for(int j=0; j < n; j++) counters[a[j]]++; int j = 0; // per ogni valore v,... for(int v = 0; v < k; v++) { while(counters[v] > 0) { a[j] = v; j++; counters[v]--; //... metto in a tanti valori uguali a v quanti ne sono stati contati in counters[v] 19/02/2007 E. Giovannetti - AlgELab Lez Analisi Primo for (inizializzazione contatori): k passi. Secondo for (conteggio valori): n passi Terzo for con while annidato: in tutto n passi In totale si hanno quindi 2n + k iterazioni: tempo =Θ(n+k) 19/02/2007 E. Giovannetti - AlgELab Lez Problema 4: ordinare un array di n elementi aventi chiavi intere comprese nel range 0.. k-1 (le chiavi possono essere ripetute) Come nel problema 3, per ogni possibile valore j della chiave bisogna contare quanti sono nell'array di partenza gli elementi di chiave uguale a j. Poiché però ora elementi aventi chiavi uguali contengono anche altri dati (in generale distinti): un elemento non può essere messo nel suo nuova posto sovrascrivendo l'elemento ivi inizialmente presente: bisogna quindi usare un array ausiliario per il risultato; nello stesso tempo, gli elementi di ciascuna chiave j devono essere presi dall'array di partenza. L'algoritmo diventa più sofisticato (vedi slide seguente). Counting sort Ordina un array di n elementi aventi chiavi intere comprese fra 0 e k-1. Vi sono in tutto 3 arrays: a: array di input da ordinare, di dimensione n; b: array ausiliario in cui mettere il risultato, di dimensione n; c: array dei contatori, di dimensione k; static void countsort(int k, ItemWithIntKey[] a) { dove ItemWithIntKey è una classe di oggetti dotati di un metodo che restituisce una chiave di tipo intero; for(int j = 0; j < k; j++) c[j] = 0; azzero i contatori (in Java si può omettere) Il seguito della procedura può essere scritto in due versioni leggermente diverse ma equivalenti. 19/02/2007 E. Giovannetti - AlgELab Lez /02/2007 E. Giovannetti - AlgELab Lez Versione 1 Per ogni j, metto in c[j] il numero di elementi di chiave uguale a j: for(int i = 0; i < n; i++) c[a[i].key()]++; Per ogni j, calcolo e metto in c[j] il numero degli elementi di chiave < j, nel modo seguemte: INVARIANTE: totale = numero di elementi di chiave < j Poiché non esistono elementi di chiave < 0, l'inizializzazione deve essere j = 0, totale = 0: int totale = 0; for(int j = 0; j < k; j++) { int temp = c[j];temp è il numero di elem. di chiave =j c[j] = totale; totale += temp; aggiorno totale aggiungendovi il vecchio c[j] salvato in temp. 19/02/2007 E. Giovannetti - AlgELab Lez Versione 1 (continua) A questo punto, per ogni j: c[j] = numero di elementi di chiave < j = indice del posto in cui mettere il primo elemento di chiave j. Allora, per ogni elemento a[i]: prendine la chiave: j = a[i].key(); guarda qual è la posizione in cui metterlo: i' = c[j]; mettilo in tale posizione: b[i'] = a[i]; incrementa l'indice i', perché il successivo elemento di chiave j andrà messo nella posizione successiva. Concisamente: for(int i = 0; i < n; i++) { b[c[a[i].key()]] = a[i]; c[a[i].key()]++; 19/02/2007 E. Giovannetti - AlgELab Lez

4 Versione 1 (continua) Osservazioni È un algoritmo di ordinamento stabile, perché il primo degli elementi di chiave j nell'array a viene messo al primo posto fra gli elementi di chiave j nell'array b, il secondo nel secondo, e così via. L'algoritmo evidentemente può, con una banale variazione, trattare il caso in cui le chiavi sono comprese in un range di valori non iniziante da zero (cioè da m a m+k-1, con m 0) 19/02/2007 E. Giovannetti - AlgELab Lez Versione 2 per ogni j, metto in c[j] il numero di elementi di chiave uguale a j: for(int i = 0; i < n; i++) c[a[i].key()]++; faccio diventare c[0] l'indice a cui mettere l'ultimo elemento di chiave 0: c[0]--; faccio diventare c[j] l'indice a cui mettere l'ultimo elemento di chiave j: for(int j = 1; j < k; j++) c[j] += c[j-1]; a questo punto si ha, per ogni j: c[j] new = c[0] old + c[1] old c[j] old = = indice del posto in cui mettere l'ultimo elemento di chiave j; per ottenere un ordinamento stabile bisogna percorrere l'array di input dalla fine verso l'inizio: for(int i = n-1; i >= 0; i--) { b[c[a[i].key()]] = a[i]; c[a[i].key()]--; Alla fine di entrambe le versioni si può ricopiare l'array ausiliario b nell'array di partenza a, in modo che la procedura abbia la forma e funzionalità usuali delle procedure di ordinamento. 19/02/2007 E. Giovannetti - AlgELab Lez Complessità (per entrambe le versioni) Complessità temporale eventuale ciclo for che inizializza i contatori: k passi; ciclo for che conta gli elementi: n passi; ciclo for che somma i contatori: k passi; ciclo for che mette gli elementi in b in ordine: n passi; eventuale ciclo for che ricopia b in a: n passi. Quindi: T(n, k) = Θ(n+k) Se k è dello stesso ordine di grandezza di n, si ha: T(n) = O(n) (complessità lineare). Complessità spaziale L'algoritmo utilizza due array ausiliari: b di lunghezza n e c di lunghezza k. Quindi anche lo spazio è lineare: S(n, k) = Θ(n+k) Se l'insieme delle possibili chiavi è molto grande l'algoritmo non è usabile: troppo dispendioso in spazio e in tempo. 19/02/2007 E. Giovannetti - AlgELab Lez Esempio Si può usare il counting sort per ordinare una sequenza di stringhe? Una stringa non è un numero, ma può essere identificata con il numero intero costituito dalla sua rappresentazione binaria (per mezzo dei codici ASCII o Unicode). Assumiamo che le stringhe che si vogliono ordinare abbiano una lunghezza massima di 20 caratteri. Quante sono le diverse possibili stringhe di lunghezza 20 su un alfabeto di 26 caratteri? Risposta: > (2 10) 20 = = (2 10 ) ~ = sarebbe necessario allocare un array c di giga elementi (che tra l'altro resterebbe poi quasi tutto vuoto...). Impossibile! 19/02/2007 E. Giovannetti - AlgELab Lez Bucket sort (ordinamento "a secchielli") Risolve lo stesso problema del counting sort: ordinare un array di n elementi aventi chiavi intere comprese fra 0 e k-1 (o fra m ed m+k-1). Opera come l'integer sort e il counting sort, mantenendo però un array di liste ("secchielli") anziché di contatori. La j-esima lista, buckets[j], conterrà gli elementi con chiave uguale a j. Alla fine si concatenano le liste in una lista-risultato, o le si ricopia in un array. Complessità: Θ(n+k). Poiché utilizza liste concatenate, è un algoritmo conveniente quando la sequenza è già rappresentata da una linked list; nel caso di array, invece, è di solito meglio il counting sort o l'integer sort. 19/02/2007 E. Giovannetti - AlgELab Lez Esercizio 2 Si completino e si provino le realizzazioni del counting sort. Si realizzino e si provino due versioni del bucket sort: una per ordinare liste concatenate, l'altra per ordinare arrays. Come bisogna fare affinché il bucket sort sia stabile? 19/02/2007 E. Giovannetti - AlgELab Lez

5 Ordinamento in base ad una tupla di chiavi. Si supponga di voler ordinare in base a cognome, nome, e anno di nascita una sequenza di record od oggetti rappresentanti persone, in modo che l'ordine sia (alfabetico) per cognome, a parità di cognome sia per nome, e a parità di nome per anno di nascita. Si può operare in modi diversi: Definire una funzione di confronto che confronta dapprima i cognomi, se questi sono uguali confronta i nomi, e così via. Ordinare dapprima per cognome mettendo gli elementi con cognomi uguali in liste separate, poi ordinare per nome ogni lista di cognomi uguali, e così via. Ordinare dapprima tutta la sequenza per anno di nascita; poi riordinarla per nome con un algoritmo stabile; infine riordinarla per cognome con un algoritmo stabile. Poiché un algoritmo stabile preserva l'ordine precedente, alla fine gli elementi risulteranno ordinati nel modo voluto! 19/02/2007 E. Giovannetti - AlgELab Lez Radix sort Ordina una sequenza di elementi con chiavi composte da coppie (o d-tuple) di valori compresi in un range limitato, per mezzo del terzo metodo illustrato nel lucido precedente e usando il counting sort o il bucket sort come algoritmo di ordinamento stabile. Il numero totale di iterazioni è quindi d(n + k), con d costante. Si ha quindi ancora complessità temporale lineare: T(n, k) = Θ(n+k) Naturalmente se d non è molto piccolo (cioè di poche unità), la costante moltiplicativa influenza pesantemente l'efficienza. 19/02/2007 E. Giovannetti - AlgELab Lez Esempio: ordinamento lineare su chiavi intere. Vogliamo realizzare un algoritmo di ordinamento lineare per array di elementi aventi chiavi di tipo intero a 32 bit (come il tipo int di Java). Si può allora: scomporre il campo di tipo int in due campi di 16 bit; ordinare due volte l'array con il counting sort: prima rispetto ai 16 bit meno significativi; poi rispetto ai 16 bit più significativi. Oppure: scomporre il campo di tipo int in 4 campi di 8 bit (bytes); ordinare quattro volte l'array con il counting sort: prima rispetto al byte più basso; poi rispetto al secondo byte dal basso; e così via. La seconda soluzione occupa meno spazio (i contatori sono 2 8 invece di 2 16 ) ma ripete il counting sort 4 volte invece di 2. 19/02/2007 E. Giovannetti - AlgELab Lez Ordinamento lineare su chiavi intere (continua) Poiché nel counting sort le chiavi devono essere interi non negativi, i campi a 16 o a 8 bit in cui si scompone un valore int devono essere di tipo intero assoluto (unsigned). In Java il solo tipo intero assoluto è il tipo char a 16 bit. Quindi, attenzione: solo int non negativi: i due campi da 16 bit sono proprio i 16 bit rispettivamente più alti e più bassi del campo int; in Java, se x è un int, usando l'operatore >> di shift: x basso = (char) x x alto = (char) (x >> 16) int anche negativi: bisogna tener conto della rappresentazione binaria in complemento a 2 dei numeri negativi; in Java, se x è un int: x basso = (char) x x alto = (char) ((x >> 16)^0x8000) (vedi esercizio 3) 19/02/2007 E. Giovannetti - AlgELab Lez Ordinamento lineare di int non negativi in Java Definiamo una funzione che da un numero di tipo int estrae i 16 bit bassi o alti, a seconda del valore 0 o 1 di un altro parametro: static char mask(int m, int x) { if(m == 0) return (char) x; // bit bassi else return (char) (x >> 16); // bit alti Definiamo una procedura di counting sort parametrica che ordina sui 16 bit inferiori o superiori: static void countsort(int k, int[] a, int subfield) { for(int i = 0; i < n; i++) c[mask(subfield, a[i])]++; c[mask(subfield, a[i])]... eccetera Definiamo infine la procedura radixsort che richiama due volte il counting sort: public static void radsort(int[] a) { countsort(0x10000, a, 0); countsort(0x10000, a, 1); dove 0x10000 è, in esadecimale, il numero 16 4, cioè 2 16 (il valore di k). 19/02/2007 E. Giovannetti - AlgELab Lez Ordinamento lineare di int non negativi in Java Se vogliamo invece effettuare la scomposizione in bytes, la funzione di estrazione potrebbe essere: static char mask(int m, int x) { switch(m) { case 1: break; case 2: x >>= 8; break; case 3: x >>= 16; break; case 4: x >>= 24; break; return (char) (x & 0xFF); (usiamo ancora il tipo char poiché in Java non esiste un tipo unsigned byte) Eccetera. 19/02/2007 E. Giovannetti - AlgELab Lez

6 Esercizio 3 Esercizio 3.1. Si completi la procedura di radix sort per interi non negativi con scomposizione in due campi da 16 bit. Si realizzi la procedura di radix sort per interi non negativi con scomposizione in bytes. Utilizzando array casuali di grandi dimensioni, si confrontino sperimentalmente tali due procedure con il quicksort, in modo da stabilire quale di esse è migliore, e in quali situazioni il radix sort batte il quicksort. Esercizio 3.2 (facoltativo). Si realizzi una procedura di radix sort per int con segno. La difficoltà è stabilire come estrarre i campi da 16 bit: ripassare la rappresentazione in compl. a due (Architetture). 19/02/2007 E. Giovannetti - AlgELab Lez