జావాలో అర్రేని రివర్స్ చేయండి

కోడింగ్‌లో శ్రేణులు తరచుగా ఉపయోగించబడతాయి మరియు ఒకే రకమైన బహుళ విలువలను ఒక వేరియబుల్‌లో నిల్వ చేసే మార్గం. కోడర్ శ్రేణిని రివర్స్ చేయాలనుకోవడానికి అనేక కారణాలు ఉండవచ్చు. శ్రేణిని రివర్స్ చేయడం అవసరం కావచ్చు, ఉదాహరణకు, సమస్య యొక్క లాజిక్ చివరి మూలకంతో ప్రారంభించాల్సిన అవసరం వచ్చినప్పుడు. ఈ సందర్భంలో, రివర్సల్ చేయడం మరియు కోడ్‌లో అవసరమైన చోట రివర్స్డ్ అర్రేని ఉపయోగించడం ఉత్తమ అభ్యాసం. ఇంకా, జావా జూనియర్స్ ఇంటర్వ్యూలలో శ్రేణిని తిప్పికొట్టడం చాలా ప్రజాదరణ పొందిన పని.

అర్రేని ఎలా రివర్స్ చేయాలి

శ్రేణిని తిప్పికొట్టడానికి అనేక మార్గాలు ఉన్నాయి మరియు ఇక్కడ మేము 5ని పరిశీలిస్తాము. ఎంపిక 1 కోసం, అసలు శ్రేణి (అవరోహణ) చివరి నుండి ఆరోహణ క్రమంలో నింపబడిన అదనపు శ్రేణిని ఉపయోగించి, ఎంపిక 2లో ఒక ఇన్-ప్లేస్ రివర్సల్‌ని ఉపయోగించి శ్రేణి రివర్స్ చేయబడుతుంది. ప్రారంభం మరియు ముగింపులో ఉన్న శ్రేణి మూలకాలు మార్పిడి చేయబడినప్పుడు, ఎంపిక 3లో, ఎంపిక 4, List.add() మరియు List.remove() లో రివర్సల్ చేయడానికి కలెక్షన్స్ ఫ్రేమ్‌వర్క్ నుండి రివర్స్() పద్ధతి ఉపయోగించబడుతుంది. ఉపయోగించబడతాయి మరియు చివరగా, ఎంపిక 5లో, పునరావృతం ఉపయోగించబడుతుంది.

ఎంపిక 1: అదనపు శ్రేణిని ఉపయోగించి అర్రేని రివర్స్ చేయడం

అదనపు శ్రేణిని ఉపయోగించి శ్రేణిని రివర్స్ చేయడానికి సరళమైన పద్ధతిని వ్రాద్దాం . ఈ ఐచ్ఛికం అదనపు శ్రేణిని ఉపయోగిస్తుంది, ఇది అవరోహణ క్రమంలో అసలైన శ్రేణి యొక్క చివరి మూలకంతో ప్రారంభించబడుతుంది, అనగా మొదటి మూలకం అసలు శ్రేణిలోని చివరి మూలకం వలె ఉంటుంది, రెండవది చివరి నుండి రెండవది మరియు అందువలన అదనపు శ్రేణిని నింపే వరకు ఆన్ చేయండి.

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

ఈ ఉదాహరణలో, మేము శ్రేణిని రివర్స్ చేసే పద్ధతిని వ్రాసాము మరియు దానికి పంపబడిన శ్రేణి ఆధారంగా కొత్త రివర్స్డ్ శ్రేణిని తిరిగి పంపాము. శ్రేణి ప్రధానంగా ప్రకటించబడింది మరియు తరువాత ఒక పద్ధతి, రివర్స్ అంటారు. పద్ధతికి వాదన శ్రేణి. పద్ధతి రివర్స్‌లో , కొత్త శ్రేణి, newArray సృష్టించబడింది మరియు శ్రేణికి సమానమైన పరిమాణంలో ఉంటుంది , పూర్తిగా ఖాళీగా ఉంటుంది. కొత్తఅరేను పూరించడానికి లూప్ కోసం A ఉపయోగించబడుతుంది మరియు శ్రేణి మొత్తం పొడవులో పనిచేస్తుంది. ఇది శ్రేణి యొక్క మొదటి మూలకంతో ప్రారంభించి, newArray యొక్క చివరి మూలకానికి కేటాయించడం ద్వారా జరుగుతుంది, ఆపై మా శ్రేణి యొక్క రెండవ మూలకాన్ని తీసుకొని , దాన్ని newArray యొక్క రెండవ చివరి మూలకానికి కేటాయించడం మరియు మొదలైనవి; newArray వెనుకకు పూరించబడింది. ఫర్ లూప్ పూర్తయినప్పుడు, newArray పూర్తిగా నిండి ఉంటుంది మరియు ఇది శ్రేణి యొక్క ఖచ్చితమైన రివర్స్ .

