Algoritmi - WordPress.com

Un algoritmo è un procedimento che risolve un determinato
problema attraverso un numero finito di passi.
Un problema risolvibile mediante un algoritmo si dice computabile.
ALCUNI TIPI DI ALGORITMI
Selection Sort
L'ordinamento per selezione è un algoritmo di ordinamento che opera in
place (un algoritmo si dice in loco oppure in place quando è in grado di
trasformare una struttura dati utilizzando soltanto un piccolo e costante
spazio di memoria extra, i dati in ingresso sono solitamente sovrascritti
con il risultato prodotto durante l'esecuzione dell'algoritmo ed in modo
simile all‘ordinamento per inserzione).
L'algoritmo è di tipo non adattivo, ossia il suo tempo di esecuzione non
dipende dall'input ma dalla dimensione dell'array.
Alla prima iterazione verrà selezionato l’elemento più piccolo dell’intero insieme e
sarà scambiato con quello che occupa la prima posizione.
Alla seconda iterazione è selezionato il secondo elemento più piccolo
dell’insieme è viene scambiato con l’elemento che occupa la seconda posizione.
Si ripete fino ad aver collocato nella posizione corretta tutti gli n elementi.
Esempio:
void selsort(int x[ ], int y) {
int z=0;
for (z=0;z<n;z++) {
int y=0;
for (y=z+1;y<n;y++) {
if (x[y] < x[y]) {
int t=x[y];
x[y]=x[z];
x[z]=t;
}
}
}
Inserction Sort
L'Insertion sort, in italiano ordinamento a inserimento, è
un algoritmo relativamente semplice per ordinare un array.

Non è molto diverso dal modo in cui un essere umano, spesso, ordina un
mazzo di carte.
Esso è un algoritmo in place, cioè ordina l'array senza doverne creare una
copia, risparmiando memoria.
Pur essendo molto meno efficiente di algoritmi più avanzati, può avere
alcuni vantaggi: ad esempio, è semplice da implementare ed è efficiente
per insiemi di partenza che sono quasi ordinati.
Ad ogni iterazione, il vettore è costituito da una parte iniziale ordinata e
da la parte rimanente che contiene i valori da ordinare.
Per ogni valore ancora da inserire, viene fatta una ricerca binaria nella
parte ordinata del vettore e vengono spostati in avanti tutti gli elementi
per liberare una posizione.
Nella posizione liberata viene inserito il valore.
Esempio:
void inssort(int a[ ] ,int n) {
int i=0,j=0;
for (i=1;i<n;i++) {
int x=a[i], s=1, d=i-1;
while (s<=d) {
int m=(s+d)/2;
if (x<a[m]) d=m-1;
else s=m+1;
}
for (j=i-1,j>=s;j--) a[j+1]=a[j];
a[s]=x;
}
}

Bubble Sort
L’algoritmo bubble sort (ordinamento a bolle) si basa sull’idea di
far emergere pian piano gli elementi più piccoli verso l’inizio dell’insieme
da ordinare facendo sprofondare gli elementi maggiori verso il fondo: un
po’ come le bollicine in un bicchiere di acqua gassata da qui il nome di
ordinamento a bolle.
Esempio:
void bubbsort(int x[ ], int y) {
bool scambio=true;
int ultimo=y-1,i=0;
while (scambio) {
scambio=false;
for (i=0;i<ultimo;i++) {
if ( x[i]> x[i+1]) {
int t= x[i];
x[i]=x[i+1];
x[i+1]=t;
scambio=true;
}
}
ultimo --;
}
}
Quick Sort
Quick sort è un algoritmo di ordinamento ricorsivo in place che,
come merge sort, si basa sul paradigma divide et impera.
La 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.
Assunto un elemento come perno, si confrontano con esso gli altri elementi
e si posizionano alla sua sinistra i minori e a destra i maggiori, senza tener
conto del loro ordine. Dopo questo stadio si ha che il perno è nella sua
posizione
definitiva. Successivamente si procede in modo ricorsivo all'ordinamento
parziale delle sottosequenze di elementi rimasti non ordinati, fino al loro
esaurimento.
Esempio:
void sort(int a[ ], int inizio, int fine) {
int x, y, z;
if (fine >inizio) {
x = a [inizio];
y= inizio + 1;
z= fine+1;
while (y < z) {
if (a [y] < x) y++;
else {
r--;
swap(a[y], a[z]);
}
void swap(int & x, int & y) {
int temp=x;
x=y;
y=temp;
}
Merge Sort
Il merge sort è un algoritmo di ordinamento basato su confronti che utilizza
un processo di risoluzione ricorsivo, sfruttando la tecnica del Divide et
Impera, che consiste nella suddivisione del problema in sottoproblemi della
stessa natura di dimensione via via più piccola.
L'insieme di elementi viene diviso in 2 metà. Se l'insieme è composto da un
numero dispari di elementi, viene diviso in 2 sottogruppi dei quali il primo ha
un elemento in meno del secondo. Supponendo di avere due sequenze già
ordinate.
Per unirle, merge sort estrae ripetutamente il minimo delle due sequenze in
ingresso e lo pone in una sequenza in uscita.
Esempio:
void mersort (int x[ ], int sinistra, int centro,
int destra)
int i = sinistra, j=centro+ 1,k=0;
void mergesort (int[] a, int left, int right) {
int y[ ];
int center;
while ((i <= centro) && (j <= destra)) {
if (left < right) {
if (x[i] <= x[j]){
center = (left + right) / 2;
y[k]=a[i];
mergesort(a, left, center);
i=i + 1;
mergesort(a, center+1, right);
} else {
merge(a, left, center, right);
y[k] = x[j];
}
j=j + 1;
}
k=k + 1;
}
for (k =left ;k<right;k++) {
a[k] = b[k - left];
}
void 1_Heap(t_id_tab a[], int n, int lh, int i){
int s, d, max;
s = 2*i + 1;
d = 2*i + 2;
if ((s < lh) && (a[s] > a[i]))
max = s;
Else
max = i;
if ((d < lh) && (a[d].chaive > a[max].chiave))
max = d;
if (max != i){ temp = a[i]; a[i] = a[max];
a[max] = temp;
1_Heap(a, n, lh, max);
void 2_Heap(t_id_tab a[], int n){
int i;
for(i = n/2 - 1; i >= 0; i--)
1 Heap(a, n, lh, i);
Heap Sort
void HeapSort(int a[ ], int n){
int i;
int lh = n;
Costruisci_Heap(a, n);
for(i = n-1; i > 0; i--){
temp = a[i];
a[i] = a[0];
a[0] = temp;
lh--;
Rendi_Heap(a, n, lh, 0); }
}
L' heap sort è un algoritmo di ordinamento iterativo ed in place proposto da
Williams nel 1964, che si basa su strutture dati ausiliarie.
L' heapsort per eseguire l'ordinamento, utilizza una struttura
chiamata heap (mucchio); un heap è rappresentabile con un albero binario in
cui tutti i nodi seguono una data proprietà, detta priorità.
Esso è completo almeno fino al penultimo livello dell'albero e ad ogni nodo
corrisponde uno ed un solo elemento.
Counting Sort
Per ogni elemento x dell'insieme da ordinare si determinano quanti elementi sono
minori di x, si usa questa informazione per assegnare ad x la sua posizione finale nel
vettore ordinato. Se, ad esempio, vi sono 8 elementi minori di x, allora x andrà messo
nella posizione 9 bisogna fare attenzione al caso in cui vi siano elementi coincidenti. In
questo caso infatti non vogliamo assegnare a tutti la stessa posizione.
void counting_sort(int* A, int Alen, int* B, int k){
int i;
int C[k];
for(i=0; i<k; i++)
C[i] = 0;
int j;
for(j=0; j<Alen; j++)
C[A[j]] = C[A[j]]+1;
for(i=1; i<k; i++)
C[i] = C[i]+C[i-1];
for (j=Alen-1; j>=0; j--){
B[C[A[j]]-1] = A[j];
C[A[j]] = C[A[j]]-1;
}
}
Bucket Sort
Il Bucket sort è un algoritmo di ordinamento per valori numerici che si assume
siano distribuiti uniformemente in un intervallo semichiuso (0,1).
La complessità del bucket sort è lineare O(n+m) (ove m è il valore max
nell'array), questo è possibile in quanto l'algoritmo non è basato su confronti.
Bucket sort suppone che l’input sia generato da un processo casuale che distribuisce
gli elementi uniformemente nell’intervallo [0, 1[. Il concetto che sta alla base
dell’algoritmo è quello di dividere l’intervallo [0, 1[ in n sotto intervalli della stessa
dimensione, detti bucket, nei quali vengono distribuiti gli n valori di input.
A questo scopo lo pseudocodice che definisce l’algoritmo suppone che l’input sia un
array A di n elementi e richiede un array ausiliario B[0...n−1] di liste concatenate
(bucket).
L’algoritmo procede semplicemente ordinando i valori in ogni bucket tramite un
ordinamento di tipo insertion sort.
L’output viene infine prodotto concatenando in ordine i vari bucket in un array.
Esempio:
#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;
FINE
Di Jessica Pasquarelli