For loop

फॉर लूप को समझने के लिए पहले आपको कुछ प्रश्नो के उत्तर देने होगे :

फॉर लूप की हमे क्या जरूरत है |

बिलकुल सही , कोई जरूरत नहीं है , अगर हमारे प्रोग्रामर जी एक ही बात को कही  कही बार लिखने को तैयार हो तो , हम बिना फॉर लूप के भी आपना काम कर सकते है | जैसे 

अगर हमे २ का पहाडा जावा में लिखना हो तो हम सिस्टम.आउट.प्रिंट से इसको इस प्रकार लिख सकते है :

System.out.println("2 * 1 = 2");

System.out.println("2 * 2 = 4");

System.out.println("2 * 3 = 6");

System.out.println("2 * 4 = 8");

System.out.println("2 * 5 = 10");

System.out.println("2 * 6 = 12");

System.out.println("2 * 7 = 14");

System.out.println("2 * 8 = 16");

System.out.println("2 * 9 = 18");

System.out.println("2 * 10 = 20");

लेकिन हमारे प्रोग्रामर जी को और भी बहुत काम है ,एवं उन्हें १० बार नहीं हजारो बार एक बात को लिखना पड़ता है , तो उन्होने फॉर लूप को बनाया और बाकी काम उस पर छोड़ दिया |


class ForLoop
{
public static void main(String args[]) {
int i,j;
for(i=1;i<=10;i++) {

System.out.println("2 *"+ i + "="+ 2*i);
}




}



}

Selection Sort

Selection सोर्ट सर्चिंग और सोर्टिंग का मेल है 

हर पास में , बिना जमा हुआ नंबर जो सबसे छोटा या सबसे बड़ा हो , वो अपनी सही जगह पर जमा दिया जाता है ।selection सोर्ट को हमे अर्रे के कुल नम्बरों की संख्या से एक कम बार चलाना पड़ता है । इस सोर्ट में दो लूप होते है । अंदर वाला लूप तो अगली छोटी या बड़ी संख्या का पता लगता है और बाहर वाला लूप उसको उसकी सही जगह पर रख देता है ।

उदहारण के लिए निचे दिया हुआ अर्रे देखिये : 

64 25 12 22 11 <- हमारे पास शुरू में यह अर्रे है 

11 25 12 22 64 <-पहले पास में हमने 64 को अर्रे के हर एलिमेंट से compare किया और उसको उसकी सही जगह पर जमा दिया जो आखिर वाली या 

11 12 25 22 64 <- दुसरे पास में हमने पहले एलिमेंट को दुसरे से compare किया और पाया की यह ठीक जमे हुए है , उसके बाद हमने दुसरे एलिमेंट को ऊपर वाले  अर्रे में  (25) को 12 से compare किया और फिर उनको ठीक से जमा दिया 

11 12 22 25 64 <- अब हमे 22 को 25 से compare किया और उनकी position को ठीक क्या 

11 12 22 25 64 <- अंत में हमारे पास sorted अर्रे है , जो हमारा पहला लक्ष्य था ।

// SelectionSort.java - integer अर्रे को सोर्ट करने का तरीका 
class SelectionSort {
  public static void main(String[] args) {
    int[] a = {11,12,22,25,64};

    sort(a);
    for (int i = 0; i < a.length; i++){
      System.out.println(a[i]);
    }
  }
  // sort function जो अर्रे को क्रम अनुसार जमाएगा 
  static void sort(int[] data) {
    int   next, indexOfNext;

    for (next = 0; next < data.length - 1; next++) {
      indexOfNext = min(data,next,data.length - 1);
      swap(data, indexOfNext, next);
    }
  }
  // दी गए सभी इंडेक्स में से  
  // सबसे छोटे एलेमेन्ट की इंडेक्स का पता लगाना
  static int min(int[] data, int start, int end) {
    int indexOfMin = start; // initial guess

    for (int i = start+1; i <= end; i++)
      if (data[i] < data[indexOfMin])
        indexOfMin = i; // found a smaller value
    return indexOfMin;
  }
  // अर्रे की entries की अदला बदली करना 
  static void swap(int[] data, int first, int second){
    int temp;

    temp = data[first];
    data[first] = data[second];
    data[second] = temp;
  }
}

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

