Inversați o matrice în Java

Matricele sunt utilizate frecvent în codificare și reprezintă o modalitate de stocare a mai multor valori de același tip într-o variabilă. Pot exista multe motive pentru care un codificator ar putea dori să inverseze o matrice. Poate fi necesar să inversați o matrice, de exemplu, atunci când logica unei probleme trebuie să înceapă cu ultimul element. În acest caz, cea mai bună practică este să faceți inversarea și apoi să utilizați matricea inversată acolo unde este necesar în cod. Mai mult, inversarea unei matrice este o sarcină foarte populară în interviurile Java Juniors.

Cum se inversează o matrice

Există multe modalități de a inversa o matrice și aici luăm în considerare 5. Pentru Opțiunea 1, o matrice este inversată utilizând o matrice suplimentară completată în ordine crescătoare de la sfârșitul matricei originale (descrescătoare), în Opțiunea 2 o inversare pe loc. se efectuează acolo unde elementele matricei de la început și de la sfârșit sunt schimbate, în Opțiunea 3, metoda reverse() din cadrul Collections este folosită pentru a face inversarea, în Opțiunea 4, List.add() și List.remove() sunt utilizate, iar în final, în Opțiunea 5, recursiunea este utilizată.

Opțiunea 1: inversarea unei matrice folosind o matrice suplimentară

Să scriem o metodă simplă de a inversa o matrice folosind o matrice suplimentară . Această opțiune folosește o matrice suplimentară care este completată începând cu ultimul element al matricei originale în ordine descrescătoare, adică primul element este același cu ultimul element din tabloul original, al doilea este același cu al doilea din ultimul și așadar pornit până când matricea suplimentară este umplută.

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

În acest exemplu, am scris o metodă care inversează o matrice și returnează o nouă matrice inversată, bazată pe matricea care i-a fost transmisă. matricea este declarată în main și apoi este apelată o metodă, reverse . Argumentul metodei este matricea. În metoda inversă , o nouă matrice, newArray , este creată și are aceeași dimensiune ca și array , doar complet goală. O buclă for este folosită pentru a completa newArray și funcționează pe toată lungimea matricei. Acest lucru se face pornind cu primul element al unui tablou și alocându-l ultimului element al newArray, apoi luând al doilea element al matricei noastre și alocându-l ultimului element al newArray și așa mai departe; newArray este completat invers. Când bucla for este completă, newArray este complet plin și este exact inversul matricei .

Opțiunea 2: Imprimați elementele unui tablou în ordine inversă

Pentru ca această opțiune să inverseze o matrice, nu este nevoie să utilizați o matrice suplimentară și nu este convertită într-o listă de matrice. În schimb, elementele matricei sunt puse în ordine inversă pe loc . Aceasta înseamnă că sunt, de fapt, schimbate. Primul element este schimbat cu ultimul element, al doilea element este schimbat cu al doilea din ultimul și așa mai departe. Se folosește o buclă for și când aceasta a fost finalizată, matricea va fi inversată. Codul arată astfel:

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

Matricea originală este tipărită ca șir folosind Arrays.toString(array) și apoi matricea noastră este transmisă ca argument în reverse . În metoda inversă în bucla for , este creată și utilizată o variabilă, temp. În bucla for , ordinea inversă se realizează în trei pași:

1. atribuirea primului element la temp
2. atribuirea ultimului element primului element
3. atribuirea temperaturii ultimului element

Acest lucru este apoi efectuat din nou de data aceasta pentru al doilea element și al doilea din ultimul element și așa mai departe. Acest lucru se face pentru elementele succesive ale matricei, dar bucla repetă doar până la jumătate din dimensiunea matricei. În esență, elementele de la capetele opuse ale matricei sunt schimbate. Această metodă va rula de două ori mai rapid decât o metodă care utilizează o buclă for care merge de la 0 la dimensiune. Ca rezultat, se realizează ordinea inversă a matricei și ni se arată cum să tipărim o matrice în ordine inversă, iar valorile sunt tipărite:

Opțiunea 3: Utilizarea Collections.reverse()

În Java, metoda inversă , care face parte din cadrul existent Collections, poate fi utilizată pentru a inversa o matrice. Să-l folosim pentru a face inversarea.

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

În principal , matricea este creată și completată ca o matrice Integer cu 5 numere. Este apoi tipărită ca o listă folosind Arrays.asList(array) și apoi funcția, reverse , este apelată și array este transmisă ca argument în această funcție. În sens invers , Collections.reverse este folosit, iar acesta este folosit în lista de matrice, Arrays.asList(array) , mai degrabă decât în ​​matricea în sine. Apoi, în pasul următor ni se arată cum să tipărim o matrice în ordine inversă utilizând System.out.println , iar de data aceasta fiecare element este tipărit pe aceeași linie:

