पायथन सिलेक्शन सॉर्ट: एक गाइड

पायथन सिलेक्शन सॉर्ट: एक गाइड

पायथन सिलेक्शन सॉर्ट एक सूची को दो छोटी सूचियों में विभाजित करता है। एक सूची सॉर्ट किए गए तत्वों को दर्शाती है। दूसरी सूची में अनसॉर्ट किए गए तत्व होते हैं। सिलेक्शन सॉर्ट प्रत्येक पुनरावृत्ति में सबसे छोटे या सबसे बड़े मानों को ढूंढता है और उन मानों को क्रमबद्ध सूची में ले जाता है।

सूचियों को सॉर्ट करना कार्यक्रमों की एक श्रृंखला में एक सामान्य संक्रिया है।

इस उदाहरण पर विचार करें: एक शिक्षक अपने छात्रों की सबसे हालिया परीक्षा में कैसा प्रदर्शन रहा, इसके बारे में अधिक जानना चाहता है। एक शिक्षक छात्रों के स्कोर को आरोही और अवरोही क्रम में सॉर्ट करना चाह सकता है। इससे उन्हें आसानी से पता चल जाएगा कि सबसे अधिक और सबसे कम टेस्ट स्कोर क्या थे।

प्रवेश करें, सिलेक्शन सॉर्ट। सिलेक्शन सॉर्ट एक एल्गोरिदम है जिसका उपयोग आप सूची को आरोही या अवरोही क्रम में सॉर्ट करने के लिए कर सकते हैं।

इस गाइड में, हम चर्चा करेंगे कि पायथन में सिलेक्शन सॉर्ट प्रोग्राम कैसे लिखें। हम इस गाइड के दौरान एक उदाहरण के माध्यम से चलेंगे ताकि आप सिलेक्शन सॉर्ट के इन-एंड-आउट्स सीख सकें।

पायथन सिलेक्शन सॉर्ट क्या है?

पायथन सिलेक्शन सॉर्ट बार-बार सूची में न्यूनतम तत्व को ढूंढता है और उस तत्व को सूची के एक विशेष अंत में ले जाता है। सॉर्ट तब तक चलता रहता है जब तक ऐरे क्रम में सॉर्ट नहीं हो जाता। आप सिलेक्शन सॉर्ट को अधिकतम तत्व ढूंढने का निर्देश भी दे सकते हैं। दोनों दृष्टिकोण सूची को सॉर्ट करते हैं।

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

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

पायथन सिलेक्शन सॉर्ट गाइड

सिलेक्शन सॉर्ट के बारे में सीखने का कोई बेहतर तरीका नहीं है एक उदाहरण के माध्यम से चलना। आइए छात्र ग्रेड की सूची को आरोही क्रम में सॉर्ट करें। इस अनसॉर्ट की गई सूची पर विचार करें:

हम अपनी सूची के पहले मान को न्यूनतम कहकर शुरू करेंगे। सिलेक्शन सॉर्ट की प्रत्येक पुनरावृत्ति सबसे छोटे तत्व को ढूंढेगी और उसे सॉर्ट की गई उप-सरणी में ले जाएगी।

न्यूनतम तत्व को सॉर्ट करना एक विकल्प है। यदि आप अधिकतम तत्व को सॉर्ट करते हैं तो सिलेक्शन सॉर्ट काम करता है। लेकिन, हम इस उदाहरण में न्यूनतम तत्व का उपयोग कर रहे हैं।

अगला, हम न्यूनतम मान की तुलना दूसरे तत्व से करेंगे। यदि यह तत्व न्यूनतम से छोटा है, तो दूसरा तत्व न्यूनतम मान बन जाना चाहिए।

हम 73 और 62 की तुलना करने जा रहे हैं। 73, 62 से बड़ा है, जिसका अर्थ है कि हमारा नया न्यूनतम मान 62 है। हमारी सूची फिर हमारी सूची में अन्य सभी नंबरों के माध्यम से जाएगी:

• क्या 61, 62 (हमारा न्यूनतम मान) से बड़ा है? नहीं, इसलिए संख्याओं को स्वैप करें। न्यूनतम 61 बन जाता है।
• क्या 69, 61 (हमारा न्यूनतम मान) से बड़ा है? हाँ, इसलिए कुछ न करें। न्यूनतम 61 पर रहता है।

हमारी सूची वही दिखती है:

जब आप सूची के अंत तक पहुंच जाते हैं, तो आप न्यूनतम को सूची की शुरुआत में ले जा सकते हैं:

61 (हमारा न्यूनतम मान) सूची की शुरुआत में ले जाया गया है, और हर दूसरे मान में एक की वृद्धि हुई है। हम इस प्रक्रिया को तब तक दोहराएंगे जब तक सभी तत्व सॉर्ट नहीं हो जाते।

हमारी सूची की प्रत्येक पुनरावृत्ति निम्नलिखित लौटाएगी:

1. 73, 62, 61, 69
2. 61, 73, 62, 69
3. 61, 62, 73, 69
4. 61, 62, 69, 73

जब सिलेक्शन सॉर्ट सूची में सभी तत्वों की जांच कर लेता है, तो सॉर्ट रुक जाएगा।

