جاوا ۾ ايري کي ڪيئن ترتيب ڏيو

ترتيب ڏيڻ پروگرامنگ ۾ سڀ کان عام ۽ ضروري عملن مان هڪ آهي. اهو هڪ مخصوص ترتيب ۾ عناصر جي ڪجهه سيٽ جي ترتيب جي نمائندگي ڪري ٿو. هي مضمون جاوا ۾ صفن کي ترتيب ڏيڻ جي معياري طريقن بابت آهي.

مختصر طور تي ترتيب ڏيڻ بابت

تنهن ڪري، ترتيب ڏيڻ ڊيٽا جي هڪ سيٽ جي ترتيب آهي. اسان جي صورت ۾، arrays. صفن کي ترتيب ڏيڻ يا ٻين ڊيٽا جي جوڙجڪ جو مقصد اهو آهي ته گڏ ڪرڻ ۾ ڊيٽا کي ڳولڻ، ترتيب ڏيڻ، يا پارس ڪرڻ آسان بڻائي. پروگرامرز کي ترتيب ڏيڻ جي ضرورت آهي اڪثر ڪري ڪنهن به پروگرامنگ ٻولي ۾ ترتيب ڏنل طريقن، فهرستن، ۽ ٻين ترتيب ڏنل ڊيٽا جي جوڙجڪ کي ترتيب ڏيڻ لاء. اهڙن طريقن کي استعمال ڪرڻ لاء، انهن کي سڏيو. آپريشن کي ممڪن طور تي آسان ڪيو ويو آهي. عام طور تي، ٺاهيل طريقا وڌ ۾ وڌ بهتر ڪيا ويا آهن؛ اڪثر ڪيسن ۾، انهن کي توهان جي نوڪري يا منصوبن لاء استعمال ڪرڻ سٺو خيال آهي. بهرحال، تقريبن هر پروگرامر، انهن جي پڙهائي دوران، پاڻ کي ترتيب ڏيڻ واري الگورتھم کي لاڳو ڪرڻ جي ضرورت آهي. تنهن ڪري، اهي مڪمل مشق توهان کي سيکاريندا آهن پروگرامنگ جي بلڪل جوهر کي سمجهڻ. ان کان سواء، ڪڏهن ڪڏهن توهان کي ڪم ۾ غير معياري ترتيب جي طريقن جي ضرورت آهي. اتي ڪيترائي ترتيب ڏيڻ وارا الگورتھم آھن. انهن وٽ طاقت ۽ ڪمزوريون آهن ڊيٽا سيٽ جي قسم يا سائيز جي لحاظ سان. معياري ترتيب ڏيڻ واري الگورتھم ۾ بلبل جي ترتيب، چونڊ ترتيب، داخل ڪرڻ جي ترتيب، ضم ڪرڻ جي ترتيب، ۽ جلدي ترتيب شامل آھن.

جاوا ۾ صفن کي ترتيب ڏيڻ لاءِ تعمير ٿيل طريقو: Arrays.sort

اچو ته آسان سان شروع ڪريون. ڪنهن اڳ ۾ ئي اسان لاءِ جاوا ۾ صفن کي ترتيب ڏيڻ جو طريقو لکيو آهي. اهو طريقو Arrays ڪلاس ۾ آهي، خاص طور تي java.util.Arrays . هي ڪلاس مختلف طريقن تي مشتمل آهي صفن سان ڪم ڪرڻ لاءِ، جهڙوڪ ترتيب ڏيڻ ۽ ڳولهڻ. Arrays.sort طريقو جاوا ۾ صفن کي ترتيب ڏيڻ لاءِ آسان رستو مهيا ڪري ٿو، ڇا انھن ۾ تار، عدد، يا ٻيا عنصر شامل آھن . جاوا ۾ Arrays.sort طريقي جا ڪيترائي مختلف قسم آھن . هتي ڪجھ عام طور تي استعمال ٿيل آھن ترتيب ڏيڻ جا طريقا Arrays ڪلاس مان:

• Arrays.sort(Array) : ان کي استعمال ڪريو سرن کي ترتيب ڏيڻ لاءِ ابتدائي قسمن يا شين جي ترتيب ۾. اهو عناصر جي قدرتي ترتيب کي استعمال ڪري ٿو.
• Arrays.sort(Array, fromIndex, toIndex) : هي اوور لوڊ ٿيل ترتيب وارو طريقو توهان کي ترتيب ڏيڻ جي اجازت ڏئي ٿو صرف صفن جو هڪ حصو جيڪو بيان ڪيل fromIndex ۽ toIndex parameters.
• Arrays.sort(Array، comparator) : ھي ھڪڙي ترتيب ڏيڻ لاءِ آھي ھڪڙي ترتيب واري مقابلي کي استعمال ڪندي شين جي صفن کي ترتيب ڏيڻ لاءِ. موازنہ ڪندڙ عناصر جي ترتيب کي بيان ڪري ٿو.
• Arrays.parallelSort(Array) : هي طريقو ورزن 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);
        }
    }
}

