🦇 📇 🤜 और फिर से छँटाई के बारे में: हम सबसे अच्छा एल्गोरिथ्म चुनते हैं ⭕️ 🚵🏻 🧝

हाल ही में एक हाइब्रिड पर एल्गोरिदम को सॉर्ट करने का विषय फिर से उठाया गया था, अर्थात्, टिम्सर्ट विधि को अच्छी तरह से वर्णित किया गया था।

ओ (एन लॉग एन) से अधिक जटिलता नहीं होने के बाद, यह आंशिक रूप से ऑर्डर किए गए डेटा को सॉर्ट करने के मामले में त्वरित होता है और यदि डेटा शुरू में सॉर्ट किया गया है तो ओ (एन) है। लेकिन इस तरह के घोषित गुणों के साथ यह केवल एल्गोरिदम नहीं है। समान जटिलता वाले कम से कम दो अधिक या कम ज्ञात तरीके हैं - ये स्मूथर्स और शेल छंटाई हैं।

लेकिन सिर्फ इसलिए कि उनकी समान जटिलता है इसका मतलब यह नहीं है कि वे सभी समान रूप से तेजी से काम करते हैं। मैंने विभिन्न आंकड़ों पर उनकी वास्तविक गति की तुलना करने की कोशिश की और देखा कि उनकी नौकरी में कौन बेहतर है।

आमतौर पर, एक ही डेटा पर एक ही जटिलता के साथ विभिन्न एल्गोरिदम के संचालन का वास्तविक समय कई बार भिन्न हो सकता है। आइए याद रखें कि ऐसा क्यों होता है और विकिपीडिया से पूछें कि वाक्यांश "एल्गोरिथ्म में जटिलता ओ (एन लॉग एन)" का क्या अर्थ है

O (n log n) एल्गोरिथ्म की जटिलता का अर्थ है कि बड़े n के लिए, एल्गोरिथम का रनिंग टाइम (या संचालन की कुल संख्या) C · n लॉग एन से अधिक नहीं है, जहां C एक निश्चित सकारात्मक स्थिरांक है।

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

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

एल्गोरिदम की तुलना में

Timsort

अच्छा विचार यहाँ , मुख्य विचार को उद्धृत करने के लिए:

एक विशेष एल्गोरिथ्म इनपुट सरणी को उप-भागों में विभाजित करता है
प्रत्येक सबर्रे को नियमित प्रविष्टि सॉर्टिंग द्वारा सॉर्ट किया जाता है।
सॉर्ट किए गए उप-प्रकार को एकल मर्ज में एक संशोधित मर्ज सॉर्ट का उपयोग करके इकट्ठा किया जाता है

सर्वोत्तम मामले में जटिलता (इनपुट डेटा को किसी भी क्रम में क्रमबद्ध किया जाता है, शायद रिवर्स की भी आवश्यकता होती है) O (n) है, और सामान्य रूप से O (n log n) से भी बदतर नहीं है।
ओ (n) अतिरिक्त मेमोरी की आवश्यकता है।

बड़ा लाभ यह है कि एल्गोरिथ्म अन्य काफी सरल एल्गोरिदम का एक संयोजन है, इसलिए इसे विभिन्न डेटा संरचनाओं के साथ परिष्कृत संचालन की आवश्यकता नहीं है। इसलिए, एक अच्छे प्रदर्शन की उम्मीद है।

Smoothsort

यह 1981 में कुख्यात ई। वी। डिक्जस्ट्रॉय द्वारा आविष्कार किया गया था और हीप्सोर्ट विचार का एक विकास है - एक बाइनरी हीप (अच्छी तरह से, या एक पिरामिड का उपयोग करके सॉर्ट करना, जैसा आप चाहते हैं)।

सबसे पहले, मैं आपको याद दिलाता हूं कि कैसे हीप्सोर्ट काम करता है:

इसमें एक तत्व जोड़कर एक ढेर का निर्माण करें (प्रत्येक के लिए जटिलता ओ (लॉग एन), कुल ओ (एन लॉग एन))
जब तक यह खाली न हो जाए, तब तक बनाए गए ढेर के मूल में निहित अधिकतम तत्व को पुनः प्राप्त करें। चूंकि जब जड़ को हटा दिया जाता है, तो ढेर दो स्वतंत्र लोगों में विभाजित हो जाता है, आपको ओ (लॉग एन) के बाद उन्हें एक में इकट्ठा करने की आवश्यकता होती है। एन तत्वों के लिए कुल में - ओ भी (एन लॉग एन)

