Comment inverser un tableau int en Java?

Avec Commons.Lang , vous pouvez simplement utiliser

ArrayUtils.reverse(int[] array)

la plupart du temps, il est plus rapide et plus sûr de s'en tenir à des bibliothèques facilement disponibles déjà testées par l'unité et par l'utilisateur lorsqu'elles prennent soin de 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 que c'est un peu plus facile de suivre la logique de l'algorithme si vous déclarez explicite des variables à suivre les indices qui changeant à 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 qu'il est plus lisible de faire cela dans une boucle de temps.

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.List s et java.util.Arrays.asList() retourne une liste qui enveloppe le tableau spécifique que vous lui passez, donc yourArray est inversé après l'invocation de Collections.reverse() .

le coût est juste la création d'une Liste-objet et aucune bibliothèque supplémentaire ne sont nécessaires.

une solution similaire a été présentée dans la réponse de Tarik et leurs commentateurs, mais je pense que cette réponse serait plus concis et plus facilement analysables.

Avec Goyave:

Collections.reverse(Ints.asList(array));

il y a déjà beaucoup de réponses ici, principalement axées sur la modification du tableau en place. Mais par souci d'exhaustivité, voici une autre approche utilisant les flux Java pour préserver le tableau original 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();

simple pour 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 va vous aider à

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

c'est comme ça que je le résoudrai personnellement. La raison derrière la création de la méthode paramétrée est de permettre à n'importe quel tableau d'être trié... pas seulement tes entiers.

j'espère que vous en retirez 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;
}

Il est plus efficace de simplement effectuer une itération de la matrice vers l'arrière.

Je ne suis pas sûr si la solution D'Aaron fait ce vi cet appel Collections.reverse(list); est-ce que quelqu'un sait?

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 qui sont plus primitives (char, byte, int, etc) alors vous pouvez faire quelques opérations de XOR fun.

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

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 entier comme:

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]

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

Voici une solution simple et rapide. Espérons que cela aide!.

public int[] reverse(int[] arr) {
    for(int i = arr.length; i > 0 ; i--){
        System.out.print(arr[i-1] + " ");
    }
    return arr;
}

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

ne serait-ce 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;

ci-dessous le programme complet dans votre machine.

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 en utilisant des tableaux ce sera la bonne source .Passez par le lien.

en utilisant la solution XOR pour éviter la variable température à 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 /

Voici une implémentation simple, pour inverser le tableau de tout type , plus prise en charge complète/partielle .

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 l'essai 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));
 }
}

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

Voici ce que j'ai trouvé:

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

Il y a deux façons d'avoir une solution pour le problème:

1. Inversez un tableau dans l'espace.

Étape 1. Permuter les éléments au début et à la fin de l'index.

Étape 2. Incrémenter l'indice de début décrémente l'indice de fin.

Étape 3. Itération de l'Étape 1 et l'Étape 2 jusqu'index de début < fin de l'index

pour cela, la complexité du temps sera O( n) et l'espace complexité O(1)

exemple de code pour inverser un tableau dans l'espace est comme:

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éer un nouveau tableau de taille égale à la matrice.

Étape 2. Insérez des éléments dans le nouveau tableau à partir de l'index de départ, tableau donné à partir de l'index de fin.

Pour ce, le temps complexité O(n) et l'espace de complexité O(n)

Exemple de code pour inverser une matrice avec l'auxiliaire tableau est comme:

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

pour ce faire, nous pouvons également utiliser L'API Collections de Java.

L'API Collections utilise à l'interne la même approche inverse dans l'espace.

exemple de code pour l'utilisation de L'API Collections est comme:

public static Integer[] reverseAnArrayWithCollections(Integer[] array) {
    List<Integer> arrayList = Arrays.asList(array);
    Collections.reverse(arrayList);
    return arrayList.toArray(array);
}

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

2 façons d'inverser un tableau .

1. en utilisant pour boucle et d'échanger les éléments jusqu'au milieu avec la complexité du temps 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));
   

   }

2. utilisant 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);

    }

public static void main (String args[]){

    //create  array
    String[] stuff ={"eggs","lasers","hats","pie","apples"};

    //print out  array
    for(String x :stuff)
        System.out.printf("%s ", x);
            System.out.println();

            //print out array in reverse order
            for(int i=stuff.length-1; i >= 0; i--)
                System.out.printf("%s ",stuff[i]);  

}

public class TryReverse {
    public static void main(String[] args) {        
        int [] array = {2,3,4,5,6,7,8,9};       
        reverse(array);
        for(int i=0; i<array.length; ++i)
            System.out.print(array[i] + " ");
    }
    public static void reverse (int [] array){
        for(int start=0, end=array.length-1; start<=end; start++, end--){
            int aux = array[start];
            array[start]=array[end];
            array[end]=aux;
        }
    }
}