Programavimo pasaulyje manipuliuoti masyvais yra pagrindinis įgūdis. Masyvas gali būti maišomas, įskaitant atsitiktinį jo elementų pertvarkymą, kaip vieną bendrą procesą. Ši procedūra yra būtina norint sukurti atsitiktinių žaidimų komplektus, vykdyti statistinius modeliavimus ar tiesiog rodyti duomenis atsitiktiniu būdu. Iš pradžių yra daug logikos, kurią galime pritaikyti maišydami masyvą; galime naudoti įvairių tipų rinkinių sistemas, tokias kaip ArrayList, maišos rinkinius, susietus sąrašus ir kt. masyvo maišymas gali būti atliekamas skirtingai ir
Masyvo maišymo algoritmas:
Toliau pateikiamas masyvo maišymo algoritmas,
1 ŽINGSNIS: PRADĖTI
2 ŽINGSNIS: Pradėkite nuo paskutinio masyvo elemento ir eikite atgal į pirmąjį elementą.
3 ŽINGSNIS: Kiekvienam indekso i elementui sugeneruokite atsitiktinį indeksą j, kad j būtų diapazone [0, i].
4 ŽINGSNIS: Sukeiskite elementus prie indeksų i ir j.
5 ŽINGSNIS: Pakartokite 2 ir 3 veiksmus visiems masyvo elementams, pereidami nuo paskutinio elemento į pirmąjį.
6 ŽINGSNIS: GALAS
Galime maišyti masyvą, kuriame yra įvairių tipų elementų, tokių kaip sveikieji skaičiai, simboliai ir kt.
Fisher-yates maišymo algoritmas:
Ši Java programa naudojama masyvo, kurį sudaro sveikieji skaičiai, maišymui.
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; } } } Išvestis:
1 3 2 4 5
Išvestis gali skirtis, jei ją vykdote savo sistemoje, nes ji atsitiktinai sutvarko elementus ir išveda sumaišytą masyvą.
Sudėtingumas:
Maišymo algoritmo erdvės sudėtingumas yra O(1), nes jis nenaudoja jokių papildomų duomenų struktūrų, kurios priklauso nuo masyvo dydžio. ShuffleArray() metodu naudojamo Fisher-Yates shuffle algoritmo laiko sudėtingumas yra O(n), kur n yra masyvo elementų skaičius.
Masyvo maišymas naudojant sąrašus 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)); } } Išvestis:
[4, 1, 7, 3, 6, 5, 2]
Išvestis gali skirtis, jei ją vykdote savo sistemoje, nes ji atsitiktinai sutvarko elementus ir išveda sumaišytą masyvą.
Sudėtingumas:
abėcėlė pagal skaičius
Erdvės sudėtingumas taip pat yra O (n). Taip yra todėl, kad metodas Collections.shuffle() pakeičia pradinį sąrašą vietoje ir nenaudoja jokių papildomų duomenų struktūrų. Šio kodo laiko sudėtingumas yra O(n), kur n yra elementų skaičius masyve.
Maišyti masyvą, kuriame yra simbolių:
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; } } } Išvestis:
Shuffled Characters: [e, f, g, d, a, c, b]
Išvestis gali skirtis, jei ją vykdote savo sistemoje, nes ji atsitiktinai sutvarko elementus ir išveda sumaišytą masyvą.
Sudėtingumas:
Maišymo algoritmo erdvės sudėtingumas yra O(1), nes jis nenaudoja jokių papildomų duomenų struktūrų, kurios priklauso nuo masyvo dydžio. ShuffleArray() metodu naudojamos programos laiko sudėtingumas yra O(n), kur n yra simbolių skaičius masyve.
Išvada:
Masyvo maišymas „Java“ yra esminis įgūdis, suteikiantis kūrėjams galimybę sukurti atsitiktinių ir nešališkų duomenų išdėstymą. Šio tyrimo metu apžvelgėme du veiksmingus metodus: metodo Collections.shuffle() naudojimą neprimityvioms masyvams ir Fisher-Yates maišymo algoritmo įgyvendinimą primityvioms masyvoms. Metodas Collections.shuffle() supaprastina objektų arba neprimityvių masyvų maišymo procesą, panaudojant integruotas funkcijas. Kita vertus, Fisher-Yates algoritmas yra efektyvus ir nešališkas būdas maišyti primityvias masyvas, užtikrinant permutacijų vienodumą.