क्विकसॉर्ट, मर्जर्ट से बेहतर क्यों है?

354

यह सवाल मुझसे एक इंटरव्यू के दौरान पूछा गया था। वे दोनों O (nlogn) हैं और फिर भी ज्यादातर लोग Mergesort के बजाय Quicksort का उपयोग करते हैं। ऐसा क्यों है?

— मलिक दाउद अहमद खोखर
स्रोत

91

यह बहुत अच्छा साक्षात्कार प्रश्न नहीं है। वास्तविक दुनिया के डेटा में फेरबदल नहीं किया जाता है: इसमें अक्सर बहुत सारे आदेश होते हैं जो एक स्मार्ट सॉर्ट का उपयोग कर सकते हैं, और जबकि न तो एल्गोरिथ्म स्वचालित रूप से ऐसा करता है, यह एक क्वॉर्ट्स की तुलना में ऐसा करने के लिए मर्ज सॉर्ट को हैक करना आसान है। GNU libc qsort, Python's list.sort, और Array.prototype.sortफ़ायरफ़ॉक्स के जावास्क्रिप्ट में सभी सॉलिड-अप मर्ज प्रकार हैं। (जीएनयू एसटीएल sortइसके बजाय इंट्रोस्पोर्ट का उपयोग करता है, लेकिन ऐसा इसलिए हो सकता है क्योंकि सी ++ में, स्वैपिंग संभावित रूप से कॉपी करने पर बड़ी जीत होती है।)

— जेसन ओरेन्डोर्फ

3

@ जेसन ऑरेन्डोर: यह क्यों है "easier to hack a mergesort to do it than a quicksort"? कोई विशिष्ट उदाहरण जिसे आप उद्धृत कर सकते हैं?

— लेज़र

16

@eSKay प्रारंभिक डेटा को सॉर्ट किए गए सबरेज़ में समूहित करके एक मर्ज सॉर्ट प्रारंभ होता है। यदि सरणी में शुरू में कुछ पहले से ही सॉर्ट किए गए क्षेत्र हैं, तो आप यह पता लगाने से बहुत समय बचा सकते हैं कि आपके शुरू होने से पहले वे वहां हैं। और आप इसे O (n) समय में कर सकते हैं। विशिष्ट उदाहरणों के लिए, मेरे द्वारा उल्लिखित तीन परियोजनाओं के स्रोत कोड देखें! सबसे अच्छा उदाहरण पायथन का टिम्सॉर्ट हो सकता है, यहां विस्तार से वर्णन किया गया है: svn.python.org/view/python/trunk/Objects/… और svn.python.org/view/python/nunk/Objects/… में कार्यान्वित किया गया ।

— जेसन ओरेंडोर्फ

4

@JasonOrendorff: सुनिश्चित नहीं है कि मैं आपके तर्क को खरीदता हूं कि पहले से ही सॉर्ट किए गए अनुभागों का लाभ लेने के लिए मर्ज़ॉर्ट्स को अधिक आसानी से संशोधित किया जा सकता है। क्विकॉर्ट के विभाजन चरण को तुच्छ रूप से बाद में संशोधित किया जा सकता है, यह देखने के लिए कि क्या परिणामी विभाजन छँटे गए हैं, और यदि वे हैं तो पुनरावृत्ति रोकें। यह संभावित रूप से तुलना की संख्या को दोगुना कर देता है, लेकिन उस चरण के ओ (एन) समय की जटिलता को नहीं बदलता है।

— j_random_hacker

3

@j_random_hacker: सही है, कि मैं क्या कर रहा था। लेकिन विचार करें: {१०, २, ३, ४, ५, ६,,,,, १, ९} लगभग पूरी तरह से पहले से ही हल होने के बावजूद, विभाजन से पहले जाँचने से यह पता नहीं चलेगा, न ही बाद में। और विभाजन बाद में इसके लिए जांच करेगा कॉल इससे पहले कि यह जांच करेगा। इस बीच, किसी भी स्थानांतरित होने से पहले विभाजन चरणों में सॉर्ट किए गए अनुक्रमों के लिए मर्ज की जाँच करें, और स्मार्ट लोग विशेष रूप से विभाजन चरण के दौरान इस तरह के रनों की तलाश करेंगे (देखें: टिम सॉर्ट)

— मूविंग डक

275

क्विकॉर्ट के पास ओ ( एन ² ) सबसे खराब स्थिति वाला रनटाइम और ओ ( एन लॉग एन ) औसत केस रनटाइम है। हालाँकि, यह कई परिदृश्यों में सॉर्ट मर्ज करने के लिए बेहतर है क्योंकि कई कारक एक एल्गोरिथ्म के रनटाइम को प्रभावित करते हैं, और, जब उन सभी को एक साथ ले जाते हैं, तो एस्कॉर्ट जीत जाता है।

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

इसके अलावा, ओक्स ( n ² ) के क्विकॉर्ट के सबसे खराब-केस रन से बचना बहुत आसान है, लगभग पूरी तरह से धुरी के एक उपयुक्त विकल्प का उपयोग करके - जैसे कि इसे यादृच्छिक पर चुनना (यह एक उत्कृष्ट रणनीति है)।

व्यवहार में, क्विकसॉर्ट के कई आधुनिक कार्यान्वयन (विशेष रूप से libstdc ++ के std::sort) वास्तव में आत्मनिरीक्षण हैं , जिनका सैद्धांतिक सबसे खराब मामला ओ ( एन लॉग एन ) है, जो मर्ज सॉर्ट के समान है। यह पुनरावृत्ति की गहराई को सीमित करके और लॉग एन से अधिक हो जाने पर एक अलग एल्गोरिथ्म ( हीप्सोर्ट ) पर स्विच करके इसे प्राप्त करता है ।

— कोनराड रुडोल्फ
स्रोत

4

विकिपीडिया लेख में कहा गया है कि यह गतिरोध में बदल जाता है, विलय नहीं ... सिर्फ FYI करें।

— सेव सिप

3

@Sev: ... जैसा कि ओरिजिनल पेपर करता है। गलती को इंगित करने के लिए धन्यवाद। - ऐसा नहीं है कि यह वास्तव में मायने रखता है, क्योंकि उनके स्पर्शोन्मुख चलने का समय समान है।

— कोनराड रुडोल्फ

110

इसे सही उत्तर के रूप में क्यों चुना गया है? यह सब बताता है कि समस्याओं का त्वरित समाधान कैसे किया जाता है। यह अभी भी नहीं बताता है कि त्वरित सॉर्ट का उपयोग अन्य की तुलना में अधिक क्यों किया जाता है? क्या उत्तर "त्वरित सॉर्ट का उपयोग अन्य की तुलना में अधिक किया जाता है क्योंकि एक गहराई के बाद आप हेस्पोर्ट पर स्विच कर सकते हैं"? .. क्यों नहीं पहली जगह में हीप्सोर्ट का उपयोग करें? .. बस समझने की कोशिश कर रहा हूँ ...

— कोडऑबस्वर

16

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

— कोनराड रुडोल्फ

4

मेमोरी के साथ-साथ क्विकॉर्ट बेहतर है।

— शाश्वत

287

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

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

इसलिए यदि डेटा को डिस्क पर सॉर्ट करना है, तो आप वास्तव में, वास्तव में विलय पर कुछ भिन्नता का उपयोग करना चाहते हैं। (आम तौर पर आप उपलेटा को फुर्सत में रखते हैं, फिर उन्हें कुछ आकार सीमा के ऊपर एक साथ मिलाना शुरू करते हैं।)

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

ऐसे कई अवसर आए हैं, जहां डिस्क खोज से बचने के तरीके समझने से मुझे डेटा प्रसंस्करण कार्य करने में दिन या सप्ताह लगने के बजाय घंटों लग गए हैं।

