जावा बबल सॉर्ट कैसे लिखें
जब प्रोग्रामर बबल प्रकार के बारे में बात करते हैं, तो वे पानी के बुलबुले के बारे में बात नहीं कर रहे हैं जो आपने शायद अपने जीवन में किसी बिंदु पर उड़ाए हैं। वे एक सॉर्टिंग एल्गोरिदम के बारे में बात कर रहे हैं जिसका उपयोग वस्तुओं की सूची को ऑर्डर करने के लिए किया जाता है।
इस गाइड में, हम बबल प्रकारों के बारे में बात करने जा रहे हैं और वे कैसे काम करते हैं। हम जावा का उपयोग करके बबल सॉर्ट को लागू करेंगे ताकि आप समझ सकें कि यह एल्गोरिथम कोड में कैसे अनुवाद करता है। आगे की हलचल के बिना, आइए जावा बबल प्रकारों में गोता लगाएँ!
जावा बबल सॉर्ट क्या है?
बबल सॉर्ट एक एल्गोरिथ्म है जो आसन्न तत्वों की तुलना करके और गलत क्रम में दिखाई देने पर उन्हें स्वैप करके मूल्यों को सॉर्ट करता है।
यह प्रक्रिया तब तक दोहराई जाती है जब तक कि सूची में प्रत्येक आइटम को सही ढंग से क्रमित नहीं किया जाता है। किसी सूची को आरोही या अवरोही क्रम में क्रमबद्ध करने के लिए बबल प्रकार का उपयोग किया जा सकता है।
बबल प्रकार एल्गोरिदम कक्षाओं में पढ़ाया जाने वाला पहला प्रकार है। ऐसा इसलिए है क्योंकि उन्हें अन्य प्रकारों की तुलना में समझना आसान है, जैसे कि सम्मिलन प्रकार या चयन प्रकार, और सॉर्टिंग एल्गोरिदम के लिए एक अच्छा परिचय प्रदान करते हैं।
बबल प्रकार सबसे प्रभावी होते हैं जब डेटा पहले से ही लगभग सॉर्ट किया जाता है। हालांकि, यदि आपका डेटा बिल्कुल भी सॉर्ट नहीं किया गया है, तो अन्य प्रकार का सॉर्ट अधिक कुशल हो सकता है।
बबल सॉर्ट कैसे काम करते हैं?
इससे पहले कि हम जावा बबल सॉर्ट के लिए कोड लिखना शुरू करें, हमें पहले यह समझना होगा कि यह एल्गोरिथम व्यवहार में कैसे लागू किया जाता है।
निम्नलिखित सूची पर विचार करें:
81% प्रतिभागियों ने कहा कि बूटकैंप में भाग लेने के बाद उन्हें अपनी तकनीकी नौकरी की संभावनाओं के बारे में अधिक आत्मविश्वास महसूस हुआ। आज ही एक बूटकैंप से मिलान करें।
बूटकैंप शुरू करने से लेकर अपनी पहली नौकरी खोजने तक, औसत बूटकैंप ग्रेड ने करियर संक्रमण में छह महीने से भी कम समय बिताया।
| 5 | 9 | 2 | 7 |
हमारा बबल सॉर्ट हमारी सूची में पहले और दूसरे तत्वों की तुलना करके शुरू होता है।
यदि पहला तत्व दूसरे तत्व से बड़ा है, तो ये तत्व स्थान बदल लेते हैं। इस मामले में, 5, 9 से बड़ा नहीं है, इसलिए तत्व अपने स्थान पर रहते हैं।
फिर, हमारा सॉर्ट हमारी सूची में अगले दो आइटमों की तुलना करेगा। 9 2 से बड़ा है, और इसलिए ये दो नंबर स्वैप करते हैं:
| 5 | 2 | 9 | 7 |
यह प्रक्रिया तब तक दोहराई जाती है जब तक कि सूची के प्रत्येक आइटम की तुलना नहीं कर ली जाती। इस मामले में, प्रदर्शन करने के लिए एक और तुलना है:क्या 9 7 से बड़ा है? 9, 7 से बड़ा है, इसलिए ये संख्याएँ अदला-बदली करती हैं:
| 5 | 2 | 7 | 9 |
हमारी सूची लगभग ऑर्डर कर दी गई है। एक बार प्रत्येक आइटम की तुलना हो जाने के बाद, बबल सॉर्ट फिर से शुरू हो जाएगा जब तक कि प्रत्येक तत्व सॉर्ट न हो जाए।
5 2 से बड़ा है, और इसलिए ये संख्याएँ अदला-बदली करती हैं।
| 2 | 5 | 7 | 9 |
हमारी सूची अब सही ढंग से ऑर्डर की गई है। हमारा बबल सॉर्ट सूची के अंत तक संख्याओं की तुलना करता रहेगा, और फिर यह बंद हो जाएगा। बबल प्रकार के लिए बस इतना ही है। यह निश्चित रूप से एक आसान एल्गोरिथम है जिसका उपयोग करने के बाद आप इसका उपयोग कर सकते हैं।
जावा बबल सॉर्ट कैसे लिखें
सिद्धांत को जानना एक बात है लेकिन आप यहां जावा बबल प्रकार के बारे में जानने के लिए आए हैं। हम सबसे अच्छी चर्चा करेंगे कि जावा में बबल सॉर्ट को कैसे लागू किया जाए।
बबल प्रकार दो प्रकार के होते हैं:
- मानक बबल सॉर्ट
- अनुकूलित बबल प्रकार
मानक बबल सॉर्ट सभी संभव तुलना करता है, भले ही किसी सरणी को सॉर्ट किया गया हो। यह बबल सॉर्ट को निष्पादित करने में लगने वाले समय को बढ़ाता है। यह सॉर्ट को कम कुशल बनाता है।
अनुकूलित बबल प्रकार इस बात पर नज़र रखते हैं कि किसी अतिरिक्त चर का उपयोग करके सूची को क्रमबद्ध किया गया है या नहीं। जैसे ही हमारी सूची को क्रमबद्ध किया जाता है, यह हमें अपने प्रकार को रोकने की अनुमति देता है।
आइए एक मानक बबल प्रकार लिखकर शुरू करें।
मानक बबल सॉर्ट
शुरू करने के लिए, हम अपने कोड में Arrays लाइब्रेरी को आयात करने जा रहे हैं। हम इसे बाद में अपने कोड में कंसोल पर छांटे गए नंबरों की हमारी सूची का प्रिंट आउट लेने के लिए उपयोग करेंगे:
java.util.Arrays आयात करें;
अब वह रास्ते से बाहर है, हम अपना एल्गोरिथम लिखना शुरू कर सकते हैं।
हम बबलसॉर्ट नामक एक वर्ग को परिभाषित करके शुरू करेंगे जो हमारे जावा प्रोग्राम के लिए कोड संग्रहीत करता है, और एक फ़ंक्शन जो हमारे प्रकार को निष्पादित करता है:
क्लास बबलसॉर्ट {शून्य सॉर्टनंबर (इंट सरणी []) {इंट आकार =सरणी। लंबाई; के लिए (इंट आइटम =0; आइटम <आकार -1; आइटम ++) {के लिए (इंट जे =0; जे <आकार - आइटम -1; जे ++) {अगर (सरणी [जे]> सरणी [जे + 1]) {इंट अस्थायी =सरणी [जे]; सरणी [जे] =सरणी [जे + 1]; सरणी [जे + 1] =अस्थायी; } } } }}
हमने sortNumbers . नामक एक फ़ंक्शन घोषित किया है जो एक चर को एक पैरामीटर के रूप में स्वीकार करता है। यह फ़ंक्शन हमारे द्वारा निर्दिष्ट संख्याओं की सूची के आकार की गणना करके शुरू होता है।
एक बार इसकी गणना हो जाने के बाद, लूप के लिए इनिशियलाइज़ किया जाता है। यह लूप हमारे ऐरे में प्रत्येक आइटम के माध्यम से चलता है। हम लूप के लिए दूसरे को इनिशियलाइज़ करते हैं जो हमें ऐरे में प्रत्येक आइटम की तुलना करने की अनुमति देता है।
यदि किसी सूची के बाईं ओर का आइटम दाईं ओर की संख्या से अधिक है, तो मानों की अदला-बदली की जाती है। नहीं तो कुछ नहीं होता।
हम इस स्वैप को "अस्थायी" नामक एक चर के लिए बाईं ओर मान निर्दिष्ट करके करते हैं। हम तुलना के बाईं ओर मौजूद मान को दाईं ओर असाइन करते हैं। फिर, बाईं ओर के मान को अस्थायी चर का मान दिया जाता है।
यदि 6 और 5 की तुलना की जा रही है, तो उनकी अदला-बदली की जाएगी। तो, हमारी सूची इस प्रकार दिखाई देगी:6, 5।
हमारा कार्यक्रम अभी कुछ नहीं करता है। हमने एक मुख्य प्रोग्राम नहीं लिखा है जो हमारे फ़ंक्शन को कॉल करता है और इसे सॉर्ट करने के लिए एक सूची देता है।
नीचे दिए गए कोड को sortNumbers के नीचे जोड़ें आपके कोड में कार्य करें:
हमने toSort नामक एक वैरिएबल घोषित किया है जो उन मानों की सूची को संग्रहीत करता है जिन्हें हम सॉर्ट करना चाहते हैं। फिर हमने बबलसॉर्ट क्लास का एक उदाहरण घोषित किया जिसे सॉर्टिंग एल्गोरिथम कहा जाता है, जिसका उपयोग हम कोड की अगली पंक्ति में sortNumbers को कॉल करने के लिए करते हैं। समारोह। जब इस फ़ंक्शन को कॉल किया जाता है, तो हमारी सूची को सॉर्ट किया जाता है।
अंत में, हम Arrays.toString() . का उपयोग करते हैं हमारी सूची को एक स्ट्रिंग में बदलने की विधि ताकि हम इसे कंसोल पर प्रिंट कर सकें। हमारा कोड लौटाता है:
[2, 5, 7, 9]
अब हमारे पास एक क्रमबद्ध सरणी है!
अनुकूलित बबल सॉर्ट
हमारे कोड को और अधिक कुशल बनाने का एक तरीका है। अभी, हमारा क्रम तब तक जारी है जब तक कि यह सभी संभव तुलना नहीं कर लेता। इसका मतलब यह है कि भले ही हमारी सरणी को सॉर्ट किया गया हो, तब तक सॉर्ट जारी रहेगा जब तक कि तुलना पूरी नहीं हो जाती।
हम अपने कोड में एक नया वेरिएबल जोड़कर इस व्यवहार को रोक सकते हैं। यदि सूची की अदला-बदली की जाती है तो यह हमें अपने प्रकार को रोकने की अनुमति देगा। आइए इस वेरिएबल को हमारे sortNumbers . में जोड़ें पहले से कार्य:
क्लास बबलसॉर्ट {शून्य सॉर्टनंबर (इंट सरणी []) {इंट आकार =सरणी। लंबाई; के लिए (इंट आइटम =0; आइटम <आकार - 1; आइटम ++) {बूलियन ने स्वैप किया =झूठा; के लिए (इंट जे =0; जे <आकार - आइटम - 1; जे ++) {अगर (सरणी [जे]> सरणी [जे + 1]) {इंट अस्थायी =सरणी [जे]; सरणी [जे] =सरणी [जे + 1]; सरणी [जे + 1] =अस्थायी; बदल गया =सच; } }अगर (हैस्वैप किया गया ==झूठा) {ब्रेक; } } }}
हमने अपने कोड में तीन बदलाव किए हैं। लूप के लिए हमारे पहले के अंदर हमने "हैस्वैप्ड" नामक एक वेरिएबल घोषित किया है। यह चर इस बात पर नज़र रखता है कि क्या स्वैप किया गया है। डिफ़ॉल्ट रूप से, यह चर "गलत" पर सेट है। यदि कोई स्वैप किया जाता है, तो इस चर का मान "सत्य" पर सेट होता है।
हमारे लूप के अंत में, हमने यह जांचने के लिए एक if स्टेटमेंट जोड़ा है कि क्या हैस्वैप्ड असत्य के बराबर है। यदि कोई स्वैप नहीं किया गया है, तो सरणी को क्रमबद्ध किया जाता है। हम अपने लूप को निष्पादित करने से रोकने के लिए "ब्रेक" कीवर्ड का उपयोग करते हैं यदि हैस्वैप्ड गलत के बराबर है।
आइए पहले लिखे गए मुख्य प्रोग्राम का उपयोग करके अपना कोड चलाएं और देखें कि क्या होता है:
[2, 5, 7, 9]
हमारी सूची को क्रमबद्ध किया गया है, लेकिन इस बार हमारा एल्गोरिदम अधिक कुशल है। यदि हम सॉर्ट करने के लिए अधिक मानों वाली बड़ी सूची का उपयोग करते हैं, तो इस एल्गोरिथम का बेहतर प्रदर्शन स्पष्ट होगा। बस, आपने जावा में एक अनुकूलित बबल सॉर्ट लिखा है!
निष्कर्ष
बबल प्रकार का उपयोग सूचियों को आरोही या अवरोही क्रम में क्रमबद्ध करने के लिए किया जाता है। वे आसन्न मूल्यों की तुलना करके और गलत क्रम में होने पर उन्हें स्वैप करके काम करते हैं।
बबल प्रकार दो प्रकार के होते हैं:मानक और अनुकूलित। मानक बबल प्रकार एक पूर्वनिर्धारित संख्या में स्वैप करते हैं जबकि अनुकूलित बबल प्रकार केवल तब तक क्रमबद्ध होते रहते हैं जब तक कि कोई सूची क्रमबद्ध न हो जाए।
अब आप एक विशेषज्ञ की तरह जावा में बबल प्रकार लिखना शुरू करने के लिए तैयार हैं!