Scarica Algoritmi di ordinamento: Merge Sort e Insertion Sort e più Schemi e mappe concettuali in PDF di Programmazione Java solo su Docsity!
Merge e Insertion Sort
Insertion Sort
L'Insertion Sort è un semplice algoritmo di ordinamento che costruisce gradualmente una lista ordinata, inserendo uno alla volta gli elementi non ancora ordinati nella posizione corretta.
Ecco come funziona l'algoritmo di Insertion Sort:
- Inizia con un'area iniziale di un elemento, che è già considerato ordinato.
- Prendi il primo elemento non ordinato dalla parte restante dell'array.
- Confronta l'elemento selezionato con gli elementi nella parte ordinata e sposta gli elementi più grandi a destra.
- Inserisci l'elemento selezionato nella posizione corretta nell'area ordinata.
- Ripeti i passaggi 2-4 finché tutti gli elementi non ordinati sono stati esaminati.
public class InsertionSort {
public static void insertionSort(int[] array) { if (array == null || array.length <= 1) { return; // Caso base: già ordinato o vuoto }
int n = array.length;
for (int i = 1; i < n; i++) { // ciclo for che itera a int key = array[i]; // Elemento corrente seleziona int j = i - 1; // Indice dell'elemento precedente
// Sposta gli elementi più grandi a destra while (j >= 0 && array[j] > key) { //ciclo while c array[j + 1] = array[j]; //spsota l'elemnto da j--; }
// Inserisci l'elemento selezionato nella posizio array[j + 1] = key; } } }
public class Main { public static void main(String[] args) { int[] array = {5, 2, 8, 12, 3}; InsertionSort.insertionSort(array); for (int num : array) { System.out.print(num + " "); } // Output: 2 3 5 8 12 } }
La complessità dell'algoritmo di Insertion Sort dipende dal numero di elementi da ordinare. Ecco la complessità nel caso peggiore, migliore:
Nel caso peggiore, quando l'array è ordinato al contrario la complessità è O(n^2), dove 'n' è il numero di elementi da ordinare. Nel caso migliore, quando l'array è già completamente ordinato la complessità è O(n), che è lineare.
array ausiliario per conservare temporaneamente i valori mentre si effettua la fusione.
- Ripeti i passaggi 2 e 3 finché l'array completo non è ordinato.
public class MergeSort { public static void sort(int[] arr) { int n = arr.length; if (arr == null || n<= 1) { return; // Caso base: già ordinato o vuoto } int mid = n / 2; int[] left = new int[mid]; int[] right = new int[n - mid]; for (int i = 0; i < mid; i++) { left[i] = arr[i]; } for (int i = mid; i < n; i++) { right[i - mid] = arr[i]; } sort(left); sort(right); merge(left, right, arr); }
private static void merge(int[] left, int[] right, int[] a int nL = left.length; int nR = right.length; int i = 0, j = 0, k = 0; while (i < nL && j < nR) { if (left[i] <= right[j]) { arr[k++] = left[i++]; } else { arr[k++] = right[j++]; } } while (i < nL) { arr[k++] = left[i++];
while (j < nR) { arr[k++] = right[j++]; } } }
public class Main { public static void main(String[] args) {
int[] array = {5, 2, 8, 12, 3}; MergeSort.sort(array); for (int num : array) { System.out.print(num + " "); } } }
La complessità del Merge Sort è O(n log n).
La complessità nel caso peggiore, nel caso medio e nel caso migliore del Merge Sort è sempre O(n log n). Questo perché l'algoritmo divide ricorsivamente l'array in due parti approssimativamente uguali e poi fonde le parti ordinate. Poiché l'operazione di divisione richiede log n passaggi (dove 'n' è il numero di elementi), e ogni passaggio richiede un tempo lineare per la fusione, l'algoritmo ha una complessità totale di O(n log n).
Perchè il merge sort è migliore
Il Merge Sort è generalmente considerato migliore rispetto al Selection Sort e al Bubble Sort per diversi motivi:
- Efficienza: Il Merge Sort ha una complessità temporale di O(n log n) nel caso peggiore, medio e migliore. Questo significa che è più efficiente dei Selection Sort e Bubble Sort, che hanno una complessità di O(n^2) nel caso peggiore. Il Merge Sort scala meglio con dimensioni di input più grandi.