— user11318
स्रोत

1

बहुत अच्छा, डेटा संरचना तक पहुँचने के लिए बनाई गई मान्यताओं के बारे में नहीं सोचा। अच्छी अंतर्दृष्टि :)

— चुतसू

2

क्या आप बता सकते हैं कि "डिस्क टू सीक" से आपका क्या मतलब है जब डेटा डिस्क पर संग्रहीत होता है तो कुछ एकल मान की खोज करता है?

— जेम्स विर्ज़बा

8

@JamesWierzba मैं इसे इस संदर्भ से लेता हूं कि उसका अर्थ है "डिस्क पर स्थान की तलाश"। घूर्णन डिस्क डिवाइस पर "तलाश" का अर्थ है, पढ़ने वाले सिर को उठाकर एक नए निरपेक्ष पते पर ले जाना, जो एक कुख्यात धीमा ऑपरेशन है। जब आप संग्रहीत डेटा को उस क्रम में एक्सेस करते हैं, तो डिस्क हार्डवेयर की तलाश नहीं होती है, यह केवल उच्च गति पर चलता है, क्रमबद्ध तरीके से आइटम को पढ़ता है।

— 16'16 को nclark

1

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

— सैम

1

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

— ssd

89

दरअसल, क्विकसॉर्ट O (n ² ) है। इसका औसत केस रनिंग टाइम O (nlog (n)) है, लेकिन इसका सबसे खराब मामला O (n ² ) है, जो तब होता है जब आप इसे किसी अनूठे आइटम की सूची में चलाते हैं। यादृच्छिकता O (n) लेता है। बेशक, यह इसके सबसे खराब मामले को नहीं बदलता है, यह सिर्फ एक दुर्भावनापूर्ण उपयोगकर्ता को आपके सॉर्ट को लंबा समय लेने से रोकता है।

QuickSort अधिक लोकप्रिय है क्योंकि यह:

इन-प्लेस (मर्जसॉर्ट को क्रमबद्ध किए जाने वाले तत्वों की संख्या के लिए अतिरिक्त मेमोरी रैखिक की आवश्यकता होती है)।
एक छोटा सा छिपी स्थिरांक है।

— डार्क शिकारी
स्रोत

4

दरअसल, क्विकॉर्ट के कार्यान्वयन हैं जो सबसे खराब स्थिति में ओ (एन * लॉग (एन)) हैं, न कि ओ (एन ^ 2)।

— JFS

12

यह कंप्यूटर की वास्तुकला पर भी निर्भर करता है। Quicksort कैश से लाभान्वित होता है, जबकि MergeSort नहीं।

— क्रिस्टियन सियुपिटु

4

@ जेएफ सेबेस्टियन: ये सबसे संभवत: इंट्रॉस्ट कार्यान्वयन हैं, न कि क्विकॉर्ट (इंट्रोसर्ट क्विकॉर्ट के रूप में शुरू होता है और अगर यह एन * लॉग (एन)) को रोकने के बारे में है, तो हाईस्पोर्ट पर स्विच करता है।

— सीजरबी

44

आप एक मर्ज को लागू कर सकते हैं।

— मार्सिन

6

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

— स्पष्ट

29

"और अभी भी ज्यादातर लोग मेरिजॉर्ट के बजाय क्विकॉर्ट का उपयोग करते हैं। ऐसा क्यों है?"

एक मनोवैज्ञानिक कारण जो नहीं दिया गया है वह यह है कि क्विकॉर्ट को अधिक चतुराई से नाम दिया गया है। यानी अच्छी मार्केटिंग।

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

— एश
स्रोत

3

जो बेहतर है उसके बारे में सवाल का जवाब नहीं देता है। एल्गोरिथ्म का नाम निर्धारित करने में अप्रासंगिक है जो बेहतर है।

— निक गैलीमोर

18

जैसा कि अन्य ने उल्लेख किया है, क्विकसॉर्ट का सबसे खराब मामला ओ (एन ^ 2) है, जबकि मर्जर्ट्स और हेस्पोर्ट ओ (एनएलएनएन) पर रहते हैं। औसत मामले पर, हालांकि, तीनों हे (nlogn) हैं; इसलिए वे काफी हद तक तुलनीय मामलों के लिए हैं।

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

— जेवियर
स्रोत

9

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

लेकिन, सच कहा जाए, तो व्यावहारिक स्थितियों में ज्यादातर लोगों को केवल अच्छे औसत प्रदर्शन की जरूरत होती है और क्विकॉर्ट ... क्विक =

सभी प्रकार के एल्गोरिदम में उनके उतार-चढ़ाव होते हैं। एक अच्छे अवलोकन के लिए एल्गोरिदम को सॉर्ट करने के लिए विकिपीडिया लेख देखें ।

— अंति रसिनें
स्रोत

7

से quicksort पर विकिपीडिया प्रविष्टि :

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

— gnobal
स्रोत

7

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

मेरिजॉर्ट यह विचार करने योग्य है कि यदि गति सार की है, तो सबसे खराब स्थिति का प्रदर्शन बर्दाश्त नहीं किया जा सकता है, और अतिरिक्त स्थान उपलब्ध है। 1

आपने कहा कि वे «वे दोनों ओ (नॉग्न) […] हैं। ये गलत है। «Quicksort सबसे खराब स्थिति में n ^ 2/2 तुलना के बारे में उपयोग करता है।» 1 ।

हालांकि मेरे अनुभव के अनुसार सबसे महत्वपूर्ण संपत्ति अनुक्रमिक पहुंच का आसान कार्यान्वयन है जिसे आप प्रोग्रामिंग भाषाओं का उपयोग करते समय सॉर्टिंग के साथ उपयोग कर सकते हैं।

1 सेग्विक, एल्गोरिदम

— रोमन ग्लास
स्रोत

मर्जरोर्ट को जगह में लागू किया जा सकता है, जैसे कि इसे अतिरिक्त स्थान की आवश्यकता नहीं है। उदाहरण के लिए एक डबल लिंक की गई सूची के साथ: stackoverflow.com/questions/2938495/…

— lanoxx

6

Quicksort व्यवहार में सबसे तेज़ छँटाई वाला एल्गोरिथम है, लेकिन इसमें कई रोग संबंधी मामले हैं जो इसे O (n2) के रूप में खराब प्रदर्शन कर सकते हैं।

हीप्सोर्ट को O (n * ln (n)) में चलाने की गारंटी है और इसके लिए केवल अतिरिक्त अतिरिक्त भंडारण की आवश्यकता है। लेकिन वास्तविक विश्व परीक्षणों के कई उद्धरण हैं जो बताते हैं कि औसत से तेज गति की तुलना में हीप्सॉर्ट काफी धीमा है।

— नियाज़
स्रोत

5

विकिपीडिया की व्याख्या है:

आमतौर पर, एस्कॉर्ट अन्य n (nlogn) एल्गोरिदम की तुलना में व्यवहार में काफी तेज है, क्योंकि इसके आंतरिक लूप को अधिकांश आर्किटेक्चर पर कुशलतापूर्वक लागू किया जा सकता है, और अधिकांश वास्तविक दुनिया के डेटा में डिजाइन विकल्प बनाना संभव है जो कि द्विघात समय की आवश्यकता की संभावना को कम करते हैं। ।

जल्दी से सुलझाएं

मर्ज़ सॉर्ट

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

— मात मानियन
स्रोत

क्विकॉर्ट्स का सबसे खराब मामला ओ (एन), मर्जेसर्ट ओ (एन लॉग एन) है - इसलिए इसमें एक बड़ा अंतर है।

— पौल २३

1

