جاوا میں ایک صف کو ریورس کریں۔

ارے کوڈنگ میں کثرت سے استعمال کیا جاتا ہے اور ایک متغیر میں ایک ہی قسم کی متعدد اقدار کو ذخیرہ کرنے کا ایک طریقہ ہے۔ اس کی بہت سی وجوہات ہو سکتی ہیں جن کی وجہ سے کوڈر ایک صف کو ریورس کرنا چاہتا ہے۔ کسی صف کو ریورس کرنا ضروری ہو سکتا ہے، مثال کے طور پر، جب کسی مسئلے کی منطق کو آخری عنصر سے شروع کرنے کی ضرورت ہو۔ اس صورت میں، بہترین عمل یہ ہے کہ الٹ جائے اور پھر کوڈ میں جہاں ضروری ہو الٹ سرنی کا استعمال کریں۔ اس سے بھی بڑھ کر، جاوا جونیئرز کے انٹرویوز میں صف کو تبدیل کرنا ایک بہت مقبول کام ہے۔

ایک صف کو ریورس کرنے کا طریقہ

ایک سرنی کو ریورس کرنے کے بہت سے طریقے ہیں، اور یہاں ہم 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 ، بنائی جاتی ہے اور اسی سائز کی ہوتی ہے جس طرح array ، صرف مکمل طور پر خالی ہوتی ہے۔ A for loop newArray کو بھرنے کے لیے استعمال کیا جاتا ہے اور ارے کی پوری لمبائی پر کام کرتا ہے۔ یہ ایک صف کے پہلے عنصر کے ساتھ شروع کرکے اور اسے newArray کے آخری عنصر کو تفویض کرکے کیا جاتا ہے ، پھر ہماری صف کا دوسرا عنصر لے کر اسے newArray کے دوسرے آخری عنصر کو تفویض کرکے ، وغیرہ۔ newArray پیچھے کی طرف بھرا ہوا ہے۔ جب for loop مکمل ہو جاتا ہے، newArray مکمل طور پر بھر جاتا ہے اور یہ صف کا بالکل الٹ ہے ۔

آپشن 2: ایک صف کے عناصر کو ریورس آرڈر میں پرنٹ کریں۔

ایک صف کو ریورس کرنے کے لیے اس اختیار کے لیے، اضافی سرنی استعمال کرنے کی ضرورت نہیں ہے، اور اسے ایک صف کی فہرست میں تبدیل نہیں کیا جاتا ہے۔ اس کے بجائے صف کے عناصر کو جگہ جگہ ریورس ترتیب میں رکھا جاتا ہے ۔ اس کا مطلب ہے کہ وہ درحقیقت تبدیل شدہ ہیں۔ پہلے عنصر کو آخری عنصر کے ساتھ تبدیل کیا جاتا ہے، دوسرے عنصر کو آخری سے دوسرے کے ساتھ تبدیل کیا جاتا ہے، وغیرہ۔ A for loop استعمال کیا جاتا ہے اور جب یہ مکمل ہو جائے گا تو صف کو الٹ دیا جائے گا۔ کوڈ اس طرح لگتا ہے:

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) کا استعمال کرتے ہوئے String کے طور پر پرنٹ کیا جاتا ہے ، اور پھر ہماری صف کو ایک دلیل کے طور پر ریورس میں منتقل کیا جاتا ہے ۔ for loop میں ریورس طریقہ میں ، ایک متغیر، temp، بنایا اور استعمال کیا جاتا ہے۔ فار لوپ میں الٹا ترتیب تین مراحل میں حاصل کیا جاتا ہے:

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) کا استعمال کرتے ہوئے ایک فہرست کے طور پر پرنٹ کیا جاتا ہے اور پھر فنکشن، reverse ، کہا جاتا ہے اور array کو اس فنکشن میں دلیل کے طور پر پاس کیا جاتا ہے۔ ریورس میں ، Collections.reverse استعمال کیا جاتا ہے، اور یہ صف کی فہرست میں استعمال ہوتا ہے، Arrays.asList(array) ، بجائے خود سرنی کے۔ پھر اگلے مرحلے میں ہمیں دکھایا گیا ہے کہ کس طرح System.out.println کا استعمال کرتے ہوئے ایک صف کو الٹ ترتیب میں پرنٹ کرنا ہے ، اور اس بار ہر عنصر کو ایک ہی لائن پر پرنٹ کیا گیا ہے۔

آپشن 4: List.add() اور List.remove() کا استعمال کرتے ہوئے ایک صف کو ریورس کریں

