Dans le monde de la programmation, manipuler des tableaux est une compétence fondamentale. Un tableau peut être mélangé, ce qui inclut la réorganisation aléatoire de ses éléments, comme un processus courant. Cette procédure est essentielle pour des tâches telles que la création de plateformes de jeu aléatoires, l'exécution de simulations statistiques ou simplement l'affichage de données de manière plus aléatoire. Au départ, il y a beaucoup de logique que nous pouvons appliquer pour mélanger un tableau ; nous pouvons utiliser différents types de frameworks de collection tels que ArrayList, des jeux de hachage, des listes chaînées, etc. le brassage d'un tableau peut être effectué différemment et
Algorithme pour mélanger un tableau :
Ce qui suit est l'algorithme pour le brassage d'un tableau,
ÉTAPE 1: COMMENCER
ÉTAPE 2: Commencez par le dernier élément du tableau et revenez en arrière jusqu'au premier élément.
ÉTAPE 3: Pour chaque élément à l'index i, générez un index aléatoire j tel que j soit dans la plage [0, i].
ÉTAPE 4: Échangez les éléments aux indices i et j.
ÉTAPE 5 : Répétez les étapes 2 et 3 pour tous les éléments du tableau, en remontant du dernier élément au premier.
ÉTAPE 6 : FIN
Nous pouvons mélanger un tableau contenant différents types d'éléments comme des entiers, des caractères, etc.
Algorithme de lecture aléatoire Fisher-Yates :
Le programme Java suivant est utilisé pour mélanger un tableau composé d'entiers.
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; } } } Sortir:
1 3 2 4 5
La sortie peut différer si vous l'exécutez sur votre système, car elle organise les éléments de manière aléatoire et génère le tableau mélangé.
Complexités :
La complexité spatiale de l'algorithme de lecture aléatoire est O(1) car il n'utilise aucune structure de données supplémentaire dépendant de la taille du tableau. La complexité temporelle de l'algorithme de lecture aléatoire de Fisher-Yates utilisé dans la méthode shuffleArray() est O(n), où n est le nombre d'éléments dans le tableau.
Mélange d'un tableau à l'aide de listes en 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)); } } Sortir:
[4, 1, 7, 3, 6, 5, 2]
La sortie peut différer si vous l'exécutez sur votre système, car elle organise les éléments de manière aléatoire et génère le tableau mélangé.
Complexités :
10 1 millions
La complexité spatiale est également O(n). En effet, la méthode Collections.shuffle() modifie la liste d'origine en place et n'utilise aucune structure de données supplémentaire. La complexité temporelle de ce code est O(n), où n est le nombre d'éléments dans le tableau.
Tableau aléatoire contenant des caractères :
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; } } } Sortir:
Shuffled Characters: [e, f, g, d, a, c, b]
La sortie peut différer si vous l'exécutez sur votre système, car elle organise les éléments de manière aléatoire et génère le tableau mélangé.
Complexités :
La complexité spatiale de l'algorithme de lecture aléatoire est O(1) car il n'utilise aucune structure de données supplémentaire dépendant de la taille du tableau. La complexité temporelle du programme utilisé dans la méthode shuffleArray() est O(n), où n est le nombre de caractères dans le tableau.
Conclusion:
Mélanger un tableau en Java est une compétence cruciale qui permet aux développeurs de créer des arrangements de données aléatoires et impartiaux. Tout au long de cette exploration, nous avons abordé deux approches efficaces : utiliser la méthode Collections.shuffle() pour les tableaux non primitifs et implémenter l'algorithme de lecture aléatoire de Fisher-Yates pour les tableaux primitifs. La méthode Collections.shuffle() simplifie le processus de brassage des objets ou des tableaux non primitifs en exploitant les fonctionnalités intégrées. D'un autre côté, l'algorithme de Fisher-Yates fournit un moyen efficace et impartial de mélanger les tableaux primitifs, garantissant ainsi l'uniformité des permutations.