ALGORITMI DI ORDINAMENTOCinzia Reverberi

COS’È UN ALGORITMO?

Un algoritmo è un insieme ben ordinato di operazioni non ambigue ed effettivamente calcolabili che, eseguito, produce un risultato e termina in una quantità finita di tempo.

In pratica, i punti principali di un algoritmo sono: -un insieme ben ordinato di operazioni -operazioni non ambigue e calcolabili -produce un risultato -termina in una quantità finita di tempo

ALGORITMO DI ORDINAMENTO E’ un algoritmo che viene utilizzato per elencare gli elementi di un

insieme secondo una sequenza stabilita da una relazione d’ordine.

Vi sono numerosi tipi di algoritmi di ordinamento:-quelli più semplici, iterativi: * insertion sort * selection sort * bubble sort

-applicabili solo in casi particolari: * counting sort * radix sort * bin o bucket sort

-più complessi, ricorsivi: * merge sort * quicksort * heapsort

INSERTION SORT È un algoritmo relativamente semplice che si occupa

di ordinare un array. Esso si occupa di ciò senza l’utilizzo di un array di appoggio (algoritmo in place).

L’algoritmo tende a spostare gli elementi maggiori verso destra: utilizza due indici. Il primo punta al secondo elemento dell’array, mentre il secondo punta al primo. Se il primo elemento è maggiore del secondo i due elementi vengono scambiati e successivamente il primo indice avanza di una posizione mentre il secondo parte da quello precedentemente puntato dal primo.

#include <stdlib.h>

#include <stdio.h>

#define MAX 100

/* * Legge in input il numero n ed n numeri interi * che memorizza nell'array. Restituisce il numero * di elementi letti (n). */

int leggi_array(int x[ ]) { int i, n; printf("Numero di elementi: ");

scanf("%d", &n);

printf("Inserisci %d elementi: ", n)

; for (i=0; i<n; i++)

scanf("%d", &x[i]); return(n); }

/* * Stampa in output l'array. *

void stampa_array(int x[ ], int n) {

int i;

for (i=0; i<n; i++)

printf("%d ", x[i]);

printf("\n");

return;

}

/* * Funzione che implementa l'algoritmo Insertion sort. * Riceve come argomento l'array ed il numero di * elementi contenuti nell'array. Non restituisce alcun * valore, ma modifica il contenuto dell'array, ordinandolo. */

void insertion_sort (int x[ ], int n) {

int i, j, app; for (i=1; i<n; i++) {

app = x[i];

j = i-1; while (j>=0 && x[j]>app) {

x[j+1] = x[j]; j--; }

x[j+1] = app; }

return; } /* * Funzione principale */

int main(void)

{ int v[MAX], n; n = leggi_array(v);

stampa_array(v, n);

insertion_sort(v, n);

stampa_array(v, n);

return(1); }

SELECTION SORT Come l’algoritmo precedente, opera in place.

I passi che compie l’algoritmo per ordinare l’array sono i seguenti:

