Bubblई सॉर्ट एल्गोरिथ्म के साथ Python सूची उदाहरण का उपयोग करना

क्या है एक Bubblई सॉर्ट?

Bubblई क्रमबद्ध करें यह एक सॉर्टिंग एल्गोरिदम है जिसका उपयोग दो आसन्न मानों की तुलना करके सूची आइटमों को आरोही क्रम में सॉर्ट करने के लिए किया जाता है। यदि पहला मान दूसरे मान से अधिक है, तो पहला मान दूसरे मान का स्थान ले लेता है, जबकि दूसरा मान पहले मान का स्थान ले लेता है। यदि पहला मान दूसरे मान से कम है, तो कोई अदला-बदली नहीं होती है।ping पूरा हो गया है।

यह प्रक्रिया तब तक दोहराई जाती है जब तक कि सूची में सभी मानों की तुलना नहीं हो जाती और यदि आवश्यक हो तो उन्हें बदल दिया जाता है। प्रत्येक पुनरावृत्ति को आमतौर पर पास कहा जाता है। बबल सॉर्ट में पास की संख्या सूची में तत्वों की संख्या में से एक घटाकर बराबर होती है।

इस में Bubblई छंटाई Python ट्यूटोरियल आप इस समस्या के समाधान, इसके अनुकूलित रूप, चरण-दर-चरण दृश्य विवरण और एक कार्यशील समाधान के बारे में जानेंगे। Python कार्यक्रम और उसकी प्रदर्शन विशेषताएँ।

कार्यान्वयन Bubblई सॉर्ट एल्गोरिथ्म

हम कार्यान्वयन को तीन (3) चरणों में विभाजित करेंगे, अर्थात् समस्या, समाधान और एल्गोरिदम जिसका उपयोग हम किसी भी भाषा के लिए कोड लिखने के लिए कर सकते हैं।

समस्या

वस्तुओं की एक सूची बेतरतीब क्रम में दी गई है, और हम उन वस्तुओं को व्यवस्थित तरीके से व्यवस्थित करना चाहते हैं।

निम्नलिखित सूची पर विचार करें:

[21, 6, 9, 33, 3]

समाधान

सूची में दो आसन्न तत्वों की तुलना करते हुए आगे बढ़ें और उन्हें आपस में बदलें।ping यदि पहला मान दूसरे मान से अधिक है तो उन्हें अस्वीकार कर दें।

परिणाम निम्न प्रकार होना चाहिए:

[3, 6, 9, 21, 33]

कलन विधि

बबल सॉर्ट एल्गोरिदम इस प्रकार काम करता है:

चरण 1) कुल तत्वों की संख्या ज्ञात कीजिए। दी गई सूची में मौजूद वस्तुओं की कुल संख्या ज्ञात कीजिए।

चरण 2) किए जाने वाले बाहरी पासों की संख्या (n – 1) निर्धारित करें। इसकी लंबाई सूची में से एक घटाने के बराबर है।

चरण 3) आउटर पास 1 के लिए इनर पास (n – 1) बार करें। पहले एलिमेंट का मान प्राप्त करें और उसकी तुलना दूसरे मान से करें। यदि दूसरा मान पहले मान से कम है, तो स्थानों को आपस में बदल दें।

चरण 4) चरण 3 को तब तक दोहराएं जब तक आप बाहरी पास (n – 1) तक न पहुंच जाएं। सूची में अगला तत्व प्राप्त करें, फिर चरण 3 में की गई प्रक्रिया को तब तक दोहराएं जब तक कि सभी मानों को उनके सही आरोही क्रम में व्यवस्थित न कर दिया जाए।

चरण 5) सभी चरण पूरे होने पर परिणाम लौटाएँ। क्रमबद्ध सूची के परिणाम लौटाएँ।

चरण 6) एल्गोरिदम को अनुकूलित करें।

यदि सूची या आसन्न मान पहले से ही क्रमबद्ध हैं, तो अनावश्यक आंतरिक पास से बचें। उदाहरण के लिए, यदि प्रदान की गई सूची में पहले से ही ऐसे तत्व हैं जिन्हें आरोही क्रम में क्रमबद्ध किया गया है, तो हम लूप को जल्दी तोड़ सकते हैं।

अनुकूलित Bubblई सॉर्ट एल्गोरिथ्म

डिफ़ॉल्ट रूप से, बबल सॉर्ट के लिए एल्गोरिथ्म Python सूची में सभी आइटम की तुलना करता है, भले ही सूची पहले से सॉर्ट की गई हो या नहीं। यदि दी गई सूची पहले से सॉर्ट की गई है, तो सभी मानों की तुलना करना समय और संसाधनों की बर्बादी है।

बबल सॉर्ट को अनुकूलित करने से हमें अनावश्यक पुनरावृत्तियों से बचने तथा समय और संसाधनों को बचाने में मदद मिलती है।

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

