Classificazione degli algoritmi di ordinamento. Algoritmi e Laboratorio a.a Lezioni. Esercizio 1. Si può fare meglio?

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 Lezione 24 Algoritmi di ordinamento non per confronti. versione 16/11/09 Quest' opera è pubblicata sotto una Licenza Creative Commons Attribution-NonCommercial-ShareAlike 2.5. Classificazione degli algoritmi di ordinamento selection sort: sul posto, anzi spazio Θ(1); non stabile; tempo Θ(n 2 ) in tutti i casi; insertion sort: sul posto, anzi spazio Θ(1); stabile; tempo Θ(n 2 ) nei casi peggiore e medio, Θ(n) nel caso migliore; mergesort: non sul posto, spazio Θ(n); stabile; tempo Θ(n log n) nei casi peggiore e medio; quicksort: sul posto, spazio Θ(log n); non stabile; tempo Θ(n 2 ) nel caso peggiore, Θ(n log n) nei casi migliore e medio; heapsort: sul posto, anzi spazio Θ(1); non stabile; tempo Θ(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. 16/11/09 E. Giovannetti - AlgELab Lez.24 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. Nella slide precedente è scritto che la complessità in spazio del quicksort è Θ(log n). In realtà abbiamo visto che nel caso peggiore essa è Θ(n); tuttavia si può implementare il quicksort in modo che la complessità del caso peggiore in spazio sia proprio Θ(log n). Come? La risposta sarà data dopo aver studiato la eliminazione della ricorsione di coda. Si può fare meglio? Abbiamo dimostrato che non può esistere un algoritmo di ordinamento per soli confronti che abbia complessità del caso peggiore e del caso medio inferiori a n log n. Quindi heapsort e mergesort sono ottimali per caso peggiore e medio, quicksort è ottimale nel caso medio. Tuttavia, se si ammettono algoritmi non per soli confronti, si può fare ancor meglio. Tali algoritmi, a differenza degli algoritmi per confronti, non sono però applicabili in tutte le situazioni. 16/11/09 E. Giovannetti - AlgELab Lez /11/09 E. Giovannetti - AlgELab Lez.24 4 Problema 1.1: ordinare un array di n elementi aventi chiavi intere tutte distinte comprese fra 0 e n-1. Algoritmi di ordinamento non basati sui confronti: ordinamento in tempo lineare. Riprendiamo un esempio illustrato nella Lezione 17, 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. 16/11/09 E. Giovannetti - AlgELab Lez /11/09 E. Giovannetti - AlgELab Lez

2 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è lo studente di matricola h nell'elemento b[h-42000]; ovviamente ciò richiede un tempo Θ(n); l'ordinamento è stato effettuato senza operare nessun confronto. 16/11/09 E. Giovannetti - AlgELab Lez.24 7 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 "puri" compresi fra e 42999, senza elementi ripetuti. Per elemento intero "puro" 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). 16/11/09 E. Giovannetti - AlgELab Lez.24 8 Intermezzo Esercizio: Dato un testo rappresentato come un array di stringhe, e dato un vocabolario di parole contenente tutte le parole del testo, visualizzare sullo schermo, per ogni parola del vocabolario, il numero di volte in cui quella parola compare nel testo. 16/11/09 E. Giovannetti - AlgELab Lez.24 9 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. 16/11/09 E. Giovannetti - AlgELab Lez Integer sort: realizzazione 1 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 v = 0; v < k; v++) counters[v] = 0; //se a[i] contiene il valore v, incremento il v-esimo contatore for(int i = 0; i < n; i++) counters[a[i]]++; int i = 0; for(int v = 0; v < k; v++) { // per ogni valore v int m = counters[v];//numero dei valori v presenti for(int j = 0; j < m; j++) a[i++] = v; // m elementi uguali a v vengono messi nell'array 16/11/09 E. Giovannetti - AlgELab Lez Integer sort: realizzazione 2 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]]++; [j]] int i = 0; // per ogni valore v,... for(int v = 0; v < k; v++) { while(counters[v] > 0) { a[i] = v; i++; counters[v]--; //... metto in a tanti valori uguali a v quanti ne sono stati contati in counters[v] 16/11/09 E. Giovannetti - AlgELab Lez

