मैं जावा में एक इंट सरणी कैसे उलट सकता हूं?

Question

मैं जावा में एक अंतर सरणी को उलटने की कोशिश कर रहा हूं।

यह विधि सरणी को उल्टा नहीं करती है।

for(int i = 0; i < validData.length; i++)
{
    int temp = validData[i];
    validData[i] = validData[validData.length - i - 1];
    validData[validData.length - i - 1] = temp;
}

इसमें ग़लत क्या है?

Comments

मैंने देखा कि मैंने क्या गलत किया। वैधता होना चाहिए। गति / 2। अन्यथा यह स्वयं को उल्टा कर देगा और स्वयं को उलट देगा।

— माइकलस्कॉट

En.wikipedia.org/wiki/In-place_algorithm देखें जिसमें इस एल्गोरिथ्म के सही संस्करण का विवरण है।

— डीन पोवेई

जावा 8: stackoverflow.com/a/46756353/1216775

— akhil_mittal

Answer 1

एक इंट सरणी को उलटने के लिए, आप आइटम को तब तक स्वैप करते हैं जब तक कि आप इस तरह मिडपॉइंट तक नहीं पहुंच जाते हैं:

for(int i = 0; i < validData.length / 2; i++)
{
    int temp = validData[i];
    validData[i] = validData[validData.length - i - 1];
    validData[validData.length - i - 1] = temp;
}

जिस तरह से आप कर रहे हैं, आप प्रत्येक तत्व को दो बार स्वैप करते हैं, इसलिए परिणाम प्रारंभिक सूची के समान है।

Comments

और मैं validData.length / 2फॉर-लूप के बाहर भाग रखना चाहूंगा ।

— जिन क्वोन

@ मैं नहीं करूंगा यह केवल अर्थ की पुष्टि करता है, और मैं शर्त लगाता हूं कि अनुकूलन करने वाला आपके लिए वैसे भी करेगा। इसके बावजूद, जब तक आप यह आवश्यक / सहायक नहीं है कि रूपरेखा से स्पष्ट सबूत नहीं है, तब तक कोई सूक्ष्म-अनुकूलन नहीं होता है।

— निकु स्तिर्का

@JinKwon ऐसा करने की तरह होगा validData.length >> 1। यह समान और तेज है, लेकिन यह कई प्रोग्रामर को भ्रमित करता है और कोई भी अच्छा संकलक स्वचालित रूप से ऐसा करेगा।

— जस्टिन

आपको केवल एक बार इस गणना को करना चाहिए validData.length - i - 1और इसे एक चर में सहेजना चाहिए।

किसी को भी अस्थायी चर के साथ एक उलट सुझाव दे सकते हैं !!

— sg28

Answer 2

Commons.Lang के साथ , आप बस का उपयोग कर सकते हैं

ArrayUtils.reverse(int[] array)

अधिकांश समय, यह जल्दी और अधिक बग-सुरक्षित होता है जो आसानी से उपलब्ध पुस्तकालयों के साथ पहले से ही यूनिट-परीक्षण और उपयोगकर्ता-परीक्षण करने के लिए छड़ी करते हैं जब वे आपकी समस्या का ध्यान रखते हैं।

Comments

मैं पसंद करूंगा कि यह कार्यात्मक जैसी शैली के लिए उलट (पारित) सरणी लौटाए।

— लॉरेंट जी

@ लॉरेंट-जी निष्पक्ष होना: सरणी को उलटने के लिए इस तरह से अधिक स्मृति कुशल है, जो शायद इसलिए उन्होंने इस तरह से किया।

— सिरिसेल्फ

मेरी बात कॉपी नहीं थी और न ही कॉपी थी। मेरा संदेश बताता है कि "(पारित)" लौटाया जाना (उलट जाने के बाद), इसलिए इसे एक अभिव्यक्ति में पारित किया जा सकता है, एक अलग बयान की आवश्यकता नहीं है।

