Invertire un array in Java

Gli array sono usati frequentemente nella codifica e sono un modo per memorizzare più valori dello stesso tipo in una variabile. Potrebbero esserci molte ragioni per cui un programmatore potrebbe voler invertire un array. Potrebbe essere necessario invertire un array, ad esempio, quando la logica di un problema deve iniziare con l'ultimo elemento. In questo caso, la procedura migliore consiste nell'eseguire l'inversione e quindi utilizzare l'array invertito dove necessario nel codice. Ancora di più, l'inversione di un array è un'attività molto popolare nelle interviste di Java Juniors.

Come invertire un array

Esistono molti modi per invertire un array e qui consideriamo 5. Per l'opzione 1, un array viene invertito utilizzando un array aggiuntivo riempito in ordine crescente dalla fine dell'array originale (discendente), nell'opzione 2 un'inversione sul posto viene eseguito dove gli elementi dell'array all'inizio e alla fine vengono scambiati, nell'opzione 3, il metodo reverse() del framework Collections viene utilizzato per eseguire l'inversione, nell'opzione 4, List.add() e List.remove() vengono utilizzati e, infine, nell'opzione 5, viene utilizzata la ricorsione.

Opzione 1: inversione di un array utilizzando un array aggiuntivo

Scriviamo un metodo semplice per invertire un array utilizzando un array aggiuntivo . Questa opzione utilizza un array aggiuntivo che viene riempito a partire dall'ultimo elemento dell'array originale in ordine decrescente, ovvero il primo elemento è uguale all'ultimo elemento nell'array originale, il secondo è uguale al penultimo e così fino a riempire l'array aggiuntivo.

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 questo esempio, abbiamo scritto un metodo che inverte un array e restituisce un nuovo array invertito, basato sull'array che gli è stato passato. array viene dichiarato in main e quindi viene chiamato un metodo, reverse . L'argomento del metodo è l'array. Nel metodo reverse , viene creato un nuovo array, newArray , che ha le stesse dimensioni di array , solo completamente vuoto. Un ciclo for viene utilizzato per riempire il newArray e opera su tutta la lunghezza dell'array. Questo viene fatto partendo dal primo elemento di un array e assegnandolo all'ultimo elemento di newArray, quindi prendendo il secondo elemento del nostro array e assegnandolo al penultimo elemento di newArray , e così via; newArray viene compilato al contrario. Quando il ciclo for è completo, newArray è completamente pieno ed è esattamente il contrario di array .

Opzione 2: stampa gli elementi di un array in ordine inverso

Affinché questa opzione inverta un array, non è necessario utilizzare un array aggiuntivo e non viene convertito in un elenco di array. Invece gli elementi dell'array vengono messi in ordine inverso sul posto . Ciò significa che sono, di fatto, scambiati. Il primo elemento viene scambiato con l'ultimo elemento, il secondo elemento viene scambiato con il penultimo e così via. Viene utilizzato un ciclo for e quando questo è stato completato, l'array sarà stato invertito. Il codice è simile al seguente:

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

L'array originale viene stampato come String utilizzando Arrays.toString(array) , quindi il nostro array viene passato come argomento in reverse . Nel metodo inverso nel ciclo for , viene creata e utilizzata una variabile, temp. Nel ciclo for l'ordine inverso si ottiene in tre fasi:

1. assegnando il primo elemento a temp
2. assegnando l'ultimo elemento al primo elemento
3. assegnando temp all'ultimo elemento

Questo viene poi ripetuto questa volta per il secondo elemento e il penultimo elemento, e così via. Questo viene fatto per gli elementi successivi dell'array, ma il ciclo itera solo fino alla metà della dimensione dell'array. Essenzialmente gli elementi alle estremità opposte dell'array vengono scambiati. Questo metodo verrà eseguito due volte più velocemente di un metodo che utilizza un ciclo for che va da 0 a size. Di conseguenza si ottiene l'ordine inverso dell'array e ci viene mostrato come stampare un array in ordine inverso e i valori vengono stampati:

Opzione 3: utilizzo di Collections.reverse()

In Java, il metodo reverse , che fa parte del framework Collections esistente, può essere utilizzato per invertire un array. Usiamolo per fare l'inversione.

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 , l'array viene creato e riempito come un array Integer con 5 numeri. Viene quindi stampato come un elenco utilizzando Arrays.asList(array) e quindi viene chiamata la funzione reverse e array viene passato come argomento in questa funzione. In reverse , Collections.reverse viene utilizzato e questo viene utilizzato nell'elenco di array, Arrays.asList(array) , anziché nell'array stesso. Quindi nel passaggio successivo ci viene mostrato come stampare un array in ordine inverso utilizzando System.out.println , e questa volta ogni elemento viene stampato sulla stessa riga:

Opzione 4: invertire un array utilizzando List.add() e List.remove()

In questa nuova opzione, List.add() e List.remove() vengono utilizzati per eseguire l'inversione. Il modo in cui funziona è che l'array viene convertito in un elenco e l'ultimo elemento dell'elenco viene rimosso e inserito all'inizio dell'elenco. Dopo che l'intero elenco è stato iterato, il nuovo elenco è un'inversione dell'originale. Nel metodo main() , viene creato un array composto da 5 numeri. Quindi lo stato originale dell'array viene inviato alla console. Questo array viene quindi inserito come argomento nel metodo reverse() . Questo metodo funziona fondamentalmente rimuovendo l'ultimo elemento e inserendolo nella parte anteriore dell'array. Infine, il nuovo stato (invertito) dell'array viene inviato alla console. Al contrario()metodo, l'array viene scritto in un List tramite Arrays.asList(array) , in modo da abilitare i metodi add() e remove() per eseguire l'inversione. Questo metodo funziona fondamentalmente rimuovendo l'ultimo elemento e inserendolo nella parte anteriore dell'array. I passaggi utilizzati da reverse() sono i seguenti. Utilizza un ciclo for per effettuare l'inversione degli elementi della lista. Lo fa inizializzando una variabile i . Inizialmente i è impostato su 0. Quando i = 0 , l'elemento in list.size() - 1 in list viene rimosso e questo sarà sempre l'ultimo elemento poiché i < list.size() - 1. Poiché il metodo remove() restituisce l'elemento che ha rimosso, questo elemento viene ora aggiunto alla lista all'indice i = 0 , cioè inserito all'inizio. Il resto dell'elenco viene quindi spostato a destra ma il nuovo elenco ha ancora lo stesso numero di elementi, ad esempio size . Continuando l'esecuzione del ciclo for con il valore successivo di i , i = 1 , viene eseguita la stessa serie di passaggi in modo che l'ultimo elemento venga rimosso e inserito in nums in i = 1 e l'elenco venga spostato a destra. Ciò continua fino a quando l'ultimo valore incrementale di i e tutti gli elementi nell'elenco non sono stati modificati. Nel secondo perL'elemento loop dell'elenco con indice i è impostato sull'elemento dell'array con indice i dove i va da 0 a list.size() - 1 . Riassumendo, i passi utilizzati sono: Passi:

1. io = 0
2. rimuovi l'elemento in list.size() - 1
3. insert elemento, che era a list.size() - 1 , a i = 0
4. incremento i
5. ripetere i passaggi da 2 a 4 (con nuovi valori per i al passaggio 3) finché non viene utilizzato l'ultimo valore incrementale di i

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

Questo codice fornisce l'output:

Opzione 5: invertire un array per ricorsione

Il metodo di ricorsione è ampiamente utilizzato nella codifica e può essere utilizzato per creare un metodo efficiente su come invertire un array. In questa opzione, l'array viene convertito in un elenco e quindi il codice va nel metodo reverse() ogni volta che rimuove l'ultimo elemento alla fine dell'elenco e l'elenco ha i valori rimossi aggiunti ad esso in ordine inverso. Come nei metodi precedenti, viene creato un array composto da 5 numeri. Viene quindi passato come argomento nella funzione reverse() . In reverse() la prima cosa da fare è trasformare l'array in un elenco e controllare la dimensione dell'elenco. Se ha un solo elemento o è nullo, il metodo termina e restituisce. In caso contrario, il primo elemento viene rimosso, ma copiato in un numero intero, valore . Il metodo reverse() viene quindi chiamato di nuovo e la ricorsione ricomincia. Quando la funzione viene inserita, vengono eseguiti gli stessi passaggi, un controllo delle dimensioni in cui, se l'elenco è maggiore di 1, il passaggio successivo sarà rimuovere il primo elemento e quindi ripetere la ricorsione. Quando la dimensione dell'elenco è 1, reverse() ritorna da dove è stato chiamato e quindi l'elenco ha ogni valore aggiunto ad esso per costruirlo in un esatto contrario dell'elenco originale.

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

L'uscita è:

Conclusione

Quindi qui abbiamo esaminato 5 modi diversi per invertire un array. L'opzione 3, che utilizza il framework Collections, è probabilmente il metodo migliore da utilizzare poiché Collections.reverse è una funzione Java già esistente, provata e testata. Ovviamente le altre opzioni possono essere utilizzate, specialmente durante l'apprendimento, ma in genere i metodi standard, se esistono, sono i migliori in quanto di solito sono altamente ottimizzati e testati. Tuttavia, puoi creare tu stesso tali metodi poiché questo è un buon esercizio di codifica e ti aiuterà ad avere successo nel tuo colloquio per Java Junior.