¿Cómo invierto una matriz int en Java?

Estoy tratando de revertir una matriz int en Java.

Este método no invierte la matriz.

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é tiene de malo?

Para invertir una matriz int, intercambia elementos hacia arriba hasta llegar al punto medio, de esta manera:

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

De la forma en que lo hace, intercambia cada elemento dos veces, por lo que el resultado es el mismo que la lista inicial.

Con Commons.Lang , simplemente podría usar

ArrayUtils.reverse(int[] array)

La mayoría de las veces, es más rápido y más seguro a prueba de errores apegarse a bibliotecas fácilmente disponibles que ya han sido probadas por la unidad y probadas por el usuario cuando se ocupan de su problema.

public class ArrayHandle {
    public static Object[] reverse(Object[] arr) {
        List<Object> list = Arrays.asList(arr);
        Collections.reverse(list);
        return list.toArray();
    }
}

Collections.reverse(Arrays.asList(yourArray));

java.util.Collections.reverse()puede invertir java.util.Listsy java.util.Arrays.asList()devuelve una lista que envuelve la matriz específica que le pasa, por yourArraylo tanto, se invierte después de la invocación de Collections.reverse().

El costo es solo la creación de un objeto List y no se requieren bibliotecas adicionales.

Se ha presentado una solución similar en la respuesta de Tarik y sus comentaristas, pero creo que esta respuesta sería más concisa y más fácil de analizar.

Creo que es un poco más fácil seguir la lógica del algoritmo si declara variables explícitas para realizar un seguimiento de los índices que está intercambiando en cada iteración del bucle.

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

También creo que es más legible hacer esto en un ciclo 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--;
    }
}

Aquí ya hay muchas respuestas, principalmente enfocadas en modificar la matriz en el lugar. Pero en aras de la exhaustividad, aquí hay otro enfoque que utiliza secuencias de Java para preservar la matriz original y crear una nueva matriz inversa:

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

Con guayaba:

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

En el caso de Java 8 , también podemos utilizar IntStreampara invertir la matriz de enteros como:

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]

Simple para loop!

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

Esto te ayudara

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

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

Así es como lo resolvería personalmente. La razón detrás de la creación del método parametrizado es permitir que se ordene cualquier matriz ... no solo sus enteros.

Espero que obtengas algo de eso.

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

Su programa solo funcionará length = 0, 1. Puedes probar :

int i = 0, j = validData.length-1 ; 
while(i < j)
{
     swap(validData, i++, j--);  // code for swap not shown, but easy enough
}

Si trabaja con datos que son más primitivos (es decir, char, byte, int, etc.), puede realizar algunas divertidas operaciones 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];
    }
}

Es más eficiente simplemente iterar la matriz hacia atrás.

No estoy seguro de si la solución de Aaron hace esto vi esta llamada Collections.reverse(list);¿Alguien sabe?

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

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

¿No sería así mucho más improbable que se cometieran errores?

    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;

Solución con o (n) complejidad de tiempo y o (1) complejidad de espacio.

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

2 formas de revertir una matriz.

1. Usando el bucle For e intercambia los elementos hasta el punto medio con una complejidad temporal 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. Uso de la función integrada (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));

   }

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

Hay algunas respuestas excelentes arriba, pero así es como lo hice:

public static int[] test(int[] arr) {

    int[] output = arr.clone();
    for (int i = arr.length - 1; i > -1; i--) {
        output[i] = arr[arr.length - i - 1];
    }
    return output;
}

a continuación se muestra el programa completo para ejecutar en su máquina.

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

Para los programas en matriz que usan matrices, esta será la buena fuente Vaya a través del enlace.

Usando la solución XOR para evitar la variable temporal, su código debería verse como

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

Vea este enlace para una mejor explicación:

http://betterexplained.com/articles/swap-two-variables-using-xor/

private static int[] reverse(int[] array){
    int[] reversedArray = new int[array.length];
    for(int i = 0; i < array.length; i++){
        reversedArray[i] = array[array.length - i - 1];
    }
    return reversedArray;
} 

Aquí hay una implementación simple, para invertir la matriz de cualquier tipo , más soporte completo / parcial .

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

}

Aquí está la prueba de unidad correspondiente

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

Esto es lo que se me ocurrió:

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

Hay dos formas de tener una solución para el problema:

1. Invierta una matriz en el espacio.

Paso 1. Intercambie los elementos al inicio y al final del índice.

Paso 2. Incremente el índice inicial disminuya el índice final.

Paso 3. Itere el Paso 1 y el Paso 2 hasta el índice inicial <índice final

Para esto, la complejidad del tiempo será O (n) y la complejidad del espacio será O (1)

El código de muestra para invertir una matriz en el espacio es como:

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. Invierta una matriz utilizando una matriz auxiliar.

Paso 1. Cree una nueva matriz de tamaño igual a la matriz dada.

Paso 2. Inserte elementos en la nueva matriz comenzando desde el índice inicial, desde la matriz dada comenzando desde el índice final.

Para esto, la complejidad temporal será O (n) y la complejidad espacial será O (n)

El código de muestra para invertir una matriz con matriz auxiliar es como:

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

Además, podemos usar la API de colecciones de Java para hacer esto.

La API de colecciones usa internamente el mismo enfoque inverso en el espacio.

El código de muestra para usar la API de colecciones es como:

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

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

    }