Programmēšanas pasaulē manipulēšana ar masīviem ir pamatprasme. Masīvu var sajaukt, kas ietver tā elementu nejaušu pārkārtošanu kā vienu kopīgu procesu. Šī procedūra ir būtiska, piemēram, nejauši izvēlētu spēļu komplektu veidošanai, statistikas simulāciju veikšanai vai datu rādīšanai nejaušākā veidā. Sākotnēji ir daudz loģikas, ko mēs varam izmantot, lai sajauktu masīvu; mēs varam izmantot dažāda veida kolekcijas ietvarus, piemēram, ArrayList, jaucējkopas, saistītos sarakstus utt. masīva jaukšanu var veikt atšķirīgi un
Masīva jaukšanas algoritms:
Tālāk ir norādīts masīva jaukšanas algoritms,
1. SOLIS: SĀKT
2. SOLIS: Sāciet no masīva pēdējā elementa un dodieties atpakaļ uz pirmo elementu.
3. SOLIS: Katram elementam indeksā i ģenerējiet nejaušu indeksu j tā, lai j būtu diapazonā [0, i].
4. SOLIS: Apmainiet elementus indeksos i un j.
5. SOLIS: Atkārtojiet 2. un 3. darbību visiem masīva elementiem, pārejot atpakaļ no pēdējā elementa uz pirmo.
6. SOLIS: BEIGAS
Mēs varam sajaukt masīvu, kurā ir dažāda veida elementi, piemēram, veseli skaitļi, rakstzīmes utt.
Fišera-Jatesa jaukšanas algoritms:
Šāda Java programma tiek izmantota, lai jauktu masīvu, kas sastāv no veseliem skaitļiem.
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; } } } Izvade:
1 3 2 4 5
Izvade var atšķirties, ja to izpildāt savā sistēmā, jo tā nejauši sakārto elementus un izvada sajaukto masīvu.
Sarežģītības:
Jaukšanas algoritma telpas sarežģītība ir O(1), jo tajā netiek izmantotas nekādas papildu datu struktūras, kas ir atkarīgas no masīva lieluma. Metodē shuffleArray() izmantotā Fisher-Yates jaukšanas algoritma laika sarežģītība ir O(n), kur n ir elementu skaits masīvā.
Masīva jaukšana, izmantojot sarakstus 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)); } } Izvade:
[4, 1, 7, 3, 6, 5, 2]
Izvade var atšķirties, ja to izpildāt savā sistēmā, jo tā nejauši sakārto elementus un izvada sajaukto masīvu.
Sarežģītības:
režisors Karans Džohars
Telpas sarežģītība ir arī O (n). Tas ir tāpēc, ka metode Collections.shuffle() maina sākotnējo sarakstu vietā un neizmanto nekādas papildu datu struktūras. Šī koda laika sarežģītība ir O(n), kur n ir elementu skaits masīvā.
Jaukts masīvs, kurā ir rakstzīmes:
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; } } } Izvade:
Shuffled Characters: [e, f, g, d, a, c, b]
Izvade var atšķirties, ja to izpildāt savā sistēmā, jo tā nejauši sakārto elementus un izvada sajaukto masīvu.
Sarežģītības:
Jaukšanas algoritma telpas sarežģītība ir O(1), jo tajā netiek izmantotas nekādas papildu datu struktūras, kas ir atkarīgas no masīva lieluma. ShuffleArray() metodē izmantotās programmas laika sarežģītība ir O(n), kur n ir rakstzīmju skaits masīvā.
Secinājums:
Masīva jaukšana Java ir būtiska prasme, kas ļauj izstrādātājiem izveidot nejaušus un objektīvus datu izkārtojumus. Šīs izpētes laikā mēs esam apskatījuši divas efektīvas pieejas: metodes Collections.shuffle() izmantošanu neprimitīviem masīviem un Fišera-Yates jaukšanas algoritma ieviešanu primitīviem masīviem. Metode Collections.shuffle() vienkāršo objektu vai primitīvo masīvu jaukšanas procesu, izmantojot iebūvētās funkcijas. No otras puses, Fisher-Yates algoritms nodrošina efektīvu un objektīvu veidu, kā sajaukt primitīvos masīvus, nodrošinot permutāciju viendabīgumu.