3 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) Riassumendo: array di elementi interi o con chiavi intere in un range limitato elementi con chiavi tutte presenti e non ripetute: la chiave dà il posto in cui mettere l'elemento; serve array ausiliario per non sovrascrivere gli elementi; elementi interi puri, ripetuti e mancanti: bisogna contare il numero di presenze di ciascun valore; non serve array ausiliario, perché i valori si scrivono direttamente senza copiarli (si sa quali sono); elementi(non interi puri) con chiavi ripetute e mancanti: come si fa? 16/11/09 E. Giovannetti - AlgELab Lez /11/09 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 nuovo 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 quindi più sofisticato (vedi slide seg.). Idea risolutiva Qual è, nell'array ordinato, il posto in cui deve andare ciascun elemento? Il primo degli elementi di chiave h deve andare nel posto successivo a tutti gli elementi di chiave < h. Cioè (poiché gli array sono indiciati a partire da 0) l'indice del primo elemento di chiave h è dato dal numero degli elementi aventi chiave < h. Allora dobbiamo calcolare per ciascuna chiave h fra 0 a k, il numero degli elementi di chiave < h. 16/11/09 E. Giovannetti - AlgELab Lez /11/09 E. Giovannetti - AlgELab Lez Idea risolutiva alternativa Qual è, nell'array ordinato, il posto in cui deve andare ciascun elemento? L'ultimo degli elementi di chiave h deve andare nell'ultimo posto di tutti gli elementi di chiave h. Cioè (poiché gli array sono indiciati a partire da 0) l'indice dell'ultimo elemento di chiave h è dato dal numero degli elementi aventi chiave h, decrementato di 1. Allora dobbiamo calcolare per ciascuna chiave h fra 0 a k, il numero degli elementi di chiave h, decrementato di 1. Soluzione del Problema 4: il 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 per ipotesi ItemWithIntKey sia 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. 16/11/09 E. Giovannetti - AlgELab Lez /11/09 E. Giovannetti - AlgELab Lez

4 Conto quanti elementi ci sono per ogni chiave, con il solito procedimento: scorro l'array di partenza a e per ogni elemento a[i], presa la chiave a[i].key(), incremento il corrispondente contatore c[a[i].key()]; Conto quanti elementi ci sono per ogni chiave, con il solito procedimento: scorro l'array di partenza a e per ogni elemento a[i], presa la chiave a[i].key(), incremento il corrispondente contatore c[a[i].key()]; 16/11/09 E. Giovannetti - AlgELab Lez /11/09 E. Giovannetti - AlgELab Lez Conto quanti elementi ci sono per ogni chiave, con il solito procedimento: scorro l'array di partenza a e per ogni elemento a[i], presa la chiave a[i].key(), incremento il corrispondente contatore c[a[i].key()]; Si noti che, usando la sintassi del nuovo for, il "per ogni" è proprio traducibile "direttamente": for(itemwithintkey item: a) c[item.key()] ++; Conto quanti elementi ci sono per ogni chiave, con il solito procedimento: scorro l'array di partenza a e per ogni elemento a[i], presa la chiave a[i].key(), incremento il corrispondente contatore c[a[i].key()]; Si noti che, usando la sintassi del nuovo for, il "per ogni" è proprio traducibile "direttamente": for(itemwithintkey item: a) c[item.key()] ++; 16/11/09 E. Giovannetti - AlgELab Lez /11/09 E. Giovannetti - AlgELab Lez Così ora per ogni j ho in c[j] il numero di elementi di chiave uguale a j; a partire da tali dati, per ogni j calcolo e metto in c[j] il numero degli elementi di chiave < j, nel modo seguente: INVARIANTE: c[0.. j-1] è già stato aggiornato; 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++) { devo mettere totale in c[j], ma prima devo salvare c[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. 16/11/09 E. Giovannetti - AlgELab Lez Che cosa è il numero di chiavi < j? 0 m chiavi < j Se m è il numero di elementi con chiave minore di j, allora nell'array ordinato tali elementi occuperanno la porzione di array a[0.. m-1] 1], e a[m] sarà il posto del primo elemento di chiave >= j; quindi, se esistono elementi di chiave j, a[m] sarà il posto del primo elemento di chiave j. 16/11/09 E. Giovannetti - AlgELab Lez

5 (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]; incremento il contatore c[j], perché il successivo elemento di chiave j andrà messo nella posizione successiva: c[j]++; Concisamente: for(int i = 0; i < n; i++) { b[c[a[i].key()]] = a[i]; c[a[i].key()]++; 16/11/09 E. Giovannetti - AlgELab Lez (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]; incremento il contatore c[j], perché il successivo elemento di chiave j andrà messo nella posizione successiva: c[j]++; Concisamente: for(int i = 0; i < n; i++) { b[c[a[i].key()]] = a[i]; c[a[i].key()]++; 16/11/09 E. Giovannetti - AlgELab Lez (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]; incremento il contatore c[j], perché il successivo elemento di chiave j andrà messo nella posizione successiva: c[j]++; Concisamente: for(int i = 0; i < n; i++) { b[c[a[i].key()]] = a[i]; c[a[i].key()]++; 16/11/09 E. Giovannetti - AlgELab Lez (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]; incremento il contatore c[j], perché il successivo elemento di chiave j andrà messo nella posizione successiva: c[j]++; Concisamente: for(int i = 0; i < n; i++) { b[c[a[i].key()]] = a[i]; c[a[i].key()]++; 16/11/09 E. Giovannetti - AlgELab Lez Con il nuovo for, e inoltre evitando, grazie al ++, la doppia chiamata del metodo key(): for(itemwithintkey item: a) { b[c[item.key()]++] = item; che naturalmente si legge: di ogni elemento item (di tipo ItemWithIntKey) dell'array a estraiamo la chiave, con essa indiciamo l'array c dei contatori, ottenendo l'indice del posto in b in cui va messo item; operiamo l'assegnazione, e poi incrementiamo il contatore, in modo che esso sia di nuovo l'indice del posto in cui mettere il successivo elemento di chiave j (se esiste). (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) 16/11/09 E. Giovannetti - AlgELab Lez /11/09 E. Giovannetti - AlgELab Lez

6 Versione 2 per ogni j, metto in c[j] il numero di elementi di chiave uguale a j: 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]; Nota: un for "discendente" non può essere sostituito dal foreach. 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. 16/11/09 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) 3n + 2k oppure 3n + k = Θ(n+k) Se k è dello stesso ordine di grandezza di n, si ha: T(n) = Θ(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. 16/11/09 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! 16/11/09 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. 16/11/09 E. Giovannetti - AlgELab Lez Come fare affinché il bucket sort sia stabile? In ciascuna lista-secchiello gli elementi devono essere nello stesso ordine in cui erano nell'array originale. Quindi gli elementi devono essere via via inseriti al fondo di ciascuna lista. Se si usa il bucket sort per ordinare un array, quando poi si estraggono gli elementi da ciascuna lista per metterli nell'array-risultato, risultato, gli elementi devono essere via via estratti dall'inizio della lista. Allora in ciascuna lista-secchiello: si inserisce solo in fondo; si estrae solo dalla testa; quindi: le liste-secchielli sono code! 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. 16/11/09 E. Giovannetti - AlgELab Lez /11/09 E. Giovannetti - AlgELab Lez

7 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! 16/11/09 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, grosso modo, d(3n + k), con d e k costanti. 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. Tuttavia... vedi slide seguente. 16/11/09 E. Giovannetti - AlgELab Lez Esempio: radix sort su elementi (o chiavi) di tipo int. Vogliamo realizzare un algoritmo di ordinamento lineare per array di elementi 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. Quale delle due scomposizioni è più efficiente? 16/11/09 E. Giovannetti - AlgELab Lez Radix sort su int: confronto fra scomposizioni. 2 counting sort su 16 bit: il range dei possibili valori di 16 bit è k = 2 16, quindi: T(n) 2(3n ) 4 counting sort su 8 bit: il range dei possibili valori di 8 bit è k = 2 8, quindi: T(n) 4(3n ) Il tempo del primo metodo cresce più lentamente di quello del secondo, ma ha una costante iniziale molto più grande; al di sotto di una certa dimensione di soglia il secondo sarà quindi più efficiente del primo. Qual è la soglia? È approssimativamente il valore di n tale che: 2(3n ) = 4(3n ) n Il secondo metodo di scomposizione, inoltre, occupa meno spazio del primo (i contatori sono 2 8 invece di 2 16 ). 16/11/09 E. Giovannetti - AlgELab Lez Radix sort su interi di b bits L'ordinamento di sequenze di interi di b bits si effettua mediante b/r esecuzioni del counting sort su r bits (con r sottomultiplo di b). Il tempo di calcolo è quindi: T(n) = Θ((b/r)(n + 2 r )) Come scegliere r, cioè la dimensione dei "pezzi" su cui eseguire il counting sort? Osserviamo che: in b/r vogliamo r il più grande possibile; ma in n + 2 r non vogliamo 2 r molto maggiore di n, cioè non vogliamo r molto maggiore di log 2 n. Sceglieremo allora r il più grande possibile con il vincolo che non superi (troppo) log 2 n. Si noti che l'addendo 2 r cresce esponenzialmente al crescere di r, mentre il fattore b/r si riduce proporzionalmente; in generale, quindi, non conviene prendere un r troppo grande. 16/11/09 E. Giovannetti - AlgELab Lez Esempio Riprendiamo l'esempio di un array di int (32 bit). array di dimensione n 1000 : log r = 8 è una scelta ottimale (4 count. sort); array di dimensione n : log r = 16 è ottimale (2 counting sort); Tali risultati sono in accordo con quelli della valutazione più precisa contenuta nut nella slide 31. Nota Rispetto ai migliori algoritmi di ordinamento per confronti, il radix sort su interi è più efficiente per array di lunghezza molto grande. Altrimenti una buona implementazione del quicksort è di solito più veloce. 16/11/09 E. Giovannetti - AlgELab Lez

8 Radix sort su chiavi intere: implementazione. 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: hf 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) 16/11/09 E. Giovannetti - AlgELab Lez Radix sort 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). 16/11/09 E. Giovannetti - AlgELab Lez Radix sort 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. 16/11/09 E. Giovannetti - AlgELab Lez 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 confron- tino 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). 16/11/09 E. Giovannetti - AlgELab Lez