सबसे बुरी स्थिति क्विकॉर्ट्स ओ (n ^ 2) है - मेरी पिछली टिप्पणी को संपादित नहीं कर सकता है और एक टाइपो बना है

— paul23

@ paul23 टिप्पणियों को हटाया जा सकता है। इसके अलावा, उत्तर ने आपकी बात को पहले ही संबोधित कर दिया था: "सबसे वास्तविक दुनिया के आंकड़ों में यह डिजाइन विकल्प बनाना संभव है जो द्विघात समय की आवश्यकता की संभावना को कम करता है"

— जिम बेल्टर

5

मैं मौजूदा महान उत्तरों में कुछ गणित जोड़ना चाहूंगा कि क्विकॉर्ट कैसे सर्वश्रेष्ठ मामले से हटकर प्रदर्शन करता है और यह कैसे संभव है, जो मुझे आशा है कि लोगों को थोड़ा बेहतर समझने में मदद मिलेगी कि क्यों ओ (एन ^ 2) मामला वास्तविक नहीं है QuickSort के अधिक परिष्कृत कार्यान्वयन में चिंता।

रैंडम एक्सेस मुद्दों के बाहर, दो मुख्य कारक हैं जो क्विकसॉर्ट के प्रदर्शन को प्रभावित कर सकते हैं और वे दोनों इस बात से संबंधित हैं कि डेटा की छंटनी कैसे की जाती है।

1) डेटा में कुंजियों की एक छोटी संख्या। सभी समान मानों का एक डेटासेट वैनीला 2-विभाजन क्विकॉर्ट पर n ^ 2 समय में सॉर्ट करेगा क्योंकि पिवट लोकेशन को छोड़कर सभी मान हर बार एक तरफ रखे जाते हैं। आधुनिक कार्यान्वयन 3-विभाजन प्रकार का उपयोग करके विधियों द्वारा इसे संबोधित करते हैं। ये विधियाँ O (n) समय में सभी समान मानों के डेटासेट पर निष्पादित होती हैं। इसलिए इस तरह के कार्यान्वयन का उपयोग करने का मतलब है कि कम संख्या में कुंजी के साथ एक इनपुट वास्तव में प्रदर्शन के समय में सुधार करता है और अब चिंता का विषय नहीं है।

2) अत्यधिक खराब धुरी चयन सबसे खराब स्थिति प्रदर्शन का कारण बन सकता है। एक आदर्श मामले में, धुरी हमेशा ऐसी होगी कि 50% डेटा छोटा होता है और 50% डेटा बड़ा होता है, जिससे प्रत्येक पुनरावृत्ति के दौरान इनपुट आधे में टूट जाएगा। यह हमें n तुलना देता है और O (n * logn) समय के लिए लॉग -2 (n) पुनरावृत्ति स्वैप समय देता है।

गैर-आदर्श धुरी चयन निष्पादन समय को कितना प्रभावित करता है?

आइए एक मामले पर विचार करें जहां पिवट को लगातार चुना जाता है ताकि 75% डेटा पिवट के एक तरफ हो। यह अभी भी O (n * logn) है, लेकिन अब लॉग का आधार 1 / 0.75 या 1.33 में बदल गया है। आधार बदलते समय प्रदर्शन में संबंध हमेशा लॉग (2) / लॉग (newBase) द्वारा निरूपित होता है। इस मामले में, वह निरंतर 2.4 है। इसलिए धुरी के चुनाव का यह गुण आदर्श की तुलना में 2.4 गुना अधिक है।

यह कितनी तेजी से खराब होता है?

बहुत जल्दी नहीं जब तक कि धुरी का विकल्प नहीं मिलता (लगातार) बहुत बुरा:

एक तरफ 50%: (आदर्श मामला)
एक तरफ 75%: लंबे समय तक 2.4 गुना
एक तरफ 90%: लंबे समय तक 6.6 गुना
एक तरफ 95%: लंबे समय तक 13.5 गुना
एक तरफ 99%: लंबे समय तक 69 बार

जैसे ही हम एक तरफ 100% पहुंचते हैं, निष्पादन का लॉग भाग n के पास पहुंच जाता है और पूरा निष्पादन asymptotically O (n ^ 2) के पास पहुंच जाता है।

क्विकसॉर्ट के एक भोले-भाले कार्यान्वयन में, सॉर्ट किए गए एरे (प्रथम तत्व पिवट के लिए) या रिवर्स-सॉर्टेड ऐरे (अंतिम तत्व पिवट के लिए) जैसे मामले विश्वसनीय रूप से एक खराब स्थिति वाले ओ (एन ^ 2) निष्पादन समय का उत्पादन करेंगे। इसके अतिरिक्त, एक पूर्वानुमानित धुरी चयन के साथ कार्यान्वयन को सबसे खराब स्थिति निष्पादन के लिए डिज़ाइन किए गए डेटा द्वारा DoS हमले के अधीन किया जा सकता है। आधुनिक कार्यान्वयन विभिन्न तरीकों से इससे बचते हैं, जैसे कि डेटा को क्रमबद्ध करने से पहले यादृच्छिक करना, 3 बेतरतीब ढंग से चुने गए अनुक्रमों के माध्यिका का चयन करना आदि। मिश्रण में इस यादृच्छिककरण के साथ, हमारे पास 2 मामले हैं:

छोटा डेटा सेट। सबसे खराब मामला यथोचित रूप से संभव है लेकिन O (n ^ 2) भयावह नहीं है क्योंकि n इतना छोटा है कि n ^ 2 भी छोटा है।
बड़ा डेटा सेट। सबसे खराब मामला सिद्धांत में संभव है लेकिन व्यवहार में नहीं।

हम कितना भयानक प्रदर्शन देख सकते हैं?

संभावना गायब छोटे हैं । आइए एक प्रकार के 5,000 मानों पर विचार करें:

हमारा काल्पनिक कार्यान्वयन 3 बेतरतीब ढंग से चुने गए अनुक्रमों के माध्यिका का उपयोग करके एक धुरी का चयन करेगा। हम उन पिवोट्स पर विचार करेंगे जो 25% -75% रेंज में "अच्छे" और पिवोट्स हैं जो 0% -25% या 75% -100% रेंज में "खराब" हैं। यदि आप 3 यादृच्छिक अनुक्रमितों के माध्यिका का उपयोग करके संभाव्यता वितरण को देखते हैं, तो प्रत्येक पुनरावृत्ति के पास एक अच्छी धुरी के साथ समाप्त होने का 11/16 मौका है। हमें गणित को सरल बनाने के लिए 2 रूढ़िवादी (और गलत) धारणाएँ बनाते हैं:

अच्छे पिवोट्स हमेशा 25% / 75% पर विभाजित होते हैं और 2.4 * आदर्श मामले में संचालित होते हैं। हमें कभी भी एक आदर्श विभाजन या 25/75 से बेहतर कोई विभाजन नहीं मिलता है।
खराब पिवोट हमेशा सबसे खराब स्थिति होते हैं और अनिवार्य रूप से समाधान के लिए कुछ भी योगदान नहीं करते हैं।

हमारा QuickSort कार्यान्वयन n = 10 पर रुक जाएगा और सम्मिलन प्रकार पर स्विच हो जाएगा, इसलिए हमें 5,000 मूल्य के इनपुट को नीचे तक तोड़ने के लिए 22 25% / 75% धुरी विभाजन की आवश्यकता है। (१० * १.३३३३३३ ^ २२> ५०००) या, हमें ४ ९ ९ ० सबसे खराब केस पिवोट्स की आवश्यकता है। ध्यान रखें कि अगर हम किसी भी बिंदु पर 22 अच्छे पिवोट्स जमा करते हैं तो सॉर्ट पूरा हो जाएगा, इसलिए सबसे खराब स्थिति या इसके पास की किसी भी चीज के लिए बहुत अच्छे भाग्य की आवश्यकता होती है । अगर यह वास्तव में n = 10 के लिए आवश्यक 22 अच्छे पिवोट्स को प्राप्त करने के लिए 88 पुनरावर्ती हमें ले गया, तो यह 4 * 2.4 * आदर्श मामला होगा या आदर्श मामले के निष्पादन समय के लगभग 10 गुना होगा। यह कैसे संभव है कि हम 88 पुनरावृत्तियों के बाद आवश्यक 22 अच्छे पिवोट्स प्राप्त नहीं करेंगे ?

