La presentazione è in caricamento. Aspetta per favore

La presentazione è in caricamento. Aspetta per favore

1 Algoritmi e Strutture Dati III. Algoritmi di Ordinamento.

Presentazioni simili


Presentazione sul tema: "1 Algoritmi e Strutture Dati III. Algoritmi di Ordinamento."— Transcript della presentazione:

1 1 Algoritmi e Strutture Dati III. Algoritmi di Ordinamento

2 2 Algoritmi di ordinamento r Selection Sort r Quick Sort r Lower bound alla complessità degli algoritmi di ordinamento asd_library.sorting.SortingAlgorithms

3 3 Selection Sort r Lelemento minimo viene messo in posizione 0 r Si itera il procedimento sulle posizioni successive SelectionSort(dati[]) { for (i=0; i

4 4 Selection Sort/2 r Versione ricorsiva SelectionSort(dati[], i) { min =

5 5 Selection Sort/3 Ordinamento del vettore di interi {5, 2, 3, 8, 1}

6 6 Come ordinare oggetti diversi da numeri r Ordinare un vettore i cui elementi sono oggetti complessi. Es. oggetti della classe: class Persona { String cognome; String CF; public Persona (String cognome, String CF) { this.cognome = cognome; this.CF = CF; } r Come ordinare un array di tali oggetti rispetto al cognome ?

7 7 Come ordinare oggetti diversi da numeri/2 r Occorre: 1. Dichiarare che tra gli oggetti della classe (Persona nellesempio) è definito un ordinamento 2. Dichiarare rispetto a quale o a quali membri della classe è definito lordinamento (il cognome nel nostro caso) 3. Definire la regola che stabilisce lordinamento tra due oggetti della classe (nel nostro caso: due oggetti di tipo persona sono ordinati alfabeticamente secondo i rispettivi cognomi) r In C++ si possono sovraccaricare gli operatori r In Java si può dichiarare che la classe (Persona) implementa linterfaccia Comparable (non è la sola possibilità)

8 8 Come ordinare oggetti diversi da numeri/3 r Il passo 1 si traduce così: class Persona implements Comparable { …… } I passi 2 e 3 consistono nellimplementare lunico metodo previsto dallinterfaccia Comparable: int compareTo(Object o) r compareTo definisce le regole che stabiliscono lordinamento tra oggetti della classe (nel nostro caso, lordinamento è quello alfabetico sui cognomi)

9 9 Come ordinare oggetti diversi da numeri/4 r Quindi: class Persona implements Comparable { String cognome; String CF; public Persona (String cognome, String CF) { this.cognome = cognome; this.CF = CF; } public int compareTo (Object pers) { return cognome.compareTo(((Persona)pers).cognome); } Nota: occorre fare il cast perché compareTo vuole un Object

10 10 Selection Sort/4 public void selectionsort(Comparable[] data) { int i, j, least; for (i = 0; i < data.length-1; i++) { for (j = i+1, least = i; j < data.length; j++) if (data[j].compareTo(data[least]) < 0) least = j; swap(data, least, i); /* Scambia gli oggetti in pos. i e least */ } Es.: versione ricorsiva

11 11 Selection Sort - Tempo di esecuzione r Supponiamo che larray contenga n elementi r Alla i-esima iterazione occorre trovare il massimo di n-i+1 elementi e sono quindi necessari n-i confronti r Vi sono n-1 cicli Costo = r Si osservi che tale costo non dipende dall eventuale ordinamento parziale dellarray (cfr. Insertion Sort)

12 12 Quick Sort Disponi lelemento maggiore in ultima posizione quicksort(array[]) { if (array.length>1) { Scegli bound; /* subarray1 e subarray2 */ while (ci sono elementi in array) if (generico elemento < bound) inserisci elemento in subarray1; else inserisci elemento in subarray2; quicksort(subarray1); quicksort(subarray2); }

13 13 Quick Sort/2 Array subarray1 subarray2 < bound >= bound < bound1 >= bound2 >= bound1 < bound2

14 14 Partizionamento dellarray [ ] con quicksort

15 15 Proprietà di Quicksort r Uniterazione termina quando lower supera upper r data[first+1..upper]: elementi minori o uguali del pivot r data[upper+1..last]: elementi maggiori del pivot r Si scambia il pivot con lelemento in posizione upper r Si chiama ricorsivamente QuickSort su data[first+1..upper-1] e su data[upper+1..last], se gli array hanno almeno due elementi r Occorre evitare upper=last, per cui si dispone lelemento maggiore in ultima posizione

16 16 Partizionamento dellarray [ ] con quicksort

17 17 Quick Sort/3 void quicksort(Comparable[] data, int first, int last) { int lower = first + 1, upper = last; swap(data, first, (first+last)/2); /* Questo serve solo perché così, in pratica è spesso più veloce */ Comparable bound = data[first]; while( (lower <= upper)){ while(data[lower].compareTo(bound) <= 0) lower++; while (bound.compareTo(data[upper]) < 0) upper--; if (lower < upper) swap(data, lower++, upper--); else lower++; } /* End while */

18 18 Quick Sort/4 swap(data, upper, first); if (first < upper-1) /* se first == upper-1 il sottoarray ha solo 2 elementi ed è ordinato */ quicksort(data, first, upper-1); if (upper+1 < last) quicksort(data, upper+1, last); }

19 19 Analisi del Quick Sort r Costo = O(No. confronti) r Costo O(n 2 ) nel caso peggiore r Costo O(n log n) nel caso migliore e medio r In pratica lalgoritmo è efficiente r Scelta pivot fondamentale

20 20 Quick Sort – Caso peggiore Lelemento di pivot è sempre il minimo Costo = O(n-1+n ) = O(n 2 ) Array n-1 n n-1 volte n-2 No. confronti per sotto-array

21 21 Quick Sort – Caso migliore Array n-1 n/ log n+1 volte n/4-1 No. confronti per sotto-array Costo = n potenza di 2 per semplicità

22 22 Efficienza algoritmi di ordinamento r Merge Sort (e Heap Sort): O(n log n) r Quick Sort, Selection Sort, Insertion Sort: O(n 2 ) Quick Sort: O(n log n) nel caso migliore Selection Sort: O(n 2 ) in tutti i casi Insertion Sort: O(n) nel caso migliore r Domanda: qual è lefficienza massima (complessità minima) ottenibile nel caso peggiore -> Lower bound

23 23 Ordinamento – limiti inferiori r Osservazione fondamentale: tutti gli algoritmi devono confrontare elementi r Dati a i, a k, tre casi possibili: a i a k, oppure a i =a k r Si assume per semplicità che tutti gli elementi siano distinti r Si assume dunque che tutti i confronti abbiano la forma a i < a k, e il risultato del confronto sia vero o falso r Nota: se gli elementi possono avere lo stesso valore allora si considerano solo confronti del tipo a i <= a k

24 24 Alberi di decisione r Un albero di decisione rappresenta i confronti eseguiti da un algoritmo su un dato input r Ogni foglia corrisponde ad una delle possibili permutazioni a 1 :a 2 a 2 :a 3 a 1 :a 3 a 2 :a 3 a 1,a 2,a 3 a 1,a 3,a 2 a 3,a 1,a 2 a 2,a 1,a 3 a 2,a 3,a 1 a 3,a 2,a 1 < < > > < > < > < > Albero di decisione per Insertion Sort sullinsieme {a 1, a 2, a 3 }

25 25 Alberi di decisione/2 r Vi sono n! possibili permutazioni -> lalbero deve contenere n! foglie r Lesecuzione di un algoritmo corrisponde ad un cammino sullalbero di decisione corrispondente allinput considerato a 1 :a 2 a 2 :a 3 a 1 :a 3 a 2 :a 3 a 1,a 2,a 3 a 1,a 3,a 2 a 3,a 1,a 2 a 2,a 1,a 3 a 2,a 3,a 1 a 3,a 2,a 1 < < > > < > < > < > Albero di decisione per Insertion Sort sullinsieme {a 1, a 2, a 3 }

26 26 Alberi di decisione/3 r Riassumendo: m Albero binario m Deve contenere n! foglie r Il più lungo cammino dalla radice ad una foglia (altezza) rappresenta il No. confronti che lalgoritmo deve eseguire nel caso peggiore Teorema: qualunque albero di decisione che ordina n elementi ha altezza Ώ (n log n) r Corollario: nessun algoritmo di ordinamento ha complessità migliore di Ώ (n log n) Nota: esistono algoritmi di ordinamento con complessità più bassa, ma richiedono informazioni aggiuntive

27 27 Dimostrazione teorema 1. Un albero di decisione è binario 2. Albero binario di altezza h non ha più di 2 h-1 foglie 1= = = h h 3.Dobbiamo avere: 2 h-1 > No. foglie = n! 4.h-1 > log(n!)

28 28 Dimostrazione teorema/2 5. n! > (n/e) n (approssimazione di Stirling) 6. h-1 > log(n/e) n = n log(n/e) = n logn – n loge = Ώ (n log n) r Corollario: gli algoritmi Merge Sort e Heap Sort hanno complessità asintotica ottima

29 29 Il problema della Selezione r Determinare li-esimo elemento più piccolo di una collezione di n elementi. r Soluzione banale: ordinare linsieme di elementi e determinare lelemento in posizione i. Costo: O(n log n). r E possibile determinare li-esimo elemento con costo lineare?

30 30 Select(i) – Algoritmo dei mediani 1. Dividi in n/5 gruppi di 5 elementi ciascuno 2. Determina il mediano di ogni gruppo di 5 elementi 3. Invoca ricorsivamente Select(n/10) sullinsieme degli n/5 mediani per determinare m, il mediano dei mediani 4. Partiziona gli n elementi nellinsieme A dei k elementi più piccoli di m, e B degli n-k elementi >=m 5. Se i<=k, allora Select (A,i), altrimenti Select (B,i- k)

31 31 Analisi di Select(i) r Osservazione: Gli insiemi A e B contengono almeno 3n/10 elementi. r T(n)<=T(n/5)+T(7n/10)+dn r Ipotesi: T(n)<=cn T(n)<=cn/5+7cn/10+dn = 9cn/10 + dn <=cn se c/10>=d

32 32 Esercizi 1. Determinare la complessità di QuickSort se ad ogni passo il mediano degli elementi dellarray è selezionato come pivot con costo m(n) 2. Determinare un lower bound sul costo della ricerca di un elemento in una collezione ordinata 3. Si consideri la seguente equazione di ricorrenza Individuare un algoritmo di ordinamento la cui funzione di costo temporale è esprimibile tramite la F(n) definita. Determinare una delimitazione superiore per la funzione F(n)


Scaricare ppt "1 Algoritmi e Strutture Dati III. Algoritmi di Ordinamento."

Presentazioni simili


Annunci Google