*/

Harmonic Series

हारमोनिक series वो series होती है जो लयबद्ध(संगीत में ) तरीके से लिखी जाती है । ऊपर दी गयी series को देख कर हम यह पता लगा सकते है की इसमें १०० वा नंबर क्या होगा? इसी प्रकार अगर में आपसे इन १०० नंबर का जोड़निकालने को कहू तो भी आप निकाल सकते है । हम यहाँ ऐसा प्रोग्राम बना रहे है जो यह जोड़ हमारे लिए निकाल सकता है ।

/*************************************************************************
 *  Compilation:  javac Harmonic.java
 *  Execution:    java Harmonic N
 *  
 *  इस हारमोनिक क्रम का N नंबर तक का जोड़ प्रिंट करेगा: 1/1 + 1/2 + ... + 1/N.

 * 
 *  % java Harmonic 10
 *  2.9289682539682538
 *
 *  % java Harmonic 10000
 *  9.787606036044348
 *
 *************************************************************************/

public class Harmonic { 
    public static void main(String[] args) { 

        // command-line पर दी गयी संख्या 
        int N = Integer.parseInt(args[0]);

        // compute 1/1 + 1/2 + 1/3 + ... + 1/N
        double sum = 0.0;
        for (int i = 1; i <= N; i++) {
            sum += 1.0 / i;
        }

        // Nth harmonic नंबर प्रिंट करेगा 
        System.out.println(sum);
    }

}

Introduction of While loop

While लूप बहुत ही महत्वपूर्ण लूप है . इस लूप को हम जब तब चलाते है जब तक की इस लूप के अंदर 

की condition false नहीं हो जाती । जैसे की हमे दो दी टेबल लिखनी है तो हम प्रोग्राम को बता सकते है

की हम टेबल तब तक प्रिंट करना चाहते है जब तक i की value १० नहीं हो जाये| 

इस प्रोग्राम में हम २ की टेबल प्रिंट करेंगे . यह बहुत आसन प्रोग्राम है आप इसको एक बार बनाये और

फिर इसको समझने की कोशिश करे तो आपको While लूप का महत्व भी पता लग जाएगा । 

/*************************************************************************
 *  Compilation:  javac TwoTable.java
 *  Execution:    java TwoTable
 * 
 *  दो की टेबल प्रिंट करो जब तक इ की value १० ना हो जाए । इन values के लिए i = 1 to 10. 
 *  इस काम को हम While लूप के साथ करेंगे और समझेंगे की बार बार repeat होने वाले काम को While 
 *  लूप से कैसे किया जा सकता है ।
 *  % java TwoTable
 *  2 * 1 = 2
 *  2 * 2 = 4 

 *  2 * 3 = 6
 *  2 * 4 = 8
 *  2 * 5 = 10 
 *  2 * 6 = 12

 *  2 * 7 = 14

 *  2 * 8 = 16 

 *  2 * 9 = 18 
 *  2 * 10 = 20
 

 *
 *************************************************************************/

public class TwoTable { 
   public static void main(String[] args) {

      // पुराना तरीका while लूप के बिना  
      System.out.println("2 * 1 = 2");
      System.out.println("2 * 2 = 4");
      System.out.println("2 * 3 = 6");

      // बची हुई टेबल नए तरीके के साथ जिसमे हम while लूप का उसे करेंगे 
      int i = 4;
      while (i <= 10) {
         System.out.print("2 * " + i + " = "); 
   System.out.println(2*i);
         i = i + 1;
      }

   }
}

सम्भंदित विडियो: