Comment puis-je 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 de bug-sûr de coller avec facilement disponibles bibliothèques déjà de l'unité testée et utilisateur-testé quand ils prennent soin de votre problème.

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 que c'est plus lisible pour ce faire, dans une boucle while.

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

Il y a déjà beaucoup de réponses ici, principalement axés sur la modification de la matrice en place. Mais par souci d'exhaustivité, voici une autre approche à l'aide de Java flux de préserver le tableau d'origine et de créer un nouveau inversée tableau:

    int[] a = {8, 6, 7, 5, 3, 0, 9};
    int[] b = IntStream.rangeClosed(1, a.length).map(i -> a[a.length-i]).toArray();

Simple boucle for!

for (int start = 0, end = array.length - 1; start <= end; start++, end--) {
    int aux = array[start];
    array[start]=array[end];
    array[end]=aux;
}

for(int i=validData.length-1; i>=0; i--){
  System.out.println(validData[i]);
 }

Votre programme de travail pour seulement 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
}

En cas de Java 8 nous pouvons également utiliser les flux d'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 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 pas en le faisant de cette façon beaucoup plus rare pour les 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 la matrice à l'aide de tableaux ce sera la bonne source.Passez par le lien.

Ici est une simple mise en œuvre, à l'inverse de la matrice de de tout type, plus plein/partiel soutien.

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

}

Ici est l'Unité correspondante de Test

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

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

1. Inverse d'une matrice dans l'espace.

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

L'étape 2. Incrémenter l'index de début décrémenter la fin de l'index.

L'étape 3. Itération de l'Étape 1 et l'Étape 2 jusqu'à la mise index < fin de l'index

Pour cela, la complexité temporelle O(n) et l'espace de complexité O(1)

Exemple de code pour inverser un tableau dans l'espace, c'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. Inverse d'une matrice à l'aide d'un auxiliaire de tableau.

L'étape 1. Créer un nouveau tableau de taille égale à la matrice.

L'étape 2. L'insertion d'éléments pour le nouveau tableau à partir de l'index de début, de la
tableau donné, dès la fin de l'index.

Pour cela, la complexité temporelle 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;
}

Aussi, nous pouvons utiliser les Collections de l'API de Java pour ce faire.

Les Collections de l'API utilise en interne les mêmes inverse dans l'espace de l'approche.

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

2 moyens pour inverser une Matrice .

1. À l'aide De la boucle et de permuter les éléments jusqu'à la mi-point avec le temps, la complexité 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. À l'aide intégrée dans la fonction (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));

   }

   De sortie : [6, 5, 4, 3, 2, 1]

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

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

Essayer ce programme en JAVA :-

import java.util.Scanner;

public class Rev_one_D {

    static int row;

    static int[] trans_arr = new int[row];

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        row = n;

        int[] arr = new int[row];
        for (int i = 0; i < row; i++) {

            arr[i] = sc.nextInt();
            System.out.print(arr[i] + " ");

            System.out.println();
        }

        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 < row; i++) {
            System.out.print(arr[i] + " ");
            System.out.println();
        }
    }
}

Voici une simple une solution 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;
}

Que j'avais l'intention de garder mon Tableau original tel qu'il était, j'ai résolu ce problème de la manière suivante:

List<Integer> normalArray= new ArrayList<>();
List<Integer> reversedArray = new ArrayList<>();

//Fill up array here

for (int i = 1; i <= normalArray.size(); i++) {
  reversedArray .add(normalArray.get(normalArray.size()-i));
}

Donc, fondamentalement, de la boucle au travers de la table initiale et ajouter toutes les valeurs dans l'ordre inverse de la nouvelle (inversé) tableau. Le type de la liste peut être n'importe quoi.
Je travaille mon chemin à travers ce code plusieurs fois, ce qui provoque certaines autres solutions que de ne pas travailler.

Vous pouvez utiliser cette

public final class ReverseComparator<T extends Comparable<T>> implements  Comparator<T> {
  @Override
  public int compare(T o1, T o2) {      
    return o2.compareTo(o1);
  }
}

Un simplement

Integer[] a = {1,6,23,4,6,8,2}
Arrays.sort(a, new ReverseComparator<Integer>());