द्विपद संभाव्यता वितरण इसका उत्तर दे सकते हैं, और इसका उत्तर लगभग 10 ^ -18 है। (n 88 है, k 21 है, पी 0.6875 है) आपका उपयोगकर्ता लगभग एक हजार गुना अधिक बिजली की चपेट में आने की संभावना है 1 सेकंड में यह क्लिक करने के लिए [SORT] की तुलना में वे देखते हैं कि 5,000 आइटम सॉर्ट किसी भी बदतर चलाते हैं 10 * आदर्श मामले से। यह मौका छोटा हो जाता है क्योंकि डेटासेट बड़ा हो जाता है। यहां कुछ सरणी आकार और उनके समान संभावनाएं 10 * से अधिक समय तक चलने वाली हैं:

640 वस्तुओं की सरणी: 10 ^ -13 (60 कोशिशों में से 15 अच्छे धुरी बिंदुओं की आवश्यकता होती है)
5,000 वस्तुओं की सरणी: 10 ^ -18 (88 प्रयासों में से 22 अच्छे पिवोट्स की आवश्यकता है)
40,000 वस्तुओं की सरणी: 10 ^ -23 (116 में से 29 अच्छे पिवोट्स की आवश्यकता होती है)

याद रखें कि यह 2 रूढ़िवादी मान्यताओं के साथ है जो वास्तविकता से भी बदतर हैं। इसलिए वास्तविक प्रदर्शन अभी तक बेहतर है, और शेष संभावना का संतुलन आदर्श के करीब नहीं है।

अंत में, जैसा कि दूसरों ने उल्लेख किया है, यहां तक कि इन बेतुके असंभावित मामलों को एक ढेर के रूप में बदलकर समाप्त किया जा सकता है यदि पुनरावृत्ति ढेर बहुत गहरा हो जाता है। तो TLDR यह है कि क्विकॉर्ट के अच्छे कार्यान्वयन के लिए, सबसे खराब स्थिति वास्तव में मौजूद नहीं है क्योंकि इसे इंजीनियर किया गया है और निष्पादन O (n * logn) समय में पूरा होता है।

— लांस समझदारी
स्रोत

1

"मौजूदा महान जवाब" - कौन से हैं? मैं उनका पता नहीं लगा सकता।

— जिम बाल्टर

त्वरित सॉर्ट के किसी भी रूपांतर को विभाजन के बारे में तुलनात्मक फ़ंक्शन को सूचित करें, इस तरह से यह उन स्थितियों का दोहन करने की अनुमति देगा जहां एक विभाजन में कुंजी का एक बड़ा हिस्सा सभी मदों के लिए समान होगा?

— सुपरकैट

4

क्विकॉर्ट क्यों अच्छा है?

QuickSort सबसे खराब स्थिति और NlogN औसत मामले में N ^ 2 लेता है। सबसे खराब स्थिति तब होती है जब डेटा को सॉर्ट किया जाता है। छँटाई शुरू होने से पहले यादृच्छिक फेरबदल द्वारा इसे कम किया जा सकता है।
क्विकसॉर्ट अतिरिक्त मेमोरी नहीं लेता है जो मर्ज सॉर्ट द्वारा लिया जाता है।
यदि डेटासेट बड़ा है और समान आइटम हैं, तो क्विकॉर्ट की जटिलता 3 तरह के विभाजन का उपयोग करके कम हो जाती है। अधिक समान वस्तुओं की संख्या बेहतर नहीं है। यदि सभी आइटम समान हैं, तो यह रैखिक समय में सॉर्ट करता है। [यह अधिकांश पुस्तकालयों में डिफ़ॉल्ट कार्यान्वयन है]

क्या क्विकॉर्ट हमेशा मर्जसॉर्ट से बेहतर है?

ज़रुरी नहीं।

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

नोट: जावा में, Arrays.sort () फ़ंक्शन ऑब्जेक्ट डेटा प्रकारों के लिए आदिम डेटा प्रकारों और मर्जेसर्ट के लिए क्विकॉर्ट का उपयोग करता है। क्योंकि ऑब्जेक्ट मेमोरी ओवरहेड का उपभोग करते हैं, इसलिए मर्जेसर्ट के लिए थोड़ा ओवरहेड जोड़ा गया हो सकता है कि प्रदर्शन के दृष्टिकोण के लिए कोई मुद्दा न हो।

संदर्भ : 3 सप्ताह के क्विकसॉर्ट वीडियो देखें, क्रेसरा में प्रिंसटन एल्गोरिदम कोर्स

— संजीव कुमार दांगी
स्रोत

"यह छँटाई शुरू होने से पहले यादृच्छिक फेरबदल द्वारा कम किया जा सकता है।" - एर, नहीं, यह महंगा होगा। इसके बजाय, यादृच्छिक पिवोट्स का उपयोग करें।

— जिम बैटर

4

क्विकसॉर्ट मर्जर्ट से बेहतर नहीं है। O (n ^ 2) (सबसे खराब स्थिति जो शायद ही कभी होती है) के साथ, quicksort मर्ज सॉर्ट के O (nlogn) की तुलना में संभवतः धीमा है। क्विकॉर्ट के पास कम ओवरहेड है, इसलिए छोटे एन और धीमे कंप्यूटर के साथ, यह बेहतर है। लेकिन कंप्यूटर आज इतनी तेजी से हैं कि एक मर्ज के अतिरिक्त ओवरहेड नगण्य है, और एक बहुत ही धीमी गति से एस्कॉर्ट का जोखिम ज्यादातर मामलों में एक मर्ज की अधिक मात्रा में उपरि से आगे निकल जाता है।

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

— xpda
स्रोत

2

आपका दूसरा वाक्य "... मर्जेसर्ट संभावित रूप से धीमा है ... मर्जर्ट"। पहला संदर्भ संभवतः क्विकॉर्ट को होना चाहिए।

— जोनाथन लेफलर

मर्ज एल्गोरिथ्म स्थिर है, तो मर्ज सॉर्ट केवल स्थिर है; इसकी गारंटी नहीं है।

— स्पष्ट

@Clearer इसकी गारंटी है यदि <=तुलना करने के लिए उपयोग किया जाता है <, और इसका कोई कारण नहीं है।

— जिम बाल्टर

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

— स्पष्ट

@ क्लेयर क्विकॉर्ट एक मर्ज सॉर्ट नहीं है ... आपके 21 दिसंबर के 14 'स्टेटमेंट का मैंने जवाब दिया कि यह मर्ज सॉर्ट के बारे में सख्ती से किया गया था और क्या यह स्थिर है। quicksort और जो तेज है वह आपकी टिप्पणी या मेरी प्रतिक्रिया के लिए बिल्कुल भी प्रासंगिक नहीं है। मेरे लिए चर्चा का अंत ... ओवर एंड आउट।

— जिम बाल्टर

3

इसका उत्तर प्राइमरी वैल्यूज़ के लिए DualPivotQuickSort के साथ लाए गए परिवर्तनों के लिए क्विकॉर्ट wrt की ओर थोड़ा झुकाव होगा। इसका उपयोग JAVA 7 में java.util.rrays में सॉर्ट करने के लिए किया जाता है

