I programmeringsvärlden är manipulering av arrayer en grundläggande färdighet. En array kan blandas, vilket inkluderar slumpmässig omarrangering av dess element, som en gemensam process. Denna procedur är viktig för saker som att bygga randomiserade spelkortlekar, köra statistiska simuleringar eller bara visa data mer slumpmässigt. Inledningsvis finns det mycket logik vi kan använda för att blanda en array; vi kan använda olika typer av samlingsramverk som ArrayList, hash-uppsättningar, länkade listor etc. blandning av en array kan göras på olika sätt och

Algoritm för att blanda en array:

Följande är algoritmen för att blanda en array,

STEG 1: START

STEG 2: Börja från det sista elementet i arrayen och gå bakåt till det första elementet.

STEG 3: För varje element vid index i, generera ett slumpmässigt index j så att j är i intervallet [0, i].

STEG 4: Byt elementen vid index i och j.

STEG 5: Upprepa steg 2 och 3 för alla element i arrayen, flytta bakåt från det sista elementet till det första.

STEG 6: SLUTET

Vi kan blanda en array som innehåller olika typer av element som heltal, tecken, etc.

Fisher-yates Shuffle Algoritm:

Följande Java-program används för att blanda en array som består av 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 

Utdata kan skilja sig om du kör det i ditt system eftersom det slumpmässigt arrangerar elementen och matar ut den blandade arrayen.

Komplexiteter:

Blandningsalgoritmens rymdkomplexitet är O(1) eftersom den inte använder några extra datastrukturer som beror på arrayens storlek. Tidskomplexiteten för Fisher-Yates shuffle-algoritm som används i shuffleArray()-metoden är O(n), där n är antalet element i arrayen.

Blanda array med listor 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] 

Utdata kan skilja sig om du kör det i ditt system eftersom det slumpmässigt arrangerar elementen och matar ut den blandade arrayen.

Komplexiteter:

vad är ymail

Utrymmeskomplexiteten är också O(n). Detta beror på att metoden Collections.shuffle() ändrar den ursprungliga listan på plats och inte använder några ytterligare datastrukturer. Tidskomplexiteten för denna kod är O(n), där n är antalet element i matrisen.

Blanda array som innehåller tecken:

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] 

Utdata kan skilja sig om du kör det i ditt system eftersom det slumpmässigt arrangerar elementen och matar ut den blandade arrayen.

Komplexiteter:

Blandningsalgoritmens rymdkomplexitet är O(1) eftersom den inte använder några extra datastrukturer som beror på arrayens storlek. Tidskomplexiteten för programmet som används i metoden shuffleArray() är O(n), där n är antalet tecken i arrayen.

Slutsats:

Att blanda en array i Java är en avgörande färdighet som ger utvecklare möjlighet att skapa randomiserade och opartiska arrangemang av data. Under hela denna utforskning har vi täckt två effektiva tillvägagångssätt: att använda metoden Collections.shuffle() för icke-primitiva arrayer och att implementera Fisher-Yates shuffle-algoritm för primitiva arrayer. Metoden Collections.shuffle() förenklar blandningsprocessen för objekt eller icke-primitiva arrayer genom att utnyttja inbyggda funktioner. Å andra sidan tillhandahåller Fisher-Yates-algoritmen ett effektivt och opartiskt sätt att blanda primitiva arrayer, vilket säkerställer enhetlighet i permutationer.