Lezione 18 (18 aprile 2012) ordinamenti

661 views

Published on

0 Comments
0 Likes
Statistics
Notes
  • Be the first to comment

  • Be the first to like this

No Downloads
Views
Total views
661
On SlideShare
0
From Embeds
0
Number of Embeds
2
Actions
Shares
0
Downloads
12
Comments
0
Likes
0
Embeds 0
No embeds

No notes for slide

Lezione 18 (18 aprile 2012) ordinamenti

  1. 1. Abilità Informatiche Ingegneria ChimicaLezione 18 del 18/04/2012 Prof. Antonino Stelitano
  2. 2. Docente Antonino StelitanoTutorLezioni Lunedì 14:00 – 17:30 aula 16 Mercoledì 15:45 – 19:00 aula 15 Lab. Paolo Ercoli – via Tiburtina 205Ricevimento: Per appuntamento antonino.stelitano@uniroma1.it stelitano.a@libero.itSito web: http://w3.uniroma1.it/ab_informatiche
  3. 3. Algoritmi di ordinamento° Gli algoritmi di ordinamento hanno lo scopo di organizzare un insieme secondo una relazione dordine stabilita.° Il caso degli algoritmi di ordinamento è particolarmente interessante, perché siamo di fronte ad algoritmi che fanno la stessa cosa, ma con complessità diversa.° La complessità è proporzionale alle dimensioni del problema, in questo caso al numero n degli elementi che dobbiamo ordinare.° Vedremo due algoritmi di ordinamento:  Ordinamento per selezione (o Selection Sort)  Ordinamento a bolle (o Bubble Sort) 3
  4. 4. Selection Sort – L’AlgoritmoI passi da seguire sono i seguenti :1) Posizionamento sul primo elemento dell’array2) Ricerca dell’elemento più grande e scambio con il primo elemento dell’array3) Posizionamento sul secondo elemento dell’array4) Ricerca dell’elemento più grande tra gli N-1 elementi rimasti e scambio con il secondo elemento dell’array5) Posizionamento sul terzo elemento dell’array6) Ricerca dell’elemento più grande tra gli N-2 elementi rimasti e scambio con il terzo elemento dell’array7) Tale procedimento viene ripetuto N-1 volteOsservazione : Per implementare l’Algoritmo abbiamo bisogno di 2 indici : Uno che tiene conto della posizione in cui si trova l’elemento da ordinare ( primo, secondo, terzo, … ) Uno che permette di scorrere l’array alla ricerca del valore maggiore A.Pi
  5. 5. Ordinamento per selezioneEsempio b d a cvettore APasso 1 d b a c d c a bPasso 2 d c b aPasso 3 A.Pi
  6. 6. Ordinamento per selezione(selection sort)° Funzionamento generale ° cerca nell’array ancora da ordinare l’elemento minimo ° porta tale elemento nella prima posizione dell’array ancora da ordinare 20 35 18 8 14 41 3 39 3 35 18 8 14 41 20 39 6
  7. 7. Ordinamento per selezione (selection sort) 20 35 18 8 14 41 3 39 3 35 18 8 14 41 20 39 Quindi, per tutti gli elementi dell’array: ° si cerca il primo elemento minimo e lo si porta in prima posizione, cioè in a[0] ° si cerca il secondo elemento minimo e lo si porta in seconda posizione, cioè in a[1] ° si cerca il terzo elemento minimo e lo si porta in seconda posizione, cioè in a[2] … ° si cerca il k-esimo elemento minimo e lo si porta in k-esima posizione, cioè in a[k] … ° Si procede così fino a che tutti gli elementi sono ordinati 7
  8. 8. Ordinamento per selezione (selection sort) ° L’individuazione dell’elemento minimo avviene scandendo tutto l’array (parte non ancora ordinata dell’array) ° Prima della prima iterazione va inizializzata la variabile min ° si assegna a min il primo elemento dell’array a[0] ° Per tutti gli elementi ° confronta min con l’elemento corrente a[i] ° se a[i] è minore di min, poni a[i] in min ° Scambia min con a[i] 20 35 18 8 14 41 3 39 ° Dobbiamo memorizzare l’indice del minimo 8
  9. 9. ° Algoritmo di ricerca del minimo min= a[0] i_min=0 for (j = 1; j < n; j++) if (a[j] < min) { min= a[j]; i_min=j; }° Scambio di min e a[0] a[i_min] = a[0]; a[0]= min; 9
  10. 10. ° La ricerca deve essere ripetuta per cercare il secondo elemento minimo, poi il terzo, il quarto, etc. fino ad arrivare all’elemento (n-1) che a quel punto sarà automaticamente ordinato° la ricerca del secondo elemento avverrà a partire dal secondo elemento (il primo è già ordinato)° la ricerca del terzo elemento avverrà a partire dal terzo elemento ………° quindi se ho ordinato i elementi cerco l’elemento più piccolo a partire dall’elemento i+1° ad ogni iterazione cerco il minimo che sposto in posizione (i+1)-esima 10
  11. 11. ° Per tutti gli elementi a[i] del vettore ° min= a[i] ° cerca il minimo a partire dell’elemento a[i+1] nella parte non ordinata da (i+1) alla fine del vettore) ° cerca l’elemento più piccolo confrontandolo con min ° quando individuato scambialo con min e memorizza la sua posizione i_min ° scambia min con a[i]° L’ultimo elemento è automaticamente ordinato, ° ciclo esterno da 0 a n-2 ° ciclo interno a partire i+1 fino a n-1° Per evitare un certo numero di assegnazioni, non memorizziamo il minimo in min, tanto abbiamo il suo indice 11
  12. 12. void SelectionSort (int A[ ], int n){ int i, j , i_min; int temp; for (i=0; i < n-1; i++) { i_min = i; /* cerca il minimo nella parte non ordinata */ for (j = i+1; j< n ; j++) if (A[j] < A[i_min]) i_min=j; if (i != i_min) { temp = A[i_min]; A[i_min] = A[i]; A[i] = temp; } }} 12
  13. 13. Complessità selection sort° Istruzione dominante ° Istruzione ripetuta più volte for (i = 0; i < n-1; i++) {……………... for (j =i+1; j< n ; j++) if (A[j] < A[i_min]) i_min=j; ……….° Il corpo del for esterno viene eseguito n -1 (ordine di n)° Il for interno viene eseguito circa n volte per ogni ciclo esterno ° Complessità: O(n2)° I cicli sono eseguiti un numero di volte che non dipende dalla particolare configurazione dei dati di ingresso. ° stesso costo per ogni possibile configurazione dei dati di ingresso;° O(n2) anche se larray è già completamente ordinato 13
  14. 14. Ordinamento a bolle (Bubble Sort)° Si basa sul confronto (ed eventuale scambio) successivo di due elementi contigui in cui il più leggero viene spinto indietro (indice più basso)° Confronto tra le ultime due posizioni (n-1 e n-2) ° si muove indietro il più leggero (verso indice più basso) ° l’elemento più piccolo viene spinto in prima posizione° Alla fine della prima scansione (sono stati analizzati n elementi) è stato ordinato un elemento: l’elemento più leggero (che si trova in posizione 0) ° Rimangono da ordinare gli altri (n-1) elementi. ° Non considero più l’elemento ordinato 14
  15. 15. Ordinamento a bolle (Bubble Sort)° L’iterazione del procedimento porterà in seconda posizione (indice 1) il successivo elemento più leggero ° Rimangono gli ultimi (n-2) ancora da ordinare.° La ripetuta applicazione di questa procedura porterà allordinamento totale dellarray.° Due cicli: ° un ciclo esterno: viene cercato lelemento i da spostare indietro. Si devono ancora ordinare (n-i) elementi ° un ciclo interno: che scorre la porzione di array alla ricerca dellelemento più leggero.° Il metodo degli scambi ripetuti garantisce che ad ogni passaggio sia ordinato un elemento --> per n elementi, servono n-1 passaggi 15
  16. 16. 30 12 18 8 14 41 3 3930 12 18 8 14 41 3 3930 12 18 8 14 3 41 3930 12 18 8 3 14 41 3930 12 18 3 8 14 41 3930 12 3 18 8 14 41 3930 3 12 18 8 14 41 393 30 12 18 8 14 41 39 16
  17. 17. ° Iterando su tutta la lunghezza dell’array (meno 1 perché l’ultimo elemento è automaticamente ordinato) (for ( i=0; i < n-1 ; i++)) ° Per tutte le coppie contigue dell’array (a partire j=n-2 e j=n-1) ° Se la coppia corrente non è ordinata, scambia tra loro gli elementi ° if (a[j] < a[j-1]) scambia la coppia° Loop interno: ° deve operare solo sulla parte che non ancora ordinata ° è legato al ciclo esterno: ° varia da n-1 a i (dove i e’ l’indice del ciclo esterno) 17
  18. 18. void BubbleSort (int A[ ], int n) { int i, j; int temp; for (i =0 ; i < n-1; i++) for (j = n-1 ; j > i ; j--) if (A[j] < A[j-1]) { temp = A[j]; A[j] = A[j-1]; A[j-1] = temp; }} 18
  19. 19. Algoritmo ottimizzato° L’array può risultare ordinato prima della fine del ciclo esterno.° Si può inserire un controllo per evitare di fare operazioni inutili: ° controllo di una variabile booleana legata all’avvenuto scambio di elementi ° quando una scansione dellarray non causa nessuno scambio, vuol dire che larray è ordinato. ° alla fine di ogni ciclo interno, si controlla il valore della variabile booleana per verificare se all’interno della scansione siano stati o meno effettuati scambi. 19
  20. 20. Algoritmo ottimizzatoDescrizione dell’algoritmo: Finché larray non è ancora ordinato ° trovato=1 ° per tutte le coppie contigue nella parte dellarray non ordinata ° se la coppia di elementi di elementi non è ordinata scambiare gli elementi della coppia trovato = 0 20
  21. 21. Algoritmo Bubble Sort ottimizzatovoid BubbleSort (int A[ ], int n){ int i=0, j, temp, ordinato; do { ordinato = 1; for (j = n-1 ; j > i ; j--) if (A[j] < A[j-1]) { temp = A[j]; A[j] = A[j-1]; A[j-1] = temp; ordinato = 0; } i++; } while (!ordinato && i < n-1);} 21
  22. 22. Complessità bubble sort° Dipende dalla configurazione dei dati di ingresso.° Caso migliore ° se larray di ingresso fosse già ordinato lalgoritmo compirebbe una sola scansione con nessuno scambio ° costo di esecuzione: O(n). ° Caso peggiore ° sono necessarie n - 1 fasi per completare la sua esecuzione (il vettore è ordinato in senso inverso) ° Proporzionale a n il ciclo interno ° costo di esecuzione: O(n2)° Si noti che è O(n2) solo nel caso peggiore, mentre il selection sort è sempre O(n2) 22

×