It is proved that for the Dual-Pivot Quicksort the average number of
comparisons is 2*n*ln(n), the average number of swaps is 0.8*n*ln(n),
whereas classical Quicksort algorithm has 2*n*ln(n) and 1*n*ln(n)
respectively. Full mathematical proof see in attached proof.txt
and proof_add.txt files. Theoretical results are also confirmed
by experimental counting of the operations.

आप यहाँ JAVA7 के निहितार्थ पा सकते हैं - http://grepcode.com/file/repository.grepcode.com/java/root/jdk/openjdk/7-b147/java/util-rrays.java

DualPivotQuickSort पर और अधिक भयानक पढ़ना - http://permalink.gmane.org/gmane.comp.java.openjdk.core-libs.devel/2628

— appbootup
स्रोत

3

मर्ज-सॉर्ट में, सामान्य एल्गोरिथ्म है:

बाईं उप-सरणी को क्रमबद्ध करें
सही उप-सरणी को सॉर्ट करें
2 सॉर्ट किए गए उप-सरणियों को मर्ज करें

शीर्ष स्तर पर, 2 सॉर्ट किए गए उप-सरणियों को विलय करने में एन तत्वों से निपटना शामिल है।

नीचे एक स्तर, चरण 3 के प्रत्येक पुनरावृत्ति में एन / 2 तत्वों के साथ काम करना शामिल है, लेकिन आपको इस प्रक्रिया को दो बार दोहराना होगा। तो आप अभी भी 2 * एन / 2 == एन तत्वों के साथ काम कर रहे हैं।

उसके नीचे एक स्तर, आप 4 * एन / 4 == एन तत्व, और इसी तरह विलय कर रहे हैं। पुनरावर्ती स्टैक में प्रत्येक गहराई में उसी गहराई के लिए सभी कॉलों में समान तत्वों का विलय करना शामिल है।

इसके बजाय त्वरित-सॉर्ट एल्गोरिथ्म पर विचार करें:

एक धुरी बिंदु उठाओ
सरणी में सही स्थान पर बाईं ओर सभी छोटे तत्वों के साथ, और बड़े तत्वों को दाईं ओर रखें
लेफ्ट-सब्रे को सॉर्ट करें
राइट-सबरे को सॉर्ट करें

शीर्ष स्तर पर, आप एक आकार N के साथ काम कर रहे हैं। फिर आप एक धुरी बिंदु को चुनते हैं, इसे उसकी सही स्थिति में डालते हैं, और फिर बाकी एल्गोरिथ्म के लिए इसे पूरी तरह से अनदेखा कर सकते हैं।

नीचे एक स्तर, आप 2 उप-सरणियों के साथ काम कर रहे हैं जिनके पास एन -1 का संयुक्त आकार है (यानी, पहले के पिवट को घटाएं)। आप प्रत्येक उप-सरणी के लिए एक धुरी बिंदु उठाते हैं, जो 2 अतिरिक्त धुरी बिंदुओं तक आता है।

नीचे एक स्तर, आप 4 उप-सरणियों के साथ संयुक्त आकार एन -3 के साथ काम कर रहे हैं, ऊपर के समान कारणों के लिए।

फिर एन -7 ... फिर एन -15 ... फिर एन -32 ...

आपके पुनरावर्ती स्टैक की गहराई लगभग समान (logN) बनी हुई है। मर्ज-सॉर्ट के साथ, आप हमेशा एन-एलर्ज मर्ज के साथ काम कर रहे हैं, पुनरावर्ती स्टैक के प्रत्येक स्तर पर। त्वरित-क्रम के साथ, तत्वों की संख्या जो आप कम कर रहे हैं जैसे ही आप स्टैक नीचे जाते हैं। उदाहरण के लिए, यदि आप पुनरावर्ती स्टैक के माध्यम से गहराई के मध्य मार्ग को देखते हैं, तो आपके द्वारा काम कर रहे तत्वों की संख्या N - 2 ^ ((logN) / 2)) == N - sqrt (N) है।

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

— RvPr
स्रोत

कि अगले स्तर पर पिवोट्स का हिस्सा नहीं है, इसलिए क्यूएस अधिक प्रदर्शन नहीं है। अतिरिक्त अंतर्दृष्टि के लिए अन्य उत्तर देखें।

— जिम बाल्टर

@JimBalter आप किस "अन्य जवाब" का जिक्र कर रहे हैं? शीर्ष उत्तर बस यही कहता है कि क्यूएस को "अतिरिक्त स्थान की आवश्यकता है और अच्छा कैश स्थानीयता प्रदर्शित करता है" लेकिन ऐसा क्यों है, इसके बारे में कोई स्पष्टीकरण नहीं देता है और न ही यह कोई उद्धरण प्रदान करता है। दूसरा उत्तर केवल यह कहता है कि बड़े डेटा सेटों के लिए मर्ज-सॉर्ट बेहतर है

— RvPr

आप गोलपोस्ट को स्थानांतरित कर रहे हैं, इसलिए क्यूएस यह कैसे संचालित होता है, इसके बारे में बुनियादी तथ्यों की व्याख्या करने के लिए अधिक प्रदर्शनशील है। अन्य प्रश्नों के उत्तर यह करते हैं कि: stackoverflow.com/questions/9444714/… ... मुझे आशा है कि यह आपके लिए पर्याप्त है; मैं आगे कोई जवाब नहीं दूंगा।

— जिम बाल्टर

3

मर्ज सॉर्ट के विपरीत त्वरित सॉर्ट एक सहायक स्थान का उपयोग नहीं करता है। जबकि मर्ज सॉर्ट एक सहायक स्थान O (n) का उपयोग करता है। लेकिन मर्ज सॉर्ट में O (nlogn) की सबसे खराब स्थिति समय जटिलता है जबकि Quick Sort की सबसे खराब स्थिति जटिलता O (n ^ 2) है जो तब होती है जब सरणी पहले से ही सॉर्ट हो जाती है।

— शांतम मित्तल
स्रोत

नहीं, QuickSort की सबसे खराब स्थिति तब नहीं होती है जब सरणी पहले से ही सॉर्ट की जाती है, जब तक कि आप पिवट के रूप में पहले या अंतिम आइटम का उपयोग नहीं करते हैं, लेकिन कोई भी ऐसा नहीं करता है।

— जिम बाल्टर

2

क्विकॉर्ट में एक बेहतर औसत मामला जटिलता है लेकिन कुछ अनुप्रयोगों में यह गलत विकल्प है। क्विकॉर्ट सर्विस हमलों से इनकार करने के लिए कमजोर है। यदि कोई हमलावर इनपुट को सॉर्ट करने के लिए चुन सकता है, तो वह आसानी से एक सेट का निर्माण कर सकता है जो ओ (n ^ 2) की सबसे खराब स्थिति समय की जटिलता को लेता है।

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

मैं इन कारणों से मेरिजॉर्ट का बहुत बड़ा प्रशंसक हूं, क्योंकि मैं क्विकसॉर्ट का हूं।

— साइमन जॉनसन
स्रोत

2

क्विकॉर्ट के पास बेहतर औसत मामला जटिलता कैसे है? वे दोनों O (nlgn) हैं। मैं तर्क दूंगा कि कोई भी हमलावर किसी भी छँटाई एल्गोरिथ्म को इनपुट प्रदान नहीं करेगा ... लेकिन अस्पष्टता से सुरक्षा नहीं संभालने के हित में, वह मान सकता है कि वह कर सकता है। जबकि n ^ 2 रनिंग टाइम nlgn से भी बदतर है, यह पर्याप्त रूप से बदतर नहीं है कि एक वेब सर्वर एक ही हमले के आधार पर दुर्घटनाग्रस्त हो जाएगा। वास्तव में, डॉस तर्क बहुत ज्यादा अशक्त है, क्योंकि कोई भी वेब सर्वर डीडीओएस हमले के लिए कमजोर है, और यह हमलावर के लिए मेजबान के सभी वितरित नेटवर्क का उपयोग करने की अधिक संभावना है, सभी टीसीपी SYN बाढ़।

