جاوا میں ایک صف کو کیسے ترتیب دیا جائے۔

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

چھانٹی کے بارے میں مختصراً

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

جاوا میں صفوں کو چھانٹنے کے لیے بلٹ ان طریقہ: Arrays.sort

آئیے سب سے آسان کے ساتھ شروع کریں۔ کسی نے پہلے ہی ہمارے لئے جاوا میں صفوں کو ترتیب دینے کا طریقہ لکھا ہے۔ یہ طریقہ Arrays کلاس میں ہے، خاص طور پر java.util.Arrays ۔ اس کلاس میں صفوں کے ساتھ کام کرنے کے مختلف طریقے ہیں، جیسے چھانٹنا اور تلاش کرنا۔ Arrays.sort طریقہ جاوا میں صف کو ترتیب دینے کا ایک آسان طریقہ فراہم کرتا ہے، چاہے وہ تار، عدد، یا دیگر عناصر پر مشتمل ہوں ۔ جاوا میں Arrays.sort طریقہ کے کئی تغیرات ہیں ۔ یہاں Arrays کلاس سے چھانٹنے کے کچھ عام استعمال شدہ طریقے ہیں :

• Arrays.sort(Array) : اس کا استعمال قدیم اقسام یا اشیاء کی صفوں کو صعودی ترتیب میں ترتیب دینے کے لیے کریں۔ یہ عناصر کی قدرتی ترتیب کا استعمال کرتا ہے۔
• Arrays.sort(Array, fromIndex, toIndex) : یہ اوور لوڈ شدہ ترتیب کا طریقہ آپ کو fromIndex اور toIndex کے پیرامیٹرز کے ذریعہ مخصوص کردہ ارے کے صرف ایک حصے کو ترتیب دینے کی اجازت دیتا ہے۔
• Arrays.sort(Array، comparator) : یہ ایک اپنی مرضی کے کمپیریٹر کا استعمال کرتے ہوئے اشیاء کی صفوں کو چھانٹنے کے لیے ہے۔ موازنہ کرنے والا عناصر کی ترتیب کی وضاحت کرتا ہے۔
• Arrays.parallelSort(Array) : یہ طریقہ ورژن ارے کو متوازی طور پر ترتیب دیتا ہے، بہتر کارکردگی کے لیے متعدد تھریڈز کا استعمال کرتا ہے۔ یہ بڑی صفوں کو چھانٹنے کے لیے فائدہ مند ہے۔
• Arrays.parallelSort(Array, fromIndex, toIndex) : parallelSort طریقہ کا یہ اوور لوڈ شدہ ورژن Array میں عناصر کی ایک مخصوص رینج کو ترتیب دینے کی اجازت دیتا ہے ۔

وہ آپ کو عناصر کو ان کی فطری ترتیب کی بنیاد پر یا حسب ضرورت موازنہ کا استعمال کرتے ہوئے تیزی سے ترتیب دینے کی اجازت دیتے ہیں۔ آئیے اس طریقہ کو دو مثالوں کے ساتھ دریافت کرتے ہیں، ایک میں تار شامل ہیں۔

مثال 1: تاروں کو چھانٹنا

فرض کریں کہ ہمارے پاس تار موسیقی کے آلات کی ایک صف ہے: "وائلن"، "وائلا"، "سیلو"، اور "ڈبل باس"۔ ہم انہیں حروف تہجی کے مطابق ترتیب دینے کے لیے Array.sort طریقہ استعمال کر سکتے ہیں۔

import java.util.Arrays;
//Arrays.sort example
public class StringSortExample {
    public static void main(String[] args) {
        String[] instruments = {"violin", "viola", "cello", "double bass"};

        Arrays.sort(instruments);

        System.out.println("Sorted Instruments:");
        for (String instrument : instruments) {
            System.out.println(instrument);
        }
    }
}

آؤٹ پٹ یہاں ہے: اس پروگرام میں، پہلے، ہم Array.sort طریقہ تک رسائی حاصل کرنے کے لیے java.util.Arrays کلاس درآمد کرتے ہیں۔ پھر ہم موسیقی کے آلات کے ناموں پر مشتمل آلات کے نام سے ایک سٹرنگ سرنی بناتے ہیں۔ اس کے بعد، ہم Arrays.sort(instruments) کہتے ہیں ۔ لہذا یہ طریقہ ایک صف حاصل کرتا ہے، عناصر کو ان کی قدرتی ترتیب (حروف تہجی) کی بنیاد پر صعودی ترتیب میں ترتیب دیتا ہے۔ آخر میں، ہم ترتیب شدہ ارے کے ذریعے لوپ کرتے ہیں اور ہر انسٹرومنٹ کو پرنٹ کرتے ہیں۔

مثال 2: انٹیجرز کو ترتیب دینا

آئیے ایک اور مثال پر غور کریں جہاں ہم صعودی ترتیب میں عدد کی ایک صف کو ترتیب دیتے ہیں۔

import java.util.Arrays;

public class IntegerSortExample {
    public static void main(String[] args) {
        int[] numbers = {8, 2, 7, 3, 1, 5};
//sort an array using Arrays.sort
        Arrays.sort(numbers);

        System.out.println("Sorted Numbers:");
        for (int number : numbers) {
            System.out.println(number);
        }
    }
}

آؤٹ پٹ: یہاں ہم متعدد غیر ترتیب شدہ عناصر کے ساتھ عدد نامی ایک عدد صف بناتے ہیں۔ اگلا، ہم Arrays.sort(نمبر) کو صعودی ترتیب میں ترتیب دینے کے لیے کہتے ہیں۔ نوٹ کریں کہ Array.sort طریقہ اصل صف میں جگہ جگہ ترمیم کرتا ہے۔ لہذا اصل Array کو رکھنے کے لیے ، ترتیب دینے سے پہلے ایک کاپی بنائیں۔

مثال 3: نزولی ترتیب

نزولی ترتیب کے بارے میں کیا خیال ہے؟ یہ Arrays.sort کے ساتھ بھی آسان ہے ۔ بس ایک حسب ضرورت موازنہ استعمال کریں۔ یہاں ایک مثال ہے:

import java.util.Arrays;
import java.util.Comparator;
//Arrays.sort with custom comparator example
public class DescendingSortExample {
    public static void main(String[] args) {
        Integer[] numbers = {8, 2, 7, 3, 1, 5};
        //sort an Array using Arrays.sort
        Arrays.sort(numbers, Comparator.reverseOrder());

        System.out.println("Sorted Numbers (Descending):");
        for (int number : numbers) {
            System.out.println(number);
        }
    }
}

آؤٹ پٹ اگلا ہے: یہاں ہمیں عدد نامی عدد کی ایک صف ملی ہے۔ Comparator.reverseOrder() کو Arrays.sort طریقہ کی دوسری دلیل کے طور پر پاس کرتے ہوئے ، ہم ایک حسب ضرورت موازنہ بتاتے ہیں جو عناصر کو نزولی ترتیب میں ترتیب دیتا ہے۔ Comparator.reverseOrder () طریقہ ایک comparator واپس کرتا ہے جو عناصر کی قدرتی ترتیب کو ریورس کرتا ہے۔ نوٹ کریں کہ یہاں، ہم پرائمیٹو انٹ ٹائپ کے بجائے انٹیجر ریپر کلاس استعمال کرتے ہیں کیونکہ Comparator.reverseOrder() طریقہ کو اشیاء کی ضرورت ہوتی ہے۔ اگر آپ کے پاس قدیم int اقدار کی ایک صف ہے، تو آپ کو اس نقطہ نظر کو استعمال کرنے سے پہلے ان کو انٹیجر اشیاء میں تبدیل کرنے کی بھی ضرورت ہوگی۔ حسب ضرورت موازنہ کا استعمال کرتے ہوئے، آپ جاوا میں Arrays.sort طریقہ استعمال کرتے ہوئے آسانی سے نزولی ترتیب میں ترتیب دے سکتے ہیں ۔

