Inverter uma matriz em Java

As matrizes são usadas com frequência na codificação e são uma forma de armazenar vários valores do mesmo tipo em uma variável. Pode haver muitas razões pelas quais um codificador pode querer inverter uma matriz. Pode ser necessário inverter um array, por exemplo, quando a lógica de um problema precisa começar pelo último elemento. Nesse caso, a melhor prática é fazer a reversão e, em seguida, usar a matriz invertida onde for necessário no código. Ainda mais, inverter uma matriz é uma tarefa muito popular nas entrevistas do Java Juniors.

Como inverter uma matriz

Existem muitas maneiras de inverter uma matriz e aqui consideramos 5. Para a Opção 1, uma matriz é invertida usando uma matriz adicional preenchida em ordem crescente a partir do final da matriz original (decrescente), na Opção 2, uma reversão no local é executado onde os elementos da matriz no início e no final são trocados, na Opção 3, o método reverse() do framework Collections é usado para fazer a reversão, na Opção 4, List.add() e List.remove() são usados ​​e, finalmente, na Opção 5, a recursão é usada.

Opção 1: Invertendo um Array usando um Array Adicional

Vamos escrever um método simples para inverter um array usando um array adicional . Esta opção usa um array adicional que é preenchido começando com o último elemento do array original em ordem decrescente, ou seja, o primeiro elemento é igual ao último elemento do array original, o segundo é igual ao penúltimo e assim ligado até que a matriz adicional seja preenchida.

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

Neste exemplo, escrevemos um método que inverte um array e retorna um novo array invertido, baseado no array que foi passado para ele. array é declarado em main e então um método, reverse , é chamado. O argumento para o método é o array. No método reverse , um novo array, newArray , é criado e tem o mesmo tamanho de array , só que completamente vazio. Um loop for é usado para preencher o newArray e opera em todo o comprimento do array. Isso é feito começando com o primeiro elemento de um array e atribuindo-o ao último elemento de newArray, em seguida, pegando o segundo elemento de nossa matriz e atribuindo-o ao penúltimo elemento de newArray e assim por diante; newArray é preenchido ao contrário. Quando o loop for é concluído, newArray está completamente cheio e é exatamente o inverso do array .

Opção 2: imprimir os elementos de uma matriz na ordem inversa

Para esta opção inverter um array, não há necessidade de usar um array adicional, e ele não é convertido em uma lista de arrays. Em vez disso, os elementos da matriz são colocados em ordem inversa no local . Isso significa que eles são, de fato, trocados. O primeiro elemento é trocado pelo último elemento, o segundo elemento é trocado pelo penúltimo e assim por diante. Um loop for é usado e quando isso for concluído, a matriz será invertida. O código fica assim:

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

A matriz original é impressa como uma String usando Arrays.toString(array) e, em seguida, nossa matriz é passada como um argumento para reverse . No método reverse no loop for , uma variável, temp, é criada e usada. No loop for , a ordem inversa é obtida em três etapas:

1. atribuindo o primeiro elemento a temp
2. atribuindo o último elemento ao primeiro elemento
3. atribuindo temp ao último elemento

Isso é então realizado novamente desta vez para o segundo elemento e penúltimo elemento, e assim por diante. Isso é feito para elementos sucessivos da matriz, mas o loop apenas itera até a metade do tamanho da matriz. Essencialmente, os elementos nas extremidades opostas da matriz são trocados. Este método será executado duas vezes mais rápido que um método que usa um loop for de 0 a tamanho. Como resultado, a ordem inversa da matriz é alcançada e mostramos como imprimir uma matriz na ordem inversa e os valores são impressos:

Opção 3: usando Collections.reverse()

Em Java, o método reverse , que faz parte do framework Collections existente, pode ser usado para inverter um array. Vamos usá-lo para fazer a reversão.

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

Em main , o array é criado e preenchido como um array inteiro com 5 números. Em seguida, é impresso como uma lista usando Arrays.asList(array) e, em seguida, a função, reverse , é chamada e o array é passado como um argumento para essa função. Em reverse , Collections.reverse é usado, e isso é usado na lista de matrizes, Arrays.asList(array) , em vez da própria matriz. Então, na próxima etapa, mostramos como imprimir uma matriz na ordem inversa usando System.out.println , e desta vez cada elemento é impresso na mesma linha:

Opção 4: inverter uma matriz usando List.add() e List.remove()

Nesta nova opção, List.add() e List.remove() são usados ​​para fazer a reversão. A maneira como isso funciona é que a matriz é convertida em uma lista e o último elemento da lista é removido e colocado no início da lista. Após toda a lista ter sido iterada, a nova lista é uma reversão da original. No método main() , uma matriz é criada com 5 números. Em seguida, o estado original da matriz é enviado ao console. Essa matriz é então colocada como um argumento para o método reverse() . Esse método funciona basicamente removendo o último elemento e inserindo-o na frente do array. Por fim, o novo estado (invertido) da matriz é enviado ao console. Ao contrário()método, o array é escrito em uma List via Arrays.asList(array) , para permitir que os métodos add() e remove() realizem a reversão. Esse método funciona basicamente removendo o último elemento e inserindo-o na frente do array. As etapas que reverse() usa são as seguintes. Ele usa um loop for para realizar a reversão dos elementos da lista. Ele faz isso inicializando uma variável i . Inicialmente o i é definido como 0. Quando i = 0 , o elemento em list.size() - 1 na lista é removido, e este sempre será o último elemento desde i < list.size() - 1. Como o método remove() retorna o elemento que removeu, esse elemento agora é adicionado à lista no índice i = 0 , ou seja, inserido no início. O restante da lista é deslocado para a direita, mas a nova lista ainda tem o mesmo número de elementos, ou seja, size . Continuando a execução do loop for com o próximo valor de i , i = 1 , o mesmo conjunto de etapas é realizado para que o último elemento seja removido e colocado em nums em i = 1 e a lista deslocada para a direita. Isso continua até que o último valor incremental de i e todos os elementos da lista tenham sido alterados. no segundo paraelemento de loop da lista com índice i é definido como elemento de array com índice i onde i vai de 0 a list.size() - 1 . Para resumir, as etapas utilizadas são: Etapas:

1. eu = 0
2. remover elemento em list.size() - 1
3. insira elemento, que estava em list.size() - 1 , em i = 0
4. incrementar eu
5. repita as etapas 2 a 4 (com novos valores para i na etapa 3) até que o último valor incremental de i seja usado

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 dá a saída:

Opção 5: inverter uma matriz por recursão

O método de recursão é amplamente utilizado na codificação e pode ser usado para criar um método eficiente de como inverter um array. Nesta opção, o array é convertido em uma lista e então o código vai para o método reverse() toda vez removendo o último elemento no final da lista e a lista tem os valores removidos adicionados a ela na ordem inversa. Como nos métodos anteriores, é criada uma matriz composta por 5 números. Em seguida, ele é passado como um argumento para a função reverse() . Em reverse() a primeira coisa que é feita é transformar o array em uma lista e verificar o tamanho da lista. Se tiver apenas um elemento ou for nulo, o método termina e retorna. Caso contrário, o primeiro elemento é removido, mas copiado para um inteiro, valor . O método reverse() é chamado novamente e a recursão começa novamente. Quando a função é inserida, os mesmos passos são executados, uma verificação de tamanho onde, se a lista for maior que 1, o próximo passo será remover o primeiro elemento e depois fazer a recursão novamente. Quando o tamanho da lista é 1, reverse() retorna para onde foi chamado e, em seguida, a lista tem cada valor adicionado a ela para construí-la em um reverso exato da 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);
   }
}

A saída é:

Conclusão

Então, aqui vimos 5 maneiras diferentes de inverter uma matriz. A opção 3, que usa a estrutura Collections, é provavelmente o melhor método a ser usado, pois Collections.reverse é uma função Java já existente, testada e comprovada. É claro que as outras opções podem ser usadas, especialmente durante o aprendizado, mas geralmente os métodos padrão, se existirem, são os melhores, pois geralmente são altamente otimizados e testados. No entanto, você mesmo pode criar esses métodos, pois este é um bom exercício de codificação e o ajudará a ter sucesso em sua entrevista para o Java Junior.