सम्मिलन जावा में क्रमबद्ध करें

छँटाई सरणियाँ सबसे आम ऑपरेशनों में से एक है जिसे जावा शुरुआती को पता होना चाहिए कि कैसे करना है। हालाँकि सरणियाँ हमेशा डेटा को व्यवस्थित करने का सबसे सुविधाजनक तरीका नहीं होती हैं और यह ज्यादातर छोटी संख्याओं पर लागू होता है, सरणी छँटाई के पीछे की अवधारणा में जटिल सॉफ़्टवेयर और डेटा विज्ञान में बहुत सारे अनुप्रयोग हैं। इस पोस्ट में, हम विस्तार से देखेंगे कि इंसर्शन सॉर्ट क्या है। इस अवधारणा को समझने में आपकी मदद करने के लिए हमने कुछ उदाहरण और अभ्यास समस्याएं शामिल की हैं।

सम्मिलन क्रम क्या है?

मूल रूप से, सम्मिलन छँटाई एक एल्गोरिथ्म है जिसका उपयोग डेवलपर्स छोटी संख्याओं के तार को व्यवस्थित करने के लिए करते हैं। यह सभी मानों को दो स्टैक में विभाजित करता है - एक सॉर्ट किया गया और एक अनसोर्टेड। एक-एक करके, "अनसोर्टेड" स्टैक में संख्याएँ निकाली जाती हैं और सही क्रम में रखी जाती हैं। आइए सम्मिलन प्रकार के इनपुट और आउटपुट पर करीब से नज़र डालें:

• इनपुट: अवर्गीकृत सांख्यिक तत्वों के साथ एक सरणी A: A[0,1, n, n-2...]।
• आउटपुट: एक सरणी जिसमें समान संख्याएँ होती हैं लेकिन पूरी तरह से क्रमबद्ध होती हैं। इसे आमतौर पर B: B[0]B[1]...B[n-1] कहा जाता है।

सम्मिलन छँटाई का उपयोग करने के कुछ मुट्ठी भर तरीके हैं - यहाँ सबसे लोकप्रिय हैं:

• संख्यात्मक छँटाई (बढ़ते क्रम): [1, 2, 3, 4, 5]
• संख्यात्मक छँटाई (घटता क्रम): [5, 4, 3, 2, 1]
• वर्णानुक्रमिक छँटाई: [ए, बी, सी, डी]

नोट: यदि आपके पास एक खाली सरणी या सिंगलटन है, तो इन्हें डिफ़ॉल्ट रूप से क्रमबद्ध माना जाता है।

सम्मिलन छँटाई के सिद्धांत को समझना

इंसर्शन सॉर्ट के पीछे के कोड की खोज करने से पहले, आइए गैर-तकनीकी भाषा का उपयोग करके एल्गोरिथम को तोड़ दें। क्योंकि हम आरोही क्रम में छँटाई के लिए कोड दिखा रहे हैं, यह इस पोस्ट में चरण दर चरण एल्गोरिथ्म की व्याख्या करने के लिए समझ में आता है। चरण 1.arr[1] बीच में और arr[n]कहाँ पर पुनरावृत्ति nएक संख्यात्मक मान है जो आमतौर पर 10 से कम होता है। चरण 2. विधि का keyउपयोग करके अनुक्रम में पिछली संख्या के लिए आपके द्वारा चुने गए तत्व (जिसे ) के रूप में जाना जाता है, की तुलना करें। चरण 3। यदि सभी तत्व उनके उत्तराधिकारी से छोटे हैं, तो तुलना को तब तक दोहराएं जब तक आपको बड़ा मूल्य न मिल जाए। चरण 4. ऑर्डर किए गए अनुक्रम को बनाने के लिए बड़े मान को छोटे वाले से एक स्थान पर स्वैप करें। sort()चरण 5। इस प्रक्रिया को तब तक दोहराएं जब तक कि आपको वर्णों की एक क्रमबद्ध स्ट्रिंग न मिल जाए

आदिम सरणियों को छाँटना