پيداوار هتي آهي: ھن پروگرام ۾، پھريون، اسين درآمد ڪريون ٿا java.util.Arrays ڪلاس تائين رسائي حاصل ڪرڻ لاءِ Array.sort طريقي سان. ان کان پوءِ اسان هڪ اسٽرنگ ايري ٺاهيندا آهيون جنهن کي آلات سڏيو ويندو آهي جنهن ۾ موسيقي جا اوزار شامل هوندا آهن. ان کان پوء، اسين سڏين ٿا 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 () طريقو ھڪڙو موازنہ ڪندڙ موٽائي ٿو جيڪو عناصر جي قدرتي ترتيب کي رد ڪري ٿو. نوٽ ڪريو ته هتي، اسان استعمال ڪريون ٿا Integer wrapper class بدران primitive int قسم جي ڇاڪاڻ ته Comparator.reverseOrder() طريقي کي شيون گهرجن ٿيون. جيڪڏهن توهان وٽ پرائمري int قدرن جو هڪ صف آهي، توهان کي پڻ ضرورت پوندي ته انهن کي انٽيجر شين ۾ تبديل ڪرڻ کان پهريان هن طريقي کي استعمال ڪرڻ کان پهريان. حسب ضرورت موازنہ استعمال ڪندي، توھان آساني سان ترتيب ڏئي سگھوٿا ھيٺئين ترتيب ۾ Arrays.sort طريقو استعمال ڪندي جاوا ۾.

جاوا ۾ خود لکيل ڪلاسيڪل ترتيب ڏيڻ وارو الگورتھم

توھان اڳ ۾ ئي ڏٺو آھي Array ترتيب ڏيڻ واري اسائنمينٽس جيڪڏھن توھان پڙھي رھيا آھيو ڪمپيوٽر سائنس آزاديءَ سان يا يونيورسٽي ۾. اتي ڪيترائي مختلف ترتيب ڏيڻ وارا الگورتھم آھن، ۽ اسين انھن مان ڪجھ کي ھن مضمون ۾ لاڳو ڪنداسين. عام طور تي، هڪ الگورتھم کي لاڳو ڪرڻ آسان آهي، اهو گهٽ موثر آهي. پروگرامر ماپ ڪن ٿا الگورتھم جي ڪارڪردگيءَ جي ماپ ان جي آپريشن جي وقت ۽ ميموري جيڪا وسيلن تي خرچ ٿئي ٿي. اهو اسان جي مضمون جو موضوع ناهي، پر اسان اهو ذڪر ڪريون ٿا ته جاوا ۾ 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 + " ");
       }
   }
}

هتي پروگرام جو هڪ نتيجو آهي: اچو ته ان جي وضاحت ڪريون قدم بہ قدم. ٻاهرئين لوپ آري جي شروعات کان ٻئي کان آخري عنصر تائين (ن-1 تائين). هي لوپ هر هڪ عنصر کي هڪ هڪ ڪري چونڊيندو آهي شروعاتي نقطي جي طور تي ترتيب ڏنل حصي جي Array . ٻاهرئين لوپ جي اندر، اسان minIndex کي موجوده انڊيڪس i ۾ شروع ڪريون ٿا ، فرض ڪريون ٿا ته اهو سڀ کان ننڍي شيءِ جو انڊيڪس آهي Array جي اڻ ترتيب ڏنل حصي ۾ . اندروني لوپ i+1 کان شروع ٿئي ٿو ۽ Array جي آخري عنصر تائين وڃي ٿو . اهو هر عنصر کي موجوده گهٽ ۾ گهٽ عنصر ( arr[minIndex] ) سان مقابلو ڪندي Array جي غير ترتيب ڏنل حصي ۾ سڀ کان ننڍي شيءِ جي انڊيڪس ڳولهي ٿو . جيڪڏهن اسان هڪ عنصر ڳوليندا آهيون جيڪو موجوده گهٽ ۾ گهٽ عنصر کان ننڍو آهي، اسان minIndex کي نئين گهٽ ۾ گهٽ عنصر جي انڊيڪس ۾ تازه ڪاري ڪندا آهيون. اندروني لوپ مڪمل ٿيڻ کان پوء، اسان Array جي غير ترتيب ڏنل حصي ۾ گھٽ ۾ گھٽ عنصر جو انڊيڪس مليو آهي . اسان ان کان پوء گھٽ ۾ گھٽ عنصر کي تبديل ڪريون ٿا اڻ ترتيب واري حصي جي پهرين عنصر سان عارضي متغير temp استعمال ڪندي. ٻاهرئين لوپ جاري آهي جيستائين سڀني عناصر کي ترتيب نه ڏنو وڃي، تدريجي طور تي ترتيب ڏنل حصي کي وڌايو وڃي . آخرڪار، ترتيب ڏنل آري کي پرنٽ ڪيو ويو آهي مکيه طريقي سان چونڊ ڪرڻ کان اڳ ۽ بعد ۾ .

