केवल पढ़ने के ढेर का उपयोग कर छँटाई

निम्नलिखित सेटिंग पर विचार करें:

हम एक ढेर दिया जाता है जिसमें आइटम नहीं है। $s$ $n$
हम अतिरिक्त स्टैक की निरंतर संख्या का उपयोग कर सकते हैं । $O(1)$
हम इन स्टाकों पर निम्नलिखित प्रचालनों को लागू कर सकते हैं:
1. जाँच करें कि क्या कोई स्टैक खाली है,
2. दो ढेर की शीर्ष वस्तुओं की तुलना करें,
3. स्टैक में शीर्ष आइटम हटाएं,
4. एक स्टैक में शीर्ष आइटम प्रिंट करें,
5. एक स्टैक के शीर्ष आइटम को दूसरे स्टैक में कॉपी करें,
6. एक स्टैक की सामग्री को दूसरे स्टैक पर कॉपी करें।

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

यहाँ तुलना के साथ ढेर को सॉर्ट करने के लिए एक एल्गोरिथ्म है : $O(n^2)$

last := empty
for i from 1 to n
  min := empty
  w := s
  while w is not empty
    if w.top > last and w.top < min
      min := w.top
    delete w.top
  print min
  last := min

क्या हम बेहतर कर सकते हैं?

क्या कोई ऐसा प्रोग्राम है जो केवल तुलनाओं का उपयोग करके स्टैक में वस्तुओं की क्रमबद्ध सूची को प्रिंट करता है ? $O(n\log n)$

ds.algorithms sorting

— सिद्धार्थ
स्रोत

ऐसा लगता है कि रजिस्टरों स्टैक की तरह व्यवहार करते हैं? ऐसा लगता है कि आप पुश और पॉप ऑपरेशन के बारे में बात कर रहे हैं। क्या यह आपके प्रश्न हैं? आप कई स्टैक और स्टैक ऑपरेशन का उपयोग करके एक स्टैक को कैसे सॉर्ट करेंगे?

— AturSams

रजिस्टर के साथ आप कर सकते हैं: बस हर नंबर को एक रजिस्टर (

) में डालें और फिर एक सामान्य सॉर्टिंग एल्गोरिथ्म (

) लागू करें।

n

$n$

O (n)

$O(n)$

O (n \lg n)

$O(n \lg n)$

— कावेह

क्या आप

रजिस्टर का उपयोग करना चाहते हैं ? अन्यथा समस्या तुच्छ है, जैसा कि केव ने टिप्पणी की थी।

O (1)

$O(1)$

— युवल फिल्मस

आपका स्वागत है। मुझे लगा कि हमें एक नहीं बल्कि कई ढेर दिए जाएंगे, मैं इसे ठीक कर दूंगा।

— केवह

@ कप्पा, क्या आप सुनिश्चित हैं कि इसे देखने में उपयोग किया जा सकता है? हम आकार से किसी भी मनमाने ढंग से खोए हुए को 1 से बड़ा नहीं रख सकते हैं। क्या आपको सॉर्ट किए गए ब्लॉक को स्टोर करने की आवश्यकता नहीं है?

— केवह

जवाबों:

$O(\log n)$ $ST=\Omega(n^2)$ $n^2/\log n$

थोड़ा और विस्तार से: हम ऊपर के ऑपरेशन 5 से दूर कर सकते हैं। धीरे-धीरे बोलना, अगर हम पहले से ही दो सूचियों के प्रमुखों की तुलना कर सकते हैं और एक सूची के प्रमुख को प्रिंट कर सकते हैं, तो हमें किसी विशेष रजिस्टर पर सूची के प्रमुख को अलग करने की कोई आवश्यकता नहीं है। यह मानते हुए, हम देखते हैं कि मशीन में प्रत्येक रजिस्टर केवल इनपुट के अंतिम विकल्प को संग्रहीत करता है।

$\ell$ $k$ $X_1,\dots,X_k$

$n$ $n$ $(i,d_1,\dots,d_k)$ $1\le i\le \ell$ $0\le d_1 ,\dots, d_k \le n$ $(i,d_1 ,\dots, d_k)$ $i$ $X_i$ $d_i$

$i$

$X_u<X_v$ $i_1$ $i_2$

$d_1,\dots,d_k$ $(i,d_1,\dots,d_k)$ $d_u$ $d_v$ $(i_1,d_1,\dots,d_k)$ $(i_2,d_1,\dots,d_k)$

$i$

$X_1 \leftarrow tail(X_2)$ $i'$

$(i,d_1,\dots,d_k)$ $(i',d_2-1,\dots,d_k)$

$i$

$print(head(X_u))$ $i'$

$(i,d_1,\dots,d_k)$ $(i',d_1,\dots,d_k)$ $d_u$

$\ell\cdot n^k$ $O(\log n)$

— सिद्धार्थ
स्रोत

क्या आप तत्वों को गिनने में सक्षम हैं? फिर, मुझे लगता है, एक काफी आसान मर्जेसर्ट कार्यान्वयन है। यदि आप स्टैक पर अतिरिक्त प्रतीकों को लगाने में सक्षम थे, तो आप इसे इस तरह से 3 स्टैक के साथ हल कर सकते हैं:

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

सभी कार्यों में रैखिक समय लगता है, इसलिए हमने सूची को में क्रमबद्ध किया है $O(n \log n)$

$n \log n$

चूंकि आप स्टैक पर नए तत्व नहीं डाल सकते हैं, इसलिए आपको अलग-अलग बिंदुओं पर समस्याएं मिल सकती हैं। इसे हल करने के लिए आप कुछ अतिरिक्त स्टैक के साथ निम्न कार्य कर सकते हैं:

$n-2^{\lfloor \log n\rfloor}$

$\log n$ $c$ $cn \log n+c\frac{n}{2} \log \frac{n}{2}+c\frac{n}{4} \log \frac{n}{4}+\ ... = O(n \log n)$ $O(n \log n)$

— cero
स्रोत

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

— सिद्धार्थ

हम किसी नए तत्व को स्टैक में नहीं धकेल सकते हैं, लेकिन 5 के अनुसार हम एक स्टैक के शीर्ष तत्व को दूसरे में धकेलने में सक्षम हैं। इसलिए स्टैक को रिवर्स ऑर्डर में कॉपी करना सबसे अधिक रैखिक समय की आवश्यकता होती है। तो मुझे लगता है, कि आप के लिए क्या पूछ रहे थे नहीं था?

— cero

जैसा कि प्रश्न में बताया गया है, आप अन्य मदों के शीर्ष पर कुछ भी धक्का नहीं दे सकते।

— केवह