I programmeringsverdenen er manipulation af arrays en grundlæggende færdighed. Et array kan blandes, hvilket inkluderer tilfældig omarrangering af dets elementer, som en fælles proces. Denne procedure er afgørende for ting som at bygge randomiserede spildæk, køre statistiske simuleringer eller bare vise data mere tilfældigt. I første omgang er der meget logik, vi kan anvende til at blande et array; vi kan bruge forskellige typer af samlingsframeworks såsom ArrayList, hash-sæt, linkede lister osv. shuffling af et array kan gøres forskelligt og

Algoritme til at blande et array:

Følgende er algoritmen for shuffle af et array,

TRIN 1: START

TRIN 2: Start fra det sidste element i arrayet og gå tilbage til det første element.

TRIN 3: For hvert element ved indeks i, generer et tilfældigt indeks j, således at j er i området [0, i].

TRIN 4: Skift elementerne ved indeks i og j.

TRIN 5: Gentag trin 2 og 3 for alle elementer i arrayet, og flyt tilbage fra det sidste element til det første.

TRIN 6: ENDE

Vi kan blande et array, der indeholder forskellige typer elementer som heltal, tegn osv.

Fisher-yates Shuffle Algoritme:

Følgende Java-program bruges til at blande et array bestående af heltal.

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

Produktion:

 1 3 2 4 5 

Outputtet kan variere, hvis du udfører det i dit system, fordi det tilfældigt arrangerer elementerne og udsender det blandede array.

Kompleksiteter:

Blandingsalgoritmens rumkompleksitet er O(1), fordi den ikke bruger nogen ekstra datastrukturer, der afhænger af arrayets størrelse. Tidskompleksiteten af ​​Fisher-Yates shuffle-algoritmen brugt i shuffleArray()-metoden er O(n), hvor n er antallet af elementer i arrayet.

Blander array ved hjælp af lister i 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)); } } 

Produktion:

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

Outputtet kan variere, hvis du udfører det i dit system, fordi det tilfældigt arrangerer elementerne og udsender det blandede array.

Kompleksiteter:

python reducere

Rumkompleksiteten er også O(n). Dette skyldes, at metoden Collections.shuffle() ændrer den oprindelige liste på plads og ikke bruger yderligere datastrukturer. Tidskompleksiteten af ​​denne kode er O(n), hvor n er antallet af elementer i arrayet.

Bland array indeholdende tegn:

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

Produktion:

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

Outputtet kan variere, hvis du udfører det i dit system, fordi det tilfældigt arrangerer elementerne og udsender det blandede array.

Kompleksiteter:

Blandingsalgoritmens rumkompleksitet er O(1), fordi den ikke bruger nogen ekstra datastrukturer, der afhænger af arrayets størrelse. Tidskompleksiteten af ​​det program, der bruges i shuffleArray()-metoden, er O(n), hvor n er antallet af tegn i arrayet.

Konklusion:

Blanding af et array i Java er en afgørende færdighed, der sætter udviklere i stand til at skabe randomiserede og upartiske arrangementer af data. Gennem denne udforskning har vi dækket to effektive tilgange: Brug af metoden Collections.shuffle() til ikke-primitive arrays og implementering af Fisher-Yates shuffle-algoritmen for primitive arrays. Collections.shuffle()-metoden forenkler blandeprocessen for objekter eller ikke-primitive arrays ved at udnytte indbyggede funktionaliteter. På den anden side giver Fisher-Yates-algoritmen en effektiv og upartisk måde at blande primitive arrays på, hvilket sikrer ensartethed i permutationer.