Este post irá discutir como reverter um array em Java.
1. Solução ingênua
Uma solução simples é criar um novo array do mesmo tipo e tamanho do array de entrada, preenchê-lo com elementos do array original na ordem inversa e então copiar o conteúdo do novo array para o original.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 |
import java.util.Arrays; class Main { // Método utilitário para reverter elementos de um array public static void reverse(int[] nums) { int[] temp = new int[nums.length]; for (int i = 0; i < nums.length; i++) { temp[nums.length - 1 - i] = nums[i]; } for (int i = 0; i < nums.length; i++) { nums[i] = temp[i]; } } public static void main(String[] args) { int[] nums = {1, 2, 3, 4, 5}; reverse(nums); System.out.println(Arrays.toString(nums)); } } |
2. Implementação no local
A implementação acima requer O(n) espaço extra para a matriz auxiliar. Podemos evitar isso modificando o array no lugar. Isso significa que a conversão deve ocorrer sem usar um array auxiliar, substituindo os elementos do array existente.
Um algoritmo no local pode ser implementado lendo os elementos de ambas as extremidades da array e trocando-os, conforme mostrado abaixo:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 |
import java.util.Arrays; class Main { // Método utilitário para trocar dois elementos nums[i] e nums[j] no array private static void swap(int[] nums, int i, int j) { int temp = nums[i]; nums[i] = nums[j]; nums[j] = temp; } // Método utilitário para reverter elementos de um array public static void reverse(int[] nums) { for (int low = 0, high = nums.length - 1; low < high; low++, high--) { swap(nums, low, high); } } public static void main(String[] args) { int[] nums = {1, 2, 3, 4, 5}; reverse(nums); System.out.println(Arrays.toString(nums)); } } |
Também podemos usar recursão para reverter um array sem usar um array auxiliar. A lógica permanece a mesma da implementação iterativa acima, mas ocupa espaço para a ligue para Stack.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 |
import java.util.Arrays; class Main { // Método utilitário para trocar dois elementos nums[i] e nums[j] no array private static void swap(int[] nums, int i, int j) { int temp = nums[i]; nums[i] = nums[j]; nums[j] = temp; } // Método recursivo para reverter elementos de um subarray formado por nums[low, high] public static void reverse(int[] nums, int low, int high) { if (low < high) { swap(nums, low, high); reverse(nums, low + 1, high - 1); } } // Método utilitário para reverter elementos de um array public static void reverse(int[] nums) { reverse(nums, 0, nums.length-1); } public static void main(String[] args) { int[] nums = {1, 2, 3, 4, 5}; reverse(nums); System.out.println(Arrays.toString(nums)); } } |
3. Usando a Stack (Stack implícita e explícita)
Outra maneira plausível de reverter uma matriz é usar a estrutura de dados da Stack. A ideia é colocar cada elemento do array em uma Stack. Em seguida, simplesmente retiramos os valores da Stack um por um e atribuímos cada item retirado de volta ao array original, começando do início.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 |
import java.util.Arrays; import java.util.Stack; class Main { // Método utilitário para reverter elementos de um array public static void reverse(int[] nums) { // cria uma Stack vazia de inteiros Stack<Integer> stack = new Stack<>(); // coloca cada elemento do array em uma Stack for (int i: nums) { stack.push(i); } //começa do índice 0 int index = 0; // retira os valores da Stack até ela ficar vazia while (!stack.isEmpty()) { // atribui cada item exibido de volta ao array original nums[index++] = stack.pop(); } } public static void main(String[] args) { int[] nums = {1, 2, 3, 4, 5}; reverse(nums); System.out.println(Arrays.toString(nums)); } } |
Podemos facilmente converter o código acima para usar a recursão ligue para Stack em vez da Stack explícita. Aqui está um programa recursivo que demonstra isso:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 |
import java.util.Arrays; class Main { // Método utilitário para reverter elementos de um array public static void reverse(int[] nums, int nextIndex) { // caso base: array vazio ou fim do array atingido if (nums == null || nextIndex == nums.length) { return; } // armazena o próximo elemento do array int value = nums[nextIndex]; // alcança o final do array usando recursão reverse(nums, nextIndex + 1); // coloca os elementos da ligue para Stack de volta em um array //começando do começo nums[nums.length - nextIndex - 1] = value; } public static void main(String[] args) { int[] nums = {1, 2, 3, 4, 5}; reverse(nums, 0); System.out.println(Arrays.toString(nums)); } } |
4. Usando Collections.reverse() método
Por fim, podemos usar o reverse() método do Collections class para inverter a ordem dos elementos na matriz especificada. Como ele aceita uma coleção como argumento, a ideia é passar um wrapper de lista apoiado pelo array fornecido.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
import java.util.Arrays; import java.util.Collections; class Main { public static void main(String[] args) { Integer[] nums = {1, 2, 3, 4, 5}; Collections.reverse(Arrays.asList(nums)); System.out.println(Arrays.toString(nums)); } } |
Isso é tudo sobre reverter uma array em Java.