Gli algoritmi di ordinamento rappresentano un argomento fondamentale nello studio della programmazione e degli algoritmi. Comprendere il loro funzionamento permette non solo di ordinare dati, ma anche di sviluppare una mentalità orientata alla progettazione di soluzioni efficienti.

Algoritmi di ordinamento.

Pubblicato il: 3-7-2026

Ultima Modifica: 3-7-2026

Algoritmi di ordinamento: Bubble Sort, Selection Sort e Quick Sort

L'ordinamento dei dati è una delle operazioni più comuni nella programmazione. Che si tratti di un elenco di nomi, di voti scolastici, di prodotti in un magazzino o di record in un database, avere i dati ordinati permette di effettuare ricerche più veloci, migliorare la leggibilità delle informazioni e semplificare molte altre elaborazioni.

📚 In questo articolo analizzeremo tre tra gli algoritmi di ordinamento più conosciuti:

🫧 Bubble Sort
🎯 Selection Sort
⚡ Quick Sort

Ogni algoritmo verrà spiegato con esempi pratici nel linguaggio C, commentati riga per riga, in modo che anche chi è alle prime armi possa comprenderne il funzionamento.

📌 Che cos'è un algoritmo di ordinamento?

Un algoritmo di ordinamento è una procedura che dispone gli elementi di un insieme secondo un determinato criterio.

Ad esempio, dato l'array:

34 12 56 8 25

dopo l'ordinamento crescente diventerà:

8 12 25 34 56

Mentre in ordine decrescente sarà:

56 34 25 12 8

🎯 Perché ordinare i dati?

L'ordinamento offre numerosi vantaggi:

✅ facilita la ricerca di informazioni;

✅ migliora la leggibilità dei dati;

✅ permette l'utilizzo di algoritmi molto più veloci, come la ricerca binaria;

✅ è utilizzato praticamente in qualsiasi programma gestionale.

📊 Gli algoritmi che vedremo

Algoritmo	Difficoltà	Velocità
Bubble Sort	⭐	Lento
Selection Sort	⭐⭐	Medio
Quick Sort	⭐⭐⭐⭐	Molto veloce

Partiremo dall'algoritmo più semplice per arrivare a uno dei più utilizzati al mondo.

🫧 Bubble Sort

Bubble Sort è probabilmente il primo algoritmo di ordinamento che si studia.

Il suo funzionamento è molto intuitivo.

Confronta due elementi vicini e, se sono nell'ordine sbagliato, li scambia.

L'operazione viene ripetuta molte volte fino a quando l'intero array risulta ordinato.

🎨 Esempio grafico

Array iniziale:

25   10   40   18

Primo confronto:

L'array diventa:

10   25   40   18

Successivamente confronta:

25   40

Sono già ordinati.

Poi:

Alla fine del primo passaggio:

10   25   18   40

Il numero più grande è già arrivato in fondo.

Per questo motivo si dice che "galleggia" come una bolla d'aria, da cui il nome Bubble Sort.

🔄 Come funziona?

L'algoritmo esegue due cicli.

Il primo ripete i passaggi.

Il secondo confronta gli elementi adiacenti.

💻 Bubble Sort in C

#include <stdio.h>

int main()
{
    
			int numeri[] = {25,10,40,18,5};
    int n = 5;

			
    int i;
    int j;
    
			int temp;

    for(i = 0; i < n - 1; i++)
    
			{
        for(j = 0; j < n - i 
			- 1; j++)
        {
            
			if(numeri[j] > numeri[j + 1])
            
			{
                
			temp = numeri[j];
                
			numeri[j] = numeri[j + 1];
                
			numeri[j + 1] = temp;
            
			}
        }
    
			}

    printf("Array ordinato:\n");

    
			for(i = 0; i < n; i++)
        
			printf("%d ", numeri[i]);

    return 0;
}

📝 Come funziona il codice?

Il primo ciclo:

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

ripete l'intero processo.

Il secondo:

for(j = 0; j < n - i - 1; j++)

confronta le coppie di elementi vicini.

Quando trova due numeri nell'ordine sbagliato esegue lo scambio.

📈 Complessità del Bubble Sort

Caso	Complessità
Migliore	O(n) con ottimizzazione
Medio	O(n²)
Peggiore	O(n²)

È semplice ma poco efficiente per grandi quantità di dati.

👍 Vantaggi

✔ Facilissimo da capire.

✔ Ideale per imparare.

✔ Poche righe di codice.

👎 Svantaggi

❌ Molto lento.

❌ Effettua molti confronti inutili.

❌ Poco adatto a grandi archivi.

🎯 Selection Sort

Il Selection Sort utilizza un approccio differente.

Invece di confrontare continuamente elementi vicini, cerca ogni volta il valore più piccolo della parte ancora non ordinata dell'array.

Una volta trovato, lo scambia con il primo elemento disponibile.

🎨 Esempio

Array:

40 18 25 8 30

Il minimo è:

Lo porta davanti:

8 18 25 40 30

Adesso cerca il minimo tra:

18 25 40 30

che è:

Già al posto corretto.

Continua fino alla fine.

💻 Selection Sort in C

#include <stdio.h>

