Baliktarin ang isang Array sa Java

Ang mga array ay madalas na ginagamit sa coding at isang paraan ng pag-iimbak ng maramihang mga halaga ng parehong uri sa isang variable. Maaaring may maraming dahilan kung bakit maaaring gusto ng isang coder na baligtarin ang isang array. Maaaring kailanganin na baligtarin ang isang array, halimbawa, kapag ang lohika ng isang problema ay kailangang magsimula sa huling elemento. Sa kasong ito, ang pinakamahusay na kasanayan ay gawin ang pagbaliktad at pagkatapos ay gamitin ang reversed array kung saan kinakailangan sa code. Higit pa rito, ang pag-reverse ng array ay isang napaka-tanyag na gawain sa mga panayam ng Java Juniors.

Paano I-reverse ang isang Array

Mayroong maraming mga paraan ng pag-reverse ng array, at dito isinasaalang-alang namin ang 5. Para sa Opsyon 1, ang isang array ay binabaligtad gamit ang isang karagdagang array na napunan sa pataas na pagkakasunud-sunod mula sa dulo ng orihinal na array (pababa), sa Opsyon 2 isang in-place reversal ay isinasagawa kung saan ang mga elemento ng array sa simula at dulo ay pinagpalit, sa Opsyon 3, ang reverse() na pamamaraan mula sa Collections framework ay ginagamit upang gawin ang pagbaliktad, sa Option 4, List.add() at List.remove() ay ginagamit, at sa wakas, sa Opsyon 5, ginagamit ang recursion.

Opsyon 1: Pagbabalik ng Array gamit ang Karagdagang Array

Sumulat tayo ng isang simpleng paraan upang baligtarin ang isang array gamit ang isang karagdagang array . Gumagamit ang opsyong ito ng karagdagang array na pinupunan simula sa huling elemento ng orihinal na array sa pababang pagkakasunud-sunod, ibig sabihin, ang unang elemento ay kapareho ng huling elemento sa orihinal na array, ang pangalawa ay kapareho ng pangalawa mula sa huli at iba pa. hanggang sa mapunan ang karagdagang array.

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

Sa halimbawang ito, nagsulat kami ng isang paraan na nagbabalik ng isang array at nagbabalik ng bagong reverse array, batay sa array na ipinasa dito. array ay ipinahayag sa pangunahing at pagkatapos ay isang pamamaraan, reverse , ay tinatawag na. Ang argumento sa pamamaraan ay ang array. Sa method reverse , isang bagong array, newArray , ay nilikha at kapareho ng laki ng array , ganap na walang laman. Ang para sa loop ay ginagamit upang punan ang newArray at gumagana sa buong haba ng array. Ginagawa ito sa pamamagitan ng pagsisimula sa unang elemento ng isang array at pagtatalaga nito sa huling elemento ng newArray, pagkatapos ay kunin ang pangalawang elemento ng aming array at italaga ito sa pangalawang huling elemento ng newArray , at iba pa; newArray ay napunan sa likod. Kapag kumpleto na ang for loop, ganap na puno ang newArray at isang eksaktong reverse ng array .

Opsyon 2: I-print ang Mga Elemento ng isang Array sa Reverse Order

Para sa opsyong ito na baligtarin ang isang array, hindi na kailangang gumamit ng karagdagang array, at hindi ito na-convert sa isang listahan ng array. Sa halip, ang mga elemento ng array ay inilalagay sa reverse order in-place . Nangangahulugan ito na sila ay, sa katunayan, ipinagpalit. Ang unang elemento ay pinapalitan ng huling elemento, ang pangalawang elemento ay pinalitan ng pangalawa mula sa huli, at iba pa. Ang isang para sa loop ay ginagamit at kapag ito ay nakumpleto na, ang array ay mababaligtad. Ang code ay ganito ang hitsura:

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