सॉर्ट की गई उप-सरणी और वह उप-सरणी जो अनसॉर्ट की गई है, दोनों हमारे लिए अदृश्य हैं। हमारा एल्गोरिदम हमारे लिए एक ऐरे को सॉर्ट करता है और ऐरे के अनसॉर्ट किए गए हिस्से को ट्रैक करता है।

पायथन में सिलेक्शन सॉर्ट कैसे करें

अब आप सिद्धांत से परिचित हैं: बहुत बढ़िया! अब बड़ी चुनौती का समय है। हम पायथन में सिलेक्शन सॉर्ट एल्गोरिदम को लागू करने जा रहे हैं। आइए एक प्रोग्राम लिखें जो पायथन ऐरे को लेता है और इसे आरोही क्रम में सॉर्ट करता है।

सॉर्ट फ़ंक्शन को परिभाषित करें

हम एक पायथन फ़ंक्शन को परिभाषित करके शुरू करेंगे जो हमारे सिलेक्शन सॉर्ट को करता है:

def sortList(array):
    length = len(array)
    for item in range(length):
        minimum = item
        for i in range(item + 1, length):
            if array[i] < array[minimum]:
                minimum = i
        (array[item], array[minimum]) = (array[minimum], array[item])

हमने पायथन len() विधि का उपयोग करके अपनी सूची की लंबाई प्राप्त करके शुरू किया। फिर हम इस का उपयोग करके एक पायथन for लूप शुरू करते हैं जो हमारी सूची में प्रत्येक आइटम पर लूप करता है।

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

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

हमारी सूची में प्रत्येक आइटम के माध्यम से लूप करने पर, हमारा एल्गोरिदम न्यूनतम मान को सूची की शुरुआत में ले जाता है। फिर, हमारा प्रोग्राम तब तक चलता रहेगा जब तक शीर्ष for लूप समाप्त नहीं हो जाता। ऐसा इसलिए है क्योंकि सिलेक्शन सॉर्ट सूची की लंबाई के बराबर बार चलते हैं।

सॉर्टिंग फ़ंक्शन को कॉल करें

आपने देखा होगा कि यदि हम अपना प्रोग्राम चलाते हैं, तो कुछ नहीं होता। ऐसा इसलिए है क्योंकि हमने अभी तक अपने कोड को नहीं बताया है कि किन मानों का उपयोग करना है। अपने प्रोग्राम के नीचे, sortList फ़ंक्शन के बाहर निम्न कोड जोड़ें:

numbers = [73, 62, 61, 69]
sortList(numbers)
print("Sorted list:", numbers)

जब हम अपना प्रोग्राम चलाते हैं, तो निम्न लौटाया जाता है:

[61, 62, 69, 73]

हमारी सूची सॉर्ट की गई है। अपनी पीठ थपथपाएं; आपने कर दिखाया!

सिलेक्शन सॉर्ट का उपयोग सूची को अवरोही क्रम में सॉर्ट करने के लिए किया जा सकता है। यदि आप सूची को इस तरह सॉर्ट करना चाहते हैं, तो आप सिलेक्शन सॉर्ट में "if" स्टेटमेंट को निम्न में बदल सकते हैं:

if array[i] > array[minimum]:

हमने कम-से चिह्न को अधिक-से चिह्न में बदल दिया है। यह हमारी सूची को अवरोही क्रम में सॉर्ट करेगा, क्योंकि न्यूनतम मान को सूची में सबसे बड़े मान पर सेट किया जाएगा। तकनीकी रूप से, हमारा न्यूनतम मान अधिकतम मान बन जाता है।

सिलेक्शन सॉर्ट का उपयोग कब करना चाहिए?

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

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

सिलेक्शन सॉर्ट के लिए जटिलता क्या है?

सिलेक्शन सॉर्ट की समय जटिलता O(n²) है। इसका मतलब है कि एल्गोरिदम की जटिलता इस बात पर निर्भर करते हुए तेजी से बढ़ेगी कि सूची में कितने तत्व हैं।

O(n²) इस एल्गोरिदम के लिए सबसे खराब स्थिति, औसत, और सर्वोत्तम स्थिति की जटिलता है। यदि आप सॉर्टिंग जटिलताओं के बारे में अधिक जानना चाहते हैं, तो बिग O नोटेशन पर हमारी गाइड देखें।

निष्कर्ष

सिलेक्शन सॉर्ट डेटा को सॉर्ट करने की एक महत्वपूर्ण विधि है। सिलेक्शन सॉर्ट सूची में प्रत्येक आइटम को पढ़ते हैं और, प्रत्येक पुनरावृत्ति पर, सबसे छोटे आइटम को सूची की शुरुआत में ले जाते हैं। यह तब तक होता है जब तक सूची में प्रत्येक आइटम पढ़ा नहीं जाता।

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

क्या आप पायथन के बारे में अधिक सीखने में रुचि रखते हैं? विशेषज्ञ सलाह के लिए हमारा संपूर्ण How to Learn Python गाइड पढ़ें जो आपके ज्ञान को आगे बढ़ाने में मदद करेगा।