एक ब्लैक बॉक्स का उपयोग करके सॉर्ट करना

Question

मान लें कि हम वास्तविक संख्याओं की सूची सॉर्ट करना चाहते हैं । मान लें कि हमें एक ब्लैक बॉक्स दिया गया है जो तुरंत वास्तविक संख्याओं को सॉर्ट कर सकता है। इस ब्लैक बॉक्स के इस्तेमाल से हमें कितना फायदा हो सकता है?एन $S$$n$$\sqrt n$

उदाहरण के लिए, क्या हम ब्लैक बॉक्स पर केवल कॉल के साथ संख्याओं को सॉर्ट कर सकते हैं ? सबसे अच्छा एल्गोरिथ्म जो मुझे मिला है वह ब्लैक बॉक्स में कॉल का उपयोग करता है । लेकिन मैं इसे और बेहतर नहीं कर पाया। यहाँ मेरा एल्गोरिथ्म है जो मर्ज-सॉर्ट के समान है:$O(\sqrt n)$$n$

पहले सूची को में सूचीबद्ध करें। लगभग आकार के साथ। फिर इन सूचियों को सॉर्ट करने के लिए ब्लैक बॉक्स में कॉल का उपयोग करें । अंत में, ब्लैक बॉक्स का उपयोग करके क्रमबद्ध सूचियों को निम्न प्रकार से मर्ज करें:$S$ रों1,एस2,। । । ,एस$\sqrt n$$s_1, s_2, ..., s_{\sqrt n}$$\sqrt n$$\sqrt n$

सूचियों के सबसे छोटे तत्वों को एक नई सूची में डालें , फिर इसे सॉर्ट करने के लिए ब्लैक बॉक्स पर कॉल करें। में नंबर (प्रथम और सबसे छोटी तत्व ) में सबसे छोटी संख्या हो जाएगा । हम इसे आउटपुट सूची के पहले स्थान पर रख सकते हैं। यह मानते हुए कि तत्व को से चुना गया है , हम को सॉर्ट लिस्ट के दूसरे सबसे छोटे तत्व , और फिर के दूसरे सबसे छोटे सदस्य की गणना करने के लिए उस पर ब्लैक बॉक्स चलाते हैं । हम तब तक जारी रखते हैं जब तक सभी तत्व छँट नहीं जाते। इस भाग के लिए ब्लैक बॉक्स कॉल की कुल संख्याएल [ 1 ] एल एस एस जे एल [ 1 ] रों जे एस एन - $L$$L[1]$$L$$S$
$s_j$$L[1]$$s_j$$S$
$n - \sqrt n$। इसलिए कुल मिलाकर कॉल की कुल संख्या होगी ।$n$