Ang orihinal na array ay naka-print bilang isang String gamit ang Arrays.toString(array) , at pagkatapos ay ang aming array ay ipapasa bilang argumento sa reverse . Sa reverse method sa for loop, isang variable, temp, ang ginawa at ginagamit. Sa for loop ang reverse order ay nakakamit sa tatlong hakbang:

1. pagtatalaga ng unang elemento sa temp
2. pagtatalaga ng huling elemento sa unang elemento
3. pagtatalaga ng temp sa huling elemento

Ito ay isasagawa muli sa pagkakataong ito para sa pangalawang elemento at pangalawa mula sa huling elemento, at iba pa. Ginagawa ito para sa magkakasunod na elemento ng array ngunit umuulit lamang ang loop hanggang kalahati ng laki ng array. Ang mga elemento sa magkabilang dulo ng array ay pinagpalit. Ang pamamaraang ito ay tatakbo nang dalawang beses nang mas mabilis kaysa sa isang paraan gamit ang isang para sa loop mula 0 hanggang sa laki. Bilang resulta, ang reverse order ng array ay nakamit at ipinapakita sa amin kung paano mag-print ng array sa reverse order at ang mga value ay nai-print out:

Opsyon 3: Paggamit ng Collections.reverse()

Sa Java, ang reverse method, na bahagi ng umiiral na balangkas ng Collections, ay maaaring gamitin upang baligtarin ang isang array. Gamitin natin ito para gawin ang pagbaliktad.

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

Sa pangunahing , ang array ay nilikha at pinupunan bilang isang Integer array na may 5 numero. Pagkatapos ay ipi-print ito bilang isang listahan gamit ang Arrays.asList(array) at pagkatapos ay ang function, reverse , ay tinatawag at array ay ipinapasa bilang argumento sa function na ito. Sa reverse , Collections.reverse ang ginagamit, at ito ay ginagamit sa array list, Arrays.asList(array) , kaysa sa array mismo. Pagkatapos sa susunod na hakbang ay ipapakita sa amin kung paano mag-print ng array sa reverse order gamit ang System.out.println , at sa pagkakataong ito ang bawat elemento ay naka-print out sa parehong linya:

Opsyon 4: Baliktarin ang isang Array gamit ang List.add() at List.remove()

Sa bagong opsyon na ito, ang List.add() at List.remove() ay ginagamit upang gawin ang pagbabalik. Ang paraan ng paggawa nito ay ang array ay na-convert sa isang listahan at ang huling elemento ng listahan ay inalis at inilagay sa simula ng listahan. Matapos maulit ang buong listahan, ang bagong listahan ay isang pagbaliktad ng orihinal. Sa pangunahing() na pamamaraan, ang isang array ay nilikha na binubuo ng 5 mga numero. Pagkatapos ang orihinal na estado ng array ay nai-output sa console. Ang array na ito ay inilalagay bilang argumento sa pamamaraan, reverse() . Ang pamamaraang ito ay karaniwang gumagana sa pamamagitan ng pag-alis ng huling elemento at pagpasok nito sa harap ng array. Panghuli, ang bagong (reversed) na estado ng array ay nai-output sa console. Sa kabaligtaran()paraan, ang array ay isinusulat sa isang Listahan sa pamamagitan ng Arrays.asList(array) , upang paganahin ang add() at remove() na mga pamamaraan upang maisagawa ang pagbaliktad. Ang pamamaraang ito ay karaniwang gumagana sa pamamagitan ng pag-alis ng huling elemento at pagpasok nito sa harap ng array. Ang mga hakbang na reverse() ay ginagamit ay ang mga sumusunod. Gumagamit ito ng for loop upang maisakatuparan ang pagbaliktad ng mga elemento ng listahan. Ginagawa ito sa pamamagitan ng pagsisimula ng isang variable na i . Sa una ang i ay nakatakda sa 0. Kapag i = 0 , ang elemento sa list.size() - 1 sa listahan ay aalisin, at ito ang palaging magiging huling elemento dahil i <list.size() - 1. Dahil ibinabalik ng paraan ng remove() ang elementong inalis nito, idinaragdag na ngayon ang elementong ito sa listahan sa index i = 0 , ibig sabihin, ipinasok sa simula. Ang natitira sa listahan ay inilipat sa kanan ngunit ang bagong listahan ay mayroon pa ring parehong bilang ng mga elemento, ibig sabihin, laki . Ang pagpapatuloy ng pagpapatupad ng para sa loop na may susunod na halaga ng i , i = 1 , ang parehong hanay ng mga hakbang ay isinasagawa upang ang huling elemento ay tinanggal at ilagay sa mga numero sa i = 1 at ang listahan ay inilipat sa kanan. Ito ay nagpapatuloy hanggang sa ang huling incremental na halaga ng i at lahat ng elemento sa listahan ay nabago. Sa pangalawa para saloop elemento ng listahan na may index i ay nakatakda sa array elemento na may index i kung saan ang i ay mula 0 hanggang list.size() - 1 . Upang buod, ang mga hakbang na ginamit ay: Mga hakbang:

1. ako = 0
2. alisin ang elemento sa list.size() - 1
3. insert element, na nasa list.size() - 1 , sa i = 0
4. pagtaas i
5. ulitin ang mga hakbang 2 hanggang 4 (na may mga bagong halaga para sa i sa hakbang 3) hanggang sa ang huling incremental na halaga ng i ay ginagamit

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

Ang code na ito ay nagbibigay ng output:

Opsyon 5: Baliktarin ang isang Array sa pamamagitan ng Recursion

Ang paraan ng recursion ay malawakang ginagamit sa coding at maaaring gamitin upang lumikha ng isang mahusay na paraan kung paano i-reverse ang isang array. Sa opsyong ito, ang array ay iko-convert sa isang listahan at pagkatapos ay ang code ay mapupunta sa method reverse() sa tuwing inaalis ang huling elemento sa dulo ng listahan at ang listahan ay may mga inalis na value na idinagdag dito sa reversed order. Tulad ng sa mga nakaraang pamamaraan, ang isang array ay nilikha na binubuo ng 5 mga numero. Pagkatapos ay ipinasa ito bilang argumento sa function, reverse() . Sa reverse() ang unang bagay na gagawin ay gawing isang listahan ang array at tingnan ang laki ng listahan. Kung mayroon lamang itong isang elemento o null pagkatapos ang pamamaraan ay matatapos at babalik. Kung hindi, ang unang elemento ay aalisin, ngunit kinopya sa isang Integer, halaga . Ang pamamaraan na reverse() ay tinawag muli at ang recursion ay magsisimula muli. Kapag ang function ay ipinasok, ang parehong mga hakbang ay isinasagawa, isang sukat ng check kung saan, kung ang listahan ay mas malaki kaysa sa 1 ang susunod na hakbang ay upang alisin ang unang elemento at pagkatapos ay gawin ang recursion muli. Kapag 1 ang laki ng listahan , babalik ang reverse() sa kung saan ito tinawag at pagkatapos ay idinagdag ng listahan ang bawat value dito upang mabuo ito sa eksaktong reverse ng orihinal na listahan.

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

Ang output ay:

Konklusyon

Kaya narito kami ay tumingin sa 5 iba't ibang mga paraan upang baligtarin ang isang array. Ang Opsyon 3, na gumagamit ng balangkas ng Mga Koleksyon, ay marahil ang pinakamahusay na paraan upang gamitin dahil ang Collections.reverse ay isang umiiral na, sinubukan at nasubok, Java function. Siyempre ang iba pang mga opsyon ay maaaring gamitin, lalo na habang nag-aaral, ngunit sa pangkalahatan ang mga karaniwang pamamaraan, kung mayroon sila, ay ang pinakamahusay dahil ang mga ito ay karaniwang lubos na na-optimize at nasubok. Gayunpaman, maaari kang gumawa ng mga ganitong pamamaraan sa iyong sarili dahil ito ay isang mahusay na pagsasanay sa pag-coding at makakatulong sa iyong magtagumpay sa iyong panayam para sa Java Junior.