Bubble Sorting

आज हम बबल सोर्ट का प्रोग्राम जावा में बनायेगे । हम इसको इतनी बारीकी से सीखेंगे की आज के बाद आपको इस प्रोग्राम को किसी भी कंप्यूटर भाषा में बनाने में कोई परेशानी नहीं होगी ।
उदहारण के लिए एक अर्रे लीजिये "5 1 4 2 8" और इसको सोर्ट कीजिये छोटे से बड़े नंबर की तरफ बबल सोर्ट के द्वारा ।
हर स्टेप में , नंबर जो बोल्ड में लिखे हुए है उन्हें compare करेंगे  और उसके लिए हमे तीन पास की आवश्यकता है ।
पहला पास:
( 5 1 4 2 8 )  ( 1 5 4 2 8 ), यहाँ पर अल्गोरिथम पहले दो नंबर को compare करेगी और फिर उन्हें स्वेप करेगी ।
( 1 5 4 2 8 )  ( 1 4 5 2 8 ), Swap करो क्यों की  5 > 4
( 1 4 5 2 8 )  ( 1 4 2 5 8 ), Swap करो क्यों की  5 > 2
( 1 4 2 5 8 )  ( 1 4 2 5 8 ), यहाँ पर क्यों की सारे एलेमेन्ट पहले से ही आर्डर में है( 8 > 5 ) इसीलिए अल्गोरिथम उन्हें स्वप नहीं करेगी ।

दूसरा पास :
( 1 4 2 5 8 )  ( 1 4 2 5 8 )
( 1 4 2 5 8 )  ( 1 2 4 5 8 ), Swap करे क्यों की  4 > 2
( 1 2 4 5 8 )  ( 1 2 4 5 8 )
( 1 2 4 5 8 )  ( 1 2 4 5 8 )

यहाँ अल्गोरिथम पहले से ही स्वप हो चुकी पर क्यों की उसे इसका पता नहीं है , इसीलिए वोह यह पूरा पास चलेगी नंबर में बिना कोई परिवर्तन किये ।
तीसरा  Pass:
( 1 2 4 5 8 )  ( 1 2 4 5 8 )
( 1 2 4 5 8 )  ( 1 2 4 5 8 )
( 1 2 4 5 8 )  ( 1 2 4 5 8 )

( 1 2 4 5 8 )  ( 1 2 4 5 8 )


/*
       जावा का बबल सोर्ट का example
        इस example से हमे यह पता लगेगा की बबल सोर्ट से हम integers को कैसे सोर्ट करते है । बबल सोर्ट सोर्टिंग अल्गोरिथम में सबसे आसन है ।
*/

public class BubbleSort {

        public static void main(String[] args) {
             
                //integer अर्रे जिसे हम सोर्ट करना चाहते है
                int intArray[] = new int[]{5,1,4,2,8};
             
                //सोर्टिंग से पहले इस अर्रे को प्रिंट कराये
                System.out.println("Array Before Bubble Sort");
                for(int i=0; i < intArray.length; i++){
                        System.out.print(intArray[i] + " ");
                }
             
                //bubble sort अल्गोरिथम के द्वारा अर्रे को सोर्ट करने वाला function
                bubbleSort(intArray);
             
                System.out.println("");
             
                // bubble sort अल्गोरिथम के बाद अर्रे को प्रिंट करना
                System.out.println("Array After Bubble Sort");
                for(int i=0; i < intArray.length; i++){
                        System.out.print(intArray[i] + " ");
                }

        }

        private static void bubbleSort(int[] intArray) {
             
                /*
                 *  bubble सोर्ट में हम अर्रे को पहले नंबर से  traverse करते है
                 * और  array_length - 1 तक compare करते रहते है  and और हर एलिमेंट को उसके अगले नंबर
                 *  से compare किया जाता है
                 * नंबर को स्वेप अगले नंबर से स्वेप करे अगर अगला नंबर बड़ा हो ।
                 *
                 * Bubble sort की स्टेप्स इस प्रकार है
                 *
                 * 1. Compare array[0] & array[1]
                 * 2. If array[0] > array [1] swap it.
                 * 3. Compare array[1] & array[2]
                 * 4. If array[1] > array[2] swap it.
                 * ...
                 * 5. Compare array[n-1] & array[n]
                 * 6. if [n-1] > array[n] then swap it.
                 *
                 * इस स्टेप के बाद आखरी इंडेक्स में हमे सबसे बड़ा नंबर मिलेगा
                 *
                 * इसी स्टेप को repeat करो  array[1] to array[n-1]
                 *
                 */
             
                int n = intArray.length;
                int temp = 0;
             
                for(int i=0; i < n; i++){
                        for(int j=1; j < (n-i); j++){
                             
                                if(intArray[j-1] > intArray[j]){
                                        //swap the elements!
                                        temp = intArray[j-1];
                                        intArray[j-1] = intArray[j];
                                        intArray[j] = temp;
                                }
                             
                        }
                }
     
        }
}

/*
बबल सोर्ट का output इस प्रकार होगा

Array Before Bubble Sort
5 1 4 2 8
Array After Bubble Sort
1 2 4 5 8

*/