एक अनुकूलन है जो आपको जटिलता ओ (एन) के साथ पहला कदम पूरा करने की अनुमति देता है, लेकिन दूसरे चरण में अभी भी जटिलता ओ (एन लॉग एन) होगी।
एल्गोरिथ्म में ओ (1) अतिरिक्त मेमोरी की आवश्यकता होती है, ढेर सीधे मूल डेटा सरणी में संग्रहीत होता है।

डायजकस्ट्रा ने लियोनार्डो ढेर के एक निर्धारित सेट के साथ एल्गोरिथ्म में एक बाइनरी हीप की जगह लेने का सुझाव दिया, जो लियोनार्डो विशेष संख्याओं के आधार पर बनाया गया है।

लियोनार्डो संख्या को निम्नानुसार परिभाषित किया गया है:

  L (0) = 1, L (1) = 1, L (i) = L (i - 2) + L (i - 1) + 1

इस क्रम के पहले कुछ सदस्य इस प्रकार हैं:

1, 3, 5, 9, 15, 25, 41, ...

लियोनार्डो के kth ढेर एक द्विआधारी वृक्ष है जिसमें वर्टिकल L (k) की संख्या है जो निम्नलिखित स्थितियों को संतुष्ट करता है:

जड़ में लिखी संख्या उप-संख्या में संख्या से कम नहीं है (इसीलिए एक गुच्छा)
बाएं सबट्री लियोनार्डो (k-1) वें ढेर है
अधिकार - (के -2) -थ

ढेर को आकार द्वारा आदेश दिया जाना चाहिए (सबसे बड़ा छोड़ दिया गया है), और उनकी जड़ों के मूल्यों को बाएं से दाएं नहीं घटाना चाहिए, जिसका अर्थ है कि सही-सबसे ढेर की जड़ हमेशा संरचना का अधिकतम तत्व होगी। संरचना मूल सरणी में संग्रहीत है, अतिरिक्त मेमोरी का आकार ओ (1) है।

किसी भी प्राकृतिक संख्या को लियोनार्दो संख्याओं के योग में विघटित किया जा सकता है, जिसका अर्थ है कि उपरोक्त संरचना को किसी भी संख्या के लिए बनाया जा सकता है।

13 तत्वों के लिए लियोनार्डो ढेर से एक संरचना का एक उदाहरण। तीन ढेर का उपयोग किया जाता है: 4, 2 और 1।

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

किसी आइटम को जोड़ते समय, ढेरों को फिर से बनाया जाना चाहिए (चित्र में लियोनार्डो के ढेर की संपत्ति 1 को पुनर्स्थापित नहीं किया गया है)

अधिकतम निकालना एक तत्व को जोड़ने के समान है और इसमें ओ (लॉग एन) से अधिक जटिलता नहीं है।

स्मूथसॉर्ट छँटाई एल्गोरिथ्म ही दो चरणों में काम करता है, जैसे हीप्सोर्ट:

एक समय में एक को जोड़कर, सभी तत्वों के लिए कई लियोनार्डो ढेर बनाए जाते हैं (प्रत्येक के लिए ओ (लॉग एन) से अधिक नहीं)
बदले में, अधिकतम तत्व निर्मित संरचना से निकाले जाते हैं (अधिकतम हमेशा सबसे सही ढेर की जड़ होगी) और संरचना को आवश्यक रूप से पुनर्स्थापित किया जाता है (प्रत्येक तत्व के लिए O (लॉग एन) से अधिक नहीं)

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

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

शेल्सॉर्ट (शैल क्रमबद्ध)

शैल छँटाई आवेषण छँटाई के लिए एक ऐड-ऑन है; एक पास के बजाय, हम कई करते हैं, और i-th पास पर हम एक दूसरे से कुछ दूरी पर खड़े तत्वों की उप-प्रकारों को सॉर्ट करते हैं।

इस स्थिति में, अंतिम पास पर, d _i 1 के बराबर होना चाहिए (अर्थात, अंतिम चरण आवेषण द्वारा सामान्य छंटाई है), यह एल्गोरिथ्म की शुद्धता की गारंटी देता है।

उदाहरण के लिए: 12 तत्वों की एक सरणी को छाँटना आवश्यक है, पास की संख्या 3 है, d ₁ = 5, d ₂ = 3, d ₃ = 1
पहले चरण में, निम्न सरणियों को क्रमबद्ध किया जाएगा:

(a1, a6, a11), (a2, a7, a12), (a3, a8), (a4, a9), (a5, a10)

दूसरे पर:

(a1, a4, a7, a10), (a2, a5, a8, a11), और a3, a6, a9, a12)

और तीसरे सरणी (a1, ..., a12) पर पूरी तरह से

आवेषण की सामान्य छंटाई पर लाभ यह है कि पहले पास में सरणी के तत्वों को कदमों में नहीं बल्कि _{i i} और d _i में स्थानांतरित किया जाता है, और एक निश्चित इलाके में पहले से ही अंतिम पास तक पहुंच गए हैं (तत्व अपने अंतिम स्थानों के करीब हैं), इसलिए बड़ी संख्या में उत्पादन करने की आवश्यकता नहीं है आदान-प्रदान।

एल्गोरिथ्म की जटिलता पास की संख्या और डी _i के मूल्यों की पसंद पर निर्भर करती है, और बहुत भिन्न हो सकती है; विकिपीडिया की एक विशेष तालिका है। परीक्षण के लिए, मैंने यहां वर्णित विकल्प चुना, सबसे खराब स्थिति में, इसकी जटिलता हे (एन ^4/3 ), और औसत ओ (एन ^7/6 ) है।

यदि डेटा को शुरू में सही क्रम में सॉर्ट किया जाता है, तो एक भी एक्सचेंज नहीं बनाया जाएगा, सभी पास "निष्क्रिय" हो जाएंगे। इसलिए, इस मामले में जटिलता केवल पास की संख्या पर निर्भर करती है। यदि उनकी संख्या निश्चित है, तो यह सिर्फ O (n) होगा।

ओ (1) अतिरिक्त मेमोरी की आवश्यकता है।

यहाँ , यहाँ और यहाँ पढ़ें।

तुलना

दरअसल, यहां सबसे दिलचस्प हिस्सा है - विभिन्न डेटा पर उपरोक्त सभी तरीकों का परीक्षण करना और उनके वास्तविक समय की तुलना करना।

निम्नलिखित कार्यान्वयन ने परीक्षण में भाग लिया, सभी कोड शुद्ध सी में लिखे गए हैं:

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

परीक्षण पैरामीटर

केवल छँटाई एल्गोरिथ्म की प्रतिक्रिया समय (सेकंड में) मापा गया था, परीक्षण डेटा उत्पन्न करने के समय को ध्यान में नहीं रखा गया था। प्रत्येक एल्गोरिथ्म को तीन बार एक ही डेटा पर चलाया गया था, सबसे अच्छा परिणाम को ध्यान में रखा गया था (ताकि अल्पकालिक सिस्टम लोड हमारे महत्वपूर्ण प्रयोग को प्रभावित न करें :))

आयरन: HP DV3510er लैपटॉप, इंटेल कोर 2 डुओ 2GHz, 2GB रैम।
OS: उबंटू 11.10

विभिन्न डेटा पर चार प्रयोग किए गए:

प्रयोग 1: साधारण डेटा पर काम करना

इस प्रयोग का उद्देश्य मनमाने ढंग से एल्गोरिदम के प्रदर्शन की तुलना करना है, न कि आदेशित डेटा। 10 ⁸ यादृच्छिक यादृच्छिक संख्याओं के 10 सेट उत्पन्न किए गए थे, प्रत्येक एल्गोरिथ्म के लिए, औसत परिचालन समय मापा गया था।

मनमानी डेटा के मामले में सभी परीक्षण किए गए एल्गोरिदम की जटिलता (शेलसॉर्ट को छोड़कर) हे (एन लॉग एन) है। दरअसल, यहां हम बहुत स्थिर सी के प्रभाव का पता लगा सकते हैं।

जैसा कि हम देख सकते हैं, किसी भी डेटा संरचनाओं का उपयोग नहीं करने वाले एल्गोरिदम काफी गंभीरता से आगे बढ़ चुके हैं। अगला, हम आंशिक रूप से ऑर्डर किए गए डेटा पर विचार करेंगे।

प्रयोग 2: समान आकार के स्वतंत्र सॉर्ट किए गए समूह

10 ⁸ विभिन्न प्राकृतिक संख्याओं को देखते हुए, बढ़ते क्रम में क्रमबद्ध। उन्हें लगातार तत्वों द्वारा समूहित करें और सभी समूहों को रिवर्स ऑर्डर में पुनर्व्यवस्थित करें।
दस नंबरों के लिए उदाहरण: 1 2 3 4 5 6 7 8 9 10
k = 1: 10 9 8 7 6 5 4 3 2 1
k = 3: 8 9 10 5 6 7 2 3 4 1
k = 5: 6 7 8 9 10 1 2 3 4 5
k = 10: 1 2 3 4 5 6 7 8 9 10

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