- si inizializza un puntatore i che va da 1 a n (dove n è la lunghezza dell'array).

-Si cerca il più piccolo elemento dell'array -Scambia l'elemento più piccolo con l'elemento alla

posizione i -Incrementa l'indice i e si torna al passo uno fino alla

fine dell'array.

/* SELECTION SORT   Ricerca il minimo nella parte di array non ancora ordinata e lo ordina. Poi prosegue con altre ricerche ripetute nella parte di array non ancora ordinata.   */  

void selection_sort(int a[], int n) { //funzione tipo void, effettua modifiche permanenti e non restituisce nulla

. int min = a[0], i = 0, j, p = 0; //dichiariamo il minimo dell'array uguale alla sua prima componente.  

while (i < n) { //scansioniamo tutto l'array   for (j = i; j < n; j++){ //scansiona tutto l'array partendo da una posizione in più

poichè uscendo da qua 1 elemento sarà già ordinato.   if (a[j] < min) { //se l'elemento attuale è minore del minimo allora l'elemento attuale

sarà il nuovo minimo min = a[j]; p = j; //memorizziamo la posizione del minimo nell'array } }  

scambia (&a[i],&a[p]); //uscendo dal ciclo for scambiamo di posizione l'elemento iniziale della scansione con il minimo trovato.

i++; //incrementiamo i per passare a scansionare il restante array non ancora ordinato. min = a[i]; //settiamo il minimo uguale all'elemento dopo.  

} }

BUBBLE SORT

È un semplice algoritmo di ordinamento. Può essere utilizzato per ordinare tutti i tipi di elementi su cui sia definita una relazione d’ordine.

Il suo nome deriva dal fatto che durante il suo procedimento ci sono dati che si muovono nell’array velocemente e altri che lo fanno più lentamente. Ciò ricorda il movimento delle bollicine in un bicchiere di champagne.

/* BUBBLESORT - Ordinamento di un Array. */  

void bubblesort (int a[], int n) { int i, j; // N.B. n-1 è l'ultima componente dell'array.

for(i = 0; i < n - 1; i++) //scansiona tutto l'array tranne l'ultima componente: n - 1 escluso. Quindi fino al penultimo elemento.

for (j = n - 1; j > i; j--) //j settato all'ultima componente e decresce ad ogni iterazione. Esce dal ciclo solo se j <= i

if (a[j] < a[j-1]) //se la componente corrente è più piccola della precedente, li scambia.

scambia(&a[j],&a[j-1]);

}

  //la funzione scambia è così composta:

void scambia(int *a, int *b) { //richiede due indirizzi di memoria in entrata che verranno memorizzati in 2

puntatori.

int temp; //la variabile d'appoggio che memorizza temporaneamente il valore di a.

temp = *a;

*a = *b;

*b = temp; } //NB. l'asterisco * dei puntatori fa riferimento sempre al valore a cui punta il puntatore.

COUNTING SORT Algoritmo di ordinamento per valori numerici interi

L'algoritmo è semplice ed intuitivo: si calcolano i valori max(A) e min (A) e si prepara un array C di dimensione pari all'intervallo dei valori con C[i] che rappresenta la frequenza dell'elemento i+min(A) nell'array di partenza A. Si visita l'array A aumentando l'elemento di C corrispondente. Dopo si visita l'array C in ordine e si scrivono su A, C[i] copie del valore i+min(A).

RADIX SORT  è un algoritmo di ordinamento per valori numerici

interi, dove l  è la lunghezza dell'array e m  è la media del numero di cifre dei  numeri.

Esegue gli ordinamenti per posizione della cifra ma partendo dalla cifra meno significativa. Questo affinché l'algoritmo non si trovi a dovere operare ricorsivamente su sottoproblemi di dimensione non valutabili a priori.

BUCKET SORT

 è un algoritmo di ordinamento per valori numerici interi

 si prepara un array C di dimensione pari a m (cioè al valore massimo che può essere nell'array) con C[i] che rappresenta la frequenza dell'elemento i nell'array di partenza A. Si visita l'array A aumentando l'elemento di C corrispondente. Dopo si visita l'array C in ordine e si scrivono su A, C[i] copie del valore i.

#include <stdio.h> void bucketSort(int array[], int n) { int i, j; int count[n]; for(i=0; i < n; i++) { count[i] = 0; } for(i=0; i < n; i++) { (count[array[i]])++; } for(i=0,j=0; i < n; i++) { for(; count[i]>0; (count[i])--) { array[j++] = i; } } } 

int main() { int array[] = {1,3,4,6,4,2,9,1,2,9}; int n = 10; int i; for (i = 0;i < n;i++) { printf("%d ", array[i]); } printf("\n"); bucketSort(array, n); for (i = 0;i < n;i++) { printf("%d ", array[i] ); } printf("\n"); return 0; } 

MERGE SORT consiste nella suddivisione del problema in

sottoproblemi via via più piccoli.

Il merge sort opera quindi dividendo l'insieme da ordinare in due metà e procedendo all'ordinamento delle medesime ricorsivamente. Quando si sono divise tutte le metà si procede alla loro fusione (merge appunto) costruendo un insieme ordinato

/* * Legge in input il numero n ed n numeri interi * che memorizza nell'array. Restituisce il numero * di elementi letti (n). */

int leggi_array(int V[]) {

int n, i;

printf("Numero di elementi: ");

scanf("%d", &n);

for (i=0; i<n; i++)

scanf("%d", &V[i]); return(n);

}

/* * Stampa in output l'array. */

void stampa_array(int V[], int n) {

int i;

for (i=0; i<n; i++) {

printf("%d ", V[i]);

}

return; }

/* * Funzione Merge per la fusione di due * componenti ordinate dell'array. */

void Merge(int A[], int p, int q, int r) {

int i, j, k, B[MAX];

i = p;

j = q+1;

k = 0;

while (i<=q && j<=r) {

if (A[i]<A[j]) {

B[k] = A[i]; i++;

}

else {

B[k] = A[j]; j++;

}

k++; }

while (i<=q) {

B[k] = A[i];

i++;

k++; }

while (j<=r) {

B[k] = A[j];

j++;

k++; } f

or (k=p; k<=r; k++) A[k] = B[k-p]; return;

}

/* * Funzione ricorsiva MergeSort. */

void MergeSort(int A[], int p, int r) {

int q;

f (p<r) { q = (p+r)/2;

MergeSort(A, p, q);

MergeSort(A, q+1, r);

Merge(A, p, q, r); }

return; }

/* * Funzione principale */

int main(void) {

int n, V[MAX];

n = leggi_array(V);

MergeSort(V, 0, n-1);

stampa_array(V, n);

return(1); }

QUICKSORT

è un ottimo algoritmo di ordinamento ricorsivo in place 

a base del suo funzionamento è l'utilizzo ricorsivo della procedura partition: preso un elemento da una struttura dati (es. array) si pongono gli elementi minori a sinistra rispetto a questo e gli elementi maggiori a destra.

void scambia (tipobase v[], long i, long j)

{

tipobase tmp=v[i];

v[i]=v[j];

v[j]=tmp;

}

void QSort (tipobase v[], long inf, long sup)

{

tipobase pivot=v[(inf+sup)/2];

long i=inf,j=sup;

while (i<=j) {

while (v[i]<pivot) i++;

while (v[j]>pivot) j--;

if (i<j)

scambia(v,i,j);

if (i<=j) {

i++;

j--;

}

}

if (inf<j) QSort(v,inf,j);

if (i<sup) QSort(v,i,sup);

}

HEAPSORT

basa la sua potenza sull’utilizzo di una struttura dati chiamata Heap, che gestisce intelligentemente le informazioni durante l’esecuzione dell’algoritmo di ordinamento.