Nel mondo della programmazione, manipolare gli array è un'abilità fondamentale. Un array può essere mescolato, il che include la riorganizzazione casuale dei suoi elementi, come un processo comune. Questa procedura è essenziale per cose come la costruzione di mazzi di gioco randomizzati, l'esecuzione di simulazioni statistiche o semplicemente la visualizzazione dei dati in modo più casuale. Inizialmente, è possibile applicare molta logica per mescolare un array; possiamo utilizzare diversi tipi di framework di raccolta come ArrayList, set di hash, elenchi collegati, ecc. il mescolamento di un array può essere eseguito in modo diverso e
Algoritmo per mescolare un array:
Quello che segue è l'algoritmo per la riproduzione casuale di un array,
PASSO 1: INIZIO
PASSO 2: Inizia dall'ultimo elemento dell'array e torna indietro fino al primo elemento.
PASSO 3: Per ogni elemento dell'indice i, genera un indice casuale j tale che j sia compreso nell'intervallo [0, i].
PASSO 4: Scambia gli elementi negli indici i e j.
PASSO 5: Ripeti i passaggi 2 e 3 per tutti gli elementi dell'array, spostandoti all'indietro dall'ultimo elemento al primo.
PASSO 6: FINE
Possiamo mescolare un array contenente diversi tipi di elementi come numeri interi, caratteri, ecc.
Algoritmo Shuffle di Fisher-Yates:
Il seguente programma Java viene utilizzato per mescolare un array composto da numeri interi.
ArrayShuffle.java
import java.util.Random; public class ArrayShuffler { public static void main(String[] args) { // Sample array of integers int[] array = {1, 2, 3, 4, 5}; // Shuffle the array shuffleArray(array); // Print the shuffled array for (int num : array) { System.out.print(num + ' '); } } public static void shuffleArray(int[] array) { Random rand = new Random(); for (int i = array.length - 1; i > 0; i--) { // Generate a random index between 0 and i (inclusive) int j = rand.nextInt(i + 1); // Swap the elements at indices i and j int temp = array[i]; array[i] = array[j]; array[j] = temp; } } } Produzione:
1 3 2 4 5
L'output potrebbe differire se lo esegui nel tuo sistema perché dispone gli elementi in modo casuale e genera l'array mescolato.
Complessità:
La complessità spaziale dell'algoritmo di riordino è O(1) perché non utilizza alcuna struttura dati aggiuntiva che dipenda dalla dimensione dell'array. La complessità temporale dell'algoritmo shuffle di Fisher-Yates utilizzato nel metodo shuffleArray() è O(n), dove n è il numero di elementi nell'array.
Array mescolato utilizzando gli elenchi in Java:
ShuffleArray.java
import java.util.Arrays; import java.util.Collections; import java.util.List; public class ShuffleArray { public static void main(String[] args) { Integer[] intArray = {1, 2, 3, 4, 5, 6, 7}; List intList = Arrays.asList(intArray); Collections.shuffle(intList); intList.toArray(intArray); // This line will not resize the array System.out.println(Arrays.toString(intArray)); } } Produzione:
[4, 1, 7, 3, 6, 5, 2]
L'output potrebbe differire se lo esegui nel tuo sistema perché dispone gli elementi in modo casuale e genera l'array mescolato.
Complessità:
cos'è un nome utente
Anche la complessità dello spazio è O(n). Questo perché il metodo Collections.shuffle() modifica l'elenco originale e non utilizza alcuna struttura dati aggiuntiva. La complessità temporale di questo codice è O(n), dove n è il numero di elementi nell'array.
Matrice casuale contenente caratteri:
ShuffleCharacters.java
import java.util.Arrays; import java.util.Random; public class ShuffleCharacters { public static void main(String[] args) { char[] charArray = {'a', 'b', 'c', 'd', 'e', 'f', 'g'}; shuffleArray(charArray); System.out.println('Shuffled Characters: ' + Arrays.toString(charArray)); } public static void shuffleArray(char[] array) { Random rand = new Random(); for (int i = array.length - 1; i > 0; i--) { int j = rand.nextInt(i + 1); // Swap characters at indices i and j char temp = array[i]; array[i] = array[j]; array[j] = temp; } } } Produzione:
Shuffled Characters: [e, f, g, d, a, c, b]
L'output potrebbe differire se lo esegui nel tuo sistema perché dispone gli elementi in modo casuale e genera l'array mescolato.
Complessità:
La complessità spaziale dell'algoritmo di riordino è O(1) perché non utilizza alcuna struttura dati aggiuntiva che dipenda dalla dimensione dell'array. La complessità temporale del programma utilizzato nel metodo shuffleArray() è O(n), dove n è il numero di caratteri nell'array.
Conclusione:
Mescolare un array in Java è un'abilità cruciale che consente agli sviluppatori di creare disposizioni di dati casuali e imparziali. Nel corso di questa esplorazione, abbiamo trattato due approcci efficaci: utilizzare il metodo Collections.shuffle() per array non primitivi e implementare l'algoritmo shuffle di Fisher-Yates per array primitivi. Il metodo Collections.shuffle() semplifica il processo di mescolamento di oggetti o array non primitivi sfruttando le funzionalità integrate. D'altra parte, l'algoritmo di Fisher-Yates fornisce un modo efficiente e imparziale per mescolare gli array primitivi, garantendo uniformità nelle permutazioni.