Programmazione

Programmazione
Algoritmi di ordinamento
Alessandra Raffaetà
Università Ca’ Foscari Venezia
Corso di Laurea in Informatica
Problema dell’ordinamento
ƒ Input: sequenza di N elementi <a1, …, aN>
ƒ Output: permutazione <ai1,…, aiN> tale che se
k < h allora minore(ak,ah).
ƒ Algoritmi basati sul confronto:
□Insertion sort.
□Selection sort.
□Bubble sort.
□Merge sort.
Insertion sort
ƒ Algoritmo di tipo incrementale.
ƒ Idea: ordinamento delle carte da gioco. Partendo con la
mano sinistra vuota e le carte sul tavolo, si preleva una
carta alla volta dal tavolo e si inserisce in posizione
corretta nella mano sinistra (cioè mantenendo le carte
in mano ordinate).
ordinata
?
i
ordinata
?
Si inserisce nel
sottoarray ordinato
[0..i-1] l’elemento di
indice i mantenendo
ordinato il
sottoarray [0..i]
Insertion sort
void insertionSort (TipoElem v[ ], int dim) {
int ind_sist,
/* indice dell’elemento da sistemare */
ind_contr;
/* indice dell’elemento da controllare */
TipoElem val_sist; /* valore dell’elemento da sistemare */
for (ind_sist = 1; ind_sist < dim; ind_sist++){
val_sist = v[ind_sist];
/* controlla e sposta gli elem partendo dall’ultimo elem sistemato */
}
}
ind_contr = ind_sist - 1;
while (ind_contr >= 0 && maggiore(v[ind_contr], val_sist)) {
v[ind_contr + 1] = v[ind_contr];
ind_contr --;
}
v[ind_contr + 1] = val_sist;
Invariante ciclo esterno dell’Insertion sort
ƒ Inv ≡ all’inizio di ogni iterazione del for il sottoarray
v[0, ind_sist) consiste degli elementi
originariamente in v[0, ind_sist) ma ordinati.
Selection sort
ƒ Idea: estrazioni successive del minimo.
ƒ Si cerca il più piccolo elemento dell’array e lo si
scambia con l’elemento di indice 0, quindi si
cerca in [1..dim-1] il più piccolo e lo si scambia
con l’elemento di indice 1 e così via.
ordinata
v
a
l
m
i
n
ordinata
m
i
n
v
a
l
Selection sort
void selectionSort (TipoElem v[ ], int dim) {
/* indice elemento minimo */
int i, j, i_min;
TipoElem temp;
for (i = 0; i < dim – 1; i++){
/* ricerca indice elemento minimo in v[i, dim-1] */
i_min = i;
for (j = i+1; j < dim; j++)
if (minore(v[j], v[i_min])
i_min = j;
if (i != i_min)
swap(v, i, i_min);
}
}
Invariante ciclo esterno del selection sort
ƒ Inv ≡ i∈ [0, dim - 1] ∧ v[0, i) ordinato
∧ ∀ k ∈[0, i). v[k] ≤ALL v[i, dim)
Bubblesort
ƒ Idea: Due elementi adiacenti si scambiano
posizione in modo che quello più piccolo si sposti
verso l’inizio dell’array.
□ Ad ogni passaggio l’elemento più piccolo si muove da
destra a sinistra fluttuando come una bolla verso
l’inizio dell’array.
ƒ Ottimizzazione: Se in un passaggio non è stato
effettuato nessuno scambio l’array è ordinato.
Bubblesort
void bubblesort(TipoElem v[ ], int dim) {
int i = 0, j, ordinato = 0;
TipoElem temp;
do {
ordinato = 1;
for (j = dim – 1; j > i; j --)
if (maggiore(v[j - 1], v[j])) {
/*elemento più piccolo galleggia verso l’alto*/
swap(v, j, j - 1);
ordinato = 0;
}
}
i++; /* ordinato == 1 sse nessuno scambio è stato effettuato */
} while (i < dim – 1 && !ordinato);
Invariante ciclo esterno del bubblesort
ƒ Inv ≡ i∈ [0, dim - 1] ∧ v[0, i) ordinato
∧ ∀ k ∈[0, i). v[k] ≤ALL v[i, dim)
∧ (ordinato → v[i, dim) ordinato)