جاوا میں خود تحریر کردہ کلاسیکل چھانٹنے والے الگورتھم

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

بلبلا چھانٹنا

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

public class BubbleSort {

       public static void bubbleSort(int[] myArray) {
           int n = myArray.length;
           for (int i = 0; i < n - 1; i++) {
               for (int j = 0; j < n - i - 1; j++) {
                   if (myArray[j] > myArray[j + 1]) {
                       // Swap myArray[j] and myArray[j+1]
                       int temp = myArray[j];
                       myArray[j] = myArray[j + 1];
                       myArray[j + 1] = temp;
                   }
               }
           }
       }

       public static void main(String[] args) {
           int[] arr = {18, 28, 2, 7, 90, 45};

           System.out.println("Array before sorting:");
           for (int num : arr) {
               System.out.print(num + " ");
           }

           bubbleSort(arr);

           System.out.println("\nArray after sorting:");
           for (int num : arr) {
               System.out.print(num + " ");
           }
       }
}

یہاں طریقہ ان پٹ کے طور پر عدد کی ایک صف لیتا ہے۔ بیرونی لوپ 0 سے n-1 تک جاتا ہے۔ یہاں n صف کا سائز ہے۔ اندرونی لوپ ملحقہ عناصر کا موازنہ کرتا ہے۔ اگر آرڈر غلط ہے تو، طریقہ ان کو تبدیل کرتا ہے۔ یہ طریقہ کار اس وقت تک دہرایا جاتا ہے جب تک کہ پوری صف کو ترتیب نہ دیا جائے۔ یہاں ہمارے پروگرام کا ایک آؤٹ پٹ ہے:

انتخاب کی ترتیب

سلیکشن الگورتھم بار بار غیر ترتیب شدہ حصے سے سب سے چھوٹے عنصر کو تلاش کرکے اور اسے شروع میں رکھ کر ایک صف کو ترتیب دیتا ہے۔ آئیے اسے جاوا میں لکھتے ہیں:

public class SelectionSort {
   public static void selectionSort(int[] myArray) {
       int n = myArray.length;

       for (int i = 0; i < n - 1; i++) {
           int minIndex = i;

           // Find the index of the minimum element in the unsorted part of the array
           for (int j = i + 1; j < n; j++) {
               if (myArray[j] < myArray[minIndex]) {
                   minIndex = j;
               }
           }

           // Swap the minimum element with the first element of the unsorted part
           int temp = myArray[minIndex];
           myArray[minIndex] = myArray[i];
           myArray[i] = temp;
       }
   }

   public static void main(String[] args) {
       int[] arr = {18, 28, 45, 2, 90, 7};

       System.out.println("Array before sorting:");
       for (int num : arr) {
           System.out.print(num + " ");
       }

       selectionSort(arr);

       System.out.println("\nArray after sorting:");
       for (int num : arr) {
           System.out.print(num + " ");
       }
   }
}

