Inverser un tableau en Java
Inverser un tableau en Java | Programmes de tableaux en Java – 16 | Dans le programme Java précédent, nous avons développé des programmes pour trouver le deuxième plus grand nombre dans le tableau et trier un tableau en Java. Dans cet article, nous verrons comment inverser un tableau en Java. Nous discuterons de différentes techniques telles que la façon d'inverser un tableau en Java en utilisant la boucle for, sans utiliser un autre tableau en Java ou en utilisant la récursivité.
Exemple :-
Tableau d'origine :- { 10, 20, 30, 40, 50 }
Inverse du tableau :- { 50, 40, 30, 20, 10 }
Inverser un tableau à l'aide d'un autre tableau
Procédure pour inverser un tableau à l'aide d'un autre tableau et d'une boucle ,
a) Prenez un tableau, supposez realArr
b) Trouvez la longueur du tableau d'origine. Voir :- Comment trouver la longueur d'un tableau en Java
c) Déclarez un autre tableau ayant la même longueur, reverseArr
d) Depuis realArr , sélectionnez à partir du dernier et insérez dans reverseArr depuis le début
e) Répétez (d) jusqu'à la fin du realArr
Un exemple de cette procédure,
int realArr[] = { 10, 20, 30 }; // original array int reverseArr[3]; // new array
Ensuite,reverseArr[0] = realArr[2];
reverseArr[1] = realArr[1];
reverseArr[2] = realArr[0];
Enfin, l'inverse du tableau :-reverseArr[] = { 30, 20, 10 };
Maintenant, laissez-nous programmer Java pour inverser un tableau en utilisant une boucle while et un autre tableau. À la place de la boucle while, vous pouvez utiliser une autre boucle comme la boucle for ou la boucle do-while.
import java.util.Arrays;
import java.util.Scanner;
public class ArrayTest {
// method to reverse an array using another array
public static int[] reverse(int[] realArr) {
// declare variables
int size = 0;
int reverseArr[] = null;
// find length of the given array
size = realArr.length;
// temporary array of the same size
reverseArr = new int[size];
// find reverse and store to temporary array
// initialize iterator variables
int i = 0;
int j = size-1;
while(i < size) {
// assign element
reverseArr[i] = realArr[j];
// update iterator variables
i++;
j--;
}
// return result
return reverseArr;
}
public static void main(String[] args) {
// declare variables
Scanner scan = null;
int size = 0;
int numbers[] = null;
int rev[] = null;
// create Scanner class object to take input
scan = new Scanner(System.in);
// read array size
System.out.print("Enter array size: ");
size = scan.nextInt();
// assign length to array
numbers = new int[size];
// read array elements
System.out.println("Enter array elements: ");
for(int i=0; i<size; i++) {
numbers[i] = scan.nextInt();
}
// find reverse and store to rev
rev = reverse(numbers);
// display reverse of the array
System.out.println("Reverse = " + Arrays.toString(rev));
// close Scanner
scan.close();
}
}Sortie :-
Entrez la taille du tableau :5
Entrez les éléments du tableau :
10 20 30 40 50
Inverse =[50, 40, 30, 20, 10]
Inverser un tableau en Java à l'aide de la boucle For
Dans le programme ci-dessus, nous avions utilisé la boucle while. Voyons maintenant la même méthode en utilisant la boucle for.
Alors que loop est une boucle de pré-test où l'expression est évaluée, seules les instructions sont exécutées. Il utilise une expression de test pour contrôler la boucle. Avant chaque itération de la boucle, l'expression de test est évaluée. La boucle for est également une boucle de pré-test, où tout d'abord l'expression d'initialisation est évaluée, puis la condition est vérifiée et si la condition est vraie, seules les instructions de la boucle for sont exécutées.
// method to reverse an array using for loop
public static int[] reverse(int[] realArr) {
// declare variables
int size = 0;
int reverseArr[] = null;
// find length of the given array
size = realArr.length;
// temporary array of the same size
reverseArr = new int[size];
// find reverse and store to temporary array
for(int i=0, j=size-1; i<size; i++, j--) {
// assign element
reverseArr[i] = realArr[j];
}
// return result
return reverseArr;
}Au lieu de la méthode précédente qui utilisait une boucle while, utilisez cette méthode ci-dessus. La procédure des deux méthodes est exactement la même, la seule différence est l'utilisation d'une boucle. La boucle for a réduit les lignes de code par rapport à la boucle while.
Inverser un tableau en Java à l'aide de la boucle While
// find reverse and store to temporary array
// initialize iterator variables
int i = 0;
int j = size-1;
while(i < size) {
// assign element
reverseArr[i] = realArr[j];
// update iterator variables
i++; // increase i
j--; // decrease j
}Utilisation de la boucle for,
// find reverse and store to temporary array
for(int i=0, j=size-1; i<size; i++, j--) {
// assign element
reverseArr[i] = realArr[j];
}Inverser un tableau sans utiliser un autre tableau en Java
Il est également possible de ne pas utiliser un autre tableau. En utilisant uniquement le tableau d'origine, nous pouvons inverser le tableau. De cette façon, nous devons échanger les éléments correspondants du premier au dernier.
Procédure pour inverser un tableau en utilisant le même tableau,
a) Prenez un tableau, supposez arr
b) Trouvez la longueur du tableau
c) Sélectionnez le premier et le dernier élément du tableau et échangez-les
d) Répétez ce processus jusqu'à longueur/2
Si la longueur du tableau est paire, tous les éléments du tableau doivent échanger avec un élément relatif, mais si la longueur du tableau est impaire, l'élément à la position centrale restera le même.
Exemple
Exemple utilisant un tableau de longueur paire,arr[] = {10,20,30,40}; // original array
Maintenant, échangez arr[0] et arr[3] puisarr[] = {40,20,30,10};
Encore une fois, échangez arr[1] et arr[2] puisarr[] = {40,30,20,10; // final result
Exemple utilisant un tableau de longueur impaire,arr[] = {10,20,30,40,50}; // original array
Maintenant, échangez arr[0] et arr[4] puisarr[] = {50,20,30,40,10};
Encore une fois, échangez arr[1] et arr[2] puisarr[] = {50,40,30,20,10}; // final result
Pas besoin de faire quoi que ce soit avec l'élément en position centrale.
Voyons maintenant la méthode Java pour trouver l'inverse d'un tableau sans utiliser un autre tableau.
Inverser un tableau en Java à l'aide de la boucle While
Méthode Java pour inverser un tableau en utilisant une boucle while et sans utiliser un autre tableau.
// method to reverse an array without another array
public static int[] reverse(int[] arr) {
// find size
int size = arr.length;
// variables
int i = 0;
int j = size - 1;
// while loop
while (i <= size / 2) {
// swap elements
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
// update i & j
i++; // increase i
j--; // decrease j
}
// return result
return arr;
}Utiliser la boucle for
Méthode Java pour inverser un tableau en utilisant la boucle for et sans utiliser un autre tableau.
// method to reverse an array without another array
public static int[] reverse(int[] arr) {
// find size
int size = arr.length;
// for loop
for(int i=0, j=size-1; i<(size/2); i++, j--) {
// swap
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
// return result
return arr;
}Inverser un tableau en Java à l'aide de la récursivité
Nous pouvons inverser un tableau en utilisant la technique de récursivité. Une méthode qui contient un appel à elle-même est appelée méthode récursive. Une technique de définition de la méthode récursive est appelée récursivité. La méthode récursive nous permet de diviser le problème complexe en cas simples simples identiques qui peuvent être manipulés facilement. C'est aussi une technique de programmation informatique bien connue :diviser pour mieux régner.
// method to reverse an array
public static int[] reverse(int[] arr) {
reverseArr(arr, 0, arr.length - 1);
return arr;
}
// recursive method
public static void reverseArr(int[] x, int i, int j) {
// swap
if (i < j) {
int tmp = x[i];
x[i] = x[j];
x[j] = tmp;
// recursive call
reverseArr(x, ++i, --j);
}
}La méthode ci-dessus ne nécessite pas un autre tableau temporaire pour stocker les valeurs. Le reverse() n'est pas une méthode récursive, il appelle en interne reverseArr() qui est une méthode récursive, et s'appelle en interne.
La complexité temporelle de toutes les méthodes données dans cet article est :- O(N) .