int main()
{
    
			int v[] = {40,18,25,8,30};
    int n = 5;

    
			int i;
    int j;
    int 
			minimo;
    int temp;

    
			for(i = 0; i < n - 1; i++)
    {
        
			minimo = i;

        for(j 
			= i + 1; j < n; j++)
        {
            
			if(v[j] < v[minimo])
                
			minimo = j;
        }

        
			temp = v[i];
        v[i] = 
			v[minimo];
        v[minimo] = 
			temp;
    }

    
			printf("Array ordinato:\n");

    for(i = 0; i 
			< n; i++)
        printf("%d 
			", v[i]);

    return 0;
}

🔎 Come lavora?

Ad ogni passaggio:

cerca il numero più piccolo;
ricorda la sua posizione;
esegue un solo scambio.

Effettua quindi meno scambi rispetto al Bubble Sort.

📈 Complessità

Caso	Complessità
Migliore	O(n²)
Medio	O(n²)
Peggiore	O(n²)

Anche se il numero di confronti rimane elevato, il numero di scambi è ridotto.

⚡ Quick Sort

Il Quick Sort è uno degli algoritmi più famosi e utilizzati.

È stato inventato nel 1959 dal matematico britannico Tony Hoare ed è ancora oggi uno degli algoritmi di ordinamento più efficienti per uso generale.

L'idea è molto intelligente.

Invece di ordinare tutto insieme, divide il problema in problemi più piccoli.

📌 Il concetto di Pivot

Quick Sort sceglie un elemento chiamato pivot.

Ad esempio:

40 18 25 8 30

Supponiamo che il pivot sia:

L'algoritmo separa i numeri in due gruppi.

Minori del pivot:

18 8

Maggiori del pivot:

40 30

Il pivot finisce automaticamente nella posizione corretta.

Successivamente ripete lo stesso procedimento sulle due parti.

🎨 Rappresentazione

40 18 25 8 30

        ↓

18 8 |25| 40 30

 ↓          ↓

18 8      30 40

L'algoritmo continua finché ogni gruppo contiene un solo elemento.

💻 Quick Sort in C

#include <stdio.h>

void 
			quicksort(int v[], int sinistra, int destra)
{
    
			int i = sinistra;
    int j = destra;
    
			int pivot = v[(sinistra + destra) / 2];
    int 
			temp;

    while(i <= j)
    
			{
        while(v[i] < pivot)
            
			i++;

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

        if(i <= j)
        
			{
            
			temp = v[i];
            
			v[i] = v[j];
            
			v[j] = temp;

            
			i++;
            
			j--;
        }
    
			}

    if(sinistra < j)
        
			quicksort(v, sinistra, j);

    if(i < destra)
        
			quicksort(v, i, destra);
}

int main()
{
    
			int v[] = {40,18,25,8,30,60,2};
    int n = 7;
    
			int i;

    quicksort(v, 0, n - 1);

    
			printf("Array ordinato:\n");

    for(i = 0; i 
			< n; i++)
        printf("%d 
			", v[i]);

    return 0;
}

🧠 La ricorsione

Quick Sort utilizza la ricorsione, cioè una funzione che richiama sé stessa.

Ogni chiamata lavora su una porzione sempre più piccola dell'array fino ad arrivare a gruppi di un solo elemento, che sono già ordinati.

È una tecnica molto potente e viene impiegata in numerosi algoritmi avanzati.

📈 Complessità del Quick Sort

Caso	Complessità
Migliore	O(n log n)
Medio	O(n log n)
Peggiore	O(n²)

Il caso peggiore è piuttosto raro se il pivot viene scelto in modo appropriato.

📊 Confronto tra gli algoritmi

Caratteristica	Bubble	Selection	Quick
Facilità di comprensione	⭐⭐⭐⭐⭐	⭐⭐⭐⭐	⭐⭐
Velocità	⭐	⭐⭐	⭐⭐⭐⭐⭐
Numero di scambi	Alto	Basso	Variabile
Uso della ricorsione	No	No	Sì
Adatto ai principianti	Sì	Sì	Dopo aver studiato la ricorsione

💡 Quando utilizzare ciascun algoritmo?

🫧 Bubble Sort

È ideale per imparare il funzionamento degli algoritmi di ordinamento e per piccoli esercizi didattici.

🎯 Selection Sort

Può essere utile quando si desidera limitare il numero di scambi tra gli elementi.

⚡ Quick Sort

È la scelta migliore nella maggior parte delle applicazioni reali, grazie alle sue elevate prestazioni su grandi quantità di dati.

🏁 Conclusioni

Il Bubble Sort è perfetto per iniziare, grazie alla sua semplicità. Il Selection Sort introduce un approccio più ragionato, riducendo il numero di scambi. Il Quick Sort, infine, mostra come tecniche avanzate come la ricorsione e la strategia "divide et impera" possano portare a prestazioni nettamente superiori.

💡 Consiglio finale: prova a implementare tutti e tre gli algoritmi utilizzando gli stessi dati di partenza e confronta il risultato. Successivamente, aumenta il numero di elementi da ordinare e misura il tempo di esecuzione di ciascun algoritmo. Questo semplice esperimento ti permetterà di capire concretamente perché, nella programmazione professionale, la scelta dell'algoritmo giusto può fare una grande differenza.