Reversere en matrise i Java

Matriser brukes ofte i koding og er en måte å lagre flere verdier av samme type i én variabel. Det kan være mange grunner til at en koder kanskje vil reversere en matrise. Det kan være nødvendig å reversere en matrise, for eksempel når logikken til et problem må starte med det siste elementet. I dette tilfellet er beste praksis å gjøre reverseringen og deretter bruke den reverserte matrisen der det er nødvendig i koden. Enda mer, reversering av en matrise er en veldig populær oppgave i Java Juniors-intervjuer.

Hvordan reversere en matrise

Det er mange måter å reversere en matrise på, og her tar vi for oss 5. For alternativ 1 reverseres en matrise ved å bruke en ekstra matrise fylt i stigende rekkefølge fra slutten av den opprinnelige matrisen (synkende), i alternativ 2 en reversering på plass utføres der matriseelementer i begynnelsen og slutten byttes over, i alternativ 3 brukes reverse()- metoden fra samlingsrammeverket for å gjøre reverseringen, i alternativ 4, List.add() og List.remove() brukes, og til slutt, i alternativ 5, brukes rekursjon.

Alternativ 1: Reversere en matrise ved hjelp av en ekstra matrise

La oss skrive en enkel metode for å reversere en matrise ved å bruke en ekstra matrise . Dette alternativet bruker en ekstra matrise som fylles med det siste elementet i den opprinnelige matrisen i synkende rekkefølge, dvs. det første elementet er det samme som det siste elementet i den originale matrisen, det andre er det samme som det andre fra sist og så på til den ekstra matrisen er fylt.

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 eksemplet skrev vi en metode som reverserer en matrise og returnerer en ny reversert matrise, basert på matrisen som ble sendt til den. array er deklarert i main og deretter kalles en metode, reverse . Argumentet til metoden er matrisen. I omvendt metode opprettes en ny matrise, newArray , og den har samme størrelse som array , bare helt tom. En for- løkke brukes til å fylle ut newArray og opererer over hele lengden av matrisen. Dette gjøres ved å starte med det første elementet i en array og tilordne det til det siste elementet i newArray, så tar det andre elementet i arrayet vårt og tilordner det til det nest siste elementet i newArray , og så videre; newArray fylles ut baklengs. Når for-løkken er fullført, er newArray helt full og er en nøyaktig omvendt av arrayen .

Alternativ 2: Skriv ut elementene til en matrise i omvendt rekkefølge

For at dette alternativet skal reversere en matrise, er det ikke nødvendig å bruke en ekstra matrise, og den konverteres ikke til en matriseliste. I stedet settes array-elementene i omvendt rekkefølge på plass . Dette betyr at de faktisk er byttet. Det første elementet byttes med det siste elementet, det andre elementet byttes med det andre fra sist, og så videre. En for -løkke brukes og når denne er fullført, vil matrisen ha blitt reversert. Koden ser slik ut:

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

Den opprinnelige matrisen skrives ut som en streng ved å bruke Arrays.toString(array) , og deretter sendes matrisen vår som et argument til revers . I omvendt metode i for - løkken opprettes og brukes en variabel, temp. I for -løkken oppnås omvendt rekkefølge i tre trinn:

1. tilordne det første elementet til temp
2. tilordne det siste elementet til det første elementet
3. tilordne temp til det siste elementet

Dette utføres igjen denne gangen for det andre elementet og nest fra siste element, og så videre. Dette gjøres for påfølgende elementer i matrisen, men løkken itererer bare opptil halvparten av matrisestørrelsen. I hovedsak byttes elementene i motsatte ender av matrisen. Denne metoden vil kjøre dobbelt så raskt som en metode som bruker en for- løkke som går fra 0 til størrelse. Som et resultat oppnås den omvendte rekkefølgen av matrisen, og vi får vist hvordan du skriver ut en matrise i omvendt rekkefølge og verdiene skrives ut:

Alternativ 3: Bruke Collections.reverse()

I Java kan den omvendte metoden, som er en del av det eksisterende samlingsrammeverket, brukes til å reversere en matrise. La oss bruke den til å gjøre reverseringen.

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 er matrisen opprettet og fylt som en heltallsmatrise med 5 tall. Den skrives deretter ut som en liste ved å bruke Arrays.asList(array) og deretter kalles funksjonen, reverse , og array sendes som et argument inn i denne funksjonen. Omvendt brukes Collections.reverse , og dette brukes på arraylisten, Arrays.asList(array) , i stedet for selve arrayen. Så i neste trinn får vi vist hvordan du skriver ut en matrise i omvendt rekkefølge ved å bruke System.out.println , og denne gangen skrives hvert element ut på samme linje:

Alternativ 4: Reversere en matrise ved å bruke List.add() og List.remove()

I dette nye alternativet brukes List.add() og List.remove() til å gjøre reverseringen. Måten dette fungerer på er at matrisen konverteres til en liste og det siste elementet i listen fjernes og settes i begynnelsen av listen. Etter at hele listen har blitt gjentatt, er den nye listen en reversering av den opprinnelige. I main() -metoden opprettes en matrise bestående av 5 tall. Deretter sendes den opprinnelige tilstanden til arrayet til konsollen. Denne matrisen legges deretter inn som et argument til metoden, reverse() . Denne metoden fungerer i utgangspunktet ved å fjerne det siste elementet og sette det inn foran i arrayet. Til slutt sendes den nye (omvendte) tilstanden til arrayet til konsollen. Omvendt ()metoden skrives matrisen til en liste via Arrays.asList(array) , for å aktivere metodene add() og remove() for å utføre reverseringen. Denne metoden fungerer i utgangspunktet ved å fjerne det siste elementet og sette det inn foran i arrayet. Trinnene reverse() bruker er som følger. Den bruker en for- løkke for å utføre reversering av elementene i listen. Den gjør dette ved å initialisere en variabel i . I utgangspunktet settes i -en til 0. Når i = 0 , fjernes elementet på list.size() - 1 i listen , og dette vil alltid være det siste elementet siden i < list.size() - 1. Siden remove() -metoden returnerer elementet den har fjernet, blir dette elementet nå lagt til listen ved indeks i = 0 , dvs. satt inn i begynnelsen. Resten av listen flyttes deretter til høyre, men den nye listen har fortsatt samme antall elementer, dvs. størrelse . Fortsetter utførelsen av for- løkken med neste verdi av i , i = 1 , det samme settet med trinn utføres slik at det siste elementet fjernes og settes inn i nums ved i = 1 og listen flyttes til høyre. Dette fortsetter til den siste inkrementelle verdien av i og alle elementene i listen er endret. I den andre forloop-elementet i listen med indeks i settes til array-elementet med indeks i hvor i er fra 0 til list.size() - 1 . For å oppsummere er trinnene som brukes: Trinn:

1. i = 0
2. fjern element på list.size() - 1
3. sett inn element, som var på list.size() - 1 , ved i = 0
4. øke i
5. gjenta trinn 2 til 4 (med nye verdier for i ved trinn 3) til den siste inkrementelle verdien av i er brukt

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 koden gir utdata:

Alternativ 5: Reversere en matrise ved rekursjon

Metoden for rekursjon brukes mye i koding og kan brukes til å lage en effektiv metode for å reversere en matrise. I dette alternativet konverteres matrisen til en liste og deretter går koden inn i metoden reverse() hver gang det siste elementet på slutten av listen fjernes, og listen har de fjernede verdiene lagt til i omvendt rekkefølge. Som i de tidligere metodene opprettes en matrise bestående av 5 tall. Det sendes deretter som et argument inn i funksjonen, reverse() . I reverse() er det første som gjøres å gjøre arrayet om til en liste og sjekke listestørrelsen. Hvis den bare har ett element eller er null, avsluttes metoden og returnerer. Hvis ikke, fjernes det første elementet, men kopieres til et heltall, verdi . Metode reverse() kalles så igjen og rekursjonen begynner på nytt. Når funksjonen er lagt inn, utføres de samme trinnene, en størrelsessjekk hvor, hvis listen er større enn 1, neste trinn vil være å fjerne det første elementet og deretter gjøre rekursjonen på nytt. Når størrelsen på listen er 1, returnerer reverse() til der den kalles fra, og listen har hver verdi lagt til seg for å bygge den opp til en nøyaktig revers av den opprinnelige listen.

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

Utgangen er:

Konklusjon

Så her har vi sett på 5 forskjellige måter å snu en matrise på. Alternativ 3, som bruker rammeverket Collections, er sannsynligvis den beste metoden å bruke siden Collections.reverse er en allerede eksisterende, utprøvd Java-funksjon. Selvfølgelig kan de andre alternativene brukes, spesielt under læring, men generelt er standardmetoder, hvis de finnes, de beste, da de vanligvis er svært optimaliserte og testet. Du kan imidlertid lage slike metoder selv siden dette er en god kodeøvelse og vil hjelpe deg med å lykkes i intervjuet for Java Junior.