3. Algoritmi di ordinamento
° Gli algoritmi di ordinamento hanno lo scopo
di organizzare un insieme secondo una
relazione d'ordine 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. Selection Sort – L’Algoritmo
I passi da seguire sono i seguenti :
1) Posizionamento sul primo elemento dell’array
2) Ricerca dell’elemento più grande e scambio con
il primo elemento dell’array
3) Posizionamento sul secondo elemento dell’array
4) Ricerca dell’elemento più grande tra gli N-1
elementi rimasti e scambio con il secondo
elemento dell’array
5) Posizionamento sul terzo elemento dell’array
6) Ricerca dell’elemento più grande tra gli N-2
elementi rimasti e scambio con il terzo elemento
dell’array
7) Tale procedimento viene ripetuto N-1 volte
Osservazione : 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
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. 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. 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. ° 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. ° 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. ° 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. 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. 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 l'array è già completamente
ordinato
13
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. 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à all'ordinamento totale dell'array.
° Due cicli:
° un ciclo esterno: viene cercato l'elemento i
da spostare indietro. Si devono ancora
ordinare (n-i) elementi
° un ciclo interno: che scorre la porzione di
array alla ricerca dell'elemento più
leggero.
° Il metodo degli scambi ripetuti garantisce
che ad ogni passaggio sia ordinato un
elemento
--> per n elementi, servono n-1 passaggi
15
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. 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. 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 dell'array
non causa nessuno scambio, vuol
dire che l'array è 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. Algoritmo ottimizzato
Descrizione dell’algoritmo:
Finché l'array non è ancora
ordinato
° trovato=1
° per tutte le coppie contigue
nella parte dell'array non
ordinata
° se la coppia di elementi di
elementi non è ordinata
scambiare gli elementi della
coppia
trovato = 0
20
21. Algoritmo Bubble Sort ottimizzato
void 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. Complessità bubble sort
° Dipende dalla configurazione dei dati
di ingresso.
° Caso migliore
° se l'array di ingresso fosse già
ordinato l'algoritmo 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