ऑप्टिमाइजेशन निम्नलिखित चरणों का उपयोग करके किया जाता है:

चरण 1) एक फ़्लैग वेरिएबल बनाएं जो किसी भी स्वैप की निगरानी करे।ping आंतरिक लूप में घटना घटित हुई है।

चरण 2) यदि मानों की स्थिति आपस में बदल गई है, तो अगले चरण पर आगे बढ़ें।

चरण 3) यदि मानों ने अपनी स्थिति नहीं बदली है, तो आंतरिक लूप को समाप्त करें और बाहरी लूप को जारी रखें।

अनुकूलित बबल सॉर्ट अधिक कुशल होता है क्योंकि यह केवल आवश्यक चरणों को ही निष्पादित करता है तथा अनावश्यक चरणों को छोड़ देता है।

दृश्य प्रतिनिधित्व

पांच तत्वों की एक सूची दी गई है, निम्नलिखित चित्र दर्शाते हैं कि बबल सॉर्ट उन्हें सॉर्ट करते समय मानों के माध्यम से कैसे पुनरावृति करता है।

नीचे दी गई छवि में अव्यवस्थित सूची दिखाई गई है:

प्रथम पुनरावृति

चरण 1)

मान 21 और 6 की तुलना करके यह पता लगाया जाता है कि कौन सा मान दूसरे से बड़ा है।

21, 6 से बड़ा है, इसलिए 21 उस स्थान पर आ जाता है जहाँ 6 था, जबकि 6 उस स्थान पर आ जाता है जहाँ 21 था।

हमारी संशोधित सूची अब ऊपर दी गई सूची जैसी दिखती है।

चरण 2)

मान 21 और 9 की तुलना की गई है।

21, 9 से बड़ा है, इसलिए हम 21 और 9 की स्थिति आपस में बदल देते हैं।

नई सूची अब ऊपर दी गई है।

चरण 3)

बड़े मान को खोजने के लिए 21 और 33 के मानों की तुलना की जाती है।

33 का मान 21 से अधिक है, इसलिए अदला-बदली नहीं होगी।ping जगह लेता है।

चरण 4)

बड़े मान को खोजने के लिए 33 और 3 के मानों की तुलना की जाती है।

मान 33, 3 से बड़ा है, इसलिए हम उनकी स्थिति बदल देते हैं।

पहले चरण के अंत में क्रमबद्ध सूची ऊपर दी गई सूची के समान होती है।

दूसरा पुनरावर्तन

दूसरे चरण के बाद नई सूची इस प्रकार है:

तीसरा पुनरावर्तन

तीसरे चरण के बाद नई सूची इस प्रकार है:

चौथा पुनरावर्तन

चौथे चरण के बाद नई सूची इस प्रकार है:

Python उदाहरण

निम्नलिखित कोड दिखाता है कि इसे कैसे कार्यान्वित किया जाए Bubblई सॉर्ट एल्गोरिथ्म में Python.

def bubbleSort(theSeq):
    n = len(theSeq)

    for i in range(n - 1):
        flag = 0

        for j in range(n - 1):
            if theSeq[j] > theSeq[j + 1]:
                tmp = theSeq[j]
                theSeq[j] = theSeq[j + 1]
                theSeq[j + 1] = tmp
                flag = 1

        if flag == 0:
            break

    return theSeq

el = [21, 6, 9, 33, 3]
result = bubbleSort(el)
print(result)

उपरोक्त बबल सॉर्ट प्रोग्राम को निष्पादित करना Python इससे निम्नलिखित परिणाम प्राप्त होते हैं:

[3, 6, 9, 21, 33]

Code व्याख्या

इसका स्पष्टीकरण Python Bubble Sort प्रोग्राम का कोड इस प्रकार है:

यहाँ,