یہاں پروگرام کا ایک آؤٹ پٹ ہے: آئیے اسے مرحلہ وار سمجھاتے ہیں۔ بیرونی لوپ ارے کے شروع سے دوسرے سے آخری عنصر تک (n-1 تک) اعادہ کرتا ہے۔ یہ لوپ ہر ایک عنصر کو ایک ایک کرکے Array کے غیر ترتیب شدہ حصے کے نقطہ آغاز کے طور پر منتخب کرتا ہے ۔ بیرونی لوپ کے اندر، ہم minIndex کو موجودہ انڈیکس i سے شروع کرتے ہیں، یہ فرض کرتے ہوئے کہ یہ Array کے غیر ترتیب شدہ حصے میں سب سے چھوٹی چیز کا انڈیکس ہے ۔ اندرونی لوپ i+1 سے شروع ہوتا ہے اور Array کے آخری عنصر تک جاتا ہے ۔ یہ ہر عنصر کا موجودہ کم از کم عنصر ( arr[minIndex] ) سے موازنہ کرکے ارے کے غیر ترتیب شدہ حصے میں سب سے چھوٹی شے کے اشاریہ کو تلاش کرتا ہے ۔ اگر ہمیں کوئی ایسا عنصر ملتا ہے جو موجودہ کم از کم عنصر سے چھوٹا ہے، تو ہم minIndex کو نئے کم از کم عنصر کے انڈیکس میں اپ ڈیٹ کرتے ہیں۔ اندرونی لوپ مکمل ہونے کے بعد، ہمیں Array کے غیر ترتیب شدہ حصے میں کم از کم عنصر کا انڈیکس مل گیا ہے ۔ اس کے بعد ہم ایک عارضی متغیر temp کا استعمال کرکے غیر ترتیب شدہ حصے کے پہلے عنصر کے ساتھ کم از کم عنصر کو تبدیل کرتے ہیں۔ بیرونی لوپ اس وقت تک جاری رہتا ہے جب تک تمام عناصر کو ترتیب نہیں دیا جاتا، آہستہ آہستہ Array کے ترتیب شدہ حصے کو بڑھاتا ہے ۔ آخر میں، سلیکشن سورٹ طریقہ کو کال کرنے سے پہلے اور بعد میں ترتیب شدہ اری کو مین طریقہ میں پرنٹ کیا جاتا ہے ۔

ترتیب کو ضم کریں۔

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

public class MergeSort {

      //Merge Sort array
      public static void mergeSort(int[] myArray) {
        if (myArray.length <= 1) {
            return;
        }

        int mid = myArray.length / 2;
        int[] left = new int[mid];
        int[] right = new int[myArray.length - mid];

        System.arraycopy(myArray, 0, left, 0, mid);
        System.arraycopy(myArray, mid, right, 0, myArray.length - mid);

        mergeSort(left);
        mergeSort(right);

        merge(myArray, left, right);
    }

    public static void merge(int[] arr, int[] left, int[] right) {
        int i = 0; // index for left subarray
        int j = 0; // index for right subarray
        int k = 0; // index for merged array

        while (i < left.length && j < right.length) {
            if (left[i] <= right[j]) {
                arr[k++] = left[i++];
            } else {
                arr[k++] = right[j++];
            }
        }

        while (i < left.length) {
            arr[k++] = left[i++];
        }

        while (j < right.length) {
            arr[k++] = right[j++];
        }
    }

    public static void main(String[] args) {
        int[] arr = {18, 2, 28, 7, 90, 45};

        System.out.println("Array before sorting:");
        for (int num : arr) {
            System.out.print(num + " ");
        }

        mergeSort(arr);

        System.out.println("\nArray after sorting:");
        for (int num : arr) {
            System.out.print(num + " ");
        }
    }
}

آؤٹ پٹ یہاں ہے: آئیے مزید واضح طور پر وضاحت کریں کہ یہ کیسے کام کرتا ہے۔ الگورتھم ارے کو بار بار دو حصوں میں تقسیم کرتا ہے جب تک کہ بیس کیس تک نہ پہنچ جائے (جب ارے میں ایک یا صفر عناصر ہوں)۔ پھر یہ انضمام کے طریقہ کار کا استعمال کرتے ہوئے ترتیب شدہ حصوں کو ایک ساتھ ملا دیتا ہے۔ ضم کرنے کا طریقہ ان پٹ کے طور پر تین صفیں لیتا ہے: اصل ارے اور بائیں اور دائیں ذیلی ریز (بائیں اور دائیں)۔ یہ بائیں اور دائیں ذیلی ریزوں سے عناصر کا موازنہ کرتا ہے اور ترتیب شدہ ترتیب میں انہیں اصل صف میں ضم کرتا ہے۔

اندراج کی ترتیب

