Tömb megfordítása Java nyelven

A tömböket gyakran használják a kódolásban, és egy mód több azonos típusú érték tárolására egy változóban. Számos oka lehet annak, hogy a kódoló meg akarja fordítani a tömböt. Szükség lehet egy tömb megfordítására, például amikor egy probléma logikájának az utolsó elemmel kell kezdődnie. Ebben az esetben a legjobb gyakorlat az, hogy megfordítja, majd szükség esetén a fordított tömböt használja a kódban. Sőt, a tömb megfordítása nagyon népszerű feladat a Java Juniors interjúkban.

Hogyan lehet megfordítani egy tömböt

Számos módja van egy tömb megfordításának, és itt az 5-öt vesszük figyelembe. Az 1. lehetőségnél a tömb megfordul egy további tömb használatával, amelyet az eredeti tömb végétől növekvő sorrendben töltenek ki (csökkenő), a 2. lehetőségnél pedig egy helyben történő megfordítást. akkor kerül végrehajtásra, amikor a tömb elején és végén lévő elemeket felcserélik, a 3. lehetőségben a Collections keretrendszer reverse() metódusa kerül megfordításra, a 4. lehetőségnél a List.add() és a List.remove() használjuk, végül az 5. lehetőségben a rekurziót használjuk.

1. lehetőség: Tömb megfordítása további tömb használatával

Írjunk egy egyszerű módszert egy tömb megfordítására egy további tömb használatával . Ez az opció egy további tömböt használ, amely az eredeti tömb utolsó elemével kezdődően van kitöltve csökkenő sorrendben, azaz az első elem megegyezik az eredeti tömb utolsó elemével, a második ugyanaz, mint a második az utolsótól és így bekapcsolva, amíg a további tömb meg nem telik.

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

Ebben a példában írtunk egy metódust, amely megfordít egy tömböt és egy új fordított tömböt ad vissza, a neki átadott tömb alapján. tömb deklarálódik a main- ban , majd egy metódus, a reverse , meghívásra kerül. A metódus argumentuma a tömb. A fordított metódusban egy új tömb, a newArray jön létre, és mérete megegyezik a tömb méretével , csak teljesen üres. A for ciklus a newArray kitöltésére szolgál , és a tömb teljes hosszában működik. Ez úgy történik, hogy egy tömb első elemével kezdjük , és hozzárendeljük a newArray utolsó eleméhez, majd vegyük a tömbünk második elemét , és hozzárendeljük a newArray második utolsó eleméhez , és így tovább; A newArray visszafelé kerül kitöltésre. Amikor a for ciklus befejeződött, a newArray teljesen megtelt, és a tömb pontos fordítottja .

2. lehetőség: Nyomtassa ki a tömb elemeit fordított sorrendben

Ahhoz, hogy ez a beállítás megfordítsa a tömböt, nincs szükség további tömb használatára, és az nem konvertálódik tömblistává. Ehelyett a tömbelemek fordított sorrendbe kerülnek a helyükre . Ez azt jelenti, hogy valójában felcserélték őket. Az első elem felcserélődik az utolsó elemmel, a második elem felcserélődik a második elemre az utolsó elemre, és így tovább. A for ciklus használatos, és ha ez befejeződött, a tömb megfordul. A kód így néz ki:

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

Az eredeti tömb karakterláncként kerül kinyomtatásra az Arrays.toString(array) használatával , majd a tömbünket argumentumként adjuk át a fordított értékre . A for ciklus fordított metódusában egy temp változó jön létre és kerül felhasználásra. A for ciklusban a fordított sorrend három lépésben érhető el:

1. az első elem hozzárendelése a temp
2. az utolsó elem hozzárendelése az első elemhez
3. hőmérséklet hozzárendelése az utolsó elemhez

Ez azután ismét megtörténik a második elemnél, az utolsótól a másodiknál ​​és így tovább. Ez megtörténik a tömb egymást követő elemeire, de a ciklus csak a tömb méretének feléig iterál. Lényegében a tömb ellentétes végén lévő elemek felcserélődnek. Ez a metódus kétszer olyan gyorsan fut, mint egy for ciklust használó metódus, amely 0-tól méretig megy. Ennek eredményeként létrejön a tömb fordított sorrendje, és megmutatjuk, hogyan kell egy tömböt fordított sorrendben nyomtatni, és kinyomtatják az értékeket:

3. lehetőség: A Collections.reverse() használata

Java-ban a meglévő Collections keretrendszer részét képező fordított metódus használható egy tömb visszafordításához. Használjuk a megfordításhoz.

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

A main -ban a tömb létrehozása és kitöltése egész számú tömbként történik 5 számmal. Ezután listaként kinyomtatja az Arrays.asList(array) segítségével , majd a reverse függvény meghívódik, és a tömb argumentumként kerül átadásra ennek a függvénynek. Fordítva a Collections.reverse használatos , és ez az Arrays.asList (array) tömblistán , nem pedig maga a tömb. Ezután a következő lépésben megmutatjuk, hogyan nyomtathatunk ki egy tömböt fordított sorrendben a System.out.println segítségével , és ezúttal minden elem ugyanabba a sorba kerül kinyomtatásra:

4. lehetőség: Tömb megfordítása a List.add() és List.remove() segítségével

Ebben az új beállításban a List.add() és a List.remove() segítségével hajtják végre a visszafordítást. Ez úgy működik, hogy a tömb listává alakul, és a lista utolsó elemét eltávolítják és a lista elejére teszik. A teljes lista ismétlése után az új lista az eredeti megfordítása. A main() metódusban egy 5 számból álló tömb jön létre. Ezután a tömb eredeti állapota megjelenik a konzolon. Ez a tömb ezután a reverse() metódus argumentumaként kerül be . Ez a módszer alapvetően úgy működik, hogy eltávolítja az utolsó elemet, és beilleszti a tömb elejére. Végül a tömb új (fordított) állapota megjelenik a konzolon. fordítva ()metódussal a tömb egy listába kerül az Arrays.asList(array) segítségével , hogy az add() és remove() metódusok végrehajthassák a visszafordítást. Ez a módszer alapvetően úgy működik, hogy eltávolítja az utolsó elemet, és beilleszti a tömb elejére. A reverse() használatának lépései a következők. For ciklust használ a lista elemeinek megfordítására. Ezt egy i változó inicializálásával teszi . Kezdetben az i értéke 0. Ha i = 0 , a list.size() - 1 elemet eltávolítják a listából , és mindig ez lesz az utolsó elem az i < list.size() - 1 óta.. Mivel a remove() metódus visszaadja az eltávolított elemet, ez az elem most i = 0 indexnél kerül a listába , azaz beszúrva az elejére. A lista többi része ezután jobbra tolódik, de az új lista továbbra is ugyanannyi elemet tartalmaz, azaz mérete . Folytatva a for ciklus végrehajtását a következő i értékkel , i = 1 , ugyanazt a lépéssort hajtjuk végre, így az utolsó elemet eltávolítjuk, és i = 1- es számokba helyezzük , és a lista jobbra tolódik. Ez addig tart, amíg az i utolsó növekményes értéke és a lista összes eleme meg nem változott. A másodikban azértAz i indexű lista cikluseleme az i indexű tömbelemre van beállítva, ahol i 0-tól list.size() - 1 -ig . Összefoglalva, a használt lépések a következők: Lépések:

1. i = 0
2. elem eltávolítása itt: list.size() - 1
3. beszúrni az elemet, amely a list.size() - 1 -nél volt , az i = 0 helyen
4. növekmény i
5. ismételje meg a 2–4. lépéseket (i új értékekkel a 3. lépésben), amíg az i utolsó növekményes értékét fel nem használja

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

Ez a kód adja a kimenetet:

5. lehetőség: Tömb megfordítása rekurzióval

A rekurziós módszert széles körben használják a kódolásban, és hatékony módszer létrehozására használható egy tömb megfordítására. Ebben az opcióban a tömb listává alakul, majd a kód a reverse() metódusba kerül minden alkalommal, amikor eltávolítja az utolsó elemet a lista végén, és a listához az eltávolított értékek fordított sorrendben kerülnek hozzáadásra. Az előző módszerekhez hasonlóan itt is létrejön egy 5 számból álló tömb. Ezután argumentumként kerül át a reverse() függvénybe . A reverse() -ben az első dolog, amit meg kell tenni, az az, hogy a tömböt listává alakítjuk, és ellenőrizzük a lista méretét. Ha csak egy eleme van, vagy nulla, akkor a metódus befejeződik és visszatér. Ha nem, akkor az első elemet eltávolítja, de egész számba másolja, érték . A reverse() metódus ezután újra meghívásra kerül, és a rekurzió újra kezdődik. A függvény beírásakor ugyanazokat a lépéseket hajtják végre, méretellenőrzést, ahol ha a lista nagyobb, mint 1, akkor a következő lépés az első elem eltávolítása, majd a rekurzió ismételt elvégzése. Ha a lista mérete 1, a reverse() visszatér oda, ahonnan meghívták, majd a listához minden érték hozzáadódik, hogy az eredeti lista pontos fordítottja legyen.

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 kimenet a következő:

Következtetés

Tehát itt megvizsgáltunk 5 különböző módot egy tömb megfordítására. A Collections keretrendszert használó 3. lehetőség valószínűleg a legjobb módszer, mivel a Collections.reverse egy már létező, kipróbált és tesztelt Java-függvény. Természetesen a többi lehetőség is használható, különösen tanulás közben, de általában a szabványos módszerek, ha vannak, a legjobbak, mivel általában nagyon optimalizáltak és teszteltek. Azonban saját maga is létrehozhat ilyen módszereket, mivel ez egy jó kódolási gyakorlat, és elősegíti, hogy sikeres legyen a Java Junior interjúban.