1. एक फ़ंक्शन bubbleSort परिभाषित करता है जो एक पैरामीटर theSeq स्वीकार करता है। कोड कुछ भी आउटपुट नहीं करता है।
2. यह कोड ऐरे की लंबाई प्राप्त करता है और उस मान को n नामक एक वेरिएबल में असाइन करता है। यह कोड कोई आउटपुट नहीं देता है।
3. यह कोड एक फॉर लूप शुरू करता है जो बबल सॉर्ट एल्गोरिदम को (n – 1) बार चलाता है। यह बाहरी लूप है। कोड कोई आउटपुट नहीं देता है।
4. यह कोड एक फ़्लैग वेरिएबल को परिभाषित करता है जिसका उपयोग यह निर्धारित करने के लिए किया जाएगा कि स्वैप हुआ है या नहीं। यह ऑप्टिमाइज़ेशन के उद्देश्य से है। कोड कोई आउटपुट नहीं देता है।
5. आंतरिक लूप शुरू करता है जो सूची में पहले से लेकर अंतिम तक सभी मानों की तुलना करता है। कोड कुछ भी आउटपुट नहीं करता है।
6. यह if कथन का उपयोग करके जाँचता है कि क्या बाएँ हाथ की ओर का मान तुरन्त दाएँ हाथ की ओर के मान से अधिक है। कोड कुछ भी आउटपुट नहीं करता है।
7. यदि शर्त सही साबित होती है, तो theSeq[j] का मान एक अस्थायी चर tmp को असाइन किया जाता है। कोड कोई आउटपुट नहीं देता है।
8. theSeq[j + 1] का मान theSeq[j] की स्थिति को असाइन किया जाता है। कोड कोई आउटपुट नहीं देता है।
9. वेरिएबल tmp का मान theSeq[j + 1] की स्थिति पर असाइन किया गया है। कोड कोई आउटपुट नहीं देता है।
10. स्वैप होने का संकेत देने के लिए फ्लैग वेरिएबल को 1 मान दिया गया है। कोड कोई आउटपुट नहीं देता है।
11. यह कोड 'if' स्टेटमेंट का उपयोग करके यह जांचता है कि वेरिएबल 'flag' का मान 0 है या नहीं। कोड कोई आउटपुट नहीं देता है।
12. यदि मान 0 है, तो हम ब्रेक स्टेटमेंट को कॉल करते हैं जो आंतरिक लूप से बाहर निकलता है।
13. सॉर्ट किए जाने के बाद theSeq का मान लौटाता है। कोड सॉर्ट की गई सूची को आउटपुट करता है।
14. एक चर el को परिभाषित करता है जिसमें यादृच्छिक संख्याओं की एक सूची होती है। कोड कुछ भी आउटपुट नहीं करता है।
15. फ़ंक्शन bubbleSort का मान एक चर परिणाम को निर्दिष्ट करता है।
16. चर परिणाम का मान प्रिंट करता है.

Bubblई सॉर्ट लाभ

बबल सॉर्ट एल्गोरिदम के कुछ फायदे निम्नलिखित हैं:

• इसे समझना आसान है।
• यह तब बहुत अच्छा प्रदर्शन करता है जब सूची पहले से ही या लगभग क्रमबद्ध हो।
• इसके लिए व्यापक मेमोरी की आवश्यकता नहीं होती।
• इस एल्गोरिदम के लिए कोड लिखना आसान है।
• अन्य सॉर्टिंग एल्गोरिदम की तुलना में इसमें स्थान की आवश्यकता न्यूनतम है।

Bubblई प्रकार के नुकसान

बबल सॉर्ट एल्गोरिदम की कुछ कमियां निम्नलिखित हैं:

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

जटिलता विश्लेषण Bubblई क्रमबद्ध करें

जटिलता तीन प्रकार की होती है:

1) सॉर्ट जटिलता

सॉर्ट कॉम्प्लेक्सिटी का उपयोग सूची को सॉर्ट करने में लगने वाले निष्पादन समय और स्थान को व्यक्त करने के लिए किया जाता है। बबल सॉर्ट सूची को सॉर्ट करने के लिए (n – 1) पुनरावृत्तियाँ करता है, जहाँ n सूची में तत्वों की कुल संख्या है।

2) समय जटिलता

बबल सॉर्ट की समय जटिलता O(n .) है²).

समय जटिलताओं को इस प्रकार वर्गीकृत किया जा सकता है:

• सबसे खराब मामला - यह वह जगह है जहाँ प्रदान की गई सूची अवरोही क्रम में है। एल्गोरिथ्म अधिकतम संख्या में निष्पादन करता है जिसे [बिग-ओ] ओ (एन) के रूप में व्यक्त किया जाता है²).
• सबसे अच्छा मामला – यह तब होता है जब दी गई सूची पहले से ही क्रमबद्ध होती है। एल्गोरिदम न्यूनतम संख्या में निष्पादन करता है जिसे [बिग-ओमेगा] Ω(n) के रूप में व्यक्त किया जाता है।
• औसत मामला – यह तब होता है जब सूची यादृच्छिक क्रम में होती है। औसत जटिलता को [बिग-थीटा] ⊝(n) के रूप में दर्शाया जाता है।²).

3) स्थान जटिलता

स्पेस कॉम्प्लेक्सिटी, लिस्ट को सॉर्ट करने के लिए आवश्यक अतिरिक्त स्पेस की मात्रा को मापती है। बबल सॉर्ट में स्वैप के लिए उपयोग किए जाने वाले टेम्परल वेरिएबल के लिए केवल एक (1) अतिरिक्त स्पेस की आवश्यकता होती है।ping इसलिए, इसकी स्पेस कॉम्प्लेक्सिटी O(1) है।

अक्सर पूछे जाने वाले प्रश्न