— CaTalyst.X

"क्विकॉर्ट के पास एक बेहतर औसत मामला जटिलता है" - नहीं यह नहीं है।

— जिम बाल्टर

2

यह कहना मुश्किल है। मर्जसॉर्ट का सबसे खराब हिस्सा n (log2n) -n + 1 है, जो कि अगर n 2 के बराबर है तो सटीक है ^ k (मैंने पहले ही यह साबित कर दिया है)। और किसी भी n के लिए, यह बीच में है (n lg n - n + 1) और (n lg n + n + O (lg n))। लेकिन QuickSort के लिए, इसका सर्वश्रेष्ठ nlog2n है (n n 2 के बराबर भी)। यदि आप Mergesort को quickSort से विभाजित करते हैं, तो यह n के अनंत होने पर एक के बराबर होता है। यह ऐसा है जैसे कि MergeSort का सबसे बुरा मामला QuickSort के सबसे अच्छे मामले से बेहतर है, हम क्विकॉर्ट का उपयोग क्यों करते हैं? लेकिन याद रखें, MergeSort जगह में नहीं है, इसके लिए 2n memeroy space की आवश्यकता होती है। और MergeSort को कई सरणी प्रतियां करने की आवश्यकता होती है, जो हमें चाहिए एल्गोरिथ्म के विश्लेषण में शामिल न करें। एक शब्द में, मर्ज़ोर्ट, थ्रू में क्विकॉर्ट की तुलना में वास्तव में फासेटर है, लेकिन वास्तव में आपको मेमरी स्पेस पर विचार करने की आवश्यकता है, सरणी कॉपी की लागत, विलय त्वरित प्रकार की तुलना में धीमा है। मैंने इसे बनाया है। प्रयोग जहां मुझे रैंडम क्लास द्वारा जावा में 1000000 अंक दिए गए थे,और इसे 2610ms, मर्जसॉर्ट द्वारा, 1370ms क्विकॉर्ट द्वारा लिया गया।

— पीटर
स्रोत

2

त्वरित सॉर्ट सबसे खराब स्थिति O (n ^ 2) है, हालांकि, औसत केस लगातार आउट मर्ज सॉर्ट करता है। प्रत्येक एल्गोरिथ्म हे (nlogn) है, लेकिन आपको यह याद रखने की आवश्यकता है कि बिग ओ के बारे में बात करते समय हम निचले जटिलता कारकों को छोड़ देते हैं। जब निरंतर कारकों की बात आती है तो त्वरित सॉर्ट में मर्ज सॉर्ट पर महत्वपूर्ण सुधार होते हैं।

मर्ज सॉर्ट के लिए O (2n) मेमोरी की भी आवश्यकता होती है, जबकि त्वरित सॉर्ट किया जा सकता है (केवल O (n) की आवश्यकता होती है)। यह एक और कारण है कि त्वरित सॉर्ट आमतौर पर मर्ज सॉर्ट पर पसंद किया जाता है।

अधिक जानकारी:

त्वरित प्रकार का सबसे खराब मामला तब होता है जब धुरी खराब तरीके से चुनी जाती है। निम्नलिखित उदाहरण पर विचार करें:

[५, ४, ३, २, १]

यदि धुरी को समूह में सबसे छोटी या सबसे बड़ी संख्या के रूप में चुना जाता है, तो ओ (एन ^ 2) में त्वरित सॉर्ट चलेगा। सूची के सबसे बड़े या सबसे छोटे 25% में मौजूद तत्व को चुनने की संभावना 0.5 है। यह एल्गोरिथ्म को एक अच्छी धुरी होने का 0.5 मौका देता है। यदि हम एक विशिष्ट पिवट चुनने वाले एल्गोरिदम को काम में लेते हैं (जैसे कि एक यादृच्छिक तत्व चुनना), तो हमारे पास पिवट की हर पसंद के लिए एक अच्छा पिवट चुनने का 0.5 मौका है। एक बड़े आकार के संग्रह के लिए हमेशा खराब धुरी चुनने की संभावना 0.5 * n है। इस संभावना के आधार पर औसत (और विशिष्ट) मामले के लिए त्वरित सॉर्ट कुशल है।

— वेड एंडरसन
स्रोत

O (2n) == O (n)। सही कथन यह है कि मर्जेसर्ट को ओ (एन) अतिरिक्त मेमोरी की आवश्यकता है (अधिक विशेष रूप से, इसे एन / 2 सहायक मेमोरी की आवश्यकता है)। और यह लिंक की गई सूचियों के लिए सही नहीं है।

— जिम बाल्टर 3'18

@JimBalter सर, क्या आप सवाल के जवाब के रूप में अपने परफ़ॉर्मेंस के बारे में हमारे साथ अपने शानदार और सार्थक विचार साझा करेंगे? अग्रिम में धन्यवाद।

— snr

2

यह एक बहुत पुराना सवाल है, लेकिन जब से मैंने हाल ही में दोनों के साथ निपटाया है मेरा 2c:

मर्ज सॉर्ट की जरूरत है औसत ~ एन लॉग एन तुलना। पहले से ही (लगभग) सॉर्ट किए गए सरणियों के लिए यह 1/2 एन लॉग एन के लिए नीचे हो जाता है, क्योंकि हम विलय करते समय (लगभग) हमेशा "बाएं" भाग 1/2 एन का चयन करते हैं और फिर दाएं 1/2 एन तत्वों को कॉपी करते हैं। इसके अतिरिक्त, मैं अनुमान लगा सकता हूं कि पहले से ही सॉर्ट किया गया इनपुट प्रोसेसर की शाखा प्रेडिक्टर को चमकदार बनाता है, लेकिन लगभग सभी शाखाओं को सही ढंग से अनुमान लगाता है, इस प्रकार पाइपलाइन स्टालों को रोकता है।

औसत पर त्वरित प्रकार की आवश्यकता होती है ~ 1.38 एन लॉग एन तुलना। यह तुलना के संदर्भ में पहले से ही क्रमबद्ध सरणी से बहुत लाभ नहीं करता है (हालांकि यह स्वैप के संदर्भ में और शायद सीपीयू के अंदर शाखा भविष्यवाणियों के संदर्भ में करता है)।

काफी आधुनिक प्रोसेसर पर मेरे बेंचमार्क निम्नलिखित दर्शाते हैं:

जब तुलना फ़ंक्शन एक कॉलबैक फ़ंक्शन होता है (जैसे कि qsort (libc कार्यान्वयन)) Quicksort रैंडम इनपुट पर मर्ज की तुलना में धीमा होता है और 64 बिट पूर्णांक के लिए पहले से छांटे गए सरणी के लिए 30% होता है।

दूसरी ओर, अगर तुलना कॉलबैक नहीं है, तो मेरा अनुभव है कि क्विकसॉर्ट आउटपरफॉर्म का विलय 25% तक होता है।

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

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

यह कहा कि पहले कहा गया सब सच है: - क्विकॉर्ट एन 2 हो सकता है, लेकिन सेडगेविक का दावा है कि एक अच्छे यादृच्छिक कार्यान्वयन से कंप्यूटर के प्रदर्शन की संभावना अधिक होती है जैसे कि बिजली गिरने से एन ^ 2 जा सकता है - मर्जेसर्ट अतिरिक्त जगह है

— virco
स्रोत

अगर तुलना सस्ती है तो qsort, सॉर्ट किए गए इनपुट के लिए भी मर्ज की धड़कन करता है?

