جاوا ۾ هڪ صف کي واپس آڻيو

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

هن مثال ۾، اسان هڪ طريقو لکيو آهي جيڪو هڪ صف کي رد ڪري ٿو ۽ هڪ نئين ريورس ٿيل صف کي واپس ڪري ٿو، ان جي بنياد تي جيڪو ان کي منظور ڪيو ويو آهي. صف کي مکيه ۾ قرار ڏنو ويو آهي ۽ پوء هڪ طريقو، ريورس ، سڏيو ويندو آهي. طريقو جو دليل صف آهي. طريقو ريورس ۾ ، هڪ نئين سري، نئين آرري ، ٺاهي وئي آهي ۽ ساڳي سائيز آهي array ، صرف مڪمل طور تي خالي. لوپ لاءِ A نئينArray کي ڀرڻ لاءِ استعمال ڪيو ويندو آهي ۽ صف جي پوري ڊيگهه تي هلندي آهي. اهو ڪيو ويندو آهي هڪ صف جي پهرين عنصر سان شروع ڪندي ۽ ان کي تفويض ڪرڻ جي آخري عنصر کي 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) استعمال ڪندي اسٽرنگ طور پرنٽ ڪيو ويندو آهي ، ۽ پوءِ اسان جي صف کي ريورس ۾ دليل طور منظور ڪيو ويندو آهي . ريورس طريقي ۾ لوپ لاء ، هڪ متغير، temp، ٺاهي ۽ استعمال ڪيو ويندو آهي. لوپ لاءِ ريورس آرڊر ٽن مرحلن ۾ حاصل ٿئي ٿو:

1. پهرين عنصر کي temp تي تفويض ڪرڻ
2. پهرين عنصر کي آخري عنصر تفويض ڪرڻ
3. آخري عنصر کي temp مقرر ڪرڻ

اهو وري ڪيو ويو آهي هن ڀيري ٻئي عنصر لاءِ ۽ ٻيو آخري عنصر کان، وغيره. اهو سر جي لڳاتار عناصر لاءِ ڪيو ويندو آهي پر لوپ صرف اڌ صف جي سائيز تائين ورجائي ٿو. لازمي طور تي عناصر صف جي سامهون سرن تي تبديل ڪيا ويا آهن. اهو طريقو 0 کان سائيز تائين لوپ لاءِ استعمال ڪرڻ واري طريقي جي ڀيٽ ۾ ٻه ڀيرا تيز ٿيندو . نتيجي ۾ صف جو ريورس آرڊر حاصل ڪيو ويو آهي ۽ اسان کي ڏيکاريو ويو آهي ته ڪيئن ريورس آرڊر ۾ هڪ صف کي پرنٽ ڪجي ۽ قيمتون پرنٽ ڪيون ويون آهن:

آپشن 3: Collections.reverse استعمال ڪندي ()

جاوا ۾، ريورس طريقو، جيڪو موجوده مجموعن جي فريم ورڪ جو حصو آهي، استعمال ڪري سگهجي ٿو هڪ صف کي ريورس ڪرڻ لاء. اچو ته ان کي استعمال ڪرڻ لاء استعمال ڪريو reversal.

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 انگن سان گڏ هڪ Integer صف جي طور تي ڀريو ويو آهي. ان کان پوءِ Arrays.asList(array) استعمال ڪندي لسٽ طور پرنٽ ڪيو ويندو آهي ۽ پوءِ فنڪشن، ريورس ، سڏيو ويندو آهي ۽ array کي هن فنڪشن ۾ دليل طور منظور ڪيو ويندو آهي. ريورس ۾ ، Collections.reverse استعمال ڪيو ويندو آهي، ۽ اهو استعمال ڪيو ويندو آهي صفن جي فهرست تي، Arrays.asList(array) ، بجاءِ خود صف جي. پوءِ ايندڙ قدم ۾ اسان کي ڏيکاريو ويو آهي ته ڪيئن ريورس آرڊر ۾ هڪ صف کي پرنٽ ڪجي System.out.println استعمال ڪندي ، ۽ هن ڀيري هر عنصر هڪ ئي لڪير تي پرنٽ ڪيو ويندو:

آپشن 4: List.add() ۽ List.remove() استعمال ڪندي هڪ صف کي واپس آڻيو