ضم ڪرڻ جي ترتيب

ضم ڪرڻ جي ترتيب هڪ تقسيم-۽-فتح الورورٿم آهي جيڪو بار بار ترتيب کي ورهائي ٿو ننڍڙن سبارريز ۾، انهن کي ترتيب ڏئي ٿو، ۽ پوءِ ترتيب ڏنل صف حاصل ڪرڻ لاءِ انهن کي ضم ڪري ٿو. ضم ڪرڻ جي ترتيب مستحڪم ۽ وڏي پيماني تي استعمال ٿيل آهي، خاص طور تي جڏهن استحڪام ۽ ضمانت جي بدترين صورت وقت جي پيچيدگي جي ضرورت آهي.

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 + " ");
        }
    }
}

پيداوار هتي آهي: اچو ته وڌيڪ وضاحت ڪريون ته اهو ڪيئن ڪم ڪري ٿو. الورورٿم آري کي ٻن حصن ۾ ورهائي ٿو بار بار جيستائين بيس ڪيس پهچي وڃي (جڏهن آري ۾ هڪ يا صفر عنصر هجي). ان کان پوء اهو ضم ڪرڻ واري طريقي سان ترتيب ڏنل اڌ کي گڏ ڪري ٿو. ضم ڪرڻ جو طريقو ٽن صفن کي انپٽ طور وٺي ٿو: اصل سري ۽ کاٻي ۽ ساڄي سباري (کاٻي ۽ ساڄي). اهو عناصرن کي کاٻي ۽ ساڄي ذيلي ذخيرو مان موازنہ ڪري ٿو ۽ ترتيب ڏنل ترتيب ۾ اصل صفن ۾ ضم ڪري ٿو .

داخل ٿيڻ جي ترتيب

Insertion Sort ڪم ڪري ٿو بار بار ھڪڙي عنصر کي غير ترتيب ڏنل حصي مان ان جي صحيح پوزيشن ۾ ترتيب ڏنل حصي ۾ داخل ڪرڻ سان. اهو ننڍڙو ڊيٽا سيٽ يا تقريبن ترتيب ڏنل ڊيٽا لاء سٺو ڪم ڪري ٿو.

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 algorithm لاڳو ڪري ٿو. اهو Array ذريعي ورجائي ٿو ۽ هر عنصر کي هڪ اهم سمجهي ٿو. اهو ان کان اڳ جي عنصرن سان ڪنجي جو مقابلو ڪري ٿو ۽ انهن کي هڪ پوزيشن اڳتي وڌائي ٿو جيڪڏهن اهي وڏا آهن، مؤثر طريقي سان عناصر کي منتقل ڪري ٿو ته جيئن صحيح پوزيشن تي چاٻي لاء ڪمرو ٺاهيو وڃي. ٻاهرئين لوپ ٻئي عنصر ( i = 1 ) کان آري جي آخري عنصر ڏانهن ورجائي ٿو. اندروني لوپ موجوده عنصر ( arr[i] ) کان شروع ٿئي ٿو ۽ پوئتي وڃي ٿو ( j = i - 1 ) جيستائين اهو چاٻي لاء صحيح پوزيشن ڳولي يا Array جي شروعات تائين پهچي . اندروني لوپ جي اندر، جيڪڏهن ڪو عنصر ( arr[j] ) ڪنجي کان وڏو آهي، ته ان کي هڪ پوزيشن اڳيان ( arr[j + 1] = arr[j] ) منتقل ڪيو وڃي ٿو ته ڪنجي لاءِ ڪمرو ٺاهيو وڃي. اهو عمل جاري آهي جيستائين چاٻي جي صحيح پوزيشن ملي ٿي. اندروني لوپ مڪمل ٿيڻ کان پوء، چيڪ صحيح پوزيشن تي رکيل آهي ( arr[j + 1] = key ). مکيه طريقي ۾، هڪ مثال جي ترتيب ٺاهي وئي آهي ۽ ترتيب ڏيڻ کان اڳ ۽ بعد ۾ داخل ٿيڻ سان ترتيب ڏيڻ جو طريقو استعمال ڪندي.

جلدي ترتيب

