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 .
Tömb: [7, 8, 9, 10, 11] Fordított tömb: [11, 10, 9, 8, 7]
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:
- az első elem hozzárendelése a temp
- az utolsó elem hozzárendelése az első elemhez
- hőmérséklet hozzárendelése az utolsó elemhez
Tömb fordított előtt : [1, 4, 9, 16, 25] Tömb fordított után : [25, 16, 9, 4, 1]
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:
Tömb fordított előtt : [1, 4, 9, 16, 25] Tömb fordított után : [25, 16, 9, 4, 1]
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:- i = 0
- elem eltávolítása itt: list.size() - 1
- beszúrni az elemet, amely a list.size() - 1 -nél volt , az i = 0 helyen
- növekmény i
- 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:
Tömb fordított előtt : [1, 4, 9, 16, 25] Tömb fordított után : [25, 16, 9, 4, 1]
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ő:
Tömb fordított előtt : [1, 4, 9, 16, 25] Tömb fordított után : [25, 16, 9, 4, 1]
GO TO FULL VERSION