Java मध्ये अॅरे उलट करा

अॅरे कोडिंगमध्ये वारंवार वापरले जातात आणि एकाच प्रकारातील अनेक मूल्ये एका व्हेरिएबलमध्ये साठवण्याचा एक मार्ग आहे. कोडरला अ‍ॅरे उलट करण्याची अनेक कारणे असू शकतात. अॅरे उलट करणे आवश्यक असू शकते, उदाहरणार्थ, जेव्हा एखाद्या समस्येचे तर्क शेवटच्या घटकापासून सुरू करणे आवश्यक असते. या प्रकरणात, उलट करणे आणि नंतर कोडमध्ये आवश्यक असेल तेथे उलट अॅरे वापरणे हा सर्वोत्तम सराव आहे. त्याहूनही अधिक, जावा ज्युनियर्सच्या मुलाखतींमध्ये अॅरे उलट करणे हे अतिशय लोकप्रिय कार्य आहे.

अॅरे उलट कसे करावे

अ‍ॅरे उलट करण्याचे अनेक मार्ग आहेत, आणि येथे आम्ही 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 , तयार केला जातो आणि अॅरे सारखाच आकार असतो , फक्त पूर्णपणे रिक्त असतो. ए फॉर लूप नवीन अॅरे भरण्यासाठी वापरला जातो आणि अॅरेच्या संपूर्ण लांबीवर चालतो. हे अॅरेच्या पहिल्या घटकापासून सुरू करून आणि नवीन अॅरेच्या शेवटच्या घटकाला नियुक्त करून केले जाते., नंतर आमच्या अॅरेचा दुसरा घटक घेऊन तो newArray च्या दुसऱ्या शेवटच्या घटकाला नियुक्त करणे , आणि असेच; newArray मागे भरले आहे. जेव्हा फॉर लूप पूर्ण होते, तेव्हा newArray पूर्णपणे भरलेला असतो आणि अॅरेचा अचूक उलट असतो .

पर्याय २: अॅरेचे घटक उलट क्रमाने मुद्रित करा

अ‍ॅरे रिव्हर्स करण्‍यासाठी या पर्यायासाठी, अतिरिक्त अॅरे वापरण्याची गरज नाही आणि ते अॅरे सूचीमध्ये रूपांतरित होत नाही. त्याऐवजी अॅरे घटक उलट क्रमाने ठेवतात . याचा अर्थ ते खरे तर स्वॅप केलेले आहेत. पहिला घटक शेवटच्या घटकासह स्वॅप केला जातो, दुसरा घटक शेवटच्या दुसर्‍या घटकासह स्वॅप केला जातो आणि असेच. 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) वापरून स्ट्रिंग म्हणून मुद्रित केले जाते आणि नंतर आमचा अ‍ॅरे रिव्हर्समध्ये वितर्क म्हणून पास केला जातो . फॉर लूपमधील रिव्हर्स पद्धतीमध्ये , एक व्हेरिएबल, temp, तयार केले जाते आणि वापरले जाते . फॉर लूपमध्ये उलट क्रम तीन चरणांमध्ये प्राप्त केला जातो :

1. तापमानाला प्रथम घटक नियुक्त करणे
2. पहिल्या घटकाला शेवटचा घटक नियुक्त करणे
3. शेवटच्या घटकाला तापमान नियुक्त करणे

हे नंतर या वेळी दुसऱ्या घटकासाठी आणि शेवटच्या घटकातील दुसऱ्यासाठी, आणि असेच केले जाते. हे अॅरेच्या क्रमिक घटकांसाठी केले जाते परंतु लूप फक्त अर्ध्या अॅरे आकारापर्यंत पुनरावृत्ती करतो. मूलत: अॅरेच्या विरुद्ध टोकावरील घटक स्वॅप केले जातात. ही पद्धत फॉर लूप वापरून 0 पासून आकारापर्यंत जाणाऱ्या पद्धतीपेक्षा दुप्पट वेगाने धावेल . परिणामी अॅरेचा रिव्हर्स ऑर्डर प्राप्त होतो आणि अॅरेला उलट क्रमाने कसे प्रिंट करायचे ते दाखवले जाते आणि व्हॅल्यू मुद्रित केल्या जातात:

पर्याय ३: Collections.reverse() वापरणे

Java मध्ये, रिव्हर्स पद्धत, जी विद्यमान कलेक्शन फ्रेमवर्कचा भाग आहे, अॅरे उलट करण्यासाठी वापरली जाऊ शकते. ते उलट करण्यासाठी वापरू.

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) वापरून सूची म्हणून मुद्रित केले जाते आणि नंतर फंक्शन, रिव्हर्स , कॉल केले जाते आणि या फंक्शनमध्ये अर्ग्युमेंट म्हणून अॅरे पास केला जातो. उलट मध्ये , Collections.reverse वापरले जाते, आणि हे अॅरे सूचीमध्ये वापरले जाते, Arrays.asList(array) , स्वतः अॅरेऐवजी. त्यानंतर पुढील चरणात System.out.println वापरून उलट क्रमाने अॅरे कसे प्रिंट करायचे ते दाखवले आहे आणि यावेळी प्रत्येक घटक एकाच ओळीवर छापला जातो:

पर्याय 4: List.add() आणि List.remove() वापरून अॅरे उलट करा

या नवीन पर्यायामध्ये, List.add() आणि List.remove() हे रिव्हर्सल करण्यासाठी वापरले जातात. हे कार्य करण्याचा मार्ग असा आहे की अॅरे सूचीमध्ये रूपांतरित केले जाते आणि सूचीतील शेवटचा घटक काढून टाकला जातो आणि सूचीच्या सुरूवातीस ठेवला जातो. संपूर्ण यादी पुनरावृत्ती झाल्यानंतर, नवीन यादी मूळच्या उलट आहे. main() पद्धतीमध्ये , 5 संख्यांचा समावेश असलेला अॅरे तयार केला जातो. मग अॅरेची मूळ स्थिती कन्सोलवर आउटपुट केली जाते. हा अ‍ॅरे नंतर मेथड, reverse() साठी वितर्क म्हणून टाकला जातो . ही पद्धत मुळात शेवटचा घटक काढून अ‍ॅरेच्या पुढील भागात टाकून कार्य करते. शेवटी, अॅरेची नवीन (उलट) स्थिती कन्सोलवर आउटपुट केली जाते. उलट ()मेथड, रिव्हर्सल पूर्ण करण्यासाठी add() आणि रिमूव्ह() पद्धती सक्षम करण्यासाठी Arrays.asList(array) द्वारे अ‍ॅरे यादीवर लिहिला जातो . ही पद्धत मुळात शेवटचा घटक काढून अ‍ॅरेच्या पुढील भागात टाकून कार्य करते. स्टेप्स रिव्हर्स() वापर खालीलप्रमाणे आहेत. सूचीतील घटकांचे उलटे कार्य करण्यासाठी ते फॉर लूप वापरते. हे व्हेरिएबल i आरंभ करून हे करते . सुरुवातीला i 0 वर सेट केले जाते. जेव्हा i = 0 , सूचीमधील list.size() - 1 मधील घटक काढून टाकला जातो आणि i < list.size() - 1 पासून हा नेहमीच शेवटचा घटक असेल. रिमूव्ह() मेथडने काढून टाकलेला घटक परत केल्यामुळे , हा घटक आता इंडेक्स i = 0 वरील सूचीमध्ये जोडला गेला आहे , म्हणजे, सुरुवातीला घातलेला आहे. नंतर सूचीचा उर्वरित भाग उजवीकडे हलविला जातो परंतु नवीन सूचीमध्ये अद्याप घटकांची संख्या समान आहे, म्हणजे आकार . i , i = 1 च्या पुढील व्हॅल्यूसह फॉर लूपची अंमलबजावणी सुरू ठेवून , चरणांचा समान संच चालविला जातो म्हणून शेवटचा घटक काढून टाकला जातो आणि i = 1 वर अंकांमध्ये ठेवला जातो आणि सूची उजवीकडे हलविली जाते. i चे शेवटचे वाढीव मूल्य आणि यादीतील सर्व घटक बदलले जाईपर्यंत हे चालू राहते. साठी दुसऱ्या मध्येइंडेक्स i सह सूचीचा लूप घटक इंडेक्स i सह अॅरे एलिमेंटवर सेट केला आहे जेथे i 0 ते list.size() - 1 आहे . सारांश देण्यासाठी, वापरलेले चरण आहेत: चरण:

1. i = 0
2. list.size() - १ वरील घटक काढून टाका
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 कार्य आहे. अर्थातच इतर पर्याय वापरले जाऊ शकतात, विशेषत: शिकत असताना, परंतु सामान्यत: मानक पद्धती, जर ते अस्तित्वात असतील तर, सर्वोत्तम आहेत कारण ते सहसा उच्च ऑप्टिमाइझ केलेले आणि तपासले जातात. तथापि, तुम्ही स्वतः अशा पद्धती तयार करू शकता कारण हा एक चांगला कोडिंग व्यायाम आहे आणि तुम्हाला जावा ज्युनियरसाठी तुमच्या मुलाखतीत यशस्वी होण्यास मदत होईल.