In der Welt der Programmierung ist die Manipulation von Arrays eine grundlegende Fähigkeit. Ein Array kann als üblicher Prozess gemischt werden, was auch die zufällige Neuanordnung seiner Elemente umfasst. Dieses Verfahren ist für Dinge wie den Aufbau zufälliger Gaming-Decks, die Durchführung statistischer Simulationen oder einfach nur die zufälligere Anzeige von Daten unerlässlich. Zunächst gibt es viel Logik, die wir anwenden können, um ein Array zu mischen. Wir können verschiedene Arten von Sammlungsframeworks wie ArrayList, Hash-Sets, verknüpfte Listen usw. verwenden. Das Mischen eines Arrays kann auf unterschiedliche Weise erfolgen

Algorithmus zum Mischen eines Arrays:

Das Folgende ist der Algorithmus für das Mischen eines Arrays:

SCHRITT 1: START

SCHRITT 2: Beginnen Sie mit dem letzten Element des Arrays und gehen Sie rückwärts zum ersten Element.

SCHRITT 3: Generieren Sie für jedes Element am Index i einen Zufallsindex j, sodass j im Bereich [0, i] liegt.

SCHRITT 4: Vertauschen Sie die Elemente an den Indizes i und j.

SCHRITT 5: Wiederholen Sie die Schritte 2 und 3 für alle Elemente im Array und gehen Sie dabei rückwärts vom letzten Element zum ersten.

SCHRITT 6: ENDE

Wir können ein Array mischen, das verschiedene Arten von Elementen wie Ganzzahlen, Zeichen usw. enthält.

Fisher-Yates-Shuffle-Algorithmus:

Das folgende Java-Programm wird zum Mischen eines Arrays aus Ganzzahlen verwendet.

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; } } } 

Ausgabe:

 1 3 2 4 5 

Die Ausgabe kann unterschiedlich sein, wenn Sie es in Ihrem System ausführen, da es die Elemente zufällig anordnet und das gemischte Array ausgibt.

Komplexitäten:

Die räumliche Komplexität des Shuffle-Algorithmus beträgt O(1), da er keine zusätzlichen Datenstrukturen verwendet, die von der Größe des Arrays abhängen. Die zeitliche Komplexität des in der shuffleArray()-Methode verwendeten Fisher-Yates-Shuffle-Algorithmus beträgt O(n), wobei n die Anzahl der Elemente im Array ist.

Array mithilfe von Listen in Java mischen:

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)); } } 

Ausgabe:

 [4, 1, 7, 3, 6, 5, 2] 

Die Ausgabe kann unterschiedlich sein, wenn Sie es in Ihrem System ausführen, da es die Elemente zufällig anordnet und das gemischte Array ausgibt.

Komplexitäten:

Quartale im Jahr

Die Raumkomplexität ist ebenfalls O(n). Dies liegt daran, dass die Methode Collections.shuffle() die ursprüngliche Liste an Ort und Stelle ändert und keine zusätzlichen Datenstrukturen verwendet. Die zeitliche Komplexität dieses Codes beträgt O(n), wobei n die Anzahl der Elemente im Array ist.

Array mit Zeichen mischen:

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; } } } 

Ausgabe:

 Shuffled Characters: [e, f, g, d, a, c, b] 

Die Ausgabe kann unterschiedlich sein, wenn Sie es in Ihrem System ausführen, da es die Elemente zufällig anordnet und das gemischte Array ausgibt.

Komplexitäten:

Die räumliche Komplexität des Shuffle-Algorithmus beträgt O(1), da er keine zusätzlichen Datenstrukturen verwendet, die von der Größe des Arrays abhängen. Die zeitliche Komplexität des in der shuffleArray()-Methode verwendeten Programms beträgt O(n), wobei n die Anzahl der Zeichen im Array ist.

Abschluss:

Das Mischen eines Arrays in Java ist eine entscheidende Fähigkeit, die es Entwicklern ermöglicht, zufällige und unvoreingenommene Anordnungen von Daten zu erstellen. Im Rahmen dieser Untersuchung haben wir zwei effektive Ansätze behandelt: die Verwendung der Collections.shuffle()-Methode für nicht-primitive Arrays und die Implementierung des Fisher-Yates-Shuffle-Algorithmus für primitive Arrays. Die Collections.shuffle()-Methode vereinfacht den Mischvorgang für Objekte oder nicht-primitive Arrays durch die Nutzung integrierter Funktionen. Andererseits bietet der Fisher-Yates-Algorithmus eine effiziente und unvoreingenommene Möglichkeit, primitive Arrays zu mischen und so die Einheitlichkeit der Permutationen sicherzustellen.