शैलसॉर्ट

From Vigyanwiki
Revision as of 17:06, 27 June 2023 by alpha>Indicwiki (Created page with "{{Short description|Sorting algorithm which uses multiple comparison intervals}} {{Infobox Algorithm |class=Sorting algorithm |image=File:Sorting shellsort anim.gif|St...")
(diff) ← Older revision | Latest revision (diff) | Newer revision → (diff)
शैलसॉर्ट
Step-by-step visualisation of Shellsort
Shellsort with gaps 23, 10, 4, 1 in action
ClassSorting algorithm
Data structureArray
Worst-case performanceO(n2) (worst known worst case gap sequence)
O(n log2n) (best known worst case gap sequence)[1]
Best-case performanceO(n log n) (most gap sequences)
O(n log2n) (best known worst-case gap sequence)[2]
Average performancedepends on gap sequence
Worst-case space complexityО(n) total, O(1) auxiliary
The steps of Shellsort.
शेलसॉर्ट के क्रमिक चरणों में 5, 3, 1 के अंतराल के साथ वस्तुओं के जोड़े की अदला-बदली

शेलसॉर्ट, जिसे शेल सॉर्ट या शेल विधि के रूप में भी जाना जाता है, एक इन-प्लेस एल्गोरिदम|इन-प्लेस तुलना सॉर्ट है। इसे या तो एक्सचेंज (बुलबुले की तरह ) द्वारा सॉर्टिंग या इंसर्शन (सम्मिलन सॉर्ट ) द्वारा सॉर्टिंग के सामान्यीकरण के रूप में देखा जा सकता है।[3]यह विधि एक दूसरे से दूर तत्वों के जोड़े को क्रमबद्ध करने से शुरू होती है, फिर तुलना किए जाने वाले तत्वों के बीच के अंतर को धीरे-धीरे कम करती है। दूर-दूर के तत्वों से शुरुआत करके, यह एक साधारण निकटतम पड़ोसी एक्सचेंज की तुलना में कुछ बाहर के तत्वों को तेजी से स्थिति में ले जा सकता है। डोनाल्ड शैल ने इस प्रकार का पहला संस्करण 1959 में प्रकाशित किया।[4][5] शेलसॉर्ट का चलने का समय उसके द्वारा उपयोग किए जाने वाले अंतराल अनुक्रम पर बहुत अधिक निर्भर है। कई व्यावहारिक वेरिएंट के लिए, उनकी समय जटिलता का निर्धारण एक खुली समस्या बनी हुई है।

विवरण

शेलसॉर्ट सम्मिलन सॉर्ट का एक अनुकूलन है जो दूर-दूर स्थित वस्तुओं के आदान-प्रदान की अनुमति देता है। विचार यह है कि तत्वों की सूची को व्यवस्थित किया जाए ताकि, कहीं से भी शुरू करके, प्रत्येक hth तत्व को लेने से एक क्रमबद्ध सूची तैयार हो सके। ऐसी सूची को एच-सॉर्टेड कहा जाता है। इसे इंटरलीव्ड सूचियों के रूप में भी सोचा जा सकता है, प्रत्येक को व्यक्तिगत रूप से क्रमबद्ध किया गया है।[6] एच के बड़े मूल्यों के साथ शुरुआत करने से तत्वों को मूल सूची में लंबी दूरी तक जाने की अनुमति मिलती है, जिससे बड़ी मात्रा में अव्यवस्था कम हो जाती है, और छोटे एच-सॉर्ट चरणों के लिए कम काम करना पड़ता है।[7] यदि सूची को किसी छोटे पूर्णांक k के लिए k-क्रमबद्ध किया जाता है, तो सूची h-क्रमबद्ध ही रहती है। 1 पर समाप्त होने वाले h मानों के घटते क्रम के लिए इस विचार का पालन करने से अंत में एक क्रमबद्ध सूची निकलने की गारंटी है।[6]