दूसरी ओर, ऐसा लगता है कि हमें निम्न प्रकार की छँटाई के लिए आवश्यक संख्या तुलनाओं पर निचली-बाउंड का उपयोग करने में सक्षम होना चाहिए: हम ब्लैक बॉक्स को का उपयोग करके लागू कर सकते हैं तुलना। अगर हम ब्लैक बॉक्स पर कॉल के साथ समस्या को हल कर सकते हैं और रैखिक-समय में विलय कर सकते हैं तो हम तुलनाओं के साथ वास्तविक संख्याओं को सॉर्ट कर सकते हैं जो कि असंभव है।ओ($\sqrt n \lg \sqrt n = \frac{1}{2} \sqrt n \lg n$no(nlgn$o(\sqrt n)$$n$$o(n \lg n)$

मुझे लगता है कि हम यह साबित कर सकते हैं कि ब्लैक बॉक्स के लिए कॉल की संख्या के लिए एक कम-सीमा है, क्योंकि ब्लैक बॉक्स का उपयोग करने वाले बहुत सारे तुलनाओं को साझा किया जाएगा और इसलिए हमारे तर्क में फिर से लिखा गया है।$\Omega(n)$

अद्यतन: जैसा कि अन्य पदों का सुझाव है, एक भी प्राप्त करने योग्य है।$\sqrt n \lg n$

Comments

आपकी टिप्पणी में एक टाइपो लगता है। "कोई एल्गोरिथ्म से भी कम समय का उपयोग कर: आप कहते हैं चाहते थे तरह कर सकते हैं मशीन के लिए कॉल के साथ कम से कम वास्तविक संख्या तुलना"? ps: आपको इस तथ्य के बारे में भी सावधान रहना चाहिए कि कम-बाउंड केवल तुलना आधारित सॉर्टिंग एल्गोरिदम के लिए है। एनएनएलएनएन एनएल जी$\sqrt{N}$$N$$N\lg N$$N\lg N$

— केव

मुझे लगता है कि हम AKS के सॉर्टिंग नेटवर्क का उपयोग करके भी प्राप्त कर सकते हैं । उनके नेटवर्क को आपके मॉडल की तात्कालिकता के रूप में माना जा सकता है जहां ब्लैक बॉक्स आकार 2 के ब्लॉक को सॉर्ट कर सकता है। उनके एल्गोरिदम राउंड का उपयोग करते हैं, प्रत्येक राउंड को 2-सॉर्टर बार कहते हैं। 2-सॉर्टर्स के एक "राउंड" को -sorters के साथ आसानी से जोड़ा जा सकता है। हे(लॉग इन करेंn)हे(एन)हे(एन)ओ($O(\sqrt{n}\log n)$$O(\log n)$$O(n)$$O(n)$$O(\sqrt{n})$ $\sqrt{n}$

— विनायक पाठक

@VinayakPathak: इनपुट डेटा को आकार के _ _ _ _ _ _ _ _ _ में ले लें , और फिर एक- वर्ग का उपयोग करके AKS नेटवर्क का उपयोग करके chunks को सॉर्ट करें, -sorter के साथ प्रत्येक तुलनित्र को प्रतिस्थापित करने के बाद । $2\sqrt{N}$$\sqrt{N}/2$$\sqrt{N}$

— 18

@ J @ ɛ E: हां, महान, जो निश्चित रूप से मेरे निर्माण की तुलना में सरल दिखता है।

— विनायक पाठक

@ J @ ɛ E, आपकी टिप्पणी का जवाब हो सकता है। :)

— केव

Answer 1

ब्लैक बॉक्स पर कॉल के साथ संभव है और कोई तुलना नहीं।$O(\sqrt n\log n)$

सबसे पहले, निम्नलिखित संतुलित विभाजन समस्या पर विचार करें: दिए गए तत्व (जहाँ ), उन्हें दो समूहों में विभाजित करें, आकार में सबसे छोटा कम से कम , के बारे में पहले समूह के सभी तत्व दूसरे समूह के सभी तत्वों से छोटे हैं। यह ब्लैक बॉक्स पर कॉल के साथ किया जा सकता है । (मैं बाद में इसका वर्णन करूँगा।) फिर इस विभाजन एल्गोरिथ्म के साथ क्विकॉर्ट का उपयोग करें:एक [ 1 .. मीटर ] $m$$A[1..m]$मीटर/4हे(एम/$\sqrt n \le m \le n$$m/4$$O(m/\sqrt n)$

def qsort(A[1..m]):
   if m < sqrt(n): sort A with one call to the black box
   else:
     Partition A[1..m] into two groups as described above.
     Recursively qsort the first group.
     Recursively qsort the second group.

प्रत्येक विभाजन कदम मानते हुए लेता ब्लैक बॉक्स के लिए कॉल, ऊपर एल्गोरिथ्म, दिए गए इनपुट , कर देगा ब्लैक बॉक्स के लिए कॉल, क्योंकि रिकर्सियन ट्री में गहराई और पेड़ के प्रत्येक स्तर में कॉल की कुल संख्या ब्लैक बॉक्स में होती है।एक[1 ..n]हे($O(m/\sqrt n)$$A[1..n]$हे(लॉगएन)ओ(n/$O(\sqrt n\log n)$$O(\log n)$$O(n/\sqrt n) = O(\sqrt n)$

विभाजन कदम इस प्रकार है:

def partition(A[1..m]):  (where sqrt(n) <= m <= n)
   Divide A into m/sqrt(n) groups of size sqrt(n) each.
   Sort each group with one call to the black box per group.
   Sort the medians of the groups with one call to the black box.
   (Note the number of groups is less than sqrt(n), because m <= n.)
   Let X be the median of the medians.
   Partition all m elements around X, using the black box as follows:
      For each group G, let Y be its median:
        Call the black box once on (G - {Y}) union {X}.
        (This gives enough information to order all elts w.r.t. X.)

Comments

एल्गोरिथ्म विभाजन के अंतिम चरण में (): "एक्स के चारों ओर सभी तत्वों का विभाजन", क्या यह एम अतिरिक्त तुलनाओं का उपयोग नहीं करेगा?

— विनायक पाठक

एल्गोरिथ्म का पालन करते हुए लाइन देखें, यह बताता है कि उस चरण को कैसे करना है। मैं इसे स्पष्ट करने के लिए संपादित करूँगा।

— नील यंग

Answer 2

मुझे लगता है कि आपका प्रश्न 1990 से बेगेल और गिल के पेपर " के-सॉर्टर का उपयोग करके एन वस्तुओं को क्रमबद्ध करना " में संबोधित किया गया था और कागज का सार यह कहता है:

के-सॉर्टर एक ऐसा उपकरण है जो यूनिट समय में कश्मीर वस्तुओं को सॉर्ट करता है। एक एल्गोरिथ्म की जटिलता जो कि के-सॉर्टर का उपयोग करती है, को के-सॉर्टर के अनुप्रयोगों की संख्या के रूप में परिभाषित किया गया है। इस माप में, n ऑब्जेक्ट्स को सॉर्ट करने की जटिलता और , n में प्रथम-क्रम की शर्तें तक। और के। 4nलॉग$\frac{n \log n}{k \log k}$$\frac{4n \log n}{k \log k}$

Comments

धन्यवाद। मुझे पेपर नहीं मिला। क्या आप कागज या इसके प्रमाण के लिए लिंक प्रदान कर सकते हैं?

— अमीरज

पेपर के लिए लिंक

— नील यंग

साइटेसरक्स पर भी ।

— केव

ध्यान दें कि जब , Beigel और Gill की सीमा । $k=\sqrt{n}$$\Theta(\sqrt{n})$

— जेफ

Answer 3

यह तरह संभव है obliviously साथ , ब्लैक बॉक्स के लिए कॉल प्रत्येक मूल इनपुट का एक सन्निहित subarray के लिए आवेदन किया। एल्गोरिथ्म ब्लैक-बॉक्स कॉल के अलावा इनपुट डेटा को कभी नहीं छूता है। विशेष रूप से, ब्लैक-बॉक्स कॉल का एक ही अनुक्रम केवल का एक फ़ंक्शन है , न कि वास्तविक इनपुट डेटा (इसलिए "गुमनामी")।$O(\sqrt{n}\log n)$$n$

यहाँ एक सरल एल्गोरिथ्म का एक स्केच है, जो कि एक ब्लैक बॉक्स का उपयोग करता है जो कि सिर्फ बजाय आकार की सबरेज़ को सॉर्ट करता है । ब्लैक बॉक्स पर कॉल की कुल संख्या लगभग । उल्लेखनीय सादगी के लिए, मान लें कि सम है और एक विषम पूर्णांक है।$k$$\sqrt{n}$$2(n/k)^2$$k$$2n/k$

BlockBubbleSort(X[0..n-1], k):
   m = floor(n/k)
   for i = 1 to m
      for j = 0 to m-1
          BlackBoxSort(X[j*k .. (j+1)*k-1])
      for j = 0 to m-1
          BlackBoxSort(X[j*k + k/2 .. (j+1)*k + k/2 - 1])

यहाँ और के लिए एल्गोरिथम का आरेख है । डेटा बाएं से दाएं यात्रा करता है; प्रत्येक बॉक्स एक है -sorter।$n=18$$k=4$$k$

जैसा कि आंकड़ा उम्मीद करता है कि यह एल्गोरिथ्म इनपुट सरणी को आकार विखंडू में तोड़ता है , और फिर एक तुलना-विनिमय ऑपरेशन के स्थान पर -sorter का उपयोग करते हुए, विखंडन पर बुलबुले को लागू करता है । शुद्धता इस बात का पालन करती है कि नेटवर्क 0s और 1s के किसी भी सरणी को सही ढंग से सॉर्ट करता है ।$k/2$$k$

जैसा कि @ VinayakPathak की टिप्पणी से पता चलता है, बाउंड को एक अलग छँटाई नेटवर्क के साथ बुलबुले के स्थान पर कम किया जा सकता है। उदाहरण के लिए, बैच का सम-विषम विलय ब्लैक-बॉक्स कॉल की संख्या को घटाकर , और अक्स छँटाई नेटवर्क यह करने के लिए कम कर देता है । यह अंतिम एल्गोरिथ्म नील के गैर-विस्मृत एल्गोरिदम से मेल खाता है (बड़े !!) निरंतर कारकों।$O((n/k)^2)$हे((एन/कश्मीर)लॉग(एन/कश्मीर))=हे($O((n/k)\log^2(n/k)) = O(\sqrt{n}\log^2 n)$$O((n/k)\log (n/k)) = O(\sqrt{n}\log n)$

Comments

धन्यवाद। क्या एक कम बाउंड साबित हो सकता है? $\Omega(\sqrt n\ lg(n))$

— अमीरज

नहीं, बीज़ेल और गिल के कागज का तात्पर्य ऊपरी सीमा है । $O(\sqrt{n})$

— जेफ

उस अच्छी तस्वीर के लिए +1! मुझसे गलती हो सकती है लेकिन मुझे लगता है कि यह पूरी तरह से सही नहीं है (अगर मैं गलत हूं तो मुझे सुधारो)। मान लिया जाए कि आउटपुट आरोही क्रम में है, यदि सबसे छोटा तत्व अंतिम स्थिति में है, तो इसके लिए कोई "पथ" नहीं है, पहली स्थिति में "यात्रा" करने के लिए। "I = 1 से m" के लिए "i = 1 से m + 1" के लिए बदलना यह सही प्रतीत होता है, हालाँकि यह कुछ अनावश्यक ओवरहेड का परिचय दे सकता है।

— जॉर्ज

@ जॉर्ज ऊप्स, आप सही कह रहे हैं; मुझे एक और परत की आवश्यकता है!

— जेफ