Opțiunea 4: inversați o matrice folosind List.add() și List.remove()

În această nouă opțiune, List.add() și List.remove() sunt folosite pentru a face inversarea. Modul în care funcționează este că matricea este convertită într-o listă și ultimul element al listei este eliminat și pus la începutul listei. După ce întreaga listă a fost repetată, noua listă este o inversare față de cea originală. În metoda main() , este creată o matrice formată din 5 numere. Apoi starea inițială a matricei este trimisă la consolă. Această matrice este apoi introdusă ca argument pentru metoda, reverse() . Această metodă funcționează practic prin eliminarea ultimului element și inserarea lui în partea din față a matricei. În cele din urmă, noua stare (inversată) a matricei este trimisă la consolă. Pe invers()metoda, matricea este scrisă într-o Listă prin Arrays.asList(array) , pentru a activa metodele add() și remove() pentru a efectua inversarea. Această metodă funcționează practic prin eliminarea ultimului element și inserarea lui în partea din față a matricei. Pașii folosiți de reverse() sunt următorii. Utilizează o buclă for pentru a efectua inversarea elementelor listei. Face acest lucru prin inițializarea unei variabile i . Inițial, i este setat la 0. Când i = 0 , elementul de la list.size() - 1 din listă este eliminat și acesta va fi întotdeauna ultimul element, deoarece i < list.size() - 1. Deoarece metoda remove() returnează elementul pe care l-a eliminat, acest element este acum adăugat în listă la indexul i = 0 , adică inserat la început. Restul listei este apoi mutat la dreapta, dar noua listă are în continuare același număr de elemente, adică dimensiunea . Continuând execuția buclei for cu următoarea valoare a lui i , i = 1 , se efectuează același set de pași, astfel încât ultimul element este eliminat și pus în nums la i = 1 și lista mutată la dreapta. Aceasta continuă până când ultima valoare incrementală a lui i și toate elementele din listă au fost modificate. În al doilea pentruelementul buclă al listei cu indice i este setat la elementul matrice cu indice i unde i este de la 0 la list.size() - 1 . Pentru a rezuma, pașii utilizați sunt: ​​Pași:

1. i = 0
2. eliminați elementul de la list.size() - 1
3. element de inserare, care a fost la list.size() - 1 , la i = 0
4. increment i
5. repetați pașii de la 2 la 4 (cu noi valori pentru i la pasul 3) până când este utilizată ultima valoare incrementală a lui 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);
       }
   }
}

Acest cod oferă rezultatul:

Opțiunea 5: inversează o matrice prin recursivitate

Metoda recursiunii este utilizată pe scară largă în codificare și poate fi folosită pentru a crea o metodă eficientă despre cum să inversați o matrice. În această opțiune, matricea este convertită într-o listă și apoi codul intră în metoda reverse() de fiecare dată când se elimină ultimul element de la sfârșitul listei, iar lista are valorile eliminate adăugate în ordine inversă. Ca și în metodele anterioare, se creează o matrice formată din 5 numere. Apoi este transmis ca argument în funcție, reverse() . În reverse() primul lucru care se face este să transformați matricea într-o listă și să verificați dimensiunea listei. Dacă are un singur element sau este nulă, metoda se termină și revine. Dacă nu, primul element este eliminat, dar copiat într-un număr întreg, valoare . Metoda reverse() este apoi apelată din nou și recursiunea începe din nou. Când se introduce funcția, se efectuează aceiași pași, o verificare a dimensiunii în care, dacă lista este mai mare de 1, următorul pas va fi eliminarea primului element și apoi repetarea recursiei. Când dimensiunea listei este 1, reverse() revine de unde este apelată și apoi lista are fiecare valoare adăugată pentru a o construi într-un revers exact al listei originale.

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

Ieșirea este:

Concluzie

Deci aici am analizat 5 moduri diferite de a inversa o matrice. Opțiunea 3, care utilizează cadrul Collections, este probabil cea mai bună metodă de utilizat, deoarece Collections.reverse este o funcție Java deja existentă, încercată și testată. Desigur, celelalte opțiuni pot fi folosite, mai ales în timpul învățării, dar în general metodele standard, dacă există, sunt cele mai bune, deoarece sunt de obicei foarte optimizate și testate. Cu toate acestea, puteți crea singur astfel de metode, deoarece acesta este un exercițiu de codificare bun și vă va ajuta să reușiți la interviul pentru Java Junior.