सरल शब्दों में, इसका मतलब है कि यदि हमारे पास 1024 संख्याओं की एक सरणी है, तो हमारा पहला अंतर (एच) 512 हो सकता है। फिर हम पहले भाग में प्रत्येक तत्व की तुलना दूसरे भाग में तत्व से करते हुए सूची में चलते हैं। हमारा दूसरा गैप (k) 256 है, जो सरणी को चार खंडों में तोड़ता है (0, 256, 512, 768 से शुरू), और हम यह सुनिश्चित करते हैं कि प्रत्येक खंड में पहले आइटम एक दूसरे के सापेक्ष क्रमबद्ध हों, फिर दूसरा आइटम प्रत्येक अनुभाग, इत्यादि। व्यवहार में गैप अनुक्रम कुछ भी हो सकता है, लेकिन सॉर्ट को समाप्त करने के लिए अंतिम गैप हमेशा 1 होता है (प्रभावी रूप से सामान्य सम्मिलन सॉर्ट के साथ समाप्त होता है)।

अंतराल 5, 3 और 1 के साथ शेलसॉर्ट का एक उदाहरण नीचे दिखाया गया है।

a1 a2 a3 a4 a5 a6 a7 a8 a9 a10 a11 a12
Input data 62 83 18 53 07 17 95 86 47 69 25 28
After 5-sorting 17 28 18 47 07 25 83 86 53 69 62 95
After 3-sorting 17 07 18 47 28 25 69 62 53 83 86 95
After 1-sorting 07 17 18 25 28 47 53 62 69 83 86 95

पहला पास, 5-सॉर्टिंग, पांच अलग-अलग उप-सरणी (ए) पर सम्मिलन सॉर्ट करता है1, ए6, ए11), (ए2, ए7, ए12), (ए3, ए8), (ए4, ए9), (ए5, ए10). उदाहरण के लिए, यह उपसरणी को बदल देता है (a1, ए6, ए11) (62, 17, 25) से (17, 25, 62) तक। अगला पास, 3-सॉर्टिंग, तीन उपसरणी पर सम्मिलन सॉर्ट करता है (ए)।1, ए4, ए7, ए10), (ए2, ए5, ए8, ए11), (ए3, ए6, ए9, ए12). अंतिम पास, 1-सॉर्टिंग, संपूर्ण सरणी का एक सामान्य सम्मिलन प्रकार है (a1,..., ए12).

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

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

स्यूडोकोड

आंतरिक सम्मिलन प्रकार के साथ, मार्सिन सिउरा के अंतराल अनुक्रम का उपयोग करना।

# Sort an array a[0...n-1].
gaps = [701, 301, 132, 57, 23, 10, 4, 1]  # Ciura gap sequence

# Start with the largest gap and work down to a gap of 1
# similar to insertion sort but instead of 1, gap is being used in each step
foreach (gap in gaps)
{
    # Do a gapped insertion sort for every elements in gaps
    # Each loop leaves a[0..gap-1] in gapped order
    for (i = gap; i < n; i += 1)
    {
        # save a[i] in temp and make a hole at position i
        temp = a[i]
        # shift earlier gap-sorted elements up until the correct location for a[i] is found
        for (j = i; (j >= gap) && (a[j - gap] > temp); j -= gap)
        {
            a[j] = a[j - gap]
        }
        # put temp (the original a[i]) in its correct location
        a[j] = temp
    }
}


गैप अनुक्रम

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

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