انسرشن سورٹ غیر ترتیب شدہ حصے سے کسی عنصر کو ترتیب شدہ حصے میں اس کی صحیح پوزیشن میں بار بار داخل کرکے کام کرتا ہے۔ یہ چھوٹے ڈیٹا سیٹس یا تقریبا ترتیب شدہ ڈیٹا کے لیے اچھی کارکردگی کا مظاہرہ کرتا ہے۔

public class InsertionSort {
    public static void insertionSort(int[] myArray) {
        int n = myArray.length;

        for (int i = 1; i < n; i++) {
            int key = myArray[i];
            int j = i - 1;

            while (j >= 0 && myArray[j] > key) {
                myArray[j + 1] = myArray[j];
                j--;
            }

            myArray[j + 1] = key;
        }
    }

    public static void main(String[] args) {
        int[] arr = {18, 90, 7, 28, 45, 2};

        System.out.println("Array before sorting:");
        for (int num : arr) {
            System.out.print(num + " ");
        }

        insertionSort(arr);

        System.out.println("\nArray after sorting:");
        for (int num : arr) {
            System.out.print(num + " ");
        }
    }
}

پروگرام کا آؤٹ پٹ معمول کی طرح ہے: یہاں insertionSort طریقہ Insertion Sort الگورتھم کو نافذ کرتا ہے۔ یہ صف کے ذریعے اعادہ کرتا ہے اور ہر عنصر کو کلید سمجھتا ہے۔ یہ کلید کا اپنے سے پہلے کے عناصر سے موازنہ کرتا ہے اور اگر وہ زیادہ ہیں تو انہیں ایک پوزیشن آگے لے جاتا ہے، عناصر کو مؤثر طریقے سے منتقل کر کے کلید کو صحیح پوزیشن پر جگہ بناتا ہے۔ بیرونی لوپ دوسرے عنصر ( i = 1 ) سے ارے کے آخری عنصر تک دہراتا ہے۔ اندرونی لوپ موجودہ عنصر ( arr[i] ) سے شروع ہوتا ہے اور پیچھے کی طرف جاتا ہے ( j = i - 1 ) جب تک کہ اسے کلید کی صحیح پوزیشن نہ مل جائے یا Array کے آغاز تک نہ پہنچ جائے ۔ اندرونی لوپ کے اندر، اگر کوئی عنصر ( arr[j] ) کلید سے بڑا ہے، تو اسے ایک پوزیشن آگے ( arr[j + 1] = arr[j] ) منتقل کر دیا جاتا ہے تاکہ کلید کے لیے جگہ بنائی جا سکے۔ یہ عمل اس وقت تک جاری رہتا ہے جب تک کہ کلید کی صحیح پوزیشن نہ مل جائے۔ اندرونی لوپ مکمل ہونے کے بعد، کلید کو صحیح پوزیشن پر رکھا جاتا ہے ( arr[j + 1] = key )۔ مرکزی طریقہ میں، insertionSort طریقہ استعمال کرتے ہوئے ترتیب دینے سے پہلے اور بعد میں ایک مثال کی صف بنائی اور پرنٹ کی جاتی ہے۔

فوری ترتیب

Quick Sort ایک تقسیم اور فتح کرنے والا الگورتھم ہے جو ایک محور عنصر کو منتخب کرتا ہے اور محور کے ارد گرد صف کو تقسیم کرتا ہے۔ ایک اصول کے طور پر، Quick Sort چھوٹے اور درمیانے درجے کے ڈیٹا سیٹوں کے لیے ضم ہونے کی ترتیب سے زیادہ تیز ہے کیونکہ اس کے کم مستقل عوامل ہیں۔

public class QuickSort {

       public static void quickSort(int[] myArray, int low, int high) {
           if (low < high) {
               int pivotIndex = partition(myArray, low, high);
               quickSort(myArray, low, pivotIndex - 1);
               quickSort(myArray, pivotIndex + 1, high);
           }
       }

