Vend et array i Java

Arrays bruges ofte i kodning og er en måde at gemme flere værdier af samme type i en variabel. Der kan være mange grunde til, at en koder måske ønsker at vende et array. Det kan være nødvendigt at vende et array, for eksempel, når logikken i et problem skal starte med det sidste element. I dette tilfælde er bedste praksis at udføre reverseringen og derefter bruge det omvendte array, hvor det er nødvendigt i koden. Endnu mere er det at vende et array en meget populær opgave i Java Juniors-interviews.

Sådan vender du et array

Der er mange måder at vende et array på, og her betragter vi 5. For valgmulighed 1 vendes et array ved hjælp af et ekstra array udfyldt i stigende rækkefølge fra slutningen af ​​det oprindelige array (faldende), i mulighed 2 en in-place reversering udføres, hvor array-elementer i begyndelsen og slutningen ombyttes, i valgmulighed 3 bruges reverse()- metoden fra samlingsrammen til at udføre reverseringen, i valgmulighed 4, List.add() og List.remove() bruges, og endelig, i mulighed 5, bruges rekursion.

Mulighed 1: Reversere et array ved hjælp af et ekstra array

Lad os skrive en simpel metode til at vende et array ved hjælp af et ekstra array . Denne mulighed bruger et ekstra array, som er udfyldt startende med det sidste element i den oprindelige array i faldende rækkefølge, dvs. det første element er det samme som det sidste element i det originale array, det andet er det samme som det andet fra sidste og så indtil det ekstra array er fyldt.

import java.util.Arrays;

public class ReverseArrayDemo {

   public static void main(String[] args) {
       int[] array = {7, 8, 9, 10, 11};
       System.out.println("Array : " + Arrays.toString(array)); // print array

       // Call function to get reversed array
       int[] reversedArray = reverse(array);
       System.out.println("Reversed array : " + Arrays.toString(reversedArray)); // print reversed array
   }

   // Method returns a new reversed array, based on the array which was passed to it.
   static int[] reverse(int[] array) {
       int[] newArray = new int[array.length];

       for (int i = 0; i < array.length; i++) {
           newArray[array.length - 1 - i] = array[i];
       }

       return newArray;
   }
}

I dette eksempel skrev vi en metode, som vender en matrix og returnerer en ny omvendt matrix, baseret på den matrix, som blev sendt til den. array erklæres i main og derefter kaldes en metode, reverse . Argumentet til metoden er arrayet. I omvendt metode oprettes et nyt array, newArray , og det har samme størrelse som array , kun helt tomt. En for- løkke bruges til at udfylde newArray og fungerer over hele længden af ​​arrayet. Dette gøres ved at starte med det første element i et array og tildele det til det sidste element i newArray, så tager det andet element i vores array og tildeler det til det næstsidste element i newArray , og så videre; newArray udfyldes baglæns. Når for-løkken er fuldført, er newArray fuldstændig fuld og er en nøjagtig omvendt af arrayet .

Mulighed 2: Udskriv elementerne i et array i omvendt rækkefølge

For at denne mulighed skal vende et array, er det ikke nødvendigt at bruge et ekstra array, og det konverteres ikke til en array-liste. I stedet sættes array-elementerne i omvendt rækkefølge på deres plads . Det betyder, at de i virkeligheden er byttet om. Det første element udskiftes med det sidste element, det andet element udskiftes med det andet fra sidst, og så videre. En for- løkke bruges, og når dette er afsluttet, vil arrayet være blevet omvendt. Koden ser sådan ud:

import java.util.Arrays;
/*
reversing an array in-place
*/
public class ReverseArrayDemo {

   public static void main(String[] args) {
       int[] array = {1, 4, 9, 16, 25};
       System.out.println("Array before reverse : " + Arrays.toString(array));

       arrayReverse(array);
       System.out.println("Array after reverse : " + Arrays.toString(array));
   }
//arrayReverse is a method that reverses array in-place
   static void arrayReverse(int[] array) {
       for (int i = 0; i < array.length / 2; i++) {
           int temp = array[i];
           array[i] = array[array.length - i - 1];
           array[array.length - i - 1] = temp;
       }
   }
}

Det originale array udskrives som en streng ved hjælp af Arrays.toString(array) , og derefter sendes vores array som et argument til omvendt . I den omvendte metode i for- løkken oprettes og bruges en variabel, temp. I for -løkken opnås den omvendte rækkefølge i tre trin:

1. at tildele det første element til temp
2. at tildele det sidste element til det første element
3. at tildele temp til det sidste element

Dette udføres så igen denne gang for det andet element og andet fra sidste element, og så videre. Dette gøres for successive elementer i arrayet, men løkken itererer kun op til halvdelen af ​​array-størrelsen. Grundlæggende er elementerne i modsatte ender af arrayet byttet om. Denne metode vil køre dobbelt så hurtigt som en metode, der bruger en for- løkke, der går fra 0 til størrelse. Som et resultat opnås den omvendte rækkefølge af arrayet, og vi får vist, hvordan man udskriver et array i omvendt rækkefølge, og værdierne udskrives:

Mulighed 3: Brug af Collections.reverse()

I Java kan den omvendte metode, som er en del af den eksisterende samlingsramme, bruges til at vende et array. Lad os bruge det til at gøre vendingen.

import java.util.Arrays;
import java.util.Collections;

public class ReverseArrayDemo {

   public static void main(String[] args) {
       Integer[] array = {1, 4, 9, 16, 25};
       System.out.println("Array before reverse : " + Arrays.toString(array));

       reverse(array);
       System.out.println("Array after reverse : " + Arrays.toString(array));
   }
//method that reverses an array
   static void reverse(Integer[] array) {
       Collections.reverse(Arrays.asList(array));
   }
}

I main oprettes og udfyldes arrayet som et heltalsarray med 5 tal. Den udskrives derefter som en liste ved hjælp af Arrays.asList(array) , og derefter kaldes funktionen, reverse , og array overføres som et argument til denne funktion. Omvendt bruges Collections.reverse , og dette bruges på arraylisten, Arrays.asList (array) frem for selve arrayet. Så i næste trin bliver vi vist, hvordan man udskriver et array i omvendt rækkefølge ved hjælp af System.out.println , og denne gang udskrives hvert element på samme linje:

Mulighed 4: Vend et array ved hjælp af List.add() og List.remove()

I denne nye mulighed bruges List.add() og List.remove() til at udføre vendingen. Måden dette fungerer på er, at arrayet konverteres til en liste, og det sidste element på listen fjernes og sættes i begyndelsen af ​​listen. Efter at hele listen er blevet gentaget, er den nye liste en vending af den oprindelige. I main() metoden oprettes et array bestående af 5 tal. Derefter sendes den oprindelige tilstand af arrayet til konsollen. Dette array sættes derefter ind som et argument til metoden, reverse() . Denne metode fungerer grundlæggende ved at fjerne det sidste element og indsætte det foran i arrayet. Til sidst udsendes den nye (omvendte) tilstand af arrayet til konsollen. Omvendt ()metode, skrives arrayet til en liste via Arrays.asList(array) , for at aktivere add() og remove() metoderne til at udføre reverseringen. Denne metode fungerer grundlæggende ved at fjerne det sidste element og indsætte det foran i arrayet. Trinene reverse() bruger er som følger. Den bruger en for- løkke til at udføre vendingen af ​​elementerne i listen. Det gør den ved at initialisere en variabel i . I starten er i sat til 0. Når i = 0 , fjernes elementet ved list.size() - 1 i listen , og dette vil altid være det sidste element siden i < list.size() - 1. Da metoden remove() returnerer det element, det har fjernet, tilføjes dette element nu til listen ved indeks i = 0 , dvs. indsat i begyndelsen. Resten af ​​listen flyttes derefter til højre, men den nye liste har stadig det samme antal elementer, dvs. størrelse . Fortsætter udførelsen af ​​for -løkken med den næste værdi af i , i = 1 , udføres det samme sæt trin, så det sidste element fjernes og sættes i nums ved i = 1 , og listen flyttes til højre. Dette fortsætter, indtil den sidste trinvise værdi af i og alle elementer i listen er blevet ændret. I den anden forloop-elementet i listen med indeks i er sat til array-elementet med indeks i , hvor i er fra 0 til list.size() - 1 . For at opsummere er de anvendte trin: Trin:

1. i = 0
2. fjern element på list.size() - 1
3. indsæt element, som var på list.size() - 1 , ved i = 0
4. stigning i
5. gentag trin 2 til 4 (med nye værdier for i i trin 3), indtil den sidste trinvise værdi af i er brugt

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class ReverseArrayDemo {

   public static void main(String[] args) {
       Integer[] array = new Integer[]{1, 4, 9, 16, 25};
       System.out.println("Array before reverse : " + Arrays.toString(array));

       reverse(array);
       System.out.println("Array after reverse : " + Arrays.toString(array));
   }

   static void reverse(Integer[] array) {
       List list = new ArrayList<>(Arrays.asList(array));

       for (int i = 0; i < list.size() - 1; i++) {
           list.add(i, list.remove(list.size() - 1));
       }

       for (int i = 0; i < list.size(); i++) {
           array[i] = list.get(i);
       }
   }
}

Denne kode giver output:

Mulighed 5: Vend et array ved rekursion

Rekursionsmetoden bruges i vid udstrækning i kodning og kan bruges til at skabe en effektiv metode til at vende et array . I denne mulighed konverteres arrayet til en liste, og derefter går koden ind i metoden reverse() hver gang det sidste element i slutningen af ​​listen fjernes, og listen har de fjernede værdier tilføjet i omvendt rækkefølge. Som i de foregående metoder oprettes et array bestående af 5 tal. Det sendes derefter som et argument til funktionen reverse() . I reverse() er den første ting, der gøres, at omdanne arrayet til en liste og kontrollere listestørrelsen. Hvis den kun har ét element eller er null, afsluttes metoden og vender tilbage. Hvis ikke, fjernes det første element, men kopieres til et heltal, værdi . Metode reverse() kaldes derefter igen, og rekursionen begynder igen. Når funktionen er indtastet, udføres de samme trin, et størrelsestjek, hvor, hvis listen er større end 1, næste trin vil være at fjerne det første element og derefter udføre rekursionen igen. Når størrelsen på listen er 1, vender reverse() tilbage til, hvor den kaldes fra, og listen har derefter hver værdi tilføjet til sig for at bygge den op til en nøjagtig omvendt af den oprindelige liste.

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class ReverseArrayDemo {

   public static void main(String[] args) {
       Integer[] array = new Integer[]{1, 4, 9, 16, 25};
       System.out.println("Array before reverse : " + Arrays.toString(array));

       List list = new ArrayList<>(Arrays.asList(array));
       reverse(list);
       System.out.println("Array after reverse : " + Arrays.toString(list.toArray()));
   }

   public static void reverse(List list) {
       if (list== null || list.size() <= 1) {
           return;
       }

       Integer value = list.remove(0);

       reverse(list);

       list.add(value);
   }
}

Udgangen er:

Konklusion

Så her har vi set på 5 forskellige måder at vende et array på. Mulighed 3, som bruger samlingsrammerne, er sandsynligvis den bedste metode at bruge, da Collections.reverse er en allerede eksisterende, afprøvet og testet Java-funktion. Selvfølgelig kan de andre muligheder bruges, især under læring, men generelt er standardmetoder, hvis de findes, de bedste, da de normalt er meget optimeret og testet. Du kan dog selv oprette sådanne metoder, da dette er en god kodningsøvelse og vil hjælpe dig med at få succes i dit interview til Java Junior.