OEIS General term (k ≥ 1) Concrete gaps Worst-case
time complexity
Author and year of publication
[e.g. when N = 2p] Shell, 1959[4]
Frank & Lazarus, 1960[8]
A000225 Hibbard, 1963[9]
A083318 , prefixed with 1 Papernov & Stasevich, 1965[10]
A003586 Successive numbers of the form (3-smooth numbers) Pratt, 1971[1]
A003462 , not greater than Knuth, 1973,[3] based on Pratt, 1971[1]
A036569 Incerpi & Sedgewick, 1985,[11] Knuth[3]
A036562 , prefixed with 1 Sedgewick, 1982[6]
A033622 Sedgewick, 1986[12]
Un­known Gonnet & [[Ricardo Baeza-Yates|Baeza-Yates]], 1991[13]
A108870 Un­known Tokuda, 1992[14]
A102549 Unknown (experimentally derived) Un­known Ciura, 2001[15]
Un­known Lee, 2021[16]

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

हालाँकि इसमें O(N लॉग N) की तुलना में अधिक जटिलता है जो तुलनात्मक प्रकारों के लिए इष्टतम है, प्रैट का संस्करण नेटवर्क को सॉर्ट करने के लिए उपयुक्त है और इसमें बैचर के बिटोनिक सॉर्टर के समान ही एसिम्प्टोटिक गेट जटिलता है।

गोनेट और बेज़ा-येट्स ने देखा कि शेलसॉर्ट औसतन सबसे कम तुलना करता है जब क्रमिक अंतराल का अनुपात लगभग 2.2 के बराबर होता है।[13]यही कारण है कि अनुपात 2.2 के साथ उनका अनुक्रम और 2.25 अनुपात के साथ टोकुडा का अनुक्रम कुशल साबित होता है। हालाँकि ऐसा क्यों है ये पता नहीं चल पाया है. सेडगेविक उन अंतरालों का उपयोग करने की अनुशंसा करता है जिनमें सबसे बड़े सामान्य भाजक कम होते हैं या जोड़ीवार सहअभाज्य होते हैं।[17][failed verification] विषम संख्या वाले अंतराल व्यवहार में अच्छा काम करते प्रतीत होते हैं: सम-संख्या वाले अंतराल से बचकर 25% की कमी देखी गई है। 3 और 5 के गुणकों से बचने वाले अंतराल <10% के छोटे लाभ उत्पन्न करते प्रतीत होते हैं।[original research?]

तुलनाओं की औसत संख्या के संबंध में, सिउरा का अनुक्रम[15]सर्वोत्तम ज्ञात प्रदर्शन है; 701 से अंतराल निर्धारित नहीं किए गए थे लेकिन अनुक्रम को पुनरावर्ती सूत्र के अनुसार आगे बढ़ाया जा सकता है .

टोकुडा का अनुक्रम, सरल सूत्र द्वारा परिभाषित , कहाँ , , व्यावहारिक अनुप्रयोगों के लिए अनुशंसित किया जा सकता है।

यदि अधिकतम इनपुट आकार छोटा है, जैसा कि तब हो सकता है जब शेलसॉर्ट का उपयोग किसी अन्य पुनरावर्ती सॉर्टिंग एल्गोरिदम जैसे कि जल्दी से सुलझाएं या मर्ज़ सॉर्ट द्वारा छोटे उप-सरणी पर किया जाता है, तो प्रत्येक इनपुट आकार के लिए एक इष्टतम अनुक्रम को सारणीबद्ध करना संभव है।[18]


कम्प्यूटेशनल जटिलता

निम्नलिखित संपत्ति रखती है: एच के बाद2-किसी भी एच की छँटाई1-क्रमबद्ध सरणी, सरणी h बनी हुई है1-क्रमबद्ध।[19] प्रत्येक एच1-सॉर्टेड और एच2-सॉर्टेड सरणी भी है (a1h1+ए2h2)-किसी भी गैर-नकारात्मक पूर्णांक के लिए क्रमबद्ध1 और ए2. शेलसॉर्ट की सबसे खराब स्थिति इसलिए सिक्के की समस्या से जुड़ी है: दिए गए पूर्णांकों के लिए एच1,..., एचnजीसीडी = 1 के साथ, फ्रोबेनियस संख्या जी(एच)।1,..., एचn) सबसे बड़ा पूर्णांक है जिसे a के रूप में प्रदर्शित नहीं किया जा सकता1h1+ ... +एnhnअऋणात्मक पूर्णांक a के साथ1,..., एn. फ्रोबेनियस संख्याओं के लिए ज्ञात सूत्रों का उपयोग करके, हम अंतराल अनुक्रमों के कई वर्गों के लिए शेलसॉर्ट की सबसे खराब स्थिति की जटिलता निर्धारित कर सकते हैं।[20] सिद्ध परिणाम उपरोक्त तालिका में दिखाए गए हैं।

