Odwróć tablicę w Javie

Tablice są często używane w kodowaniu i służą do przechowywania wielu wartości tego samego typu w jednej zmiennej. Może istnieć wiele powodów, dla których programista może chcieć odwrócić tablicę. Może być konieczne odwrócenie tablicy, na przykład, gdy logika problemu musi zaczynać się od ostatniego elementu. W takim przypadku najlepszą praktyką jest wykonanie odwrócenia, a następnie użycie odwróconej tablicy tam, gdzie to konieczne w kodzie. Co więcej, odwracanie tablicy jest bardzo popularnym zadaniem w rozmowach kwalifikacyjnych Java Juniors.

Jak odwrócić tablicę

Istnieje wiele sposobów odwrócenia tablicy, a tutaj rozważymy 5. W Opcji 1 tablica jest odwracana przy użyciu dodatkowej tablicy wypełnionej w porządku rosnącym od końca oryginalnej tablicy (malejąco), w Opcji 2 odwrócenie w miejscu odbywa się tam, gdzie elementy tablicy na początku i na końcu są zamieniane, w Opcji 3 do odwrócenia używana jest metoda reverse() z frameworka Collections, w Opcji 4, List.add() i List.remove() są używane, i wreszcie, w Opcji 5, używana jest rekurencja.

Opcja 1: Odwrócenie tablicy za pomocą dodatkowej tablicy

Napiszmy prostą metodę odwracania tablicy za pomocą dodatkowej tablicy . Ta opcja wykorzystuje dodatkową tablicę, która jest wypełniana zaczynając od ostatniego elementu oryginalnej tablicy w kolejności malejącej, tzn. pierwszy element jest taki sam jak ostatni element w oryginalnej tablicy, drugi taki sam jak drugi od końca itd. aż do zapełnienia dodatkowej tablicy.

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

W tym przykładzie napisaliśmy metodę, która odwraca tablicę i zwraca nową odwróconą tablicę na podstawie tablicy, która została do niej przekazana. array jest zadeklarowana w main , a następnie wywoływana jest metoda reverse . Argumentem metody jest tablica. W metodzie reverse tworzona jest nowa tablica, newArray , która ma taki sam rozmiar jak array , tylko jest całkowicie pusta. Pętla for służy do wypełniania tablicy newArray i działa na całej długości tablicy. Odbywa się to poprzez rozpoczęcie od pierwszego elementu tablicy i przypisanie go do ostatniego elementu newArray, a następnie pobranie drugiego elementu z naszej tablicy i przypisanie go do przedostatniego elementu newArray i tak dalej; newArray jest wypełniana od tyłu. Kiedy pętla for jest zakończona, nowa tablica jest całkowicie zapełniona i stanowi dokładną odwrotność tablicy .

Opcja 2: Wydrukuj elementy tablicy w odwrotnej kolejności

Aby ta opcja odwracała tablicę, nie ma potrzeby używania dodatkowej tablicy i nie jest ona konwertowana na listę tablic. Zamiast tego elementy tablicy są umieszczane na miejscu w odwrotnej kolejności . Oznacza to, że w rzeczywistości są zamienione. Pierwszy element jest zamieniany z ostatnim elementem, drugi element jest zamieniany z drugim od ostatniego i tak dalej. Używana jest pętla for , a po jej zakończeniu tablica zostanie odwrócona. Kod wygląda następująco:

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

Oryginalna tablica jest drukowana jako String przy użyciu Arrays.toString(array) , a następnie nasza tablica jest przekazywana jako argument do reverse . W odwrotnej metodzie w pętli for tworzona jest i używana zmienna temp. W pętli for odwrotną kolejność uzyskuje się w trzech krokach:

1. przypisanie pierwszego elementu do temp
2. przypisanie ostatniego elementu do pierwszego elementu
3. przypisanie temp do ostatniego elementu

Jest to następnie przeprowadzane ponownie, tym razem dla drugiego elementu i drugiego od ostatniego elementu i tak dalej. Odbywa się to dla kolejnych elementów tablicy, ale pętla iteruje tylko do połowy rozmiaru tablicy. Zasadniczo elementy na przeciwległych końcach tablicy są zamienione. Ta metoda będzie działać dwa razy szybciej niż metoda wykorzystująca pętlę for przechodzącą od 0 do rozmiaru. W rezultacie uzyskuje się odwrotną kolejność tablicy i pokazano nam, jak wydrukować tablicę w odwrotnej kolejności, a wartości są drukowane:

Opcja 3: użycie Collections.reverse()

W Javie do odwrócenia tablicy można użyć metody reverse , która jest częścią istniejącej struktury Collections. Użyjmy go do odwrócenia.

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

W main tablica jest tworzona i wypełniana jako tablica liczb całkowitych z 5 liczbami. Następnie jest drukowana jako lista za pomocą Arrays.asList(array) , a następnie wywoływana jest funkcja reverse , a tablica jest przekazywana jako argument do tej funkcji. W odwrotnym przypadku używany jest Collections.reverse , który jest używany na liście tablic, Arrays.asList(array) , a nie na samej tablicy. Następnie w następnym kroku pokazujemy, jak wydrukować tablicę w odwrotnej kolejności za pomocą System.out.println i tym razem każdy element jest drukowany w tej samej linii:

Opcja 4: Odwróć tablicę za pomocą List.add() i List.remove()

W tej nowej opcji, List.add() i List.remove() są używane do wykonania odwrócenia. Działa to w ten sposób, że tablica jest konwertowana na listę, a ostatni element listy jest usuwany i umieszczany na początku listy. Po iteracji całej listy nowa lista jest odwrotnością oryginału. W metodzie main() tworzona jest tablica składająca się z 5 liczb. Następnie oryginalny stan tablicy jest wysyłany do konsoli. Ta tablica jest następnie umieszczana jako argument metody reverse() . Ta metoda zasadniczo działa poprzez usunięcie ostatniego elementu i wstawienie go z przodu tablicy. Na koniec nowy (odwrócony) stan tablicy jest wysyłany do konsoli. w odwrotnej kolejności ()tablica jest zapisywana na liście za pomocą Arrays.asList(array) , aby umożliwić metodom add() i remove() wykonanie odwrócenia. Ta metoda zasadniczo działa poprzez usunięcie ostatniego elementu i wstawienie go z przodu tablicy. Kroki, których używa funkcja reverse(), są następujące. Wykorzystuje pętlę for do odwrócenia elementów listy. Czyni to poprzez inicjalizację zmiennej i . Początkowo i jest ustawione na 0. Gdy i = 0 , element w list.size () - 1 jest usuwany i zawsze będzie to ostatni element od i < list.size() - 1. Ponieważ metoda remove() zwraca usunięty element, element ten jest teraz dodawany do listy pod indeksem i = 0 , czyli wstawiany na początku. Pozostała część listy jest następnie przesuwana w prawo, ale nowa lista nadal ma tę samą liczbę elementów, tj. rozmiar . Kontynuując wykonywanie pętli for z następną wartością i , i = 1 , wykonywany jest ten sam zestaw kroków, więc ostatni element jest usuwany i umieszczany w nums w i = 1 , a lista jest przesuwana w prawo. Dzieje się tak, dopóki ostatnia wartość przyrostu i i wszystkie elementy na liście nie zostaną zmienione. W drugim zaelement pętli listy o indeksie i jest ustawiany na element tablicy o indeksie i , gdzie i wynosi od 0 do list.size() - 1 . Podsumowując, zastosowane kroki to: Kroki:

1. ja = 0
2. usuń element z list.size() - 1
3. wstaw element, który był w list.size() - 1 , w i = 0
4. przyrost I
5. powtarzaj kroki od 2 do 4 (z nowymi wartościami dla i w kroku 3), aż zostanie użyta ostatnia przyrostowa wartość 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);
       }
   }
}

Ten kod daje dane wyjściowe:

Opcja 5: Odwróć tablicę przez rekurencję

Metoda rekurencji jest szeroko stosowana w kodowaniu i może być wykorzystana do stworzenia wydajnej metody odwracania tablicy. W tej opcji tablica jest konwertowana na listę, a następnie kod przechodzi do metody reverse() za każdym razem, gdy usuwany jest ostatni element na końcu listy, a usunięte wartości są dodawane do listy w odwrotnej kolejności. Podobnie jak w poprzednich metodach tworzona jest tablica składająca się z 5 liczb. Następnie jest przekazywany jako argument do funkcji reverse() . W reverse() pierwszą rzeczą, którą się robi, jest przekształcenie tablicy w listę i sprawdzenie rozmiaru listy. Jeśli ma tylko jeden element lub ma wartość null, metoda kończy się i zwraca. Jeśli nie, pierwszy element jest usuwany, ale kopiowany do typu Integer, wartość . Następnie ponownie wywoływana jest metoda reverse() i rekurencja zaczyna się od nowa. Po wprowadzeniu funkcji wykonywane są te same kroki, sprawdzanie rozmiaru, gdzie jeśli lista jest większa niż 1, następnym krokiem będzie usunięcie pierwszego elementu, a następnie ponowne wykonanie rekurencji. Gdy rozmiar listy wynosi 1, funkcja reverse() powraca do miejsca, z którego została wywołana, a następnie do listy dodaje się każdą wartość , aby utworzyć dokładną odwrotność oryginalnej listy.

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

Dane wyjściowe to:

Wniosek

Więc tutaj przyjrzeliśmy się 5 różnym sposobom odwrócenia tablicy. Opcja 3, która wykorzystuje framework Collections, jest prawdopodobnie najlepszą metodą, ponieważ Collections.reverse to już istniejąca, wypróbowana i przetestowana funkcja Java. Oczywiście można korzystać z innych opcji, zwłaszcza podczas nauki, ale generalnie standardowe metody, jeśli istnieją, są najlepsze, ponieważ są zwykle wysoce zoptymalizowane i przetestowane. Możesz jednak stworzyć takie metody samodzielnie, ponieważ jest to dobre ćwiczenie z kodowania i pomoże ci odnieść sukces na rozmowie kwalifikacyjnej dla Java Junior.