पायथन क्विकसॉर्ट एक धुरी तत्व का चयन करता है और एक के तत्वों को विभाजित करता है सरणी दो नए . में सरणी एस. पिवट से ऊंची संख्याएं एक में चली जाती हैं सरणी ; धुरी से कम संख्या दूसरे में जाती है। प्रत्येक सरणी को क्रमबद्ध किया जाता है और फिर सभी सरणी s को एक में मिला दिया जाता है।
पायथन क्विकसॉर्ट को कैसे कोड करें
प्रोग्रामिंग में सूची को सॉर्ट करने के लिए आप बहुत सारे सॉर्टिंग एल्गोरिदम का उपयोग कर सकते हैं। पायथन सम्मिलन प्रकार, बुलबुला प्रकार, और बहुत कुछ है। QuickSort सबसे आम प्रकारों में से एक है।
इस गाइड में, हम इस बारे में बात करने जा रहे हैं कि QuickSorts क्या हैं और वे कैसे काम करते हैं। हम पायथन क्विकसॉर्ट के एक उदाहरण के माध्यम से चलेंगे ताकि आप सीख सकें कि इसे कैसे लागू किया जाए।
आगे की हलचल के बिना, चलिए शुरू करते हैं!
पायथन क्विकसॉर्ट क्या है?
एक पायथन क्विकसॉर्ट एल्गोरिथ्म एक सरणी को उप सरणियों में विभाजित करता है। यह एल्गोरिथ्म सूची में प्रत्येक तत्व को क्रमबद्ध करने के लिए इन उप सरणियों को पुनरावर्ती रूप से कॉल करता है। एक उप सरणी की सामग्री एक धुरी तत्व द्वारा निर्धारित की जाती है जिसे एक नए उप सरणी में स्थानांतरित नहीं किया जाता है।
QuickSort एल्गोरिथ्म विभाजित और जीतता है। इसका मतलब है कि सूची को छाँटने का कार्य कई उप-कार्यों में विभाजित है। सॉर्ट के अंत में, इन उप-कार्यों के परिणाम एक क्रमबद्ध सूची को वापस करने के लिए एक साथ आते हैं।
QuickSort में, सबटास्क प्रत्येक उप सूची के लिए एक पिवट सेट कर रहा है और पिवट के सापेक्ष उनके मूल्य के आधार पर तत्वों को ऑर्डर कर रहा है।
मुझे Python QuickSort का उपयोग कब करना चाहिए?
जब समय की जटिलता मायने रखती है तो QuickSort उपयोगी होता है। ऐसा इसलिए है क्योंकि QuickSort अन्य एल्गोरिदम की तुलना में कम मेमोरी स्पेस का उपयोग करता है, जो उन्हें एक दक्षता को बढ़ावा देता है।
81% प्रतिभागियों ने कहा कि बूटकैंप में भाग लेने के बाद उन्हें अपनी तकनीकी नौकरी की संभावनाओं के बारे में अधिक आत्मविश्वास महसूस हुआ। आज ही एक बूटकैंप से मिलान करें।
बूटकैंप शुरू करने से लेकर अपनी पहली नौकरी खोजने तक, औसत बूटकैंप ग्रेड ने करियर संक्रमण में छह महीने से भी कम समय बिताया।
यदि आप पायथन रिकर्सन से परिचित हैं, तो आपको केवल QuickSort का उपयोग करना चाहिए। ऐसा इसलिए है क्योंकि QuickSort एल्गोरिथ्म पुनरावर्ती कार्यों पर निर्भर करता है।
एक QuickSort छोटे सरणियों पर मर्ज सॉर्ट की तुलना में अधिक कुशल है। हालांकि, बड़े डेटा सेट पर, इंसर्शन सॉर्ट या मर्ज सॉर्ट तेज़ हो सकता है।
क्विकसॉर्ट कैसे काम करता है?
एक QuickSort धुरी के रूप में काम करने के लिए एक तत्व चुनता है। यह सूची में कोई भी तत्व हो सकता है। इस ट्यूटोरियल के लिए, हम सूची (3) में अंतिम आइटम चुनने जा रहे हैं।
| 8 | 4 | 5 | 2 | 1 | 3 |
जब हम सूची में आइटम के माध्यम से लूप करते हैं तो एक QuickSort पिवट के मूल्य की तुलना प्रत्येक संख्या से करता है। यदि कोई आइटम पिवट संख्या से बड़ा है, तो हम संख्या को पिवट के बाद ले जाते हैं; अन्यथा, हम पिवट से पहले संख्या को आगे बढ़ाते हैं:
| 2 | 1 | 3 | 8 | 5 | 4 |
मान 3 हमारी सूची से नीचे चला गया है। 3 से कम के सभी आइटम इसके बाईं ओर चले गए; तीन से अधिक के सभी मान इसके दाईं ओर चले गए।
हमारे पायथन सरणी को दो हिस्सों में विभाजित किया गया है:पिवट से बड़े आइटम और पिवट से कम आइटम।
एक बार जब यह प्रक्रिया शुरू हो जाती है, तो दोनों हिस्सों में से प्रत्येक पर एक नई धुरी शुरू होती है। यह धुरी अलग से शुरू होती है और ऊपर दिए गए समान एल्गोरिदम का उपयोग करती है। सबसे पहले, हम एक पिवट मान सेट करेंगे जो प्रत्येक सूची में अंतिम मान के बराबर है:
| एक धुरी | <टीडी>दो पिवट करें | <टीडी>|||
| 2 | 1 | <टीडी>8 | 5 | 4 |
इसके बाद, हम पिवट से बड़े सभी मानों को पिवट के दाईं ओर ले जाएंगे। हम पिवट से छोटे सभी मानों को बाईं ओर ले जाते हैं।
| एक धुरी | <टीडी>दो पिवट करें | <टीडी>|||
| 1 | 2 | <टीडी>4 | 8 | 5 |
यह प्रक्रिया तब तक जारी रहती है जब तक हम अपनी सूची को क्रमबद्ध नहीं कर लेते:
| पहली बार | 1 | 2 | <टीडी>4 | 8 | 5 |
| दूसरी बार | <टीडी>1 | <टीडी>8 | 5 | ||
| | <टीडी> 5 | 87t?/ | |||
| तीसरी बार | <टीडी>8 |
हमारी अंतिम सरणी इस तरह दिखती है:
| 1 | 2 | 3 | 4 | 5 | 8 |
पायथन क्विकसॉर्ट उदाहरण
QuickSort को दो फ़ंक्शन की आवश्यकता होती है:एक पिवट फ़ंक्शन और एक QuickSort फ़ंक्शन।
आइए विभाजन फ़ंक्शन से शुरू करें। यह पिवट तत्व के मान के आधार पर सरणी को विभाजित या तैयार करेगा।
हमारा विभाजन कार्य करेगा:
- पिवट तत्व चुनें
- पिवट से बड़े सभी आइटम को पिवट के दाईं ओर ले जाएं
- पिवट से छोटे सभी आइटम को पिवट के बाईं ओर ले जाएं
QuickSort Python Program
आइए एक प्रोग्राम लिखें जो इस एल्गोरिथम को लागू करता है:
डीईएफ़ तैयार (संख्या, कम, उच्च):पिवट =संख्याएं [उच्च] आइटम =निम्न -1 के लिए मैं सीमा में (निम्न, उच्च):यदि संख्याएं [i] <=धुरी:आइटम =आइटम + 1 (संख्याएं) [आइटम], संख्याएं [i]) =(संख्याएं [i], संख्याएं [आइटम]) (संख्याएं [आइटम + 1], संख्याएं [उच्च]) =(संख्याएं [उच्च], संख्याएं [आइटम + 1]) वापसी आइटम + 1
सबसे पहले, हम एक धुरी तत्व का चयन करते हैं। यह हमारी सूची में सबसे अधिक संख्या के बराबर है।
इसके बाद, हम लूप के लिए पायथन का उपयोग करके सूची में सभी वस्तुओं के माध्यम से लूप करते हैं। यदि कोई संख्या पिवट से कम या उसके बराबर है, तो उसे पिवट के बाईं ओर ले जाया जाता है। अन्यथा, यह धुरी के दाईं ओर जाता है।
हमारा पायथन फ़ंक्शन नया उच्च मान लौटाता है। नया उच्च मान आइटम + 1 के बराबर है।
इसके बाद, हमें अपना एल्गोरिदम चलाना होगा। हम एक अलग फ़ंक्शन लिखकर ऐसा कर सकते हैं:
def quick_sort(numbers, low, high):यदि कम है <उच्च:पिवट =तैयार (संख्या, कम, उच्च) Quick_sort(नंबर, कम, पिवट -1) Quick_sort(नंबर, पिवट + 1, उच्च)यह फ़ंक्शन यह देखने के लिए जाँच करता है कि क्या "निम्न" का मान "उच्च" के मान से कम है। अगर ऐसा है, तो हमारा क्रम जारी रह सकता है। नहीं तो हमारा क्रम रुक जाता है। अगर हमारा क्रम बंद हो जाता है, तो इसका मतलब है कि हमने सूची को छाँट लिया है।
इसके बाद, हमारा फ़ंक्शन तैयार () को कॉल करता है तरीका। यह पिवट के लिए एक पॉइंटर की पहचान करता है और आइटम को उनके सही स्थान पर ले जाता है।
हमारा फ़ंक्शन तब quick_sort() . को कॉल करता है विधि दो बार। पहली बार, हम पिवट के बाईं ओर के तत्वों पर QuickSort चलाते हैं। दूसरी बार, हम पिवट के दायीं ओर के तत्वों पर QuickSort चलाते हैं। इसलिए, हमारा फ़ंक्शन पुनरावर्ती है क्योंकि यह स्वयं को कॉल करता है।
यह तब तक जारी रहता है जब तक सूची में प्रत्येक आइटम को क्रमबद्ध नहीं किया जाता है।
मुख्य विधि लिखना
आइए एक मुख्य प्रोग्राम लिखें जो सॉर्ट करने के लिए एक सूची को परिभाषित करता है:
मान =[8, 4, 5, 2, 1, 3]total_values =len(values)quick_sort(values, 0, Total_values - 1)print(values)सबसे पहले, हम सॉर्ट करने के लिए मानों की एक सूची निर्दिष्ट करते हैं। हम अपने मूल्यों की सूची की लंबाई की गणना करने के लिए पायथन लेन () पद्धति का उपयोग करते हैं। इसके बाद, हम quick_sort() . को कॉल करते हैं विधि।
हम "मान" को उन संख्याओं के रूप में पास करते हैं जिन्हें हम सॉर्ट करना चाहते हैं। फिर हम 0 को निम्न संख्या के रूप में पास करते हैं। "मान" माइनस 1 की लंबाई हमारे द्वारा निर्दिष्ट उच्च मान है। उच्च मान मानों की लंबाई माइनस 1 है क्योंकि सूची के पहले आइटम में इंडेक्स नंबर 0 होता है।
आइए अपना प्रोग्राम चलाने का प्रयास करें:
[1, 2, 3, 4, 5, 8]हमारा कोड एक क्रमबद्ध सूची देता है! हमने कर दिया। अपने मुंह मियां मिट्ठू बनना। QuickSort को समझना या कार्यान्वित करना आसान नहीं है।
जटिलता अवलोकन
औसतन, यह एल्गोरिथम O(n* log n) पर प्रदर्शन करेगा। ऐसा तब होता है जब धुरी तत्व सबसे बड़ा या सबसे छोटा तत्व नहीं होता है और जब धुरी तत्व मध्य तत्व के पास नहीं होता है।
QuickSort में O(n2) की सबसे खराब स्थिति है। यह तब होता है जब पिवट के रूप में चुना गया तत्व या तो सबसे बड़ा या सबसे छोटा तत्व होता है। यदि ऐसा है, तो पिवट तत्व हमेशा क्रमबद्ध सरणी के अंत में होगा। यह कई अनावश्यक उप सरणियाँ बनाएगा।
इस एल्गोरिथ्म के लिए सबसे अच्छा मामला जटिलता ओ (एन * लॉग एन) है। ऐसा तब होता है जब पिवट तत्व या तो मध्य तत्व के बराबर होता है या मध्य तत्व के पास होता है।
एल्गोरिथम जटिलता के बारे में अधिक जानने के लिए, बिग ओ नोटेशन के लिए हमारी मार्गदर्शिका देखें।
निष्कर्ष
पायथन क्विकसॉर्ट्स एक सूची को छोटी सूचियों में विभाजित करने के लिए रिकर्सन का उपयोग करते हैं जिन्हें तब क्रमबद्ध किया जाता है। प्रत्येक सूची को एक पिवट तत्व के आसपास क्रमबद्ध किया जाता है। धुरी से बड़े तत्वों को इसके दाईं ओर ले जाया जाता है; छोटे तत्वों को पिवट के बाईं ओर ले जाया जाता है।
पायथन सीखने के शीर्ष संसाधनों, ऑनलाइन पाठ्यक्रमों और पुस्तकों के बारे में मार्गदर्शन के लिए, हमारी विस्तृत हाउ टू लर्न पायथन गाइड पढ़ें।