Comment inverser un tableau int en Java?
J'essaie d'inverser un tableau int en Java.
Cette méthode n'inverse pas le tableau.
for(int i = 0; i < validData.length; i++)
{
int temp = validData[i];
validData[i] = validData[validData.length - i - 1];
validData[validData.length - i - 1] = temp;
}
Qu'est-ce qui va pas avec ça?
Pour inverser un tableau int, vous échangez les éléments jusqu'à atteindre le point médian, comme ceci:
for(int i = 0; i < validData.length / 2; i++)
{
int temp = validData[i];
validData[i] = validData[validData.length - i - 1];
validData[validData.length - i - 1] = temp;
}
En procédant ainsi, vous permutez chaque élément deux fois. Le résultat est identique à la liste initiale.
Avec Commons.Lang , vous pouvez simplement utiliser
ArrayUtils.reverse(int[] array)
La plupart du temps, il est plus rapide et plus sûr d’attraper des bogues avec des bibliothèques facilement disponibles déjà testées par unité et testées par l’utilisateur lorsqu’elles prennent en charge votre problème.
public class ArrayHandle {
public static Object[] reverse(Object[] arr) {
List<Object> list = Arrays.asList(arr);
Collections.reverse(list);
return list.toArray();
}
}
Je pense qu'il est un peu plus facile de suivre la logique de l'algorithme si vous déclarez des variables explicites pour garder une trace des index que vous échangez à chaque itération de la boucle.
public static void reverse(int[] data) {
for (int left = 0, right = data.length - 1; left < right; left++, right--) {
// swap the values at the left and right indices
int temp = data[left];
data[left] = data[right];
data[right] = temp;
}
}
Je pense aussi que c'est plus lisible de le faire en boucle.
public static void reverse(int[] data) {
int left = 0;
int right = data.length - 1;
while( left < right ) {
// swap the values at the left and right indices
int temp = data[left];
data[left] = data[right];
data[right] = temp;
// move the left and right index pointers in toward the center
left++;
right--;
}
}
Collections.reverse(Arrays.asList(yourArray));
Java.util.Collections.reverse() peut inverser Java.util.Lists et Java.util.Arrays.asList() renvoie une liste qui encapsule le tableau spécifique que vous lui transmettez. Par conséquent, yourArray est inversé après l'appel de Collections.reverse().
Le coût ne représente que la création d'un objet de liste et aucune bibliothèque supplémentaire n'est requise.
Une réponse similaire a été présentée dans la réponse de Tarik et de leurs commentateurs, mais je pense que cette réponse serait plus concise et plus facilement analysable.
Il y a déjà beaucoup de réponses ici, principalement axées sur la modification du tableau en place. Mais dans un souci de complétude, voici une autre approche utilisant des flux Java pour conserver le tableau d'origine et créer un nouveau tableau inversé:
int[] a = {8, 6, 7, 5, 3, 0, 9};
int[] b = IntStream.rangeClosed(1, a.length).map(i -> a[a.length-i]).toArray();
Avec goyave:
Collections.reverse(Ints.asList(array));
Simple pour la boucle!
for (int start = 0, end = array.length - 1; start <= end; start++, end--) {
int aux = array[start];
array[start]=array[end];
array[end]=aux;
}
Cela vous aidera
int a[] = {1,2,3,4,5};
for (int k = 0; k < a.length/2; k++) {
int temp = a[k];
a[k] = a[a.length-(1+k)];
a[a.length-(1+k)] = temp;
}
Voici comment je le résoudre personnellement. La création de la méthode paramétrée a pour but de permettre à tout tableau d'être trié ... pas uniquement à vos entiers.
J'espère que vous en tirerez quelque chose.
@Test
public void reverseTest(){
Integer[] ints = { 1, 2, 3, 4 };
Integer[] reversedInts = reverse(ints);
assert ints[0].equals(reversedInts[3]);
assert ints[1].equals(reversedInts[2]);
assert ints[2].equals(reversedInts[1]);
assert ints[3].equals(reversedInts[0]);
reverseInPlace(reversedInts);
assert ints[0].equals(reversedInts[0]);
}
@SuppressWarnings("unchecked")
private static <T> T[] reverse(T[] array) {
if (array == null) {
return (T[]) new ArrayList<T>().toArray();
}
List<T> copyOfArray = Arrays.asList(Arrays.copyOf(array, array.length));
Collections.reverse(copyOfArray);
return copyOfArray.toArray(array);
}
private static <T> T[] reverseInPlace(T[] array) {
if(array == null) {
// didn't want two unchecked suppressions
return reverse(array);
}
Collections.reverse(Arrays.asList(array));
return array;
}
for(int i=validData.length-1; i>=0; i--){
System.out.println(validData[i]);
}
Dans le cas de Java 8 , nous pouvons également utiliser des flux pour inverser le tableau d'entiers en tant que:
int[] sample = new int[]{1,2,3,4,5};
int size = sample.length;
int[] reverseSample = IntStream.range(0,size).map(i -> sample[size-i-1])
.toArray(); //Output: [5, 4, 3, 2, 1]
Votre programme ne fonctionnera que pour length = 0, 1. Vous pouvez essayer:
int i = 0, j = validData.length-1 ;
while(i < j)
{
swap(validData, i++, j--); // code for swap not shown, but easy enough
}
Si vous travaillez avec des données plus primitives (caractères, octets, entiers, etc.), vous pouvez effectuer quelques opérations amusantes XOR.
public static void reverseArray4(int[] array) {
int len = array.length;
for (int i = 0; i < len/2; i++) {
array[i] = array[i] ^ array[len - i - 1];
array[len - i - 1] = array[i] ^ array[len - i - 1];
array[i] = array[i] ^ array[len - i - 1];
}
}
public void getDSCSort(int[] data){
for (int left = 0, right = data.length - 1; left < right; left++, right--){
// swap the values at the left and right indices
int temp = data[left];
data[left] = data[right];
data[right] = temp;
}
}
Il est plus efficace d’itérer simplement le tableau à l’arrière.
Je ne suis pas sûr si la solution d'Aaron fait cela vi cet appel Collections.reverse(list); Est-ce que quelqu'un le sait?
Solution avec o(n) complexité temporelle et o(1) complexité spatiale.
void reverse(int[] array) {
int start = 0;
int end = array.length - 1;
while (start < end) {
int temp = array[start];
array[start] = array[end];
array[end] = temp;
start++;
end--;
}
}
public void display(){
String x[]=new String [5];
for(int i = 4 ; i > = 0 ; i-- ){//runs backwards
//i is the nums running backwards therefore its printing from
//highest element to the lowest(ie the back of the array to the front) as i decrements
System.out.println(x[i]);
}
}
Cela ne serait-il pas beaucoup plus improbable pour des erreurs?
int[] intArray = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
int[] temp = new int[intArray.length];
for(int i = intArray.length - 1; i > -1; i --){
temp[intArray.length - i -1] = intArray[i];
}
intArray = temp;
public static void main(String args[]) {
int [] arr = {10, 20, 30, 40, 50};
reverse(arr, arr.length);
}
private static void reverse(int[] arr, int length) {
for(int i=length;i>0;i--) {
System.out.println(arr[i-1]);
}
}
vous trouverez ci-dessous le programme complet à exécuter sur votre ordinateur.
public class ReverseArray {
public static void main(String[] args) {
int arr[] = new int[] { 10,20,30,50,70 };
System.out.println("reversing an array:");
for(int i = 0; i < arr.length / 2; i++){
int temp = arr[i];
arr[i] = arr[arr.length - i - 1];
arr[arr.length - i - 1] = temp;
}
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}
}
Pour les programmes sur matrice utilisant des tableaux ce sera la bonne source .
Voici ce que je suis venu avec:
// solution 1 - boiler plated
Integer[] original = {100, 200, 300, 400};
Integer[] reverse = new Integer[original.length];
int lastIdx = original.length -1;
int startIdx = 0;
for (int endIdx = lastIdx; endIdx >= 0; endIdx--, startIdx++)
reverse[startIdx] = original[endIdx];
System.out.printf("reverse form: %s", Arrays.toString(reverse));
// solution 2 - abstracted
// convert to list then use Collections static reverse()
List<Integer> l = Arrays.asList(original);
Collections.reverse(l);
System.out.printf("reverse form: %s", l);
Voici une implémentation simple, pour inverser un tableau de tout type , plus complet/partiel support.
import Java.util.logging.Logger;
public final class ArrayReverser {
private static final Logger LOGGER = Logger.getLogger(ArrayReverser.class.getName());
private ArrayReverser () {
}
public static <T> void reverse(T[] seed) {
reverse(seed, 0, seed.length);
}
public static <T> void reverse(T[] seed, int startIndexInclusive, int endIndexExclusive) {
if (seed == null || seed.length == 0) {
LOGGER.warning("Nothing to rotate");
}
int start = startIndexInclusive < 0 ? 0 : startIndexInclusive;
int end = Math.min(seed.length, endIndexExclusive) - 1;
while (start < end) {
swap(seed, start, end);
start++;
end--;
}
}
private static <T> void swap(T[] seed, int start, int end) {
T temp = seed[start];
seed[start] = seed[end];
seed[end] = temp;
}
}
Voici le test unitaire correspondant
import static org.hamcrest.CoreMatchers.is;
import static org.junit.Assert.assertThat;
import org.junit.Before;
import org.junit.Test;
public class ArrayReverserTest {
private Integer[] seed;
@Before
public void doBeforeEachTestCase() {
this.seed = new Integer[]{1,2,3,4,5,6,7,8};
}
@Test
public void wholeArrayReverse() {
ArrayReverser.<Integer>reverse(seed);
assertThat(seed[0], is(8));
}
@Test
public void partialArrayReverse() {
ArrayReverser.<Integer>reverse(seed, 1, 5);
assertThat(seed[1], is(5));
}
}
Utilisation de la solution XOR pour éviter la variable temp à laquelle votre code devrait ressembler
for(int i = 0; i < validData.length; i++){
validData[i] = validData[i] ^ validData[validData.length - i - 1];
validData[validData.length - i - 1] = validData[i] ^ validData[validData.length - i - 1];
validData[i] = validData[i] ^ validData[validData.length - i - 1];
}
Voir ce lien pour une meilleure explication:
http://betterexplained.com/articles/swap-two-variables-using-xor/
2 façons d'inverser un tableau.
En utilisant la boucle For et permutez les éléments jusqu'au point médian avec une complexité temporelle de O (n/2).
private static void reverseArray() { int[] array = new int[] { 1, 2, 3, 4, 5, 6 }; for (int i = 0; i < array.length / 2; i++) { int temp = array[i]; int index = array.length - i - 1; array[i] = array[index]; array[index] = temp; } System.out.println(Arrays.toString(array));}
Utilisation de la fonction intégrée (Collections.reverse ())
private static void reverseArrayUsingBuiltInFun() { int[] array = new int[] { 1, 2, 3, 4, 5, 6 }; Collections.reverse(Ints.asList(array)); System.out.println(Arrays.toString(array));}
Sortie: [6, 5, 4, 3, 2, 1]
public static int[] reverse(int[] array) {
int j = array.length-1;
// swap the values at the left and right indices //////
for(int i=0; i<=j; i++)
{
int temp = array[i];
array[i] = array[j];
array[j] = temp;
j--;
}
return array;
}
public static void main(String []args){
int[] data = {1,2,3,4,5,6,7,8,9};
reverse(data);
}
static int[] reverseArray(int[] a) {
int ret[] = new int[a.length];
for(int i=0, j=a.length-1; i<a.length && j>=0; i++, j--)
ret[i] = a[j];
return ret;
}
Il y a deux façons d'avoir une solution au problème:
1. Inverser un tableau dans l'espace.
Étape 1. Échangez les éléments au début et à la fin de l'index.
Étape 2. Incrémenter l'index de début décrémente l'index de fin.
Étape 3. Itérez les étapes 1 et 2 jusqu'au début de l'index <end index
Pour cela, la complexité temporelle sera O(n) et la complexité spatiale sera O (1).
Voici un exemple de code permettant d’inverser un tableau dans l’espace:
public static int[] reverseAnArrayInSpace(int[] array) {
int startIndex = 0;
int endIndex = array.length - 1;
while(startIndex < endIndex) {
int temp = array[endIndex];
array[endIndex] = array[startIndex];
array[startIndex] = temp;
startIndex++;
endIndex--;
}
return array;
}
2. Inverser un tableau en utilisant un tableau auxiliaire.
Étape 1. Créez un nouveau tableau de taille égale au tableau donné.
Étape 2. Insérez des éléments dans le nouveau tableau à partir de l'index de départ, à partir du tableau donné
Pour cela, la complexité temporelle sera O(n) et la complexité spatiale sera O (n).
Voici un exemple de code permettant d’inverser un tableau avec un tableau auxiliaire:
public static int[] reverseAnArrayWithAuxiliaryArray(int[] array) {
int[] reversedArray = new int[array.length];
for(int index = 0; index < array.length; index++) {
reversedArray[index] = array[array.length - index -1];
}
return reversedArray;
}
Nous pouvons également utiliser l'API Collections de Java.
L'API Collections utilise en interne la même approche inverse dans l'espace.
Voici un exemple de code d'utilisation de l'API Collections:
public static Integer[] reverseAnArrayWithCollections(Integer[] array) {
List<Integer> arrayList = Arrays.asList(array);
Collections.reverse(arrayList);
return arrayList.toArray(array);
}