ఎంపిక 2: శ్రేణి యొక్క మూలకాలను రివర్స్ ఆర్డర్‌లో ముద్రించండి

శ్రేణిని రివర్స్ చేయడానికి ఈ ఎంపిక కోసం, అదనపు శ్రేణిని ఉపయోగించాల్సిన అవసరం లేదు మరియు ఇది శ్రేణి జాబితాగా మార్చబడదు. బదులుగా శ్రేణి మూలకాలు రివర్స్ ఆర్డర్‌లో ఉంచబడతాయి . దీనర్థం, వాస్తవానికి, అవి మార్చుకోబడ్డాయి. మొదటి మూలకం చివరి మూలకంతో మార్చబడింది, రెండవ మూలకం చివరి నుండి రెండవ దానితో మార్చబడుతుంది మరియు మొదలైనవి. లూప్ కోసం A ఉపయోగించబడుతుంది మరియు ఇది పూర్తయినప్పుడు, శ్రేణి రివర్స్ చేయబడుతుంది. కోడ్ ఇలా కనిపిస్తుంది:

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

అసలైన శ్రేణి Arrays.toString(array)ని ఉపయోగించి స్ట్రింగ్‌గా ముద్రించబడుతుంది , ఆపై మా శ్రేణి రివర్స్‌కి ఆర్గ్యుమెంట్‌గా పంపబడుతుంది . ఫర్ లూప్‌లో రివర్స్ పద్ధతిలో , ఒక వేరియబుల్, టెంప్ సృష్టించబడుతుంది మరియు ఉపయోగించబడుతుంది . ఫర్ లూప్‌లో రివర్స్ ఆర్డర్ మూడు దశల్లో సాధించబడుతుంది :

1. ఉష్ణోగ్రతకు మొదటి మూలకాన్ని కేటాయించడం
2. మొదటి మూలకానికి చివరి మూలకాన్ని కేటాయించడం
3. చివరి మూలకానికి టెంప్‌ని కేటాయించడం

ఇది ఈసారి రెండవ మూలకం మరియు చివరి మూలకం నుండి రెండవది మరియు మొదలైన వాటి కోసం మళ్లీ నిర్వహించబడుతుంది. ఇది శ్రేణి యొక్క వరుస మూలకాల కోసం చేయబడుతుంది, అయితే లూప్ శ్రేణి పరిమాణంలో సగం వరకు మాత్రమే పునరావృతమవుతుంది. ముఖ్యంగా శ్రేణి యొక్క వ్యతిరేక చివర్లలోని మూలకాలు మార్పిడి చేయబడతాయి. ఈ పద్ధతి 0 నుండి పరిమాణానికి వెళ్లే లూప్‌ని ఉపయోగించే పద్ధతి కంటే రెండింతలు వేగంగా నడుస్తుంది . ఫలితంగా శ్రేణి యొక్క రివర్స్ ఆర్డర్ సాధించబడుతుంది మరియు శ్రేణిని రివర్స్ ఆర్డర్‌లో ఎలా ముద్రించాలో మాకు చూపబడింది మరియు విలువలు ముద్రించబడతాయి:

ఎంపిక 3: Collections.reverse()ని ఉపయోగించడం

జావాలో, ఇప్పటికే ఉన్న కలెక్షన్స్ ఫ్రేమ్‌వర్క్‌లో భాగమైన రివర్స్ పద్ధతి, శ్రేణిని రివర్స్ చేయడానికి ఉపయోగించవచ్చు. రివర్సల్ చేయడానికి దాన్ని ఉపయోగించుకుందాం.

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

ప్రధానంగా , శ్రేణి సృష్టించబడింది మరియు 5 సంఖ్యలతో పూర్ణాంక శ్రేణిగా పూరించబడుతుంది. ఇది Arrays.asList(array)ని ఉపయోగించి జాబితాగా ముద్రించబడుతుంది మరియు తర్వాత ఫంక్షన్, రివర్స్ , అని పిలుస్తారు మరియు array ఈ ఫంక్షన్‌లోకి ఆర్గ్యుమెంట్‌గా పంపబడుతుంది. రివర్స్‌లో , Collections.reverse ఉపయోగించబడుతుంది మరియు ఇది శ్రేణిలో కాకుండా అర్రే జాబితాలో ఉపయోగించబడుతుంది, Arrays.asList( array ) . తరువాతి దశలో System.out.println ఉపయోగించి శ్రేణిని రివర్స్ ఆర్డర్‌లో ఎలా ముద్రించాలో చూపబడతాము మరియు ఈసారి ప్రతి మూలకం ఒకే లైన్‌లో ముద్రించబడుతుంది:

ఎంపిక 4: List.add() మరియు List.remove()ని ఉపయోగించి అర్రేని రివర్స్ చేయండి

ఈ కొత్త ఎంపికలో, రివర్సల్ చేయడానికి List.add() మరియు List.remove() ఉపయోగించబడతాయి. ఇది పని చేసే విధానం ఏమిటంటే, శ్రేణి జాబితాగా మార్చబడుతుంది మరియు జాబితా యొక్క చివరి మూలకం తీసివేయబడుతుంది మరియు జాబితా ప్రారంభంలో ఉంచబడుతుంది. మొత్తం జాబితాను పునరావృతం చేసిన తర్వాత, కొత్త జాబితా అసలైన దానికి విరుద్ధంగా ఉంటుంది. ప్రధాన() పద్ధతిలో , 5 సంఖ్యలతో కూడిన శ్రేణి సృష్టించబడుతుంది. అప్పుడు శ్రేణి యొక్క అసలు స్థితి కన్సోల్‌కు అవుట్‌పుట్ చేయబడుతుంది. ఈ శ్రేణి పద్ధతికి వాదనగా ఉంచబడుతుంది, రివర్స్() . ఈ పద్ధతి ప్రాథమికంగా చివరి మూలకాన్ని తీసివేసి, శ్రేణి ముందు భాగంలో చొప్పించడం ద్వారా పని చేస్తుంది. చివరగా, అర్రే యొక్క కొత్త (రివర్స్డ్) స్థితి కన్సోల్‌కు అవుట్‌పుట్ చేయబడింది. రివర్స్‌లో ()పద్ధతి, రివర్సల్‌ను అమలు చేయడానికి add() మరియు remove() పద్ధతులను ప్రారంభించడానికి శ్రేణి Arrays.asList(array) ద్వారా జాబితాకు వ్రాయబడుతుంది . ఈ పద్ధతి ప్రాథమికంగా చివరి మూలకాన్ని తీసివేసి, శ్రేణి ముందు భాగంలో చొప్పించడం ద్వారా పని చేస్తుంది. రివర్స్ () ఉపయోగాలు క్రింది విధంగా ఉన్నాయి. ఇది జాబితా యొక్క మూలకాల యొక్క రివర్సల్‌ను నిర్వహించడానికి లూప్‌ను ఉపయోగిస్తుంది . ఇది వేరియబుల్ iని ప్రారంభించడం ద్వారా దీన్ని చేస్తుంది . ప్రారంభంలో i 0కి సెట్ చేయబడింది. i = 0 , జాబితాలో list.size() - 1 వద్ద ఉన్న మూలకం తీసివేయబడుతుంది మరియు i < list.size() - 1 నుండి ఇది ఎల్లప్పుడూ చివరి మూలకం అవుతుంది.. Remove() పద్ధతి అది తీసివేసిన మూలకాన్ని తిరిగి ఇస్తుంది కాబట్టి , ఈ మూలకం ఇప్పుడు సూచిక i = 0 వద్ద జాబితాకు జోడించబడింది , అనగా, ప్రారంభంలో చొప్పించబడింది. జాబితా యొక్క మిగిలిన భాగం కుడివైపుకి మార్చబడుతుంది, అయితే కొత్త జాబితాలో ఇప్పటికీ అదే సంఖ్యలో మూలకాలు ఉన్నాయి, అంటే పరిమాణం . i , i = 1 యొక్క తదుపరి విలువతో ఫర్ లూప్ యొక్క అమలును కొనసాగిస్తూ , అదే దశల సెట్ నిర్వహించబడుతుంది కాబట్టి చివరి మూలకం తీసివేయబడుతుంది మరియు i = 1 వద్ద సంఖ్యలలో ఉంచబడుతుంది మరియు జాబితా కుడి వైపుకు మార్చబడుతుంది. ఇది i యొక్క చివరి ఇంక్రిమెంటల్ విలువ మరియు జాబితాలోని అన్ని మూలకాలు మార్చబడే వరకు కొనసాగుతుంది . కోసం రెండవ లోఇండెక్స్ iతో ఉన్న జాబితా యొక్క లూప్ మూలకం i సూచిక i తో ఉన్న శ్రేణి మూలకానికి సెట్ చేయబడింది, ఇక్కడ i 0 నుండి list.size() - 1 వరకు ఉంటుంది . సంగ్రహంగా చెప్పాలంటే, ఉపయోగించే దశలు: దశలు:

1. i = 0
2. list.size() వద్ద మూలకాన్ని తొలగించండి - 1
3. చొప్పించు మూలకం, ఇది list.size() - 1 వద్ద , i = 0 వద్ద ఉంది
4. ఇంక్రిమెంట్ i
5. i యొక్క చివరి పెంపు విలువ ఉపయోగించబడే వరకు 2 నుండి 4 దశలను పునరావృతం చేయండి (దశ 3 వద్ద 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);
       }
   }
}

ఈ కోడ్ అవుట్‌పుట్ ఇస్తుంది:

ఎంపిక 5: రికర్షన్ ద్వారా అర్రేని రివర్స్ చేయండి

పునరావృత పద్ధతి కోడింగ్‌లో విస్తృతంగా ఉపయోగించబడుతుంది మరియు శ్రేణిని ఎలా రివర్స్ చేయాలనే దానిపై సమర్థవంతమైన పద్ధతిని రూపొందించడానికి ఉపయోగించవచ్చు. ఈ ఐచ్ఛికంలో, శ్రేణి జాబితాగా మార్చబడుతుంది మరియు తర్వాత కోడ్ పద్ధతి రివర్స్‌లోకి వెళుతుంది() ప్రతిసారీ జాబితా చివరిలో చివరి మూలకాన్ని తీసివేస్తుంది మరియు జాబితా రివర్స్‌డ్ ఆర్డర్‌లో తీసివేయబడిన విలువలను జోడించింది. మునుపటి పద్ధతులలో వలె, 5 సంఖ్యలతో కూడిన శ్రేణి సృష్టించబడుతుంది. ఇది రివర్స్ () ఫంక్షన్‌లోకి ఆర్గ్యుమెంట్‌గా పంపబడుతుంది . రివర్స్‌లో () చేసిన మొదటి విషయం ఏమిటంటే , శ్రేణిని జాబితాగా మార్చడం మరియు జాబితా పరిమాణాన్ని తనిఖీ చేయడం. ఇది ఒక మూలకాన్ని మాత్రమే కలిగి ఉంటే లేదా శూన్యంగా ఉంటే, పద్ధతి పూర్తి చేసి తిరిగి వస్తుంది. కాకపోతే, మొదటి మూలకం తీసివేయబడుతుంది, కానీ పూర్ణాంకానికి కాపీ చేయబడుతుంది, విలువ . మెథడ్ రివర్స్() మళ్లీ పిలవబడుతుంది మరియు పునరావృతం మళ్లీ ప్రారంభమవుతుంది. ఫంక్షన్‌ను నమోదు చేసినప్పుడు, అదే దశలు నిర్వహించబడతాయి, పరిమాణాన్ని తనిఖీ చేయండి, జాబితా 1 కంటే ఎక్కువ ఉంటే తదుపరి దశ మొదటి మూలకాన్ని తీసివేసి, ఆపై పునరావృతం చేయడం. జాబితా పరిమాణం 1 అయినప్పుడు, రివర్స్() అది ఎక్కడ నుండి పిలవబడుతుందో తిరిగి వస్తుంది మరియు ఆపై జాబితాకు ప్రతి విలువ జోడించబడి, దానిని అసలు జాబితా యొక్క ఖచ్చితమైన రివర్స్‌గా రూపొందించడానికి.

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

అవుట్‌పుట్:

ముగింపు

కాబట్టి ఇక్కడ మేము శ్రేణిని రివర్స్ చేయడానికి 5 విభిన్న మార్గాలను చూశాము. సేకరణల ఫ్రేమ్‌వర్క్‌ని ఉపయోగించే ఎంపిక 3, బహుశా Collections.reverse ఇప్పటికే ఉన్న, ప్రయత్నించిన మరియు పరీక్షించబడిన, Java ఫంక్షన్ అయినందున ఉపయోగించడానికి ఉత్తమమైన పద్ధతి . వాస్తవానికి ఇతర ఎంపికలు ముఖ్యంగా నేర్చుకునేటప్పుడు ఉపయోగించబడతాయి, కానీ సాధారణంగా ప్రామాణిక పద్ధతులు, అవి ఉనికిలో ఉంటే, అవి సాధారణంగా అత్యంత ఆప్టిమైజ్ చేయబడి మరియు పరీక్షించబడినందున ఉత్తమమైనవి. అయితే, ఇది మంచి కోడింగ్ వ్యాయామం మరియు జావా జూనియర్ కోసం మీ ఇంటర్వ్యూలో విజయం సాధించడంలో మీకు సహాయం చేస్తుంది కాబట్టి మీరు అలాంటి పద్ధతులను మీరే సృష్టించుకోవచ్చు.