— लॉरेंट जी

Answer 3

public class ArrayHandle {
    public static Object[] reverse(Object[] arr) {
        List<Object> list = Arrays.asList(arr);
        Collections.reverse(list);
        return list.toArray();
    }
}

Comments

निश्चित रूप से यह होगा। एक सूची केवल वस्तुओं को पकड़ सकती है, आदिमों को नहीं, इसलिए सभी प्राइमेटिव्स ( intइस मामले में) अपने संबंधित रैपर (इस मामले में) से लिपटे हुए हैं Integerऔर सूची में डाल दिए गए हैं। आप देखते हैं, Integerएस ऑब्जेक्ट हैं। @ टोम

— ११६T४

बाहर देखो: अगर मैं गलत नहीं हूँ तो मूल सरणी संशोधित है। यह स्पष्ट करने के लिए कि आप कुछ भी वापस नहीं करना चाहते हैं।

— एंड्रिया जिलियो

@ 11684 हाँ, सामान्य सूचियाँ केवल वस्तुएँ रख सकती हैं। लेकिन विधि एक सरणी को स्वीकार करती है। Arrays आदिम धारण कर सकते हैं। इसलिए इससे int[]अलग है Integer[]। इसे आज़माएँ Integer[] array = new int[5]:। आपको एक संकलन त्रुटि मिलेगी। यही कारण है कि जावा Arraysवर्ग आदिम सरणियों के साथ काम करने के तरीकों का एक गुच्छा परिभाषित करता है। int[]उपरोक्त विधि को पास करने की कोशिश करने के परिणामस्वरूप कुछ ऐसा होगा The method reverse(Object[]) in the type MakeSimple is not applicable for the arguments (int[])। @ फ़ीलिप - इन-प्लेस एल्गोरिथम कम मेमोरी का उपयोग करता है और तेजी से चलता है।

— बजे ब्रायन मैककिनटन

@ और वास्तव में, यह नहीं है। द्वारा लौटाई गई सूची Arrays.asList()मूल सरणी को संदर्भित नहीं करती है, और न ही सरणी वापस आती है। यह इस पद्धति की समस्याओं में से एक है: यह ट्रिपल मेमोरी का उपयोग करती है और इन-प्लेस एल्गोरिथम के रूप में कार्य को तीन गुना करती है।

— बजे ब्रायन मैककिनटन

