यहां एक कार्यान्वयन है जो सूची को केवल एक बार ट्रेस करता है, रन एकत्र करता है, फिर उसी तरह मर्ज को शेड्यूल करता है जिस तरह से मर्ज करें।
जटिलता हे (एन लॉग एम) जहां n वस्तुओं की संख्या है और एम रन की संख्या है। सबसे अच्छा मामला O (n) है (यदि डेटा पहले से ही सॉर्ट किया गया है) और सबसे खराब स्थिति उम्मीद के मुताबिक O (n log n) है।
इसके लिए ओ (लॉग एम) अस्थायी मेमोरी की आवश्यकता होती है; सॉर्ट सूची में जगह में किया जाता है।
(नीचे अद्यतन। टिप्पणीकार एक अच्छी बात यह है कि मुझे यहाँ इसका वर्णन करना चाहिए)
एल्गोरिथ्म का सार है:
while list not empty
accumulate a run from the start of the list
merge the run with a stack of merges that simulate mergesort's recursion
merge all remaining items on the stack
रनिंग रनिंग के लिए बहुत स्पष्टीकरण की आवश्यकता नहीं होती है, लेकिन आरोही रन और अवरोही रन (घूमना) दोनों को संचित करने का अवसर लेना अच्छा है। यहाँ यह रन के प्रमुख की तुलना में छोटी वस्तुओं को प्रस्तुत करता है और रन के अंत से अधिक या इसके बराबर आइटम जोड़ता है। (ध्यान दें कि छंटनी की स्थिरता को बनाए रखने के लिए पहले से कम सख्त का उपयोग करना चाहिए।)
यहां सिर्फ मर्जिंग कोड पेस्ट करना आसान है:
int i = 0;
for ( ; i < stack.size(); ++i) {
if (!stack[i])
break;
run = merge(run, stack[i], comp);
stack[i] = nullptr;
}
if (i < stack.size()) {
stack[i] = run;
} else {
stack.push_back(run);
}
सूची को छाँटने पर विचार करें (dagibecfjh) (रन की अनदेखी)। स्टैक स्थिति इस प्रकार आगे बढ़ती है:
[ ]
[ (d) ]
[ () (a d) ]
[ (g), (a d) ]
[ () () (a d g i) ]
[ (b) () (a d g i) ]
[ () (b e) (a d g i) ]
[ (c) (b e) (a d g i ) ]
[ () () () (a b c d e f g i) ]
[ (j) () () (a b c d e f g i) ]
[ () (h j) () (a b c d e f g i) ]
फिर, अंत में इन सभी सूचियों को मर्ज करें।
ध्यान दें कि स्टैक [i] पर वस्तुओं की संख्या (रन) या तो शून्य या 2 ^ i है और स्टैक का आकार 1 + log2 (nruns) से घिरा है। प्रत्येक तत्व को स्टैक स्तर के अनुसार एक बार मर्ज किया जाता है, इसलिए ओ (एन लॉग एम) तुलना। यहाँ Timsort के लिए एक समान समानता है, हालांकि Timsort एक फिबोनाची अनुक्रम की तरह कुछ का उपयोग करके अपने ढेर को बनाए रखता है जहां यह दो की शक्तियों का उपयोग करता है।
संचित रन किसी भी पहले से ही सॉर्ट किए गए डेटा का लाभ उठाते हैं ताकि पहले से ही सॉर्ट की गई सूची (एक रन) के लिए सबसे अच्छा मामला जटिलता ओ (एन) हो। चूँकि हम आरोही और अवरोही दोनों तरह के रन बना रहे हैं, रन हमेशा कम से कम लंबाई के होंगे 2. (यह कम से कम एक से अधिकतम स्टैक की गहराई कम कर देता है, पहले स्थान पर रन खोजने की लागत के लिए भुगतान करना।) सबसे खराब स्थिति जटिलता। ओ (एन लॉग एन), जैसा कि अपेक्षित है, डेटा के लिए जो अत्यधिक यादृच्छिक है।
(उम ... दूसरा अपडेट)
या बस नीचे-ऊपर मर्जोर्ट पर विकिपीडिया देखें ।