Kehren Sie ein Array in Java um

Arrays werden häufig beim Codieren verwendet und stellen eine Möglichkeit dar, mehrere Werte desselben Typs in einer Variablen zu speichern. Es kann viele Gründe geben, warum ein Programmierer ein Array umkehren möchte. Es kann erforderlich sein, ein Array umzukehren, beispielsweise wenn die Logik eines Problems mit dem letzten Element beginnen muss. In diesem Fall besteht die beste Vorgehensweise darin, die Umkehrung durchzuführen und dann bei Bedarf im Code das umgekehrte Array zu verwenden. Darüber hinaus ist das Umkehren eines Arrays eine sehr beliebte Aufgabe in Interviews mit Java Juniors.

So kehren Sie ein Array um

Es gibt viele Möglichkeiten, ein Array umzukehren, und hier betrachten wir 5. Bei Option 1 wird ein Array mithilfe eines zusätzlichen Arrays umgekehrt, das in aufsteigender Reihenfolge vom Ende des ursprünglichen Arrays aus (absteigend) gefüllt wird, bei Option 2 erfolgt eine direkte Umkehrung wird ausgeführt, wobei Array-Elemente am Anfang und Ende vertauscht werden. In Option 3 wird die Methode reverse() aus dem Collections-Framework verwendet, um die Umkehrung durchzuführen. In Option 4 werden List.add() und List.remove() verwendet. werden verwendet, und schließlich wird in Option 5 die Rekursion verwendet.

Option 1: Umkehren eines Arrays mithilfe eines zusätzlichen Arrays

Schreiben wir eine einfache Methode zum Umkehren eines Arrays mithilfe eines zusätzlichen Arrays . Diese Option verwendet ein zusätzliches Array, das beginnend mit dem letzten Element des ursprünglichen Arrays in absteigender Reihenfolge gefüllt wird, dh das erste Element ist dasselbe wie das letzte Element im ursprünglichen Array, das zweite ist dasselbe wie das vorletzte und so weiter weiter, bis das zusätzliche Array gefüllt ist.

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

In diesem Beispiel haben wir eine Methode geschrieben, die ein Array umkehrt und ein neues umgekehrtes Array zurückgibt, basierend auf dem Array, das an sie übergeben wurde. Das Array wird in main deklariert und dann wird eine Methode, reverse , aufgerufen. Das Argument der Methode ist das Array. In der Methode reverse wird ein neues Array, newArray , erstellt und hat die gleiche Größe wie array , ist jedoch vollständig leer. Eine for- Schleife wird zum Füllen des newArray verwendet und arbeitet über die gesamte Länge des Arrays. Dies geschieht, indem Sie mit dem ersten Element eines Arrays beginnen und es dem letzten Element von newArray zuweisen, dann das zweite Element unseres Arrays nehmen und es dem vorletzten Element von newArray zuweisen und so weiter; newArray wird rückwärts ausgefüllt. Wenn die for-Schleife abgeschlossen ist, ist newArray vollständig gefüllt und eine genaue Umkehrung des Arrays .

Option 2: Drucken Sie die Elemente eines Arrays in umgekehrter Reihenfolge

Für diese Option zum Umkehren eines Arrays muss kein zusätzliches Array verwendet werden und es wird nicht in eine Array-Liste konvertiert. Stattdessen werden die Array-Elemente vor Ort in umgekehrter Reihenfolge angeordnet . Das bedeutet, dass sie tatsächlich vertauscht sind. Das erste Element wird mit dem letzten Element vertauscht, das zweite Element wird mit dem vorletzten vertauscht und so weiter. Es wird eine for- Schleife verwendet, und wenn diese abgeschlossen ist, ist das Array umgekehrt. Der Code sieht so aus:

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

Das ursprüngliche Array wird mit Arrays.toString(array) als String ausgegeben und dann wird unser Array als Argument an reverse übergeben . Bei der umgekehrten Methode in der for- Schleife wird eine Variable, temp, erstellt und verwendet. In der for- Schleife wird die umgekehrte Reihenfolge in drei Schritten erreicht:

1. Zuweisen des ersten Elements zu temp
2. Zuweisen des letzten Elements zum ersten Element
3. Dem letzten Element temp zuordnen

Dies wird dann erneut durchgeführt, diesmal für das zweite Element und das vorletzte Element usw. Dies geschieht für aufeinanderfolgende Elemente des Arrays, die Schleife iteriert jedoch nur bis zur Hälfte der Array-Größe. Im Wesentlichen werden die Elemente an den gegenüberliegenden Enden des Arrays vertauscht. Diese Methode wird doppelt so schnell ausgeführt wie eine Methode, die eine for- Schleife von 0 bis zur Größe verwendet. Dadurch wird die umgekehrte Reihenfolge des Arrays erreicht und uns wird gezeigt, wie ein Array in umgekehrter Reihenfolge gedruckt und die Werte ausgedruckt werden:

Option 3: Collections.reverse() verwenden

In Java kann die Reverse- Methode, die Teil des vorhandenen Collections-Frameworks ist, zum Umkehren eines Arrays verwendet werden. Nutzen wir es für die Umkehrung.

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

In main wird das Array als Integer-Array mit 5 Zahlen erstellt und gefüllt. Anschließend wird es mithilfe von Arrays.asList(array) als Liste ausgedruckt. Anschließend wird die Funktion „ reverse “ aufgerufen und das Array als Argument an diese Funktion übergeben. In umgekehrter Reihenfolge wird Collections.reverse verwendet, und zwar für die Array-Liste Arrays.asList(array) und nicht für das Array selbst. Dann wird uns im nächsten Schritt gezeigt, wie man mit System.out.println ein Array in umgekehrter Reihenfolge druckt , und dieses Mal wird jedes Element in derselben Zeile ausgedruckt:

Option 4: Umkehren eines Arrays mit List.add() und List.remove()

In dieser neuen Option werden List.add() und List.remove() für die Umkehrung verwendet. Dies funktioniert so, dass das Array in eine Liste umgewandelt wird und das letzte Element der Liste entfernt und an den Anfang der Liste gestellt wird. Nachdem die gesamte Liste wiederholt wurde, ist die neue Liste eine Umkehrung des Originals. In der Methode main() wird ein Array bestehend aus 5 Zahlen erstellt. Anschließend wird der ursprüngliche Zustand des Arrays an die Konsole ausgegeben. Dieses Array wird dann als Argument für die Methode reverse() eingefügt . Bei dieser Methode wird grundsätzlich das letzte Element entfernt und am Anfang des Arrays eingefügt. Abschließend wird der neue (umgekehrte) Zustand des Arrays an die Konsole ausgegeben. Im Gegenteil()Methode wird das Array über Arrays.asList(array) in eine Liste geschrieben , um den Methoden add() und remove() die Durchführung der Umkehrung zu ermöglichen. Bei dieser Methode wird grundsätzlich das letzte Element entfernt und am Anfang des Arrays eingefügt. Die Schritte, die reverse() verwendet, sind wie folgt. Es verwendet eine for- Schleife, um die Umkehrung der Elemente der Liste durchzuführen. Dies geschieht durch die Initialisierung einer Variablen i . Anfänglich ist i auf 0 gesetzt. Wenn i = 0 ist , wird das Element bei list.size() - 1 in der Liste entfernt, und dies wird immer das letzte Element sein, da i < list.size() - 1. Da die Methode „remove()“ das von ihr entfernte Element zurückgibt, wird dieses Element nun am Index i = 0 zur Liste hinzugefügt , also am Anfang eingefügt. Der Rest der Liste wird dann nach rechts verschoben, aber die neue Liste hat immer noch die gleiche Anzahl an Elementen, also die gleiche Größe . Wenn die Ausführung der for- Schleife mit dem nächsten Wert von i , i = 1 , fortgesetzt wird, werden die gleichen Schritte ausgeführt, sodass das letzte Element entfernt und bei i = 1 in Nums eingefügt und die Liste nach rechts verschoben wird. Dies wird so lange fortgesetzt, bis der letzte inkrementelle Wert von i und alle Elemente in der Liste geändert wurden. Im zweiten fürDas Schleifenelement der Liste mit dem Index i wird auf das Array-Element mit dem Index i gesetzt , wobei i von 0 bis list.size() - 1 reicht . Zusammenfassend sind die verwendeten Schritte: Schritte:

1. ich = 0
2. Element bei list.size() entfernen - 1
3. Element einfügen, das sich bei list.size() - 1 befand , bei i = 0
4. Inkrement i
5. Wiederholen Sie die Schritte 2 bis 4 (mit neuen Werten für i in Schritt 3), bis der letzte inkrementelle Wert von i verwendet wird

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

Dieser Code liefert die Ausgabe:

Option 5: Ein Array durch Rekursion umkehren

Die Rekursionsmethode wird häufig in der Codierung verwendet und kann zur Erstellung einer effizienten Methode zum Umkehren eines Arrays verwendet werden. Bei dieser Option wird das Array in eine Liste konvertiert und dann geht der Code jedes Mal in die Methode reverse(), wenn das letzte Element am Ende der Liste entfernt wird, und der Liste werden die entfernten Werte in umgekehrter Reihenfolge hinzugefügt. Wie bei den vorherigen Methoden wird ein Array bestehend aus 5 Zahlen erstellt. Anschließend wird es als Argument an die Funktion reverse() übergeben . Bei reverse() wird zunächst das Array in eine Liste umgewandelt und die Listengröße überprüft. Wenn es nur ein Element hat oder null ist, wird die Methode beendet und zurückgegeben. Wenn nicht, wird das erste Element entfernt, aber in eine Ganzzahl kopiert, Wert . Anschließend wird die Methode reverse() erneut aufgerufen und die Rekursion beginnt von neuem. Wenn die Funktion eingegeben wird, werden dieselben Schritte ausgeführt, nämlich eine Größenprüfung. Wenn die Liste größer als 1 ist, besteht der nächste Schritt darin, das erste Element zu entfernen und dann die Rekursion erneut durchzuführen. Wenn die Größe der Liste 1 beträgt, kehrt reverse() dorthin zurück, wo sie aufgerufen wurde, und dann werden der Liste alle Werte hinzugefügt, um sie zu einer exakten Umkehrung der ursprünglichen Liste aufzubauen.

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

Die Ausgabe ist:

Abschluss

Hier haben wir uns fünf verschiedene Möglichkeiten angesehen, ein Array umzukehren. Option 3, die das Collections-Framework verwendet, ist wahrscheinlich die beste Methode, da es sich bei Collections.reverse um eine bereits vorhandene, bewährte Java-Funktion handelt. Natürlich können die anderen Optionen insbesondere beim Lernen genutzt werden, aber im Allgemeinen sind Standardmethoden, sofern vorhanden, die besten, da sie in der Regel stark optimiert und getestet sind. Sie können solche Methoden jedoch selbst erstellen, da dies eine gute Programmierübung ist und Ihnen bei Ihrem Vorstellungsgespräch für Java Junior helfen wird.