10 की शक्तियों के बराबर सभी k के लिए माप लिया गया था।

आप निम्नलिखित पैटर्न देख सकते हैं:

जब डेटा आंशिक रूप से सॉर्ट किया जाता है (दोनों ग्राफ़ की तुलना करें) क्विकॉर्ट और हीप्सॉर्ट भी प्यार करते हैं। यह स्पर्शोन्मुख जटिलता को प्रभावित नहीं करता है, लेकिन काम की गति अभी भी काफी बढ़ जाती है
Timsort परवाह नहीं करता है कि डेटा किस क्रम में क्रमबद्ध है, दोनों मामलों में यह बहुत तेजी से काम करता है
स्मूथसॉर्ट की आंशिक डेटा ऑर्डर करने की अपनी समझ है। इस परीक्षण में वास्तविक प्रदर्शन लाभ केवल पूरी तरह से सॉर्ट किए गए डेटा के साथ ध्यान देने योग्य है। इस मामले में भी जब सरणी में छोटी संख्या में पूरी तरह से छांटे गए टुकड़े होते हैं, तो उन्हें पुनर्व्यवस्थित करने के लिए, एल्गोरिथ्म को लियोनार्डो ढेर के साथ बड़ी संख्या में ऑपरेशन करने की आवश्यकता होती है, जो काफी "भारी" हैं।
शेल्सॉर्ट, इसकी अधिक जटिलता (n = 10 ⁸ n ^7/6 > n लॉग एन के साथ) के बावजूद, अक्सर स्मूथसॉर्ट की तुलना में कम समय में काम करता है। यह एल्गोरिथम की सापेक्ष सादगी के कारण है। लेकिन पूरी तरह से सॉर्ट किए गए डेटा के साथ, शेल्सॉर्ट अभी भी सभी पास करने के लिए मजबूर है, भले ही एक तत्व को फिर से व्यवस्थित न कर रहा हो। इसलिए, k = 10 ^{8 के लिए,} परिणाम माना एल्गोरिदम में लगभग सबसे खराब है

प्रयोग 3: विभिन्न आकारों के क्रमबद्ध समूह, मूल्यों की सीमित सीमा

एक सीमित सीमा से 10 ⁸ पूर्णांक दिए गए हैं (हमारे मामले में [0 ... 100000]) और उन्हें 1 से k तक के मनमाने आकार के समूहों द्वारा आदेश दिया गया है।

इस तरह का डेटा सेट पहले से ही वास्तविक कार्यों के डेटा से मेल खाता है, मुझे डायस निकटता गुणांकों की गणना के लिए उन लोगों से निपटना पड़ा

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

प्रयोग 4: मनमानी व्यवस्था

हम दूसरे तरीके से आंशिक रूप से ऑर्डर किए गए डेटा उत्पन्न करेंगे: 10 ⁸ मनमाना प्राकृतिक संख्याएं लें, उन्हें क्रमबद्ध करें और स्थानों में दो तत्वों के मनमाने ढंग से क्रमांकन करें।

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

परिणाम

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

नेटवर्क पर स्मूथर्स के बारे में काफी जानकारी है (अन्य एल्गोरिदम की तुलना में) और आकस्मिक नहीं: विचार और विवादास्पद प्रदर्शन की जटिलता के कारण, यह एक लागू पद्धति की तुलना में एल्गोरिथम शोधन की अधिक संभावना है। मुझे इस एल्गोरिथम का केवल एक वास्तविक अनुप्रयोग मिला - सोफिया-सिप लाइब्रेरी में, जिसका उद्देश्य आईएम और वीओआईपी अनुप्रयोगों के निर्माण के लिए है।

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

मैं ध्यान देना चाहता हूं कि मैंने विशेष रूप से प्रदर्शन की तुलना की है, और विशेष रूप से अन्य मापदंडों (जैसे अतिरिक्त मेमोरी का उपयोग) पर ध्यान केंद्रित नहीं किया है।

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

पढ़ने के लिए धन्यवाद। मुझे आशा है कि आप रुचि रखते थे।

और फिर से छँटाई के बारे में: हम सबसे अच्छा एल्गोरिथ्म चुनते हैं