Appunti per il modulo di algoritmi e strutture dati - Sezione di ...

2.2 Due algoritmi di ordinamento iterativi
Il problema dell’ordinamento è quello di ordinare in modo crescente o decrescente, in base ad una qualche
definizione di relazione d’ordine, un insieme di elementi. In questa sezione presentiamo due algoritmi di
ordinamento non ricorsivi. Nelle sezioni successive torneremo sul problema e definiremo altri algoritmi
più efficienti. Consideriamo il caso in cui l’insieme sia memorizzato in un array. Il primo algoritmo
che consideriamo, chiamato selection-sort (ordinamento per selezione) è il seguente: dato un array di n
elementi, si cerca l’elemento più piccolo e lo si mette al primo posto. Poi si cerca il più piccolo fra i
rimanenti n − 1 elementi e lo si mette al secondo posto, e così via. Una possibile funzione è la seguente.
Essa usa una funzione che scambia due elementi di un array. Supponiamo che gli elementi dell’array
siano interi.
void exchange ( int & x, int & y) {
int temp ;
temp =x; x=y; y= temp ;
}
void selectionSort ( int *A, int n) {
for ( int i =0; i< n -1; i ++) {
int min = i;
for ( int j=i +1; j< n; j ++)
if (A[j] < A[ min ]) min =j;
exchange (A[i], A[ min ]);
}
}
Calcoliamo ora, utilizzando la regola induttiva definita nella precedente sezione, la complessità del
tempo di esecuzione della procedura definita, in funzione del numero di elementi nell’array, cioè n. Si
vede facilmente che il tempo di tutti gli assegnamenti del programma è O(1); come esempio, consideriamo
j=i+1;:
C[[j = i + 1]] = C[[i + 1]] = C[[i]] + C[[1]] = O(1) + O(1) = O(1)
dove l’ultimo passaggio è ottenuto utilizzando la regola della somma. Calcoliamo ora la complessità
del comando condizionale:
C[[if(A[j] < A[min])min = j]] = C[[A[j] < A[min]]] + C[[min = j]] = O(1) + O(1) + O(1) = O(1)
Consideriamo ora il for più interno. Il suo corpo viene eseguito n − i − 1 volte all’i-esima iterazione.
Possiamo fare qualche considerazione per esprimere il tempo in termini solo di n. Poiché i non diventa
mai minore di 0, abbiamo che n − 1 è un limite per n − i. Quindi un limite al numero di volte in cui il
for è eseguito è n − 1, che è O(n). Abbiamo:
C[[for . . .]] = = C[[i + 1]] + (C[[n − 1]] + C[[if . . .]] + C[[j + +]])O(n) = O(1) + O(1) + O(1)O(n) = O(n)
dove l’ultimo passagio è ottenuto applicando le regole della somma e del prodotto. L’assegnamento
min=i e la chaimata alla funzione exchange hanno complessità costante. Quindi il corpo del for più
esterno ha complessità O(n). Poiché esso è eseguito, n − 1 volte, il for ha complessità O(n 2 ). Infine,
poiché il blocco più esterno è costituto dal solo comando for, abbiamo che O(n 2 ) è anche l’ordine di
complessità del tempo di esecuzione dell’intera funzione. Nel calcolo della complessità fin qui descritto,
abbiamo approssimato per eccesso il tempo del ciclo più interno supponendo che ogni sua iterazione
10