Vänd en array i Java

Matriser används ofta i kodning och är ett sätt att lagra flera värden av samma typ i en variabel. Det kan finnas många anledningar till att en kodare kanske vill vända en array. Det kan vara nödvändigt att vända en array, till exempel när logiken i ett problem måste börja med det sista elementet. I det här fallet är bästa praxis att göra omkastningen och sedan använda den omvända arrayen där det behövs i koden. Ännu mer, vända en array är en mycket populär uppgift i Java Juniors-intervjuer.

Hur man vänder en array

Det finns många sätt att vända en array, och här betraktar vi 5. För alternativ 1 vänds en array med en extra array fylld i stigande ordning från slutet av den ursprungliga arrayen (fallande), i alternativ 2 en in-place reversering utförs där arrayelement i början och slutet byts över, i alternativ 3 används reverse() -metoden från samlingsramverket för att göra omkastningen, i alternativ 4, List.add() och List.remove() används, och slutligen, i alternativ 5, används rekursion.

Alternativ 1: Vända en array med en extra array

Låt oss skriva en enkel metod för att vända en array med en extra array . Det här alternativet använder en extra array som fylls med början med det sista elementet i den ursprungliga arrayen i fallande ordning, dvs det första elementet är detsamma som det sista elementet i den ursprungliga arrayen, det andra är samma som det andra från sist och så på tills den extra arrayen är fylld.

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 det här exemplet skrev vi en metod som vänder en array och returnerar en ny omvänd array, baserat på arrayen som skickades till den. array deklareras i main och sedan anropas en metod, reverse . Argumentet till metoden är arrayen. I omvänd metod skapas en ny array, newArray , som har samma storlek som array , bara helt tom. En for- loop används för att fylla i newArray och fungerar över hela längden av arrayen. Detta görs genom att börja med det första elementet i en array och tilldela det till det sista elementet i newArray, sedan ta det andra elementet i vår array och tilldela det till det näst sista elementet i newArray , och så vidare; newArray fylls i baklänges. När for-loopen är klar är newArray helt full och är en exakt omvänd array .

Alternativ 2: Skriv ut elementen i en array i omvänd ordning

För att det här alternativet ska vända en array behöver du inte använda en extra array och den konverteras inte till en arraylista. Istället sätts arrayelementen i omvänd ordning på plats . Det betyder att de i själva verket är utbytta. Det första elementet byts ut med det sista elementet, det andra elementet byts ut med det andra från sist, och så vidare. En for -loop används och när denna har slutförts kommer arrayen att ha vänts om. Koden ser ut så här:

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 ursprungliga arrayen skrivs ut som en sträng med Arrays.toString(array) , och sedan skickas vår array som ett argument till omvänd . I den omvända metoden i for -loopen skapas och används en variabel, temp. I for -slingan uppnås den omvända ordningen i tre steg:

1. tilldela det första elementet till temp
2. att tilldela det sista elementet till det första elementet
3. tilldela temp till det sista elementet

Detta utförs sedan igen denna gång för det andra elementet och näst efter det sista elementet, och så vidare. Detta görs för successiva element i arrayen men loopen itererar bara upp till halva arraystorleken. I huvudsak är elementen i motsatta ändar av arrayen utbytta. Denna metod kommer att köras dubbelt så snabbt som en metod som använder en for- loop som går från 0 till storlek. Som ett resultat uppnås den omvända ordningen för arrayen och vi visas hur man skriver ut en array i omvänd ordning och värdena skrivs ut:

Alternativ 3: Använd Collections.reverse()

I Java kan den omvända metoden, som är en del av det befintliga samlingsramverket, användas för att vända en array. Låt oss använda den för att göra vändningen.

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 skapas och fylls matrisen som en heltalsmatris med 5 nummer. Den skrivs sedan ut som en lista med Arrays.asList(array) och sedan anropas funktionen, reverse , och array skickas som ett argument till denna funktion. Omvänt används Collections.reverse , och detta används i arraylistan, Arrays.asList(array) , snarare än själva arrayen. Sedan visas i nästa steg hur man skriver ut en array i omvänd ordning med System.out.println , och denna gång skrivs varje element ut på samma rad:

Alternativ 4: Vänd en array med List.add() och List.remove()

I det här nya alternativet används List.add() och List.remove() för att göra omkastningen. Sättet detta fungerar är att arrayen konverteras till en lista och det sista elementet i listan tas bort och placeras i början av listan. Efter att hela listan har upprepats, är den nya listan en omkastning av originalet. I main() -metoden skapas en array som består av 5 nummer. Sedan matas det ursprungliga tillståndet för arrayen ut till konsolen. Denna array läggs sedan in som ett argument till metoden, reverse() . Denna metod fungerar i princip genom att ta bort det sista elementet och infoga det längst fram i arrayen. Slutligen matas det nya (omvända) tillståndet för arrayen ut till konsolen. Omvänt ()metod, skrivs arrayen till en lista via Arrays.asList(array) , för att möjliggöra metoderna add() och remove() för att utföra omkastningen. Denna metod fungerar i princip genom att ta bort det sista elementet och infoga det längst fram i arrayen. De steg som reverse() använder är som följer. Den använder en for- loop för att utföra omkastningen av elementen i listan. Den gör detta genom att initiera en variabel i . Initialt sätts i:et till 0. När i = 0 tas elementet vid list.size() - 1 i listan bort, och detta kommer alltid att vara det sista elementet sedan i < list.size() - 1. Eftersom metoden remove() returnerar elementet som det har tagit bort, läggs detta element nu till i listan vid index i = 0 , dvs infogat i början. Resten av listan flyttas sedan åt höger men den nya listan har fortfarande samma antal element, dvs storlek . Fortsätter exekveringen av for -slingan med nästa värde på i , i = 1 , samma uppsättning steg utförs så att det sista elementet tas bort och sätts i nums vid i = 1 och listan flyttas åt höger. Detta fortsätter tills det sista inkrementella värdet av i och alla element i listan har ändrats. I den andra förloop-elementet i listan med index i sätts till arrayelementet med index i där i är från 0 till list.size() - 1 . För att sammanfatta, stegen som används är: Steg:

1. i = 0
2. ta bort element på list.size() - 1
3. infoga element, som var på list.size() - 1 , vid i = 0
4. öka i
5. upprepa steg 2 till 4 (med nya värden för i i steg 3) tills det sista inkrementella värdet av i används

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

Denna kod ger utdata:

Alternativ 5: Vänd en array genom rekursion

Rekursionsmetoden används flitigt i kodning och kan användas för att skapa en effektiv metod för hur man vänder en array . I det här alternativet konverteras arrayen till en lista och sedan går koden till metoden reverse() varje gång det sista elementet tas bort i slutet av listan och listan har de borttagna värdena lagt till i omvänd ordning. Som i de tidigare metoderna skapas en array som består av 5 nummer. Det skickas sedan som ett argument till funktionen reverse() . I reverse() är det första som görs att förvandla arrayen till en lista och kontrollera liststorleken. Om den bara har ett element eller är null avslutas metoden och returneras. Om inte tas det första elementet bort, men kopieras till ett heltal, värde . Metoden reverse() anropas sedan igen och rekursionen börjar igen. När funktionen är inmatad utförs samma steg, en storlekskontroll där, om listan är större än 1, nästa steg blir att ta bort det första elementet och sedan göra rekursionen igen. När storleken på listan är 1, återgår reverse() till där den anropas från och sedan har listan lagts till varje värde för att bygga upp det till en exakt omvändning av den ursprungliga listan.

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

Utgången är:

Slutsats

Så här har vi tittat på 5 olika sätt att vända en array. Alternativ 3, som använder ramverket Collections, är förmodligen den bästa metoden att använda eftersom Collections.reverse är en redan existerande, beprövad och testad Java-funktion. Naturligtvis kan de andra alternativen användas, särskilt under inlärning, men generellt sett är standardmetoder, om de finns, de bästa eftersom de vanligtvis är mycket optimerade och testade. Du kan dock skapa sådana metoder själv eftersom detta är en bra kodningsövning och hjälper dig att lyckas med din intervju för Java Junior.