Invertir una matriz en Java

Las matrices se utilizan con frecuencia en la codificación y son una forma de almacenar múltiples valores del mismo tipo en una variable. Puede haber muchas razones por las que un codificador quiera invertir una matriz. Puede ser necesario invertir una matriz, por ejemplo, cuando la lógica de un problema debe comenzar con el último elemento. En este caso, la mejor práctica es hacer la inversión y luego usar la matriz invertida donde sea necesario en el código. Aún más, invertir una matriz es una tarea muy popular en las entrevistas de Java Juniors.

Cómo invertir una matriz

Hay muchas formas de invertir una matriz, y aquí consideramos 5. Para la Opción 1, una matriz se invierte usando una matriz adicional rellenada en orden ascendente desde el final de la matriz original (descendente), en la Opción 2 una inversión en el lugar se lleva a cabo donde los elementos de la matriz al principio y al final se intercambian, en la Opción 3, el método reverse() del marco de Colecciones se usa para hacer la inversión, en la Opción 4, List.add() y List.remove() se utilizan, y finalmente, en la Opción 5, se utiliza la recursividad.

Opción 1: invertir un arreglo usando un arreglo adicional

Escribamos un método simple para invertir una matriz usando una matriz adicional . Esta opción utiliza una matriz adicional que se llena comenzando con el último elemento de la matriz original en orden descendente, es decir, el primer elemento es el mismo que el último elemento de la matriz original, el segundo es el mismo que el penúltimo y así encendido hasta que se llene la matriz adicional.

import java.util.Arrays;

public class ReverseArrayDemo {

   public static void main(String[] args) {
       int[] array = {7, 8, 9, 10, 11};
       System.out.println("Array : " + Arrays.toString(array)); // print array

       // Call function to get reversed array
       int[] reversedArray = reverse(array);
       System.out.println("Reversed array : " + Arrays.toString(reversedArray)); // print reversed array
   }

   // Method returns a new reversed array, based on the array which was passed to it.
   static int[] reverse(int[] array) {
       int[] newArray = new int[array.length];

       for (int i = 0; i < array.length; i++) {
           newArray[array.length - 1 - i] = array[i];
       }

       return newArray;
   }
}

En este ejemplo, escribimos un método que invierte una matriz y devuelve una nueva matriz invertida, en función de la matriz que se le pasó. La matriz se declara en main y luego se llama a un método, reverse . El argumento del método es la matriz. En el método reverse , se crea una nueva matriz, newArray , y tiene el mismo tamaño que la matriz , solo que completamente vacía. Se utiliza un bucle for para completar newArray y opera en toda la longitud de la matriz. Esto se hace comenzando con el primer elemento de una matriz y asignándolo al último elemento de newArray, luego tomando el segundo elemento de nuestra matriz y asignándolo al penúltimo elemento de newArray , y así sucesivamente; newArray se rellena al revés. Cuando el ciclo for está completo, newArray está completamente lleno y es exactamente lo contrario de la matriz .

Opción 2: imprimir los elementos de una matriz en orden inverso

Para que esta opción invierta una matriz, no es necesario utilizar una matriz adicional y no se convierte en una lista de matrices. En su lugar, los elementos de la matriz se colocan en orden inverso en el lugar . Esto significa que, de hecho, están intercambiados. El primer elemento se intercambia con el último elemento, el segundo elemento se intercambia con el penúltimo, y así sucesivamente. Se usa un ciclo for y cuando esto se ha completado, la matriz se habrá invertido. El código se ve así:

import java.util.Arrays;
/*
reversing an array in-place
*/
public class ReverseArrayDemo {