— इऑनिल

2

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

— एल्डियन फ़ाज़रीहेडी
स्रोत

Pivots का इससे कोई लेना-देना नहीं है कि QS के पास कम पुनरावर्ती कॉल क्यों हैं ... ऐसा इसलिए है क्योंकि QS की आधी पुनरावर्ती पूंछ पुनरावृत्ति है, जिसे समाप्त किया जा सकता है।

— जिम बाल्टर

2

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

1- सहायक स्थान: त्वरित सॉर्ट एक इन-प्लेस सॉर्टिंग एल्गोरिथ्म है। इन-प्लेस सॉर्टिंग का अर्थ है कि सॉर्ट करने के लिए अतिरिक्त संग्रहण स्थान की आवश्यकता नहीं है। दूसरी ओर मर्ज सॉर्ट को सॉर्ट किए गए सरणियों को मर्ज करने के लिए एक अस्थायी सरणी की आवश्यकता होती है और इसलिए यह इन-प्लेस नहीं है।

2- सबसे खराब स्थिति:O(n^2) रैंडमाइज़्ड क्विकॉर्ट के इस्तेमाल से क्विकॉर्ट्स के सबसे खराब मामले को टाला जा सकता है। सही धुरी चुनकर आसानी से उच्च संभावना से बचा जा सकता है। सही धुरी तत्व चुनकर एक औसत मामले के व्यवहार को प्राप्त करने से यह प्रदर्शन को बेहतर बनाता है और मर्ज की तरह कुशल हो जाता है।

3- संदर्भ की स्थानीयता : क्विकॉर्ट विशेष रूप से अच्छा कैश स्थानीयता प्रदर्शित करता है और यह वर्चुअल मेमोरी वातावरण जैसे कई मामलों में मर्ज सॉर्ट की तुलना में तेज़ बनाता है।

4- टेल रिकर्सन: क्विकॉर्ट टेल रीर्सिव है जबकि मर्ज सॉर्ट नहीं है। एक पूंछ पुनरावर्ती कार्य एक फ़ंक्शन है जहां पुनरावर्ती कॉल फ़ंक्शन द्वारा निष्पादित अंतिम चीज़ है। पूंछ पुनरावर्ती कार्यों को गैर पूंछ पुनरावर्ती कार्यों से बेहतर माना जाता है क्योंकि पूंछ-पुनरावृत्ति को संकलक द्वारा अनुकूलित किया जा सकता है।

— हिमांशु कंसल
स्रोत

1

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

तथापि! मैं व्यक्तिगत रूप से अक्सर मर्जर्ट्स या एक क्विकॉर्ट वेरिएंट का उपयोग करता हूं जो कि क्वर्ट्स के खराब होने पर मर्जेसर्ट को नीचा दिखाता है। याद है। Quicksort औसत पर केवल O (n log n) है । यह सबसे खराब स्थिति है O (n ^ 2)! Mergesort हमेशा O (n log n) होता है। ऐसे मामलों में जहां रीयलटाइम परफॉर्मेंस या रिस्पॉन्सिबिलिटी जरूरी है और आपका इनपुट डेटा किसी दुर्भावनापूर्ण स्रोत से आ सकता है, आपको प्लेन क्विकॉर्ट का इस्तेमाल नहीं करना चाहिए।

— डीजे कैपेलिस
स्रोत

1

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

मैं सोच रहा था कि मूलांक देखना इतना दुर्लभ क्यों है या बकेट सॉर्ट । वे O (n) हैं, कम से कम लिंक की गई सूचियों पर और सभी इसे लेता है जो कुंजी को क्रमिक संख्या में परिवर्तित करने की कुछ विधि है। (स्ट्रिंग्स और फ्लोट्स ठीक काम करते हैं।)

मैं सोच रहा हूं कि इसका कारण यह है कि कंप्यूटर विज्ञान कैसे पढ़ाया जाता है। यहां तक कि मुझे एलगोरिदम विश्लेषण में अपने व्याख्याता को प्रदर्शित करना था कि ओ (एन लॉग (एन)) की तुलना में तेजी से छांटना संभव है। (उनके पास सबूत था कि आप तुलना नहीं कर सकते O (n लॉग (n)) की तेजी से , जो कि सत्य है।)

अन्य समाचारों में, फ़्लोटर्स को पूर्णांकों के रूप में क्रमबद्ध किया जा सकता है, लेकिन आपको बाद में नकारात्मक संख्याओं को बदलना होगा।

संपादित करें: वास्तव में, यहां फ़्लोट्स-के-पूर्णांक को सॉर्ट करने का एक और भी शातिर तरीका है: http://www.stereopsis.com/radix.html । ध्यान दें कि बिट-फ़्लिपिंग ट्रिक का उपयोग किया जा सकता है, भले ही आप वास्तव में उपयोग किए जाने वाले सॉर्टिंग एल्गोरिथ्म की परवाह किए बिना ...

— एंडर्स यूरेनियस
स्रोत

1

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

— कोनराड रूडोल्फ

यह है हे (एन), जहां n है कुल इनपुट आकार, कि तत्वों का आकार भी शामिल है,। यह सच है कि आप इसे लागू कर सकते हैं ताकि आपको बहुत सारे शून्य के साथ पैड करना पड़े, लेकिन तुलना के लिए खराब कार्यान्वयन का उपयोग करना बकवास है। (यह कहा, कार्यान्वयन कठिन हो सकता है, ymmv।)

— एंडर्स यूरेनियस

ध्यान दें कि यदि आप GNU libc का उपयोग कर रहे हैं, qsortतो मर्ज सॉर्ट है।

— जेसन ओरेंडोर्फ

एर, सटीक होने के लिए, यह एक मर्ज सॉर्ट है जब तक कि आवश्यक अस्थायी मेमोरी आवंटित नहीं की जा सकती। cvs.savannah.gnu.org/viewvc/libc/stdlib/…

— जेसन

1

त्वरित बनाम मर्ज करने के लिए छोटे परिवर्धन।

इसके अलावा यह छँटाई वस्तुओं की तरह पर निर्भर कर सकते हैं। यदि आइटम तक पहुंच, स्वैप और तुलना सरल ऑपरेशन नहीं है, जैसे कि प्लेन मेमोरी में पूर्णांकों की तुलना करना, तो मर्ज सॉर्ट को पसंदीदा एल्गोरिदम माना जा सकता है।

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

इसके अलावा, "लिंक की गई सूची" जैसे कस्टम कंटेनरों में, त्वरित प्रकार का कोई लाभ नहीं है।
1. लिंक की गई सूची पर मर्ज करें, अतिरिक्त मेमोरी की आवश्यकता नहीं है। 2. त्वरित क्रम में तत्वों तक पहुँच अनुक्रमिक नहीं है (स्मृति में)

— minorlogic
स्रोत

0

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

सरणियों के विपरीत, पसंद की सूची में हम O (1) स्थान और O (1) समय के साथ बीच में आइटम सम्मिलित कर सकते हैं, इसलिए मर्ज प्रकार में मर्ज कार्रवाई को बिना किसी अतिरिक्त स्थान के लागू किया जा सकता है। हालांकि, सरणियों के लिए अतिरिक्त स्थान का आवंटन और डी-आबंटन मर्ज सॉर्ट के रन समय पर प्रतिकूल प्रभाव पड़ता है। मर्ज सॉर्ट भी लिंक की गई सूची का पक्षधर है क्योंकि डेटा को क्रमिक रूप से एक्सेस किया जाता है, बिना अधिक यादृच्छिक मेमोरी एक्सेस के।

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