ھن نئين آپشن ۾، List.add() ۽ List.remove() استعمال ڪيا ويندا آھن ريورسل ڪرڻ لاءِ. اهو ڪم ڪرڻ جو طريقو اهو آهي ته صف کي هڪ فهرست ۾ تبديل ڪيو ويو آهي ۽ فهرست جي آخري عنصر کي هٽايو ويو آهي ۽ لسٽ جي شروعات ۾ رکيل آهي. سڄي لسٽ کي ٻيهر ورجائڻ کان پوءِ، نئين لسٽ اصل جي بدلي آهي. مکيه () طريقي ۾ ، هڪ صف ٺاهي وئي آهي جنهن ۾ 5 نمبر شامل آهن. ان کان پوء صف جي اصل حالت ڪنسول ڏانهن نڪتل آهي. هي صف وري هڪ دليل جي طور تي طريقي سان رکيل آهي، reverse() . اهو طريقو بنيادي طور تي ڪم ڪري ٿو آخري عنصر کي ختم ڪندي ۽ ان کي صف جي سامهون ۾ داخل ڪندي. آخر ۾، صف جي نئين (ريورس ٿيل) رياست ڪنسول ڏانهن ٻاھر ڪڍيو ويو آھي. ريورس () طريقي ۾ ، صف کي Arrays.asList(array) ذريعي هڪ لسٽ ۾ لکيو ويو آهي ، انهي کي چالو ڪرڻ لاء add() ۽ هٽائڻ () طريقن کي ريورسل ڪرڻ لاء. اهو طريقو بنيادي طور تي ڪم ڪري ٿو آخري عنصر کي ختم ڪندي ۽ ان کي صف جي سامهون ۾ داخل ڪندي. مرحلا ريورس () استعمال ھيٺ ڏنل آھن. اهو استعمال ڪري ٿو لوپ لاءِ لسٽ جي عناصر جي رد عمل کي انجام ڏيڻ لاءِ. اهو هڪ variable i . شروعات ۾ i کي 0 تي سيٽ ڪيو ويندو آهي. جڏهن i = 0 ، فهرست ۾ موجود عنصر list.size() - 1 کي هٽايو ويندو آهي، ۽ اهو هميشه آخري عنصر هوندو جڏهن i <list.size() - 1 . جيئن ته remove() طريقو ان عنصر کي واپس ڪري ٿو جيڪو ان کي هٽايو ويو آهي، اهو عنصر هاڻي فهرست ۾ شامل ڪيو ويو آهي index i = 0 ، يعني، شروع ۾ داخل ڪيو ويو. فهرست جي باقي ساڄي طرف منتقل ڪئي وئي آهي پر نئين لسٽ اڃا تائين عنصرن جو ساڳيو تعداد آهي، يعني سائيز . i , i = 1 جي ايندڙ قيمت سان لوپ جي عمل کي جاري رکندي ، قدمن جو ساڳيو سيٽ ڪيو ويندو آهي، تنهن ڪري آخري عنصر کي هٽايو ويندو آهي ۽ نمبر ۾ رکيل آهي i = 1 ۽ فهرست کي ساڄي طرف منتقل ڪيو ويو آهي. اهو جاري رهندو جيستائين i جي آخري واڌارو قدر ۽ فهرست ۾ سڀني عنصرن کي تبديل ڪيو ويو آهي. انڊيڪس i سان لسٽ جي لوپ عنصر لاءِ سيڪنڊ ۾ انڊيڪس i سان ايري عنصر تي سيٽ ڪيو ويو آهي جتي i 0 کان list.size() - 1 تائين آهي . اختصار ڪرڻ لاء، استعمال ٿيل قدم آهن: قدم:

1. i = 0
2. list.size() - 1 تي عنصر ختم ڪريو
3. داخل ڪريو عنصر، جيڪو هو list.size() - 1 تي ، i = 0 تي
4. واڌ i
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: Recursion by Recursion a Array

ٻيهر ورجائڻ جو طريقو ڪوڊنگ ۾ وڏي پيماني تي استعمال ٿيندو آهي ۽ استعمال ڪري سگهجي ٿو هڪ موثر طريقو ٺاهڻ لاءِ ته ڪيئن هڪ صف کي ريورس ڪجي. هن آپشن ۾، صف کي لسٽ ۾ تبديل ڪيو ويندو آهي ۽ پوءِ ڪوڊ ميٿڊ ۾ وڃي ٿو ريورس() هر دفعي لسٽ جي آخر ۾ آخري عنصر کي هٽائڻ سان ۽ لسٽ کي هٽايو ويو آهي ان ۾ شامل ڪيل قدرن کي ريورس آرڊر ۾. جيئن پوئين طريقن ۾، هڪ صف ٺاهي وئي آهي جنهن ۾ 5 نمبر شامل آهن. ان کان پوء هڪ دليل جي طور تي فنڪشن ۾ منظور ڪيو ويو آهي، ريورس () . ريورس ۾ () پهرين شيء جيڪا ڪئي وئي آهي صف کي هڪ فهرست ۾ ڦيرايو ۽ لسٽ جي سائيز تي چيڪ ڪريو. جيڪڏهن اهو صرف هڪ عنصر آهي يا نيل آهي ته پوء طريقو ختم ٿئي ٿو ۽ واپسي. جيڪڏهن نه، پهريون عنصر هٽايو ويو آهي، پر نقل ڪيو ويو آهي هڪ Integer , value . طريقو ريورس () وري سڏيو ويندو آهي ۽ ٻيهر ٻيهر شروع ٿئي ٿو. جڏهن فنڪشن داخل ڪيو ويندو آهي، ساڳيا مرحلا ڪيا ويندا آهن، هڪ سائيز چيڪ ڪريو جتي، جيڪڏهن فهرست 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 اڳ ۾ ئي موجود، آزمايل ۽ آزمايل، جاوا فنڪشن آھي. يقيناً ٻيا آپشن استعمال ڪري سگھجن ٿا، خاص طور تي سکيا دوران، پر عام طور تي معياري طريقا، جيڪڏھن اھي موجود آھن، بھترين آھن، جيئن اھي عام طور تي بھترين ۽ آزمايل آھن. تنهن هوندي، توهان اهڙا طريقا پاڻ ٺاهي سگهو ٿا ڇو ته هي هڪ سٺو ڪوڊنگ مشق آهي ۽ توهان جي جاوا جونيئر لاءِ توهان جي انٽرويو ۾ ڪامياب ٿيڻ ۾ مدد ڪندي.