En el mundo de la programación, manipular arrays es una habilidad fundamental. Una matriz se puede mezclar, lo que incluye reorganizar aleatoriamente sus elementos, como un proceso común. Este procedimiento es esencial para cosas como construir plataformas de juego aleatorias, ejecutar simulaciones estadísticas o simplemente mostrar datos de forma más aleatoria. Inicialmente, hay mucha lógica que podemos aplicar para mezclar una matriz; Podemos usar diferentes tipos de marcos de recopilación como ArrayList, conjuntos de hash, listas vinculadas, etc. La mezcla aleatoria de una matriz se puede realizar de manera diferente y
Algoritmo para mezclar una matriz:
El siguiente es el algoritmo para la reproducción aleatoria de una matriz,
PASO 1: COMENZAR
PASO 2: Comience desde el último elemento de la matriz y retroceda hasta el primer elemento.
PASO 3: Para cada elemento en el índice i, genere un índice aleatorio j tal que j esté en el rango [0, i].
ETAPA 4: Intercambie los elementos en los índices i y j.
PASO 5: Repita los pasos 2 y 3 para todos los elementos de la matriz, retrocediendo desde el último elemento al primero.
PASO 6: FIN
Podemos mezclar una matriz que contenga diferentes tipos de elementos como números enteros, caracteres, etc.
Algoritmo aleatorio de Fisher-yates:
El siguiente programa Java se utiliza para mezclar una matriz formada por números enteros.
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; } } } Producción:
1 3 2 4 5
El resultado puede diferir si lo ejecuta en su sistema porque organiza los elementos aleatoriamente y genera la matriz aleatoria.
Complejidades:
La complejidad espacial del algoritmo aleatorio es O(1) porque no utiliza ninguna estructura de datos adicional que dependa del tamaño de la matriz. La complejidad temporal del algoritmo aleatorio de Fisher-Yates utilizado en el método shuffleArray() es O(n), donde n es el número de elementos de la matriz.
Mezclar matrices usando listas 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)); } } Producción:
[4, 1, 7, 3, 6, 5, 2]
El resultado puede diferir si lo ejecuta en su sistema porque organiza los elementos aleatoriamente y genera la matriz aleatoria.
Complejidades:
pitón de inserción
La complejidad del espacio también es O(n). Esto se debe a que el método Collections.shuffle() modifica la lista original en su lugar y no utiliza ninguna estructura de datos adicional. La complejidad temporal de este código es O(n), donde n es el número de elementos de la matriz.
Matriz aleatoria que contiene caracteres:
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; } } } Producción:
Shuffled Characters: [e, f, g, d, a, c, b]
El resultado puede diferir si lo ejecuta en su sistema porque organiza los elementos aleatoriamente y genera la matriz aleatoria.
Complejidades:
La complejidad espacial del algoritmo aleatorio es O(1) porque no utiliza ninguna estructura de datos adicional que dependa del tamaño de la matriz. La complejidad temporal del programa utilizado en el método shuffleArray() es O(n), donde n es el número de caracteres de la matriz.
Conclusión:
Mezclar una matriz en Java es una habilidad crucial que permite a los desarrolladores crear arreglos de datos aleatorios e imparciales. A lo largo de esta exploración, hemos cubierto dos enfoques efectivos: usar el método Collections.shuffle() para matrices no primitivas e implementar el algoritmo aleatorio de Fisher-Yates para matrices primitivas. El método Collections.shuffle() simplifica el proceso de mezcla de objetos o matrices no primitivas aprovechando las funcionalidades integradas. Por otro lado, el algoritmo de Fisher-Yates proporciona una manera eficiente e imparcial de mezclar matrices primitivas, asegurando uniformidad en las permutaciones.