Home >> Programación >> Java
¿Quieres saber cómo invertir arrays en Java? ¿Lo que estás buscando es darle la vuelta a un array para que esté en orden inverso?. No sigas buscando, has llegado al sitio apropiado.
Te voy a explicar dos formas de invertir arrays en Java: La primera es usando un bucle y variables auxiliares y la segunda es utilizando un array auxiliar.
No importa el tipo de dato que almacenes en tu array, cualquiera de las dos formas te será útil para invertir el orden de los arrays en Java:
Cómo invertir arrays en Java utilizando un bucle y variables auxiliares
La primera forma de invertir un array en Java consiste en recorrer el array e ir intercambiando sus elementos (el primero por el último, el segundo por el penúltimo, etc.).
Para conseguir esto será necesario recorrer el array solo hasta la mitad. Cuando llegues al elemento central del array ya estará dado la vuelta.
Fíjate en el siguiente ejemplo:
Se trata de un array de 5 elementos. Cada elemento es un entero (pero el tipo es indiferente, debe funcionar con cualquier dato).
El elemento que ocupa la posición 0 (4) se debe copiar en la posición 4, y el que ocupa la 4 (7) se debe copiar en la posición 0. Si lo piensas bien es un intercambio de valores.
Al completar este paso se debe repetir el proceso con las posiciones 1 y 3. Una vez completado este paso el array estará al revés.
¿Está claro lo que debes hacer? Pues manos a la obra. Vamos escribir el código que realiza esta tarea:
int [] array = {4,6,2,8,7};
for (int i = 0; i < array.length/2; i++) {
int j = array.length-i-1;
int a = array[i];
int b = array[j];
array[i] = b;
array[j] = a;
}
He utilizado más variables de las necesarias, pero quiero que lo entiendas. Luego te explicaré cómo mejorarlo.
Fíjate en el for. La condición es i < array.length/2. Lo hago de esta forma porque solo quiero recorrer el array hasta la mitad. En este caso el array tiene 5 elementos, por lo que array.length devuelve el valor 5. Si lo divido entre 2 el resultado es 2 (recuerda que es una división entera y no hay decimales). De esta forma la condición del bucle queda como i < 2. ¿Tiene sentido? Si, porque la posición central es la 2 y es justo donde debe parar. De esta forma consigo que la variable i tome los valores 0 y 1.
Ahora vamos a analizar lo que hay dentro del bucle. Fíjate en la primera instrucción:
int j = array.length-i-1;
Imagina que el bucle está en su primera iteración. Eso significa que i tiene valor 0, por lo que a la variable j se le asignará el resultado de array.length-0-1 (5-0-1), es decir 4, que se corresponde con la última posición del array:
Cuando el bucle esté en su segunda iteración la variable i tendrá valor 1, por lo que la variable j tendrá valor 3:
¿Qué puedes deducir de este comportamiento? El índice i te permite recorrer el array de izquierda a derecha y el índice j en orden inverso. Es justo lo que necesitas para intercambiar las posiciones.
Perfecto, ya tenemos los índices. Ahora veamos para qué sirven las variables a y b.
Si te fijas, a la variable a le asigno el valor de array[i] y a la variable b le asigno el valor de array[j]:
int a = array[i];
int b = array[j];
Y justo a continuación guardo en la posición i (array[i]) lo que contiene la variable b, es decir, lo que había en la posición j.
También guardo en la posición j (array[j]) lo que contiene la variable a, es decir, lo que había en la posición i:
array[i] = b;
array[j] = a;
¿Qué consigues con esto? Intercambiar los valores que tiene el array en las posiciones i y j.
Al finalizar el bucle el array estará en orden inverso. Compruébalo ejecutando el siguiente código que muestra todos los elementos del array por pantalla:
for (int i = 0; i < array.length; i++) {
System.out.println(array[i]);
}
Eliminar variables innecesarias
Ahora vamos a optimizar el código un poco. Como ya te he comentado he utilizado más variables de las necesarias para que te resultase más fácil entenderlo. Ahora vamos a quitar todas las variables que no necesitemos.
El objetivo es intercambiar el dato de la posición i por el que se encuentra en la posición j. Puedo conseguir lo mismo de esta forma:
int [] array = {4,6,2,8,7};
for (int i = 0; i < array.length/2; i++) {
int j = array.length-i-1;
int a = array[i];
array[i] = array[j];
array[j] = a;
}
Como puedes ver me he ahorrado la variable b. Al copiar en la variable a el dato almacenado en array[i] puedo escribir sobre array[i] sin temor a perder la información que había antes, puesto que existe una copia en a. Lo que se encuentra en array[j] se copia en array[i] y lo que había en array[i], que ahora está en la variable a, se copia en array[j]. Consigo exactamente lo mismo pero con una variable menos.
¿Te puedes ahorrar alguna variable más? Si. Te puedes ahorrar la variable j (aunque no te lo recomiendo).
Piensa que la variable j toma su valor de la siguiente operación: array.length-i-1. Lo único que debes hacer es escribir esa operación en cada lugar en el que uses la j:
int [] array = {4,6,2,8,7};
for (int i = 0; i < array.length/2; i++) {
int a = array[i];
array[i] = array[array.length-i-1];
array[array.length-i-1] = a;
}
El resultado es el mismo, aunque yo en este caso preferiría seguir usando la variable j porque queda más claro el código, se realizan menos operaciones internamente y a la hora de depurar también es más sencillo.
Cómo invertir arrays en Java utilizando un array auxiliar
Vamos a ver ahora la segunda forma de invertir el orden de un array. En este caso vamos a utilizar un segundo array en el que volcaremos el primero en orden inverso y posteriormente sustituiremos el array original por este segundo.
Fíjate en este ejemplo, la idea es bastante sencilla:
El código en java quedaría así:
int [] array = {4,6,2,8,7};
int [] auxiliar = new int[array.length];
for (int i = 0; i < array.length; i++) {
int j = array.length-i-1;
auxiliar[j] = array[i];
}
array = auxiliar;
Paso 1: Copiar el array original en el auxiliar en orden inverso.
Fíjate que en la linea 2 declaro un nuevo array sin datos iniciales. Ese será el array auxiliar en el que volcaremos el array original en orden inverso. Este segundo array debe tener la misma longitud que el array original, por eso utilizo array.length para especificar el tamaño.
Veamos ahora el for. Utilizo la variable i como índice y utilizo array.length en la condición. La idea es recorrer el array original entero de izquierda a derecha (de la posición 0 a la más alta). No hay mayor misterio aquí. Lo interesante realmente está dentro del bucle.
En la primera instrucción dentro del bucle (línea 5) declaro una nueva variable j:
int j = array.length-i-1;
Esta variable servirá como índice para el segundo array.
Tienes que tener clara una cosa: si el array original lo vas a recorrer empezando en la posición 0, el array auxiliar lo tendrás que recorrer en orden inverso, empezando en la última posición. Por tanto el valor de su índice tendrá que ir en decremento.
Piensa que en cada iteración del array el valor de la variable i se incrementa en una unidad (i++). Por tanto, cuando i tenga valor 0, la variable j tomará el valor de array.length-0-1 (5-0-1), es decir 4. De la misma forma cuando i valga 1 la variable j tomará el valor de array.length-1-1 (5-1-1), es decir 3. Y lo mismo ocurrirá con i=2 (j=2), i=3 (j=1) e i=4 (j=0) (haz el cálculo para comprobarlo).
Veamos ahora la siguiente instrucción:
auxiliar[j] = array[i];
Esta instrucción simplemente copia el dato almacenado en la posición i del array original en la posición j del array auxiliar. Teniendo los indices bien definidos la copia se realizará en orden inverso.
Cuando i tenga valor 0 el valor de j será 4, por tanto el dato de la posición 0 del primer array se copiará en la posición 4 del segundo:
En la siguiente iteración la variable i tendrá valor 1 y la variable j tendrá valor 3. Por lo que el valor almacenado en la posición 1 del primer array se copiará en la posición 3 del segundo:
El proceso se irá repitiendo con el resto de posiciones hasta que el bucle for complete todas sus iteraciones.
NOTA: En este caso también te puedes ahorrar la variable j haciendo el cálculo del índice directamente así:
for (int i = 0; i < array.length; i++) {
auxiliar[j] = array[array.length-i-1];
}
Paso 2:
Una vez el bucle finalice, el array auxiliar será una copia del original, pero en orden inverso. Ya solo falta sustituir el array original por el auxiliar. De eso se encarga la instrucción de la línea 8:
array = auxiliar;
Más fácil imposible. Basta con hacer una asignación.
Ahora puedes comprobar que todo ha ido bien mostrando el array original por pantalla con el siguiente código. Si todo ha ido bien debe mostrarse en orden inverso a como lo has declarado:
for (int i = 0; i < array.length; i++) {
System.out.println(array[i]);
}