चूंकि एल्गोरिद्म सबसे सरल जावा संचालनों में से एक है, यहां तक ​​कि पूर्ण शुरुआती लोगों को इसे लागू करने में ज्यादा परेशानी नहीं होनी चाहिए। यहां किसी सरणी को क्रमबद्ध करने के लिए चरण-दर-चरण मार्गदर्शिका दी गई है

1. छँटाई के लिए एक सरणी घोषित करें

आरंभ करने के लिए, आइए मूल्यों की एक स्ट्रिंग बनाएं जिसे हम बाद में जावा का उपयोग करके प्रदर्शित करेंगे। सम्मिलन प्रकार का उपयोग करने के लिए, आपको एक सरणी बनाने की आवश्यकता है। उसके लिए, प्रयोग करेंint[]

int[] arrayA = {10, 14, 20, 30};

2. एल्गोरिथ्म को लागू करने के लिए Sort_arr का उपयोग करें

सम्मिलन प्रकार को लागू करने के लिए Sort_arr विधि सबसे सामान्य तरीकों में से एक है। व्यवहार में, ऐसा दिखता है:

for(int i=0; i< sort_arr.length; ++i){
        int j = i;

3. एक लूप और एक पुनरावर्तक बनाएँ

सम्मिलन छँटाई एल्गोरिथ्म में एक लूप का उपयोग करके, डेवलपर्स को प्रत्येक तत्व के लिए तर्क को दोहराना नहीं पड़ता है। हालांकि लूप बनाना जटिल लगता है, यह काफी सरल है - यहाँ एक उदाहरण दिया गया है:

for(int i=0; i< sort_arr.length; ++i){

अब जब आपके पास कार्यशील लूप है, तो यह एक पुनरावर्तक बनाने का समय है जो वांछित क्रम में सभी तत्वों को सॉर्ट करेगा। अब से, हम पुनरावर्तक को " j" के रूप में संदर्भित करेंगे।

int j = i;

4. "जबकि लूप" बनाना

जब सम्मिलन क्रम की बात आती है, तो एक नए, क्रमबद्ध सरणी के लिए "जबकि" लूप आवश्यक होता है। आरोही-क्रम सम्मिलन प्रकार के लिए इसे सेट अप करने के लिए, एक डेवलपर को दो शर्तों का पालन करने की आवश्यकता होती है:

• J को असाइन किया गया मान 0 से अधिक होना चाहिए
• निर्दिष्ट मान इंडेक्स j-1से अधिक होना चाहिएj

जैसे ही लूप में दोनों स्थितियां सत्य होती हैं, सरणी का कुंजी मान jइंडेक्स के बराबर होगा।

5. सरणी छँटाई

आपके द्वारा while लूप सेट करने के बाद, and jमानों j-1की अदला-बदली तब तक की जाएगी जब तक कि while लूप में एक या दोनों स्थितियाँ विफल नहीं हो जातीं। इसी तरह, लूप के लिए प्रत्येक मान के लिए छँटाई दोहराई जाएगी जब तक कि फॉर-लूप की स्थिति भी विफल नहीं हो जाती। यहां बताया गया है कि इंसर्शन सॉर्ट की प्रक्रिया व्यवहार में कैसे काम करती है:

int key = sort_arr[j];
          sort_arr[j] = sort_arr[j-1];
          sort_arr[j-1] = key;
          j = j-1;

एक ArrayList को सॉर्ट करना

यद्यपि सम्मिलन छँटाई के पीछे के गणित को समझना महत्वपूर्ण है, जब यह वास्तविक जीवन के सॉफ़्टवेयर विकास की बात आती है, तो आप आदिम सरणियों में अनुक्रमों की तुलना में बहुत अधिक ArrayLists को क्रमबद्ध करेंगे। यहाँ एक ArrayList को सॉर्ट करने के लिए चरण-दर-चरण मार्गदर्शिका दी गई है:

1. Elementसंग्रह से संबंधित वस्तुओं के लिए एक नई कक्षा बनाएँ ।

   public class Element {
       private int id;
   
       public Element(int id) {
           this.id = id;
       }

2. एक संग्रह के भीतर, एक विधि है compareTo()- हम इसका उपयोग दो तत्वों की आईडी की तुलना करने के लिए करेंगे।

   public int compareTo(Element element) {
           int res = 0;
           if (this.id < element.getId()) {
               res = -1;
           }
           if (this.id > element.getId()) {
               res = 1;
           }
           return res;
       }
   }

3. एल्गोरिदम लागू करें और वस्तुओं की ArrayListतुलना करने के बजाय उन्हें सॉर्ट करने के लिए कुछ लूप बनाएं।

   public static void insertionSortArrayList(List<element> list) {
       for (int j = 1; j < list.size(); j++) {
           Element current = list.get(j);
           int i = j-1;
           while ((i > -1) && ((list.get(i).compareTo(current)) == 1)) {
               list.set(i+1, list.get(i));
               i--;
           }
           list.set(i+1, current);
       }
   }

4. जैसा कि नीचे दिखाया गया है, आप और भी तत्व जोड़ सकते हैं ArrayList:

   List<element> list = new ArrayList<>();
   
   // Create elements w/ IDs 0-24
   for (int i = 0; i < 25; i++) {
       list.add(new Element(i));
   }
   
   // To use insertion sort, shuffle the values
   Collections.shuffle(list);

5. अब छँटाई का समय आ गया है:

   // This helps print values before sorting
   list.forEach(e -> System.out.print(e.getId() + ", "));
   
   // Sort the list
   insertionSortArrayList(list);
   
   System.out.println();
   
   // Display a sorted array
   list.forEach(e -> System.out.print(e.getId() + ", "));

6. अब यह सुनिश्चित करने के लिए कि हमने कोई गलती नहीं की है, इनपुट और आउटपुट की तुलना करते हैं। यहाँ हम एक उदाहरण के रूप में उपयोग की जाने वाली स्ट्रिंग की तुलना कर रहे हैं।

   4, 2, 6, 7, 0, 5, 9, 1, 8, 3,
   0, 1, 2, 3, 4, 5, 6, 7, 8, 9,

निवेशन छँटाई अभ्यास समस्याएँ

अब जब आप इस छँटाई एल्गोरिथम में महारत हासिल कर चुके हैं, तो यह आपके सैद्धांतिक और व्यावहारिक कौशल का परीक्षण करने का समय है। सिद्धांत प्रश्नोत्तरी #1 आपको एक सरणी [1, 4, 6, 8] दी गई है और इसमें एक नया तत्व n = 7 जोड़ रहे हैं। संख्याओं का क्रमबद्ध क्रम प्राप्त करने के लिए आपको कितनी तुलना करनी होगी? सरणी में अनुक्रमणिका n का अंतिम मान इंगित करें। थ्योरी क्विज़ #2 एक जॉब इंटरव्यू में, एक टीम लीड आपसे यह साबित करने के लिए कहती है कि सॉर्ट इंसर्शन एक अक्षम तरीका है। [0, 3, 6, 8, 9] की एक अंकीय स्ट्रिंग को देखते हुए, छँटाई के लिए आवश्यक रनिंग टाइम को अधिकतम करने के लिए आपके इनपुट अनुक्रम का क्रम क्या होना चाहिए? अभ्यास समस्या जावा के लिए सम्मिलन प्रकार का उपयोग करके [0, 1, 4, 5, 2, 3, 7, 9, 8] सरणी को उसके आरोही क्रम में क्रमबद्ध करें।

निष्कर्ष

सम्मिलन प्रकार को समझने में सबसे बड़ी चुनौती यह समझने में है कि प्रक्रिया कैसे काम करती है। एक बार जब आप इसमें महारत हासिल कर लेते हैं, तो टेम्पलेट को कोड में बदलना केक का एक टुकड़ा है। जब तक आप अभ्यास करते हैं और समय के साथ प्रासंगिक अभ्यास समस्याओं पर दोबारा गौर करते हैं, आप अपनी प्रविष्टि सॉर्ट गति में तेजी से सुधार करेंगे।