जावा में एक ऐरे को उल्टा करें

Arrays कोडिंग में अक्सर उपयोग किया जाता है और एक ही प्रकार के कई मानों को एक चर में संग्रहीत करने का एक तरीका है। एक सांकेतिक शब्दों में बदलनेवाला एक सरणी को उलटना चाहता है, इसके कई कारण हो सकते हैं। किसी सरणी को उल्टा करना आवश्यक हो सकता है, उदाहरण के लिए, जब किसी समस्या के तर्क को अंतिम तत्व से प्रारंभ करने की आवश्यकता होती है। इस मामले में, सबसे अच्छा अभ्यास उलटा करना है और फिर कोड में आवश्यक होने पर उलटा सरणी का उपयोग करना है। इससे भी अधिक, जावा जूनियर्स साक्षात्कार में एक सरणी को उलटना एक बहुत ही लोकप्रिय कार्य है।

किसी ऐरे को कैसे उल्टा करें

एक सरणी को उलटने के कई तरीके हैं, और यहां हम 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 बनाई जाती है और सरणी के समान आकार होती है , केवल पूरी तरह से खाली होती है। एक for लूप का उपयोग नए ऐरे में भरने के लिए किया जाता है और सरणी की पूरी लंबाई पर काम करता है। यह एक सरणी के पहले तत्व से शुरू करके और इसे नए ऐरे के अंतिम तत्व को निर्दिष्ट करके किया जाता है, फिर हमारे सरणी का दूसरा तत्व लेना और इसे newArray के दूसरे अंतिम तत्व को असाइन करना , और इसी तरह; newArray पीछे की ओर भरा हुआ है। जब लूप के लिए पूर्ण हो जाता है, तो newArray पूरी तरह से भर जाता है और सरणी के बिल्कुल विपरीत होता है ।

विकल्प 2: किसी ऐरे के तत्वों को उल्टे क्रम में प्रिंट करें

इस विकल्प के लिए एक सरणी को उलटने के लिए, अतिरिक्त सरणी का उपयोग करने की कोई आवश्यकता नहीं है, और इसे सरणी सूची में परिवर्तित नहीं किया जाता है। इसके बजाय सरणी तत्वों को रिवर्स ऑर्डर इन-प्लेस में रखा जाता है । इसका मतलब है कि वे वास्तव में अदला-बदली कर रहे हैं। पहले तत्व को अंतिम तत्व से बदल दिया जाता है, दूसरे तत्व को दूसरे से अंतिम से बदल दिया जाता है, और इसी तरह। लूप के लिए उपयोग किया जाता है और जब यह पूरा हो जाता है, तो सरणी को उलट दिया जाएगा। कोड इस तरह दिखता है:

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) का उपयोग करके एक सूची के रूप में मुद्रित किया जाता है और फिर फ़ंक्शन, रिवर्स को कॉल किया जाता है और सरणी को इस फ़ंक्शन में तर्क के रूप में पारित किया जाता है। रिवर्स में , Collections.reverse का उपयोग किया जाता है, और इसका उपयोग सरणी के बजाय सरणी सूची, Arrays.asList(array) पर किया जाता है। फिर अगले चरण में हमें दिखाया गया है कि System.out.println का उपयोग करके किसी ऐरे को रिवर्स ऑर्डर में कैसे प्रिंट किया जाए , और इस बार प्रत्येक तत्व को उसी लाइन पर प्रिंट किया जाता है:

विकल्प 4: List.add () और List.remove () का उपयोग करके एक ऐरे को उल्टा करें

इस नए विकल्प में, उलटा करने के लिए List.add() और List.remove() का उपयोग किया जाता है। जिस तरह से यह काम करता है वह यह है कि सरणी को एक सूची में बदल दिया जाता है और सूची के अंतिम तत्व को हटा दिया जाता है और सूची की शुरुआत में डाल दिया जाता है। पूरी सूची के पुनरावृत्त होने के बाद, नई सूची मूल का उलट है। main() मेथड में , एक Array बनाया जाता है जिसमें 5 नंबर होते हैं। फिर सरणी की मूल स्थिति को कंसोल पर आउटपुट किया जाता है। इस सरणी को तब विधि, रिवर्स() के तर्क के रूप में रखा जाता है । यह विधि मूल रूप से अंतिम तत्व को हटाकर और सरणी के सामने डालने से काम करती है। अंत में, सरणी की नई (उलट) स्थिति को कंसोल पर आउटपुट किया जाता है। उल्टा ()विधि, सरणी को उलटने के लिए ऐड () और रिमूव () विधियों को सक्षम करने के लिए, Arrays.asList(array) के माध्यम से एक सूची में लिखा गया है। यह विधि मूल रूप से अंतिम तत्व को हटाकर और सरणी के सामने डालने से काम करती है। रिवर्स () का उपयोग करने वाले चरण इस प्रकार हैं। यह सूची के तत्वों को उलटने के लिए for लूप का उपयोग करता है। यह एक वेरिएबल i को इनिशियलाइज़ करके करता है । प्रारंभ में i को 0 पर सेट किया जाता है। जब i = 0 , सूची में list.size() - 1 पर तत्व हटा दिया जाता है, और यह हमेशा अंतिम तत्व होगा क्योंकि i <list.size() - 1. चूंकि निकालें () विधि उस तत्व को वापस कर देती है जिसे उसने हटा दिया है, यह तत्व अब सूची में i = 0 पर सूची में जोड़ा गया है , अर्थात शुरुआत में डाला गया है। सूची के शेष भाग को फिर दाईं ओर स्थानांतरित कर दिया जाता है लेकिन नई सूची में अभी भी तत्वों की संख्या समान होती है, अर्थात size । i , i = 1 के अगले मान के साथ for लूप के निष्पादन को जारी रखते हुए , चरणों का एक ही सेट किया जाता है, इसलिए अंतिम तत्व को हटा दिया जाता है और i = 1 पर अंकों में डाल दिया जाता है और सूची को दाईं ओर स्थानांतरित कर दिया जाता है। यह i के अंतिम वृद्धिशील मूल्य और सूची में सभी तत्वों को बदलने तक जारी रहता है। दूसरे में के लिएइंडेक्स i के साथ सूची का लूप तत्व इंडेक्स i के साथ सरणी तत्व पर सेट है जहां i 0 से list.size() - 1 है । संक्षेप में, उपयोग किए गए चरण हैं: चरण:

1. मैं = 0
2. सूची पर तत्व निकालें । आकार () - 1
3. तत्व सम्मिलित करें, जो कि list.size() - 1 पर , i = 0 पर था
4. वेतन वृद्धि मैं
5. चरण 2 से 4 दोहराएं (चरण 3 पर i के लिए नए मानों के साथ) जब तक कि 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 पहले से मौजूद, आजमाया और परखा हुआ, जावा फ़ंक्शन है। बेशक अन्य विकल्पों का उपयोग किया जा सकता है, खासकर सीखने के दौरान, लेकिन आम तौर पर मानक तरीके, यदि वे मौजूद हैं, तो वे सबसे अच्छे हैं क्योंकि वे आमतौर पर अत्यधिक अनुकूलित और परीक्षण किए जाते हैं। हालाँकि, आप स्वयं इस तरह के तरीके बना सकते हैं क्योंकि यह एक अच्छा कोडिंग अभ्यास है और जावा जूनियर के लिए आपके साक्षात्कार में सफल होने में आपकी मदद करेगा।