Inverser un tableau en Java

Les tableaux sont fréquemment utilisés dans le codage et sont un moyen de stocker plusieurs valeurs du même type dans une variable. Il peut y avoir de nombreuses raisons pour lesquelles un codeur peut vouloir inverser un tableau. Il peut être nécessaire d'inverser un tableau, par exemple, lorsque la logique d'un problème doit commencer par le dernier élément. Dans ce cas, la meilleure pratique consiste à effectuer l'inversion, puis à utiliser le tableau inversé si nécessaire dans le code. De plus, l'inversion d'un tableau est une tâche très populaire dans les interviews de Java Juniors.

Comment inverser un tableau

Il existe de nombreuses façons d'inverser un tableau, et ici nous considérons 5. Pour l'option 1, un tableau est inversé à l'aide d'un tableau supplémentaire rempli dans l'ordre croissant à partir de la fin du tableau d'origine (décroissant), dans l'option 2, une inversion sur place est effectuée là où les éléments du tableau au début et à la fin sont permutés, dans l'option 3, la méthode reverse() du framework Collections est utilisée pour effectuer l'inversion, dans l'option 4, List.add() et List.remove() sont utilisés, et enfin, dans l'option 5, la récursivité est utilisée.

Option 1 : inverser un tableau à l'aide d'un tableau supplémentaire

Écrivons une méthode simple pour inverser un tableau en utilisant un tableau supplémentaire . Cette option utilise un tableau supplémentaire qui est rempli en commençant par le dernier élément du tableau d'origine dans l'ordre décroissant, c'est-à-dire que le premier élément est le même que le dernier élément du tableau d'origine, le second est le même que l'avant-dernier et donc jusqu'à ce que le tableau supplémentaire soit rempli.

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

Dans cet exemple, nous avons écrit une méthode qui inverse un tableau et renvoie un nouveau tableau inversé, basé sur le tableau qui lui a été passé. array est déclaré dans main puis une méthode, reverse , est appelée. L'argument de la méthode est le tableau. Dans la méthode reverse , un nouveau tableau, newArray , est créé et a la même taille que array , mais complètement vide. Une boucle for est utilisée pour remplir le newArray et fonctionne sur toute la longueur du tableau. Cela se fait en commençant par le premier élément d'un tableau et en l'affectant au dernier élément de newArray, puis en prenant le deuxième élément de notre tableau et en l'affectant à l'avant-dernier élément de newArray , et ainsi de suite ; newArray est rempli à l'envers. Lorsque la boucle for est terminée, newArray est complètement plein et est l'inverse exact du tableau .

Option 2 : imprimer les éléments d'un tableau dans l'ordre inverse

Pour que cette option inverse un tableau, il n'est pas nécessaire d'utiliser un tableau supplémentaire et il n'est pas converti en liste de tableaux. Au lieu de cela, les éléments du tableau sont mis dans l'ordre inverse in-place . Cela signifie qu'ils sont, en fait, échangés. Le premier élément est permuté avec le dernier élément, le deuxième élément est permuté avec l'avant-dernier, et ainsi de suite. Une boucle for est utilisée et une fois celle-ci terminée, le tableau aura été inversé. Le code ressemble à ceci :

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

Le tableau d'origine est imprimé en tant que String en utilisant Arrays.toString(array) , puis notre tableau est passé en argument dans reverse . Dans la méthode inverse de la boucle for , une variable, temp, est créée et utilisée. Dans la boucle for , l'ordre inverse est réalisé en trois étapes :

1. assigner le premier élément à temp
2. affectation du dernier élément au premier élément
3. assigner temp au dernier élément

Ceci est ensuite effectué à nouveau cette fois pour le deuxième élément et l'avant-dernier élément, et ainsi de suite. Ceci est fait pour les éléments successifs du tableau mais la boucle n'itère que jusqu'à la moitié de la taille du tableau. Essentiellement, les éléments aux extrémités opposées du tableau sont permutés. Cette méthode s'exécutera deux fois plus vite qu'une méthode utilisant une boucle for allant de 0 à size. En conséquence, l'ordre inverse du tableau est obtenu et on nous montre comment imprimer un tableau dans l'ordre inverse et les valeurs sont imprimées :

Option 3 : Utiliser Collections.reverse()

En Java, la méthode reverse , qui fait partie du framework Collections existant, peut être utilisée pour inverser un tableau. Profitons-en pour faire l'inverse.

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

Dans main , le tableau est créé et rempli comme un tableau Integer avec 5 nombres. Il est ensuite imprimé sous forme de liste en utilisant Arrays.asList(array) puis la fonction, reverse , est appelée et array est passé comme argument dans cette fonction. Inverse , Collections.reverse est utilisé, et ceci est utilisé sur la liste de tableaux, Arrays.asList(array) , plutôt que sur le tableau lui-même. Ensuite, à l'étape suivante, on nous montre comment imprimer un tableau dans l'ordre inverse en utilisant System.out.println , et cette fois chaque élément est imprimé sur la même ligne :