मार्क एलन वीस ने साबित किया कि शेलसॉर्ट ओ (एन लॉग एन) समय में चलता है जब इनपुट सरणी विपरीत क्रम में होती है।[21] संचालन की औसत संख्या के संबंध में, कोई भी सिद्ध परिणाम व्यावहारिक अंतराल अनुक्रम से संबंधित नहीं है। उन अंतरालों के लिए जो दो की घात हैं, एस्पेलिड ने इस औसत की गणना इस प्रकार की .[22] डोनाल्ड नुथ ने दो अंतराल (एच, 1) के साथ एन-तत्व सरणी को सॉर्ट करने की औसत जटिलता निर्धारित की .[3]यह इस प्रकार है कि h = Θ(N) के साथ दो-पास शेलसॉर्ट1/3</कप>) औसतन OF(N) बनाता है5/3) तुलना/उलट/चलने का समय। एंड्रयू याओ ने तीन-पास शेलसॉर्ट की औसत जटिलता पाई।[23] उनके परिणाम को स्वंते जानसन और नुथ द्वारा परिष्कृत किया गया था:[24] तीन अंतराल (सीएच, सीजी, 1) के साथ शेलसॉर्ट के दौरान की गई तुलना/व्युत्क्रम/चलने के समय की औसत संख्या, जहां एच और जी कोप्राइम हैं, है पहले पास में, दूसरे पास में और तीसरे पास में. अंतिम सूत्र में ψ(h, g) एक जटिल फलन है जो लक्षणात्मक रूप से बराबर है . विशेष रूप से, जब h = Θ(N7/15) और g = Θ(N1/5), छँटाई का औसत समय O(N) है23/15).

प्रयोगों के आधार पर, यह अनुमान लगाया गया है कि थॉमस एन. हिब्बार्ड के अंतराल अनुक्रम के साथ शेलसॉर्ट O(N) में चलता है5/4) औसत समय,[3]और गोनेट और बाएज़ा-येट्स के अनुक्रम के लिए औसतन 0.41N ln N (ln ln N + 1/6) तत्व चाल की आवश्यकता होती है।[13]जब क्रमबद्ध सरणियों में लाखों तत्व होते हैं तो अन्य अनुक्रमों के लिए पूर्व में रखे गए संचालन की औसत संख्या का अनुमान विफल हो जाता है।

नीचे दिया गया ग्राफ़ शेलसॉर्ट के विभिन्न वेरिएंट में तत्व तुलनाओं की औसत संख्या को सैद्धांतिक निचली सीमा से विभाजित करके दिखाता है, यानी लॉग2एन!, जहां अनुक्रम 1, 4, 10, 23, 57, 132, 301, 701 को सूत्र के अनुसार बढ़ाया गया है .

Shell sort average number of comparisons (English).svg

कोलमोगोरोव जटिलता के सिद्धांत को लागू करते हुए, जियांग, मिंग एल आई , और पॉल विटैनी|विटैनी

[25] पी-पास शेलसॉर्ट में संचालन/चलने के समय की औसत संख्या के क्रम के लिए निम्नलिखित निचली सीमा साबित हुई: Ω(pN1+1/पी) जब पी ≤ लॉग करें2एन और Ω(पीएन) जब पी > लॉग करें2एन।