यह विधि स्वयं काम कर सकती है, लेकिन कोई भी int[]इस पद्धति के तर्क के रूप में पास नहीं कर सकता है ( "असंगत प्रकार: int [] वस्तु में परिवर्तित नहीं किया जा सकता है] []" ।

— एम सी सम्राट

Answer 4

Collections.reverse(Arrays.asList(yourArray));

java.util.Collections.reverse()रिवर्स कर सकता है java.util.Listऔर java.util.Arrays.asList()उस सूची को लौटाता है जो आपके पास जाने वाले विशिष्ट सरणी को लपेटता है, इसलिए yourArrayके आह्वान के बाद उलट जाता है Collections.reverse()।

लागत केवल एक सूची-वस्तु का निर्माण है और किसी अतिरिक्त पुस्तकालय की आवश्यकता नहीं है।

तारिक और उनके टिप्पणीकारों के उत्तर में एक समान समाधान प्रस्तुत किया गया है, लेकिन मुझे लगता है कि यह उत्तर अधिक संक्षिप्त और अधिक आसानी से सुगम होगा।

Comments

वस्तुओं के सरणियों के लिए, यह एक अच्छा समाधान है। लेकिन यह आदिम के सरणियों के लिए काम नहीं करता है। ई। जी। एक गुजर int[]करने के लिए asList(...)एक वापस आ जाएगी नहीं List<Integer>है, लेकिन एक List<int[]>, एक तत्व से युक्त। वहाँ AFAICS कोई अंतर्निहित तरीका एक कन्वर्ट करने के लिए सरल है int[]एक करने के लिए Integer[]।

— मार्टिन

यह आदिम सरणियों के साथ काम नहीं करेगा ... संग्रह dosnt एक मान लौटाता है तो अब आपके पास स्मृति में एक सूची के रूप में एक बेकार सरणी है

— नाइटस्कीकोड

@MartinRust जावा 8+: Arrays.stream(arr).boxed().collect(Collectors.toList())याArrays.stream(arr).boxed().toArray(Integer[]::new)

— साइमन फोर्सबर्ग

Answer 5

मुझे लगता है कि एल्गोरिथ्म के तर्क का पालन करना थोड़ा आसान है यदि आप उन सूचकांकों का ट्रैक रखने के लिए स्पष्ट चर घोषित करते हैं जो आप लूप के प्रत्येक पुनरावृत्ति पर स्वैप कर रहे हैं।

public static void reverse(int[] data) {
    for (int left = 0, right = data.length - 1; left < right; left++, right--) {
        // swap the values at the left and right indices
        int temp = data[left];
        data[left]  = data[right];
        data[right] = temp;
    }
}

मुझे यह भी लगता है कि थोड़ी देर के पाश में ऐसा करना अधिक पठनीय है।

public static void reverse(int[] data) {
    int left = 0;
    int right = data.length - 1;

    while( left < right ) {
        // swap the values at the left and right indices
        int temp = data[left];
        data[left] = data[right];
        data[right] = temp;

        // move the left and right index pointers in toward the center
        left++;
        right--;
    }
}

Comments

पुराने स्कूल की अदला-बदली अधिक आसान लगती है, लेकिन हाँ जब एरे इंडेक्स वैल्यूज़ को छोड़ दिया जाए तो सही, ... डिबगिंग के लिए मददगार होगा यदि कोई हो

— श्रीनाथ गणेश

आप 'सार्वजनिक स्थैतिक शून्य स्वैप (इंट [] डेटा, इंट इंडेक्स 1, इंट इंडेक्स 2) {...} भी जोड़ सकते हैं और इसे' रिवर्स 'से इस तरह उपयोग कर सकते हैं: स्वैप (डेटा, बाएं, दाएं)।

— pm_

Answer 6

यहां पहले से ही बहुत सारे उत्तर हैं, जो अधिकतर सरणी में जगह को संशोधित करने पर केंद्रित हैं। लेकिन पूर्णता की खातिर, यहां जावा स्ट्रीम का उपयोग करके मूल सरणी को संरक्षित करने और एक नया उलटा सरणी बनाने के लिए एक और तरीका दिया गया है:

    int[] a = {8, 6, 7, 5, 3, 0, 9};
    int[] b = IntStream.rangeClosed(1, a.length).map(i -> a[a.length-i]).toArray();

Answer 7

अमरूद के साथ:

Collections.reverse(Ints.asList(array));

Comments

ये जबरदस्त है! छोटा और प्रभावी। सभी asListतरीकों की तरह , यह एक ऐसा दृश्य बनाता है जो सीधे बैकिंग (आदिम) सरणी के माध्यम से लिखता है। मुझे लगता है कि नीचे के मतदाता ने गलती से सोचा कि यह एक बॉक्सिंग सूची या कुछ और है।

— ल्यूक उशरवुड

@LukeUsherwood संभवत: तब भी बॉक्सिंग से कुछ ओवरहेड होगा और प्रत्येक तत्व पर कॉलिंग सेट और अनबॉक्सिंग होगा। लेकिन मैं आपसे सहमत हूं कि यह एक शानदार समाधान है।

— पैट्रिक पार्कर

वास्तव में, यह ध्यान देने योग्य है। मुझे नहीं लगता कि मैं व्यक्तिगत रूप से काम करने वाले कोड के बहुमत में एक बड़ी बात होगी - हमारे 'गर्म' क्षेत्रों को अच्छी तरह से परिभाषित किया गया है, बाकी सभी प्रकार के 'गोंद कोड' हैं। उसी समय मैं इस बात से शंकित हूं कि मेमोरी मंथन एक अतिरिक्त "छिपी हुई" लागत भी पैदा करता है जो कि प्रोफाइलर्स वास्तविक कार्य के लिए विशेषता नहीं रखते हैं।

— ल्यूक उशरवुड

@LukeUsherwood यह अभी भी एक मुख्य सरणी के बजाय एक बॉक्सिंग सूची

— लौटाता है

@AnthonyJClink निश्चित नहीं है कि "यह" क्या संदर्भित करता है, लेकिन JDK उपयोगिता Collections.reverseएक शून्य विधि है। यह एक अमरूद आंतरिक वर्ग पर इन-प्लेस काम करता है जो एक लपेटता है int[](क्योंकि यह कभी भी बॉक्सिंग की सूची नहीं रखता है Integerमैं कक्षा को "बॉक्सिंग सूची" नहीं कहूंगा, बल्कि "एक सरणी की सूची दृश्य")। लेकिन हाँ यह एक इंटरफ़ेस पासिंग Integerऑब्जेक्ट्स के माध्यम से संचालित होता है, इसलिए यह बहुत सारे अस्थायी ऑब्जेक्ट मंथन और बॉक्सिंग का उल्लेख करेगा। IntStreamप्रदर्शन के मामलों के लिए एक या एक आदिम-संग्रह पुस्तकालय का प्रयास करें । (ट्रोव, कोलोबोक, एक्लिप्स कलेक्शंस, ...)

— ल्यूक उशेरवुड

Answer 8

जावा 8 के मामले में हम IntStreamपूर्णांकों की सारणी को उलटने के लिए भी उपयोग कर सकते हैं :

int[] sample = new int[]{1,2,3,4,5};
int size = sample.length;
int[] reverseSample = IntStream.range(0,size).map(i -> sample[size-i-1])
                      .toArray(); //Output: [5, 4, 3, 2, 1]

Answer 9

पाश के लिए सरल!

for (int start = 0, end = array.length - 1; start <= end; start++, end--) {
    int aux = array[start];
    array[start]=array[end];
    array[end]=aux;
}

Comments

भविष्य में, कृपया पूछने वाले को विशेष रूप से बताएं कि उन्होंने क्या गलत किया, और आपने क्या किया।

— कार्तिक चुघ

बदलने के start <= endलिएstart < end

— लियोनार्ड पाउली

Answer 10

इससे आपको मदद मिलेगी

int a[] = {1,2,3,4,5};
for (int k = 0; k < a.length/2; k++) {
    int temp = a[k];
    a[k] = a[a.length-(1+k)];
    a[a.length-(1+k)] = temp;
}

Answer 11

for(int i=validData.length-1; i>=0; i--){
  System.out.println(validData[i]);
 }

Comments

दुर्भाग्य से, यह यहां सबसे साफ उत्तर उपलब्ध है, क्योंकि प्रत्येक डेवलपर को यह पता होगा कि इसे कैसे करना है और इसके लिए किसी भी विस्तारित पैकेज की आवश्यकता नहीं है।

— होल्डऑफहंगर

Answer 12

यह है कि मैं इसे व्यक्तिगत रूप से कैसे हल करूंगा। पैरामीरिज्ड विधि बनाने के पीछे का कारण किसी भी सरणी को क्रमबद्ध करने की अनुमति देना है ... न कि केवल आपके पूर्णांक।

मुझे आशा है कि आप इससे कुछ चमकेंगे।

@Test
public void reverseTest(){
   Integer[] ints = { 1, 2, 3, 4 };
   Integer[] reversedInts = reverse(ints);

   assert ints[0].equals(reversedInts[3]);
   assert ints[1].equals(reversedInts[2]);
   assert ints[2].equals(reversedInts[1]);
   assert ints[3].equals(reversedInts[0]);

   reverseInPlace(reversedInts);
   assert ints[0].equals(reversedInts[0]);
}

@SuppressWarnings("unchecked")
private static <T> T[] reverse(T[] array) {
    if (array == null) {
        return (T[]) new ArrayList<T>().toArray();
    }
    List<T> copyOfArray = Arrays.asList(Arrays.copyOf(array, array.length));
    Collections.reverse(copyOfArray);
    return copyOfArray.toArray(array);
}

private static <T> T[] reverseInPlace(T[] array) {
    if(array == null) {
        // didn't want two unchecked suppressions
        return reverse(array);
    }

    Collections.reverse(Arrays.asList(array));
    return array;
}

Comments

प्राइमरी का उपयोग करके मूल समस्या को हल नहीं करता है।

— मेलिंडा ग्रीन

प्रिम्स को वस्तुओं में बदलने के कई तरीके हैं। मैं हमेशा जावा में जहां भी संभव हो प्राइम्स से बचने की सलाह देता हूं और मेरा यह भी मानना ​​है कि इसे प्रोत्साहित किया जाना चाहिए।

— एंथनीजलिंक

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

— मेलिंडा ग्रीन

आपको वास्तव में सरणी की प्रतिलिपि बनाने की आवश्यकता नहीं है, बस Collections.reverse(asList(arraytoReverse)); return arrayToReverse;। asListसरणी के चारों ओर एक आवरण है, इसलिए मूल सरणी उलट है।

— रेडियोडेफ

Answer 13

आपका कार्यक्रम केवल काम करेगा length = 0, 1। तुम कोशिश कर सकते हो :

int i = 0, j = validData.length-1 ; 
while(i < j)
{
     swap(validData, i++, j--);  // code for swap not shown, but easy enough
}

Comments

शायद आप एक विधि कॉल के बजाय एक इनलाइन स्वैप के लिए छद्म कोड के रूप में स्वैप करते हैं, लेकिन अगर यह काम नहीं करेगा। जावा संदर्भ से गुजरता है इसलिए चर के लिए स्वैप विधि लिखना संभव नहीं है।

— डीन पोवेई

मेरा मतलब था कि जिस भी तरीके से आप v [i] & v [j] को स्वैप कर सकते हैं। मुझे पता है कि जावा में मेथड कॉल कैसे काम करता है। विधि के लिए, आप स्वैप (v, i ++, j--) जैसे कुछ कर सकते हैं;

— फास्टकोडवा

डीन, सरणी वैधता एक वस्तु है, जिसे संदर्भ द्वारा पारित किया गया है, इसलिए स्वैप () विधि पूरी तरह से काम करेगी।

— Gaël Oberson

Answer 14

यदि ऐसे डेटा के साथ काम करना जो अधिक आदिम है (यानी चार, बाइट, इंट, आदि) तो आप कुछ मजेदार एक्सओआर ऑपरेशन कर सकते हैं।

public static void reverseArray4(int[] array) {
    int len = array.length;
    for (int i = 0; i < len/2; i++) {
        array[i] = array[i] ^ array[len - i  - 1];
        array[len - i  - 1] = array[i] ^ array[len - i  - 1];
        array[i] = array[i] ^ array[len - i  - 1];
    }
}

Comments

बहुत प्यारा वास्तव में उत्पादन कोड में उपयोग करने के लिए लेकिन फिर भी मजेदार है। अधिकतम क्यूटनेस के लिए, इस तरह% = ऑपरेशन का उपयोग करें: सरणी [i]% = सरणी [लेन - मैं - १], इत्यादि

— मेलिंडा ग्रीन

इसी तरह, लेकिन थोड़ा छोटा:for (int m = x.length, i = --m / 2; ++i <= m;) { x[i] ^= x[m - i]; x[i] ^= x[m - i] ^= x[i]; }

— थॉमस म्यूलर

Answer 15

यह सरणी को पीछे की ओर सीधा करने के लिए सबसे अधिक कुशल है।

मुझे यकीन नहीं है कि अगर हारून का समाधान इस vi इस फोन Collections.reverse(list);करता है किसी को पता है?

Comments

सरणी के ऊपर पीछे की ओर एक नए सरणी की आवश्यकता होती है। मैं ऊपर दिए गए समाधान को पसंद करता हूं जो एक नई सरणी बनाने के बिना इनलाइन को उलट देता है।

— mmcdole

@Simucal एक नई व्यूह रचना क्यों? बस इसे पीछे की तरफ से खुजलाएं।

— ट्रेकजाज़

Answer 16

public void getDSCSort(int[] data){
        for (int left = 0, right = data.length - 1; left < right; left++, right--){
            // swap the values at the left and right indices
            int temp = data[left];
            data[left]  = data[right];
            data[right] = temp;
        }
    }

Answer 17

public void display(){
  String x[]=new String [5];
  for(int i = 4 ; i > = 0 ; i-- ){//runs backwards

    //i is the nums running backwards therefore its printing from       
    //highest element to the lowest(ie the back of the array to the front) as i decrements

    System.out.println(x[i]);
  }
}

Comments

हां मैंने आउटपुट के साथ समान और स्पष्ट कोड की कोशिश की है int [] a = {1,3,5,2,6,7}; for (int i = a.length-1; i> = 0; i--) {System.out.print ([[i] + "");} 'यह पिछले इंडेक्स से फर्स्ट इंडेक्स में एरे को उल्टा कर देगा

— रॉकेट_03

Answer 18

क्या यह इस तरह नहीं करना गलतियों के लिए बहुत अधिक संभावना है?

    int[] intArray = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    int[] temp = new int[intArray.length];
    for(int i = intArray.length - 1; i > -1; i --){
            temp[intArray.length - i -1] = intArray[i];
    }
    intArray = temp;

Answer 19

ओ (एन) समय जटिलता और ओ (1) अंतरिक्ष जटिलता के साथ समाधान।

void reverse(int[] array) {
    int start = 0;
    int end = array.length - 1;
    while (start < end) {
        int temp = array[start];
        array[start] = array[end];
        array[end] = temp;
        start++;
        end--;
    }
}

Comments

बस FYI करें, यह लूप के लिए एक जटिल में सरलीकृत किया जा सकता है for (int start = 0, end = array.length - 1; start < end; start++, end--) { ... }:।

— टिम कुक

Answer 20

एक ऐरे को उलटने के 2 तरीके।

1. लूप का उपयोग करना और ओ (एन / 2) की समय जटिलता के साथ मध्य बिंदु तक तत्वों को स्वैप करें।

   private static void reverseArray() {
   int[] array = new int[] { 1, 2, 3, 4, 5, 6 };
   
   for (int i = 0; i < array.length / 2; i++) {
       int temp = array[i];
       int index = array.length - i - 1;
       array[i] = array[index];
       array[index] = temp;
   }
   System.out.println(Arrays.toString(array));

   }

2. बिल्ट इन फंक्शन का उपयोग करना (कलेक्शंस .reverse) ()

   private static void reverseArrayUsingBuiltInFun() {
   int[] array = new int[] { 1, 2, 3, 4, 5, 6 };
   
   Collections.reverse(Ints.asList(array));
   System.out.println(Arrays.toString(array));

   }

   आउटपुट: [६, ५, ४, ३, २, १]

Comments

क्या है Ints?

— कोडिंगनो

@CodingNow यह अमरूद उपयोगिता सहायक वर्गों में से एक है - यहाँ

— 16

Answer 21

    public static void main(String args[])    {
        int [] arr = {10, 20, 30, 40, 50}; 
        reverse(arr, arr.length);
    }

    private static void reverse(int[] arr,    int length)    {

        for(int i=length;i>0;i--)    { 
            System.out.println(arr[i-1]); 
        }
    }

Answer 22

ऊपर कुछ महान जवाब हैं, लेकिन यह है कि मैंने यह कैसे किया:

public static int[] test(int[] arr) {

    int[] output = arr.clone();
    for (int i = arr.length - 1; i > -1; i--) {
        output[i] = arr[arr.length - i - 1];
    }
    return output;
}

Answer 23

नीचे आपकी मशीन में चलने का पूरा कार्यक्रम है।

public class ReverseArray {
    public static void main(String[] args) {
        int arr[] = new int[] { 10,20,30,50,70 };
        System.out.println("reversing an array:");
        for(int i = 0; i < arr.length / 2; i++){
            int temp = arr[i];
            arr[i] = arr[arr.length - i - 1];
            arr[arr.length - i - 1] = temp;
        }
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }   
    }
}

सरणियों का उपयोग करके मैट्रिक्स पर कार्यक्रमों के लिए यह लिंक के माध्यम से सबसे अच्छा स्रोत होगा ।

Answer 24

अस्थायी चर से बचने के लिए XOR समाधान का उपयोग करके आपका कोड दिखना चाहिए

for(int i = 0; i < validData.length; i++){
    validData[i] = validData[i] ^ validData[validData.length - i - 1];
    validData[validData.length - i - 1] = validData[i] ^ validData[validData.length - i - 1];
    validData[i] = validData[i] ^ validData[validData.length - i - 1];
}

बेहतर स्पष्टीकरण के लिए इस लिंक को देखें:

http://betterexplained.com/articles/swap-two-variables-using-xor/

Answer 25

private static int[] reverse(int[] array){
    int[] reversedArray = new int[array.length];
    for(int i = 0; i < array.length; i++){
        reversedArray[i] = array[array.length - i - 1];
    }
    return reversedArray;
} 

Comments

कृपया अपने उत्तर में स्पष्टीकरण जोड़ने पर विचार करें। कोड-केवल उत्तर कुछ भी स्पष्ट नहीं करते हैं।

— rgettman 20

Answer 26

यहां किसी भी प्रकार के सरणी को उल्टा करने के लिए एक सरल कार्यान्वयन है , साथ ही पूर्ण / आंशिक समर्थन भी।

import java.util.logging.Logger;

public final class ArrayReverser {
 private static final Logger LOGGER = Logger.getLogger(ArrayReverser.class.getName());

 private ArrayReverser () {

 }

 public static <T> void reverse(T[] seed) {
    reverse(seed, 0, seed.length);
 }

 public static <T> void reverse(T[] seed, int startIndexInclusive, int endIndexExclusive) {
    if (seed == null || seed.length == 0) {
        LOGGER.warning("Nothing to rotate");
    }
    int start = startIndexInclusive < 0 ? 0 : startIndexInclusive;
    int end = Math.min(seed.length, endIndexExclusive) - 1;
    while (start < end) {
        swap(seed, start, end);
        start++;
        end--;
    }
}

 private static <T> void swap(T[] seed, int start, int end) {
    T temp =  seed[start];
    seed[start] = seed[end];
    seed[end] = temp;
 }  

}

यहाँ इसी यूनिट टेस्ट है

import static org.hamcrest.CoreMatchers.is;
import static org.junit.Assert.assertThat;

import org.junit.Before;
import org.junit.Test;

public class ArrayReverserTest {
private Integer[] seed;

@Before
public void doBeforeEachTestCase() {
    this.seed = new Integer[]{1,2,3,4,5,6,7,8};
}

@Test
public void wholeArrayReverse() {
    ArrayReverser.<Integer>reverse(seed);
    assertThat(seed[0], is(8));
}

 @Test
 public void partialArrayReverse() {
    ArrayReverser.<Integer>reverse(seed, 1, 5);
    assertThat(seed[1], is(5));
 }
}

Answer 27

यहाँ मैं के साथ आया हूँ:

// solution 1 - boiler plated 
Integer[] original = {100, 200, 300, 400};
Integer[] reverse = new Integer[original.length];

int lastIdx = original.length -1;
int startIdx = 0;

for (int endIdx = lastIdx; endIdx >= 0; endIdx--, startIdx++)
   reverse[startIdx] = original[endIdx];

System.out.printf("reverse form: %s", Arrays.toString(reverse));

// solution 2 - abstracted 
// convert to list then use Collections static reverse()
List<Integer> l = Arrays.asList(original);
Collections.reverse(l);
System.out.printf("reverse form: %s", l);

Answer 28

समस्या के समाधान के दो तरीके हैं:

1. अंतरिक्ष में एक सरणी उल्टा।

चरण 1. शुरू और अंत सूचकांक पर तत्वों को स्वैप करें।

चरण 2. प्रारंभ सूचकांक में वृद्धि अंत सूचकांक में वृद्धि।

चरण 3. Iterate चरण 1 और चरण 2 प्रारंभ करें इंडेक्स <अंत इंडेक्स तक

इसके लिए, समय जटिलता O (n) होगी और अंतरिक्ष जटिलता O (1) होगी

अंतरिक्ष में एक सरणी को उलटने के लिए नमूना कोड इस तरह है:

public static int[] reverseAnArrayInSpace(int[] array) {
    int startIndex = 0;
    int endIndex = array.length - 1;
    while(startIndex < endIndex) {
        int temp = array[endIndex];
        array[endIndex] = array[startIndex];
        array[startIndex] = temp;
        startIndex++;
        endIndex--;
    }
    return array;
}

2. सहायक सरणी का उपयोग करके एक सरणी को उल्टा करें।

चरण 1. दिए गए सरणी के बराबर आकार का एक नया सरणी बनाएं।

चरण 2. अंत इंडेक्स से शुरू होने वाले दिए गए एरे इंडेक्स से शुरू होने वाले नए एरे में तत्वों को डालें।

इसके लिए, समय जटिलता O (n) होगी और अंतरिक्ष जटिलता O (n) होगी

सहायक सरणी के साथ एक सरणी को उलटने के लिए नमूना कोड इस तरह है:

public static int[] reverseAnArrayWithAuxiliaryArray(int[] array) {
    int[] reversedArray = new int[array.length];
    for(int index = 0; index < array.length; index++) {
        reversedArray[index] = array[array.length - index -1]; 
    }
    return reversedArray;
}

इसके अलावा, हम ऐसा करने के लिए Java से कलेक्शंस API का उपयोग कर सकते हैं।

संग्रह एपीआई आंतरिक रूप से अंतरिक्ष दृष्टिकोण में एक ही रिवर्स का उपयोग करता है।

संग्रह एपीआई का उपयोग करने के लिए नमूना कोड इस प्रकार है:

public static Integer[] reverseAnArrayWithCollections(Integer[] array) {
    List<Integer> arrayList = Arrays.asList(array);
    Collections.reverse(arrayList);
    return arrayList.toArray(array);
}

Answer 29

static int[] reverseArray(int[] a) {
     int ret[] = new int[a.length];
     for(int i=0, j=a.length-1; i<a.length && j>=0; i++, j--)
         ret[i] = a[j];
     return ret;
}

Answer 30

 public static int[] reverse(int[] array) {

    int j = array.length-1;
    // swap the values at the left and right indices //////
        for(int i=0; i<=j; i++)
        {
             int temp = array[i];
                array[i] = array[j];
                array[j] = temp;
           j--;
        }

         return array;
    }

      public static void main(String []args){
        int[] data = {1,2,3,4,5,6,7,8,9};
        reverse(data);

    }