भले ही दोनों सॉर्टिंग एल्गोरिदम औसत जटिलता हे (NlogN), आमतौर पर साधारण कार्यों के लिए लोग भंडारण के लिए एक सरणी का उपयोग करते हैं, और इस कारण से त्वरित सॉर्ट पसंद का एल्गोरिथ्म होना चाहिए।

संपादित करें: मुझे अभी पता चला है कि मर्ज सॉर्ट सबसे खराब / सबसे अच्छा / एवीजी केस हमेशा उलझा हुआ होता है, लेकिन क्विक सॉर्ट n2 से अलग हो सकता है (सबसे खराब स्थिति जब तत्वों को पहले से ही सॉर्ट किया जाता है) nlogn करने के लिए (एवीजी / बेस्ट केस तब होता है जब पिवट हमेशा दो में सरणी बना देता है। आधा)।

— साद
स्रोत

0

समय और अंतरिक्ष जटिलता दोनों पर विचार करें। मर्ज सॉर्ट के लिए: समय जटिलता: O (nlogn), अंतरिक्ष जटिलता: O (nlogn)

त्वरित प्रकार के लिए: समय जटिलता: O (n ^ 2), अंतरिक्ष जटिलता: O (n)

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

इस प्रकार, त्वरित सॉर्ट को मर्ज सॉर्ट के बजाय कई अनुप्रयोगों में पसंद किया जाता है।

— पंकज
स्रोत

-1

सी / सी ++ भूमि में, जब स्टेल कंटेनरों का उपयोग नहीं किया जाता है, तो मैं क्विकॉर्ट का उपयोग करता हूं, क्योंकि यह रन टाइम में बनाया गया है, जबकि मर्जेसर्ट नहीं है।

इसलिए मेरा मानना है कि कई मामलों में, यह केवल कम से कम प्रतिरोध का मार्ग है।

इसके अलावा प्रदर्शन त्वरित सॉर्ट के साथ बहुत अधिक हो सकता है, ऐसे मामलों के लिए जहां पूरे डेटासेट काम करने वाले सेट में फिट नहीं होते हैं।

— EvilTeach
स्रोत

3

वास्तव में, यदि यह qsort () लाइब्रेरी फ़ंक्शन है जिसके बारे में आप बात कर रहे हैं, तो इसे क्विकॉर्ट के रूप में लागू किया जा सकता है या नहीं किया जा सकता है।

— थॉमस पैड्रॉन-मैक्कार्थी

3

कोनराड, इस बारे में थोड़ा गुदा होने के लिए खेद है, लेकिन आपको वह गारंटी कहां मिलती है? मैं इसे ISO C मानक में, या C ++ मानक में नहीं पा सकता हूँ।

— थॉमस पैड्रॉन-मैक्कार्थी

2

GNU libc qsortएक मर्ज सॉर्ट है जब तक कि तत्वों की संख्या सही मायने में विशाल या अस्थायी मेमोरी आवंटित नहीं की जा सकती है। cvs.savannah.gnu.org/viewvc/libc/stdlib/…

— जेसन

-3

इसका एक कारण अधिक दार्शनिक है। क्विकसॉर्ट शीर्ष-> नीचे दर्शन है। छांटने के लिए n तत्वों के साथ, n हैं! संभावनाओं। M & nm के 2 विभाजनों के साथ, जो पारस्परिक रूप से अनन्य हैं, संभावनाओं की संख्या परिमाण के कई क्रमों में नीचे जाती है। म! * (nm)! n की तुलना में कई आदेशों से छोटा है! अकेला। कल्पना कीजिए ५! बनाम 3! * 2 !. 5! 2 और 3 प्रत्येक के 2 विभाजन की तुलना में 10 गुना अधिक संभावनाएं हैं। और 900K बनाम 1 लाख फैक्टरोल के लिए अतिरिक्त! * 100K! बनाम इसलिए किसी सीमा या विभाजन के भीतर किसी भी आदेश को स्थापित करने के बारे में चिंता करने के बजाय, विभाजन में व्यापक स्तर पर आदेश स्थापित करें और विभाजन के भीतर संभावनाओं को कम करें। एक सीमा के भीतर पहले से स्थापित कोई भी आदेश बाद में परेशान हो जाएगा यदि विभाजन स्वयं पारस्परिक रूप से अनन्य नहीं हैं।

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

क्विक सॉर्ट प्रबंधकीय दृष्टिकोण की तरह है जहां किसी को शुरू में किसी आदेश की चिंता नहीं होती है, केवल आदेश के लिए कोई संबंध नहीं होने के साथ एक व्यापक मानदंड को पूरा करने के बारे में। फिर विभाजन तब तक संकुचित होते हैं जब तक कि आप एक हल किया हुआ सेट न प्राप्त कर लें। क्विकॉर्ट में असली चुनौती अंधेरे में विभाजन या कसौटी खोजने में है जब आप तत्वों को छाँटने के बारे में कुछ नहीं जानते हैं। यही कारण है कि हम या तो एक औसत मूल्य खोजने के लिए कुछ खर्च करने की जरूरत है या यादृच्छिक या कुछ मनमाना "प्रबंधकीय" दृष्टिकोण पर 1 उठाओ। एक परिपूर्ण मंझला खोजने के लिए प्रयास की महत्वपूर्ण राशि ले सकते हैं और फिर से एक बेवकूफ नीचे तक पहुंच सकते हैं। तो क्विकॉर्ट बस एक यादृच्छिक धुरी लेने की उम्मीद करता है और आशा करता है कि यह बीच में कहीं होगा या 3, 5 या कुछ और का माध्यिका खोजने के लिए कुछ काम करेगा और एक बेहतर माध्यिका खोजने के लिए लेकिन पूर्ण और डॉन बनने की योजना नहीं बनाएगा ' टी शुरू में आदेश देने में किसी भी समय बर्बाद। ऐसा लगता है कि अगर आप भाग्यशाली हैं या कभी-कभी n ^ 2 में गिरावट आती है, जब आपको कोई मंझला नहीं मिलता है, लेकिन बस एक मौका लें। किसी भी तरह से डेटा यादृच्छिक है। सही। इसलिए मैं शीर्ष के साथ अधिक सहमत हूं -> एस्कॉर्ट का तार्किक दृष्टिकोण नीचे है और यह पता चलता है कि यह मौका है कि यह धुरी चयन और तुलनाओं के बारे में लेता है जो पहले बचाता है किसी भी सावधानीपूर्वक और पूरी तरह से स्थिर नीचे की तुलना में अधिक बेहतर काम करता है -> अप दृष्टिकोण की तरह मर्ज़ सॉर्ट। परंतु तुलना करता है कि यह पहले से बचाता है किसी भी सावधानीपूर्वक और पूरी तरह से स्थिर नीचे की तुलना में अधिक बार बेहतर काम करता है -> मर्ज की तरह अप-अप दृष्टिकोण। परंतु तुलना करता है कि यह पहले से बचाता है किसी भी सावधानीपूर्वक और पूरी तरह से स्थिर नीचे की तुलना में अधिक बार बेहतर काम करता है -> मर्ज की तरह अप-अप दृष्टिकोण। परंतु

— सर्दियों तरबूज
स्रोत

धुरी चयन की यादृच्छिकता से एस्कॉर्ट लाभ। यादृच्छिक धुरी स्वाभाविक रूप से 50:50 विभाजन की ओर होती है और चरम सीमाओं में से एक की ओर लगातार होने की संभावना नहीं है। औसत विभाजन 60-40 या 70-30 तक भी नॉग्लन का निरंतर कारक काफी कम है।

— विंटर मेलन

यह पूरी बकवास है। एस्कॉर्ट का उपयोग उसके प्रदर्शन के कारण किया जाता है, न कि "दर्शन" ... और "आदेश के खो जाने के लिए बाध्य होने के बारे में" दावा केवल झूठ है।

— जिम बाल्टर