Option 4 : inverser un tableau à l'aide de List.add() et List.remove()

Dans cette nouvelle option, List.add() et List.remove() sont utilisés pour effectuer l'inversion. La façon dont cela fonctionne est que le tableau est converti en liste et que le dernier élément de la liste est supprimé et placé au début de la liste. Une fois que toute la liste a été itérée, la nouvelle liste est une inversion de l'originale. Dans la méthode main() , un tableau est créé composé de 5 nombres. Ensuite, l'état d'origine du tableau est envoyé à la console. Ce tableau est ensuite placé en argument de la méthode reverse() . Cette méthode fonctionne essentiellement en supprimant le dernier élément et en l'insérant à l'avant du tableau. Enfin, le nouvel état (inversé) du tableau est envoyé à la console. A l' envers(), le tableau est écrit dans une List via Arrays.asList(array) , afin de permettre aux méthodes add() et remove() d'effectuer l'inversion. Cette méthode fonctionne essentiellement en supprimant le dernier élément et en l'insérant à l'avant du tableau. Les étapes que reverse() utilise sont les suivantes. Il utilise une boucle for pour effectuer l'inversion des éléments de la liste. Il le fait en initialisant une variable i . Initialement, le i est défini sur 0. Lorsque i = 0 , l'élément à list.size() - 1 dans la liste est supprimé, et ce sera toujours le dernier élément puisque i < list.size() - 1. Puisque la méthode remove() renvoie l'élément qu'elle a supprimé, cet élément est maintenant ajouté à la liste à l'indice i = 0 , c'est-à-dire inséré au début. Le reste de la liste est alors décalé vers la droite mais la nouvelle liste a toujours le même nombre d'éléments, c'est-à-dire size . Poursuivant l'exécution de la boucle for avec la valeur suivante de i , i = 1 , le même ensemble d'étapes est effectué de sorte que le dernier élément est supprimé et mis en chiffres à i = 1 et la liste décalée vers la droite. Cela continue jusqu'à ce que la dernière valeur incrémentielle de i et tous les éléments de la liste aient été modifiés. Dans la seconde pourL'élément de boucle de la liste avec l'index i est défini sur l'élément de tableau avec l'index i où i est compris entre 0 et list.size() - 1 . Pour résumer, les étapes utilisées sont : Étapes :

1. je = 0
2. supprimer l'élément à list.size() - 1
3. insert element, qui était à list.size() - 1 , à i = 0
4. incrémenter je
5. répéter les étapes 2 à 4 (avec de nouvelles valeurs pour i à l'étape 3) jusqu'à ce que la dernière valeur incrémentielle de i soit utilisée

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

Ce code donne la sortie :

Option 5 : inverser un tableau par récursivité

La méthode de récursivité est largement utilisée dans le codage et peut être utilisée pour créer une méthode efficace sur la façon d'inverser un tableau. Dans cette option, le tableau est converti en une liste, puis le code passe dans la méthode reverse() à chaque fois en supprimant le dernier élément à la fin de la liste et la liste a les valeurs supprimées qui lui sont ajoutées dans l'ordre inverse. Comme dans les méthodes précédentes, un tableau est créé composé de 5 nombres. Il est ensuite passé en argument à la fonction reverse() . Dans reverse(), la première chose à faire est de transformer le tableau en liste et de vérifier la taille de la liste. S'il n'a qu'un seul élément ou s'il est nul, la méthode se termine et revient. Sinon, le premier élément est supprimé, mais copié dans un entier, valeur . La méthode reverse() est alors appelée à nouveau et la récursivité recommence. Lorsque la fonction est entrée, les mêmes étapes sont effectuées, une vérification de la taille où, si la liste est supérieure à 1, l'étape suivante consistera à supprimer le premier élément, puis à refaire la récursivité. Lorsque la taille de la liste est 1, reverse() retourne à l'endroit d'où elle est appelée, puis chaque valeur est ajoutée à la liste pour la construire en un inverse exact de la liste d'origine.

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

La sortie est :

Conclusion

Nous avons donc examiné ici 5 façons différentes d'inverser un tableau. L'option 3, qui utilise le framework Collections, est probablement la meilleure méthode à utiliser puisque Collections.reverse est une fonction Java déjà existante, éprouvée et testée. Bien sûr, les autres options peuvent être utilisées, en particulier lors de l'apprentissage, mais généralement les méthodes standard, si elles existent, sont les meilleures car elles sont généralement hautement optimisées et testées. Cependant, vous pouvez créer vous-même de telles méthodes car il s'agit d'un bon exercice de codage et cela vous aidera à réussir votre entretien pour Java Junior.