       public static int partition(int[] arr, int low, int high) {
           int pivot = arr[high];
           int i = low - 1;

           for (int j = low; j < high; j++) {
               if (arr[j] <= pivot) {
                   i++;
                   swap(arr, i, j);
               }
           }

           swap(arr, i + 1, high);
           return i + 1;
       }

       public static void swap(int[] arr, int i, int j) {
           int temp = arr[i];
           arr[i] = arr[j];
           arr[j] = temp;
       }

       public static void main(String[] args) {
           int[] arr = {18, 28, 2, 90, 7, 45};

           System.out.println("Array before sorting:");
           for (int num : arr) {
               System.out.print(num + " ");
           }

           quickSort(arr, 0, arr.length - 1);

           System.out.println("\nArray after sorting:");
           for (int num : arr) {
               System.out.print(num + " ");
           }
       }
}

آؤٹ پٹ یہاں ہے: تو یہاں ہمارے پاس فوری ترتیب کو نافذ کرنے کے تین طریقے ہیں۔ QuickSort طریقہ تین پیرامیٹرز لیتا ہے: ترتیب دینے کے لیے Array ، subarray کا کم انڈیکس، اور subarray کا ہائی انڈیکس۔ ابتدائی طور پر، یہ چیک کرتا ہے کہ آیا سبیری میں ایک سے زیادہ عنصر ہیں۔ اگر ایسا ہے تو، یہ پارٹیشن کا طریقہ استعمال کرتے ہوئے ایک محور کا انتخاب کرتا ہے، پیوٹ سے پہلے ذیلی رے کو بار بار ترتیب دیتا ہے، اور پیوٹ کے بعد سبیری کو بار بار ترتیب دیتا ہے۔ تقسیم کا طریقہ پیوٹ کو ذیلی رے ( arr[high] ) کے آخری عنصر کے طور پر منتخب کرتا ہے ۔ یہ پارٹیشن انڈیکس (i) کو کم انڈیکس مائنس 1 پر سیٹ کرتا ہے۔ یہ پھر کم انڈیکس سے ہائی انڈیکس - 1 پر دہرتا ہے اور چیک کرتا ہے کہ آیا ہر عنصر محور سے کم یا برابر ہے۔ اگر ایسا ہے تو، یہ عنصر کو پارٹیشن انڈیکس (i) کے عنصر کے ساتھ تبدیل کرتا ہے اور پارٹیشن انڈیکس کو بڑھاتا ہے۔ آخر میں، یہ پیوٹ عنصر کو پارٹیشن انڈیکس + 1 کے عنصر کے ساتھ تبدیل کرتا ہے اور پارٹیشن انڈیکس واپس کرتا ہے۔ تقسیم کا طریقہ پیوٹ کو ذیلی رے ( arr[high] ) کے آخری عنصر کے طور پر منتخب کرتا ہے ۔ یہ پارٹیشن انڈیکس (i) کو کم انڈیکس مائنس 1 پر سیٹ کرتا ہے۔ یہ پھر کم انڈیکس سے ہائی انڈیکس - 1 پر اعادہ کرتا ہے اور چیک کرتا ہے کہ آیا ہر آئٹم محور سے چھوٹا ہے یا برابر ہے۔ اگر ایسا ہے تو، یہ عنصر کو پارٹیشن انڈیکس (i) کے عنصر کے ساتھ تبدیل کرتا ہے اور پارٹیشن انڈیکس کو بڑھاتا ہے۔ آخر میں، یہ پیوٹ عنصر کو پارٹیشن انڈیکس + 1 کے عنصر کے ساتھ تبدیل کرتا ہے اور پارٹیشن انڈیکس واپس کرتا ہے۔ swap طریقہ ایک افادیت کا طریقہ ہے جو Array میں دو عناصر کو تبدیل کرنے کے لیے استعمال کیا جاتا ہے ۔ مرکزی طریقہ میں ، QuickSort طریقہ استعمال کرتے ہوئے ترتیب دینے سے پہلے اور بعد میں ایک مثال کی صف بنائی اور پرنٹ کی جاتی ہے ۔

نتائج

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