इसलिए, शेलसॉर्ट के पास औसत समय में चलने की संभावनाएं हैं जो केवल अंतराल अनुक्रमों का उपयोग करते समय एन लॉगएन की तरह बढ़ती है जिनकी अंतराल की संख्या सरणी आकार के लघुगणक के अनुपात में बढ़ती है। हालाँकि, यह अज्ञात है कि क्या शेलसॉर्ट औसत-केस जटिलता के इस स्पर्शोन्मुख क्रम तक पहुँच सकता है, जो तुलनात्मक प्रकारों के लिए इष्टतम है। निचली सीमा में पॉल विटैनी|विटैनी द्वारा सुधार किया गया था[26] प्रत्येक पास की संख्या के लिए को

 

कहाँ . उदाहरण के लिए, यह परिणाम सभी के लिए जियांग-ली-विटैनी की निचली सीमा को दर्शाता है -वृद्धि अनुक्रमों को पारित करें और विशेष वृद्धि अनुक्रमों के लिए उस निचली सीमा में सुधार करें। वास्तव में औसत मामले के लिए वर्तमान में ज्ञात सभी सीमाएँ (निचली और ऊपरी) इस निचली सीमा से सटीक रूप से मेल खाती हैं। उदाहरण के लिए, यह नया परिणाम देता है कि जेनसन-नुथ ऊपरी सीमा प्रयुक्त वेतन वृद्धि अनुक्रम के लिए परिणामी निचली सीमा से मेल खाती है, यह दर्शाता है कि इस वृद्धि अनुक्रम के लिए तीन पास शेलसॉर्ट का उपयोग किया जाता है तुलना/विपरीतता/चलने का समय। सूत्र हमें वृद्धि अनुक्रमों की खोज करने की अनुमति देता है जो निचली सीमाएं उत्पन्न करते हैं जो अज्ञात हैं; उदाहरण के लिए चार पासों के लिए एक वृद्धि क्रम जिसकी निचली सीमा इससे अधिक है वृद्धि क्रम के लिए . निचली सीमा बन जाती है शेलसॉर्ट के किसी भी संस्करण की सबसे खराब स्थिति की जटिलता उच्च क्रम की है: प्लाक्सटन, मैं बिजुरान गया और टॉर्स्टन सुएल ने दिखाया कि यह कम से कम उतनी ही तेजी से बढ़ता है .[27][28] रॉबर्ट साइफर ने एक मजबूत निचली सीमा साबित की: कब सभी के लिए .[29]


अनुप्रयोग

शेलसॉर्ट अधिक संचालन करता है और इसमें क्विकसॉर्ट की तुलना में अधिक सीपीयू कैश#कैश मिस होता है। हालाँकि, चूंकि इसे छोटे कोड का उपयोग करके कार्यान्वित किया जा सकता है और कॉल स्टैक का उपयोग नहीं किया जाता है, अंतः स्थापित प्रणालियाँ पर लक्षित सी मानक लाइब्रेरी में क्यूसॉर्ट फ़ंक्शन के कुछ कार्यान्वयन क्विकॉर्ट के बजाय इसका उपयोग करते हैं। उदाहरण के लिए, शेलसॉर्ट का उपयोग uClibc लाइब्रेरी में किया जाता है।[30] इसी तरह के कारणों से, अतीत में, शेलसॉर्ट का उपयोग लिनक्स कर्नेल में किया जाता था।[31] शेलसॉर्ट परिचय के उप-एल्गोरिदम के रूप में भी काम कर सकता है, छोटी उपसरणी को सॉर्ट करने के लिए और जब रिकर्सन गहराई एक निश्चित सीमा से अधिक हो जाती है तो मंदी को रोकने के लिए। उदाहरण के लिए, यह सिद्धांत bzip2 कंप्रेसर में नियोजित है।[32]


यह भी देखें

