La presentazione è in caricamento. Aspetta per favore

La presentazione è in caricamento. Aspetta per favore

1 Algoritmi di ordinamento r Selection Sort r Quick Sort r Lower bound alla complessità degli algoritmi di ordinamento.

Presentazioni simili


Presentazione sul tema: "1 Algoritmi di ordinamento r Selection Sort r Quick Sort r Lower bound alla complessità degli algoritmi di ordinamento."— Transcript della presentazione:

1 1 Algoritmi di ordinamento r Selection Sort r Quick Sort r Lower bound alla complessità degli algoritmi di ordinamento

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

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

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

5 5 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 ?

6 6 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à)

7 7 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)

8 8 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

9 9 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

10 10 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)

11 11 Quick Sort 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); }

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

13 13 Partizionamento dellarray [ ] con quicksort

14 14 Partizionamento dellarray [ ] con quicksort

15 15 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++; /* 1 */ } /* End while */ 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); }

16 16 Quick Sort/4 void quicksort(Comparable[] data) { if (data.length < 2) return; int max = 0; /* Trova max. e mettilo alla fine; serve per evitare che lower cresca oltre la dim. dell array (non è detto che accada ma può succedere) */ for (int i = 1; i < data.length; i++) if (data[max].compareTo(data[i]) < 0) max = i; swap(data, data.length-1, max); // largest el is now in its quicksort(data, 0, data.length-2); // final position; }

17 17 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

18 18 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

19 19 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à

20 20 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

21 21 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

22 22 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 }

23 23 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 }

24 24 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

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

26 26 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


Scaricare ppt "1 Algoritmi di ordinamento r Selection Sort r Quick Sort r Lower bound alla complessità degli algoritmi di ordinamento."

Presentazioni simili


Annunci Google