Quick Sort هڪ تقسيم ۽ فتح ڪرڻ وارو الگورٿم آهي جيڪو هڪ محور عنصر کي منتخب ڪري ٿو ۽ پيوٽ جي چوڌاري Array کي ورهائي ٿو. ضابطي جي طور تي، تڪڙي ترتيب ننڍي ۽ وچولي سائيز جي ڊيٽا سيٽن لاءِ ضم ڪرڻ جي ترتيب کان وڌيڪ تيز آھي ان جي گھٽ مسلسل فڪٽرن جي ڪري.

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 جي اعلي انڊيڪس. شروعات ۾، اهو چيڪ ڪري ٿو ته ڇا subarray هڪ کان وڌيڪ عنصر آهي. جيڪڏهن ائين آهي، اهو ورهاڱي جي طريقي سان استعمال ڪندي هڪ محور کي چونڊيندو آهي، بار بار ترتيب ڏئي ٿو سباري کي pivot کان اڳ، ۽ recursively pivot کان پوء subarray کي ترتيب ڏئي ٿو. ورهاڱي جو طريقو پيوٽ کي سباري جي آخري عنصر طور چونڊيندو آهي ( arr[high] ). اهو ورهاڱي واري انڊيڪس (i) کي گهٽ انڊيڪس مائنس 1 تي سيٽ ڪري ٿو. اهو پوءِ لوئي انڊيڪس کان هاءِ انڊيڪس - 1 ڏانهن ورجائي ٿو ۽ چيڪ ڪري ٿو ته هر عنصر پيوٽ کان گهٽ يا برابر آهي. جيڪڏهن ائين آهي، اهو عنصر کي تبديل ڪري ٿو عنصر سان ورهاڱي واري انڊيڪس (i) ۾ ۽ ورهاڱي واري انڊيڪس کي وڌايو. آخرڪار، اهو پيوٽ عنصر کي عنصر سان تبديل ڪري ٿو ورهاڱي واري انڊيڪس + 1 تي ۽ ورهاڱي واري انڊيڪس کي واپس ڪري ٿو. ورهاڱي جو طريقو پيوٽ کي سباري جي آخري عنصر طور چونڊيندو آهي ( arr[high] ). اهو ورهاڱي واري انڊيڪس (i) کي گهٽ انڊيڪس مائنس 1 تي سيٽ ڪري ٿو. اهو پوءِ لوئي انڊيڪس کان هاءِ انڊيڪس - 1 ڏانهن ورجائي ٿو ۽ چيڪ ڪري ٿو ته هر شئي ننڍي آهي يا پيوٽ جي برابر آهي. جيڪڏهن ائين آهي، اهو عنصر کي تبديل ڪري ٿو عنصر سان ورهاڱي واري انڊيڪس (i) ۾ ۽ ورهاڱي واري انڊيڪس کي وڌايو. آخرڪار، اهو پيوٽ عنصر کي عنصر سان تبديل ڪري ٿو ورهاڱي واري انڊيڪس + 1 تي ۽ ورهاڱي واري انڊيڪس کي واپس ڪري ٿو. swap طريقو ھڪڙو يوٽيلٽي طريقو آھي جيڪو Array ۾ ٻن عناصر کي مٽائڻ لاءِ استعمال ڪيو ويندو آھي . مکيه طريقي ۾ ، هڪ مثال صف ٺاهي وئي آهي ۽ ڇپيل آهي ترتيب ڏيڻ کان اڳ ۽ پوءِ QuickSort طريقو استعمال ڪندي.

نتيجو

هن آرٽيڪل مان توهان معلوم ڪيو آهي ته جاوا ٻولي ۾ هڪ صف کي ڪيئن ترتيب ڏيو. توھان استعمال ڪري سگھوٿا ھڪ ٺاھيل Arrays.sort طريقو يا پنھنجو پاڻ تي لاڳو ڪري سگھوٿا مقبول ترتيب ڏيڻ جا طريقا جيئن ته بلبل ترتيب، ضم ترتيب وغيره. توهان پڻ ڪوشش ڪري سگهو ٿا توهان جي پنهنجي ترتيب واري طريقي تي حملو ڪرڻ جي. اهو توهان جي ڪم تي منحصر آهي. جيڪڏھن توھان کي تڪڙو حل ڪرڻ جي ضرورت آھي ھڪڙي ترتيب واري مسئلي کي، صرف استعمال ڪريو اڳ-لکيل طريقو. جيڪڏهن توهان پروگرامنگ سکندا آهيو ۽ ان ۾ بهتر ٿيڻ جي ڪوشش ڪندا آهيو، اهو هڪ سٺو خيال آهي ته توهان پنهنجي طرفان ڪجهه ترتيب ڏيڻ جا طريقا لکو.