   public static void main(String[] args) {
       int[] array = {1, 4, 9, 16, 25};
       System.out.println("Array before reverse : " + Arrays.toString(array));

       arrayReverse(array);
       System.out.println("Array after reverse : " + Arrays.toString(array));
   }
//arrayReverse is a method that reverses array in-place
   static void arrayReverse(int[] array) {
       for (int i = 0; i < array.length / 2; i++) {
           int temp = array[i];
           array[i] = array[array.length - i - 1];
           array[array.length - i - 1] = temp;
       }
   }
}

La matriz original se imprime como una cadena usando Arrays.toString(array) y luego nuestra matriz se pasa como argumento a reverse . En el método inverso en el bucle for , se crea y utiliza una variable, temp. En el bucle for , el orden inverso se logra en tres pasos:

1. asignando el primer elemento a temp
2. asignar el último elemento al primer elemento
3. asignando temp al último elemento

Esto se lleva a cabo de nuevo esta vez para el segundo elemento y el penúltimo elemento, y así sucesivamente. Esto se hace para elementos sucesivos de la matriz, pero el bucle solo itera hasta la mitad del tamaño de la matriz. Esencialmente, los elementos en los extremos opuestos de la matriz se intercambian. Este método se ejecutará dos veces más rápido que un método que usa un bucle for que va de 0 a tamaño. Como resultado, se logra el orden inverso de la matriz y se muestra cómo imprimir una matriz en orden inverso y se imprimen los valores:

Opción 3: Usar Collections.reverse()

En Java, el método inverso , que forma parte del marco de colecciones existente, se puede utilizar para invertir una matriz. Usémoslo para hacer la inversión.

import java.util.Arrays;
import java.util.Collections;

public class ReverseArrayDemo {

   public static void main(String[] args) {
       Integer[] array = {1, 4, 9, 16, 25};
       System.out.println("Array before reverse : " + Arrays.toString(array));

       reverse(array);
       System.out.println("Array after reverse : " + Arrays.toString(array));
   }
//method that reverses an array
   static void reverse(Integer[] array) {
       Collections.reverse(Arrays.asList(array));
   }
}

En main , la matriz se crea y se completa como una matriz de enteros con 5 números. Luego se imprime como una lista usando Arrays.asList(array) y luego se llama a la función, reverse , y array se pasa como argumento a esta función. En reversa , se usa Collections.reverse , y esto se usa en la lista de matrices, Arrays.asList(array) , en lugar de la matriz en sí. Luego, en el siguiente paso, se nos muestra cómo imprimir una matriz en orden inverso usando System.out.println , y esta vez cada elemento se imprime en la misma línea:

Opción 4: invertir una matriz usando List.add() y List.remove()

En esta nueva opción, List.add() y List.remove() se utilizan para realizar la inversión. La forma en que esto funciona es que la matriz se convierte en una lista y el último elemento de la lista se elimina y se coloca al principio de la lista. Una vez que se ha iterado toda la lista, la nueva lista es una inversión de la original. En el método main() , se crea una matriz que consta de 5 números. Luego, el estado original de la matriz se envía a la consola. Esta matriz luego se coloca como un argumento para el método, reverse() . Este método básicamente funciona eliminando el último elemento e insertándolo al frente de la matriz. Por último, el nuevo estado (invertido) de la matriz se envía a la consola. Al revés()método, la matriz se escribe en una Lista a través de Arrays.asList(array) , para permitir que los métodos add() y remove() lleven a cabo la inversión. Este método básicamente funciona eliminando el último elemento e insertándolo al frente de la matriz. Los pasos que utiliza reverse() son los siguientes. Utiliza un bucle for para realizar la inversión de los elementos de la lista. Lo hace inicializando una variable i . Inicialmente, i se establece en 0. Cuando i = 0 , el elemento en list.size() - 1 en list se elimina, y este siempre será el último elemento ya que i < list.size() - 1. Dado que el método remove() devuelve el elemento que ha eliminado, este elemento ahora se agrega a la lista en el índice i = 0 , es decir, se inserta al principio. El resto de la lista se desplaza hacia la derecha, pero la nueva lista aún tiene el mismo número de elementos, es decir, tamaño . Continuando con la ejecución del ciclo for con el siguiente valor de i , i = 1 , se lleva a cabo el mismo conjunto de pasos para que el último elemento se elimine y se ponga en números en i = 1 y la lista se desplace a la derecha. Esto continúa hasta que se cambia el último valor incremental de i y todos los elementos de la lista. en el segundo porel elemento de bucle de la lista con el índice i se establece en el elemento de la matriz con el índice i donde i es de 0 a list.size() - 1 . En resumen, los pasos utilizados son: Pasos:

1. yo = 0
2. eliminar elemento en list.size() - 1
3. inserte el elemento, que estaba en list.size() - 1 , en i = 0
4. incremento yo
5. repita los pasos 2 a 4 (con nuevos valores para i en el paso 3) hasta que se use el último valor incremental de i

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class ReverseArrayDemo {

   public static void main(String[] args) {
       Integer[] array = new Integer[]{1, 4, 9, 16, 25};
       System.out.println("Array before reverse : " + Arrays.toString(array));

       reverse(array);
       System.out.println("Array after reverse : " + Arrays.toString(array));
   }

   static void reverse(Integer[] array) {
       List list = new ArrayList<>(Arrays.asList(array));

       for (int i = 0; i < list.size() - 1; i++) {
           list.add(i, list.remove(list.size() - 1));
       }

       for (int i = 0; i < list.size(); i++) {
           array[i] = list.get(i);
       }
   }
}

Este código da la salida:

Opción 5: invertir una matriz por recursividad

El método de recursión se usa ampliamente en la codificación y se puede usar para crear un método eficiente sobre cómo invertir una matriz. En esta opción, la matriz se convierte en una lista y luego el código pasa al método reverse() cada vez que se elimina el último elemento al final de la lista y la lista tiene los valores eliminados agregados en orden inverso. Como en los métodos anteriores, se crea una matriz que consta de 5 números. Luego se pasa como un argumento a la función, reverse() . En reverse(), lo primero que se hace es convertir la matriz en una lista y verificar el tamaño de la lista. Si solo tiene un elemento o es nulo, el método finaliza y regresa. Si no, el primer elemento se elimina, pero se copia a un número entero., valor _ Luego se vuelve a llamar al método reverse() y la recursión comienza de nuevo. Cuando se ingresa a la función, se realizan los mismos pasos, una verificación de tamaño donde, si la lista es mayor a 1, el siguiente paso será eliminar el primer elemento y luego volver a hacer la recursividad. Cuando el tamaño de la lista es 1, reverse() regresa al lugar desde donde se llama y luego a la lista se le agrega cada valor para construirla en un reverso exacto de la lista original.

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class ReverseArrayDemo {

   public static void main(String[] args) {
       Integer[] array = new Integer[]{1, 4, 9, 16, 25};
       System.out.println("Array before reverse : " + Arrays.toString(array));

       List list = new ArrayList<>(Arrays.asList(array));
       reverse(list);
       System.out.println("Array after reverse : " + Arrays.toString(list.toArray()));
   }

   public static void reverse(List list) {
       if (list== null || list.size() <= 1) {
           return;
       }

       Integer value = list.remove(0);

       reverse(list);

       list.add(value);
   }
}

La salida es:

Conclusión

Así que aquí hemos visto 5 formas diferentes de invertir una matriz. La opción 3, que usa el marco de Collections, es probablemente el mejor método para usar, ya que Collections.reverse es una función de Java ya existente y probada. Por supuesto, se pueden usar las otras opciones, especialmente durante el aprendizaje, pero generalmente los métodos estándar, si existen, son los mejores, ya que generalmente están altamente optimizados y probados. Sin embargo, puede crear dichos métodos usted mismo, ya que este es un buen ejercicio de codificación y lo ayudará a tener éxito en su entrevista para Java Junior.