संदर्भ

  1. 1.0 1.1 1.2 Pratt, Vaughan Ronald (1979). Shellsort and Sorting Networks (Outstanding Dissertations in the Computer Sciences) (PDF). Garland. ISBN 978-0-8240-4406-0. Archived (PDF) from the original on 7 September 2021.
  2. "Shellsort & Comparisons".
  3. 3.0 3.1 3.2 3.3 3.4 Knuth, Donald E. (1997). "Shell's method". The Art of Computer Programming. Volume 3: Sorting and Searching (2nd ed.). Reading, Massachusetts: Addison-Wesley. pp. 83–95. ISBN 978-0-201-89685-5.
  4. 4.0 4.1 Shell, D. L. (1959). "A High-Speed Sorting Procedure" (PDF). Communications of the ACM. 2 (7): 30–32. doi:10.1145/368370.368387. S2CID 28572656.
  5. Some older textbooks and references call this the "Shell–Metzner" sort after Marlene Metzner Norton, but according to Metzner, "I had nothing to do with the sort, and my name should never have been attached to it." See "Shell sort". National Institute of Standards and Technology. Retrieved 17 July 2007.
  6. 6.0 6.1 6.2 Sedgewick, Robert (1998). Algorithms in C. Vol. 1 (3rd ed.). Addison-Wesley. pp. 273–281. ISBN 978-0-201-31452-6.
  7. Kernighan, Brian W.; Ritchie, Dennis M. (1996). The C Programming Language (2nd ed.). Prentice Hall. p. 62. ISBN 978-7-302-02412-5.
  8. Frank, R. M.; Lazarus, R. B. (1960). "A High-Speed Sorting Procedure". Communications of the ACM. 3 (1): 20–22. doi:10.1145/366947.366957. S2CID 34066017.
  9. Hibbard, Thomas N. (1963). "An Empirical Study of Minimal Storage Sorting". Communications of the ACM. 6 (5): 206–213. doi:10.1145/366552.366557. S2CID 12146844.
  10. Papernov, A. A.; Stasevich, G. V. (1965). "A Method of Information Sorting in Computer Memories" (PDF). Problems of Information Transmission. 1 (3): 63–75.
  11. Incerpi, Janet; Sedgewick, Robert (1985). "Improved Upper Bounds on Shellsort" (PDF). Journal of Computer and System Sciences. 31 (2): 210–224. doi:10.1016/0022-0000(85)90042-x.
  12. Sedgewick, Robert (1986). "A New Upper Bound for Shellsort". Journal of Algorithms. 7 (2): 159–173. doi:10.1016/0196-6774(86)90001-5.
  13. 13.0 13.1 13.2 Gonnet, Gaston H.; Baeza-Yates, Ricardo (1991). "Shellsort". Handbook of Algorithms and Data Structures: In Pascal and C (2nd ed.). Reading, Massachusetts: Addison-Wesley. pp. 161–163. ISBN 978-0-201-41607-7. Extensive experiments indicate that the sequence defined by α = 0.45454 < 5/11 performs significantly better than other sequences. The easiest way to compute 0.45454n is by (5 * n — 1)/11 using integer arithmetic.
  14. Tokuda, Naoyuki (1992). "An Improved Shellsort". In van Leeuven, Jan (ed.). Proceedings of the IFIP 12th World Computer Congress on Algorithms, Software, Architecture. Amsterdam: North-Holland Publishing Co. pp. 449–457. ISBN 978-0-444-89747-3.
  15. 15.0 15.1 Ciura, Marcin (2001). "Best Increments for the Average Case of Shellsort" (PDF). In Freiwalds, Rusins (ed.). Proceedings of the 13th International Symposium on Fundamentals of Computation Theory. London: Springer-Verlag. pp. 106–117. ISBN 978-3-540-42487-1. Archived from the original (PDF) on 23 September 2018.
  16. Lee, Ying Wai (2021). "Empirically Improved Tokuda Gap Sequence in Shellsort". arXiv:2112.11112 [cs.DS].
  17. Sedgewick, Robert (1998). "Shellsort". Algorithms in C++, Parts 1–4: Fundamentals, Data Structure, Sorting, Searching. Reading, Massachusetts: Addison-Wesley. pp. 285–292. ISBN 978-0-201-35088-3.
  18. Forshell, Olof (22 May 2018). "How to choose the lengths of my sub sequences for a shell sort?". Stack Overflow. Additional commentary at Fastest gap sequence for shell sort? (23 May 2018).
  19. Gale, David; Karp, Richard M. (April 1972). "A Phenomenon in the Theory of Sorting" (PDF). Journal of Computer and System Sciences. 6 (2): 103–115. doi:10.1016/S0022-0000(72)80016-3.
  20. Selmer, Ernst S. (March 1989). "On Shellsort and the Frobenius Problem" (PDF). BIT Numerical Mathematics. 29 (1): 37–40. doi:10.1007/BF01932703. hdl:1956/19572. S2CID 32467267.
  21. Weiss, Mark Allen (1989). "A good case for Shellsort". Congressus Numerantium. 73: 59–62.
  22. Espelid, Terje O. (December 1973). "Analysis of a Shellsort Algorithm". BIT Numerical Mathematics. 13 (4): 394–400. doi:10.1007/BF01933401. S2CID 119443598. The quoted result is equation (8) on p. 399.
  23. Yao, Andrew Chi-Chih (1980). "An Analysis of (h, k, 1)-Shellsort" (PDF). Journal of Algorithms. 1 (1): 14–50. doi:10.1016/0196-6774(80)90003-6. S2CID 3054966. STAN-CS-79-726. Archived from the original (PDF) on 4 March 2019.
  24. Janson, Svante; Knuth, Donald E. (1997). "Shellsort with Three Increments" (PDF). Random Structures and Algorithms. 10 (1–2): 125–142. arXiv:cs/9608105. CiteSeerX 10.1.1.54.9911. doi:10.1002/(SICI)1098-2418(199701/03)10:1/2<125::AID-RSA6>3.0.CO;2-X.
  25. Jiang, Tao; Li, Ming; Vitányi, Paul (September 2000). "A Lower Bound on the Average-Case Complexity of Shellsort" (PDF). Journal of the ACM. 47 (5): 905–911. arXiv:cs/9906008. CiteSeerX 10.1.1.6.6508. doi:10.1145/355483.355488. S2CID 3265123.
  26. Vitányi, Paul (March 2018). "On the average-case complexity of Shellsort" (PDF). Random Structures and Algorithms. 52 (2): 354–363. arXiv:1501.06461. doi:10.1002/rsa.20737. S2CID 6833808.
  27. Plaxton, C. Greg; Poonen, Bjorn; Suel, Torsten (24–27 October 1992). "Improved Lower Bounds for Shellsort" (PDF). Annual Symposium on Foundations of Computer Science (FOCS 1992). Pittsburgh, United States. 33: 226–235. CiteSeerX 10.1.1.43.1393. doi:10.1109/SFCS.1992.267769. ISBN 978-0-8186-2900-6.
  28. Plaxton, C. Greg; Suel, Torsten (May 1997). "Lower Bounds for Shellsort" (PDF). Journal of Algorithms. 23 (2): 221–240. CiteSeerX 10.1.1.460.2429. doi:10.1006/jagm.1996.0825.
  29. Cypher, Robert (1993). "A Lower Bound on the Size of Shellsort Sorting Networks". SIAM Journal on Computing. 22: 62–71. doi:10.1137/0222006.
  30. Novoa, Manuel III. "libc/stdlib/stdlib.c". Retrieved 29 October 2014.
  31. "kernel/groups.c". GitHub. Retrieved 5 May 2012.
  32. Julian Seward. "bzip2/blocksort.c". Retrieved 30 March 2011.


ग्रन्थसूची


बाहरी संबंध