اس نئے آپشن میں، List.add() اور List.remove() کو ریورسل کرنے کے لیے استعمال کیا جاتا ہے۔ اس کے کام کرنے کا طریقہ یہ ہے کہ صف کو فہرست میں تبدیل کر دیا جاتا ہے اور فہرست کے آخری عنصر کو ہٹا کر فہرست کے شروع میں رکھ دیا جاتا ہے۔ پوری فہرست کو دوبارہ دہرانے کے بعد، نئی فہرست اصل سے الٹ ہے۔ مین () طریقہ میں ، 5 نمبروں پر مشتمل ایک صف بنائی جاتی ہے۔ پھر سرنی کی اصل حالت کنسول میں آؤٹ پٹ ہوجاتی ہے۔ اس صف کو پھر طریقہ کی دلیل کے طور پر ڈالا جاتا ہے، reverse() ۔ یہ طریقہ بنیادی طور پر آخری عنصر کو ہٹا کر اور اسے صف کے سامنے ڈال کر کام کرتا ہے۔ آخر میں، سرنی کی نئی (الٹ) حالت کنسول میں آوٹ پٹ ہو جاتی ہے۔ ریورس() طریقہ میں ، ارے کو ایک لسٹ میں Arrays.asList(array) کے ذریعے لکھا جاتا ہے ، تاکہ add() اور remove() طریقوں کو ریورسل کرنے کے قابل بنایا جا سکے۔ یہ طریقہ بنیادی طور پر آخری عنصر کو ہٹا کر اور اسے صف کے سامنے ڈال کر کام کرتا ہے۔ ریورس () کے استعمال کے اقدامات درج ذیل ہیں۔ یہ فہرست کے عناصر کو تبدیل کرنے کے لیے ایک لوپ کا استعمال کرتا ہے۔ یہ ایک متغیر شروع کرکے ایسا کرتا ہے i ۔ ابتدائی طور پر i کو 0 پر سیٹ کیا جاتا ہے۔ جب i = 0 ، فہرست میں list.size() - 1 کا عنصر ہٹا دیا جاتا ہے، اور i <list.size() - 1 کے بعد سے یہ ہمیشہ آخری عنصر ہوگا ۔ چونکہ remove() طریقہ اس عنصر کو واپس کرتا ہے جسے اس نے ہٹا دیا ہے، اس لیے یہ عنصر اب فہرست میں شامل کیا گیا ہے index i = 0 ، یعنی شروع میں داخل کیا گیا ہے۔ اس کے بعد فہرست کا بقیہ حصہ دائیں طرف منتقل کر دیا جاتا ہے لیکن نئی فہرست میں اب بھی عناصر کی ایک ہی تعداد ہے، یعنی سائز ۔ i , i = 1 کی اگلی قدر کے ساتھ for loop کے عمل کو جاری رکھتے ہوئے ، اقدامات کا ایک ہی سیٹ کیا جاتا ہے تاکہ آخری عنصر کو ہٹا کر 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: تکرار کے ذریعے ایک صف کو ریورس کریں۔

تکرار کا طریقہ کوڈنگ میں بڑے پیمانے پر استعمال کیا جاتا ہے اور اس کا استعمال ایک موثر طریقہ بنانے کے لیے کیا جا سکتا ہے کہ کسی صف کو کیسے ریورس کیا جائے۔ اس آپشن میں، صف کو ایک فہرست میں تبدیل کیا جاتا ہے اور پھر کوڈ ہر بار فہرست کے آخر میں آخری عنصر کو ہٹاتے ہوئے طریقہ ریورس() میں چلا جاتا ہے اور فہرست میں حذف شدہ اقدار کو الٹ ترتیب میں شامل کیا جاتا ہے۔ پچھلے طریقوں کی طرح، 5 نمبروں پر مشتمل ایک صف بنائی گئی ہے۔ اس کے بعد اسے فنکشن میں ایک دلیل کے طور پر منتقل کیا جاتا ہے، reverse() ۔ ریورس () میں سب سے پہلے جو کام کیا جاتا ہے وہ ہے سرنی کو فہرست میں تبدیل کرنا اور فہرست کے سائز کو چیک کرنا۔ اگر اس میں صرف ایک عنصر ہے یا کالعدم ہے تو طریقہ ختم ہوجاتا ہے اور واپس آجاتا ہے۔ اگر نہیں، تو پہلا عنصر ہٹا دیا جاتا ہے، لیکن انٹیجر ، قدر میں کاپی کر دیا جاتا ہے ۔ طریقہ ریورس () پھر دوبارہ کہا جاتا ہے اور تکرار دوبارہ شروع ہوتا ہے۔ جب فنکشن داخل کیا جاتا ہے، وہی اقدامات کیے جاتے ہیں، ایک سائز کی جانچ پڑتال کی جاتی ہے، اگر فہرست 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 پہلے سے موجود، آزمایا اور تجربہ شدہ جاوا فنکشن ہے۔ بلاشبہ دوسرے آپشنز کو استعمال کیا جا سکتا ہے، خاص طور پر سیکھنے کے دوران، لیکن عام طور پر معیاری طریقے، اگر وہ موجود ہیں، تو بہترین ہیں کیونکہ وہ عام طور پر انتہائی بہتر اور جانچے جاتے ہیں۔ تاہم، آپ ایسے طریقے خود بنا سکتے ہیں کیونکہ یہ کوڈنگ کی ایک اچھی مشق ہے اور جاوا جونیئر کے لیے آپ کے انٹرویو میں کامیاب ہونے میں آپ کی مدد کرے گی۔