तीन ढेर के साथ एक कतार कैसे लागू करें?

136

मुझे एक एल्गोरिथम पुस्तक ( एल्गोरिदम, रॉबर्ट सेडगविक और केविन वेन द्वारा 4 वें संस्करण ) में यह सवाल आया था ।

तीन ढेर के साथ कतार। तीन स्टैक के साथ एक कतार को लागू करें ताकि प्रत्येक कतार ऑपरेशन स्टैक संचालन की एक निरंतर (सबसे खराब स्थिति) की संख्या ले। चेतावनी: उच्च डिग्री कठिनाई।

मुझे पता है कि 2 स्टैक के साथ एक कतार कैसे बनाई जाती है लेकिन मैं 3 स्टैक के साथ समाधान नहीं ढूंढ सकता हूं। कोई उपाय ?

(ओह और, यह होमवर्क नहीं है :))

algorithm data-structures

— DuoSRX
स्रोत

30

मुझे लगता है कि यह हनोई संस्करण का एक टॉवर है ।

— गम्बू

14

@ जेसन: यह प्रश्न कोई डुप्लिकेट नहीं है, क्योंकि यह O (1) के लिए परिशोधन समय पूछता है, जबकि यह प्रत्येक ऑपरेशन के लिए O (1) सबसे खराब स्थिति के लिए पूछता है। डुओसआरएक्स का दो-स्टैक समाधान पहले से ही ओ (1) परिचालित समय प्रति ऑपरेशन है।

— अंतरजाल

15

लेखक ने कहा कि जब वह "चेतावनी: कठिनाई का उच्च स्तर" कहकर मजाक नहीं कर रहा था।

— BoltClock

9

@ जंबो दुर्भाग्य से हनोई के टॉवर की समय जटिलता निरंतर समय के पास कहीं नहीं है!

— प्रशन २०'११

12

ध्यान दें: पाठ में प्रश्न इस पर अद्यतन किया गया है: एक कतार को ढेर की निरंतर संख्या के साथ लागू करें ["3" नहीं] ताकि प्रत्येक कतार संचालन एक स्थिर (सबसे खराब स्थिति) स्टैक संचालन की संख्या ले। चेतावनी: उच्च डिग्री कठिनाई। ( algs4.cs.princeton.edu/13stacks - धारा 1.3.43)। ऐसा प्रतीत होता है कि प्रो। सेडगेविक ने मूल चुनौती स्वीकार कर ली है।

— मार्क पीटर्स

44

सारांश

O (1) एल्गोरिथ्म 6 स्टैक के लिए जाना जाता है
O (1) एल्गोरिथ्म 3 स्टैक के लिए जाना जाता है, लेकिन आलसी मूल्यांकन का उपयोग करना जो व्यवहार में अतिरिक्त आंतरिक डेटा संरचनाओं से मेल खाता है, इसलिए यह एक समाधान का गठन नहीं करता है
सेडगेविक के पास के लोगों ने पुष्टि की है कि उन्हें मूल प्रश्न के सभी बाधाओं के भीतर 3-स्टैक समाधान के बारे में पता नहीं है

विवरण

इस लिंक के पीछे दो कार्यान्वयन हैं: http://www.eecs.usma.edu/webs/people/okasaki/jfp95/index.html

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

उनमें से एक O (1) है, लेकिन SIX स्टैक का उपयोग करता है। हालांकि, यह आलसी निष्पादन के बिना काम करता है।

अद्यतन: ओकासाकी का पेपर यहाँ है: http://www.eecs.usma.edu/webs/people/okasaki/jfp95.ps और ऐसा लगता है कि वह वास्तव में ओ (1) संस्करण के लिए केवल 2 स्टैक का उपयोग करता है जो आलसी मूल्यांकन करता है। समस्या यह है कि यह वास्तव में आलसी मूल्यांकन पर आधारित है। सवाल यह है कि क्या यह आलसी मूल्यांकन के बिना 3-स्टैक एल्गोरिथ्म में अनुवादित किया जा सकता है।

अद्यतन: एक और संबंधित एल्गोरिथ्म को होल्गर पीटरसन द्वारा पेपर "स्टैक बनाम डेक्स" में वर्णित किया गया है, जो कम्प्यूटिंग और कॉम्बिनेटरिक्स पर 7 वें वार्षिक सम्मेलन में प्रकाशित हुआ है। आप Google पुस्तकें से लेख पा सकते हैं। 225-226 पृष्ठों की जाँच करें। लेकिन एल्गोरिथ्म वास्तव में वास्तविक समय सिमुलेशन नहीं है, यह तीन स्टैक पर एक डबल-एंडेड कतार का रैखिक-समय सिमुलेशन है।

gusbro: "जैसा कि @Leonel ने कुछ दिन पहले कहा था, मुझे लगा कि प्रो। सेडगविक के साथ जांच करना उचित होगा अगर उसे कोई समाधान पता था या कोई गलती थी। तो मैंने उसे लिखा था। मुझे सिर्फ एक प्रतिक्रिया मिली (हालांकि यह नहीं है) खुद को लेकिन प्रिंसटन के एक सहयोगी से) इसलिए मैं आप सभी के साथ साझा करना पसंद करता हूं। उन्होंने मूल रूप से कहा कि उन्हें तीन स्टैक का उपयोग करने वाले एल्गोरिदम का पता था और लगाए गए अन्य अवरोधों (जैसे आलसी मूल्यांकन का उपयोग नहीं करना)। उन्हें एक एल्गोरिथ्म का उपयोग करने का पता था। 6 स्टैक्स जैसा कि हम पहले से ही यहां के जवाबों को देखते हुए जानते हैं। इसलिए मुझे लगता है कि एल्गोरिदम को खोजने के लिए सवाल अभी भी खुला है (या साबित नहीं किया जा सकता है)। "

— रेवती.हिमा
स्रोत

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

— flolo

1

नमस्ते, कार्यान्वयन एक कार्यात्मक भाषा में हैं जहां सूचियाँ ढेर के अनुरूप होती हैं जब तक कि पॉइंटर्स साझा नहीं किए जाते हैं, और वे नहीं हैं; छह-स्टैक संस्करण वास्तव में छह "सादे" स्टैक का उपयोग करके लागू किया जा सकता है। दो / तीन स्टैक संस्करण के साथ समस्या यह है कि यह छिपे हुए डेटा संरचनाओं (क्लोजर) का उपयोग करता है।

— अंति हूइमा

क्या आप सुनिश्चित हैं कि छह-स्टैक समाधान संकेत साझा नहीं करता है? में rotate, यह कैसा दिखता frontसूची दोनों को सौंप दिया जाता है oldfrontऔर f, और इन तो अलग से संशोधित कर रहे हैं।

— इंटरजे

14

Algs4.cs.princeton.edu/13stacks पर स्रोत सामग्री को बदल दिया गया है: 43. [ लगातार "नहीं" 3 "] ढेर के साथ एक कतार को लागू करें ताकि प्रत्येक कतार संचालन एक स्थिर (सबसे खराब स्थिति) की संख्या को ढेर कर ले। संचालन। चेतावनी: उच्च डिग्री कठिनाई। चुनौती का शीर्षक अभी भी "तीन ढेर के साथ कतार" हालांकि :-) कहता है।

— मार्क पीटर्स

3

@AnttiHuima छह-स्टैक लिंक मर चुका है, क्या आप जानते हैं कि यह कहीं मौजूद है?

— क्वेंटिन Pradet

12

ठीक है, यह वास्तव में कठिन है, और एकमात्र समाधान जिसके साथ मैं आ सकता था, कोबायशी मारू परीक्षण (किसी तरह धोखा दिया) के लिए किर्क समाधान का मुझे याद है: विचार, हम ढेर के ढेर का उपयोग करते हैं (और इसका उपयोग सूची बनाने के लिए करते हैं )। मैं संचालन को en / dequeue और धक्का और पॉप कहता हूं, फिर हमें मिलता है:

queue.new() : Stack1 = Stack.new(<Stack>);  
              Stack2 = Stack1;  

enqueue(element): Stack3 = Stack.new(<TypeOf(element)>); 
                  Stack3.push(element); 
                  Stack2.push(Stack3);
                  Stack3 = Stack.new(<Stack>);
                  Stack2.push(Stack3);
                  Stack2 = Stack3;                       

dequeue(): Stack3 = Stack1.pop(); 
           Stack1 = Stack1.pop();
           dequeue() = Stack1.pop()
           Stack1 = Stack3;

isEmtpy(): Stack1.isEmpty();

(StackX = StackY सामग्री की नकल नहीं है, केवल संदर्भ की एक प्रति है। बस इसे आसान बनाने के लिए वर्णन करना है। आप 3 स्टैक की एक सरणी का उपयोग कर सकते हैं और उन्हें अनुक्रमणिका के माध्यम से एक्सेस कर सकते हैं, वहां आप बस इंडेक्स वेरिएबल के मान को बदल देंगे। )। स्टैक-ऑपरेशन-शब्दों में सब कुछ ओ (1) में है।

और हाँ, मैं इसके तर्क को जानता हूं, क्योंकि हमारे पास 3 से अधिक ढेर हैं, लेकिन हो सकता है कि यह आप में से अन्य लोगों को अच्छे विचार दे।

संपादित करें: स्पष्टीकरण उदाहरण:

 | | | |3| | | |
 | | | |_| | | |
 | | |_____| | |
 | |         | |
 | |   |2|   | |
 | |   |_|   | |
 | |_________| |
 |             |
 |     |1|     |
 |     |_|     |
 |_____________|

मैंने यहां स्टैक 1 को दिखाने के लिए थोड़ी ASCII- कला के साथ कोशिश की।

हर तत्व एक ही तत्व स्टैक में लिपटे हुए है (इसलिए हमारे पास केवल ढेर के प्रकार हैं)।

आप पहले तत्व को हटाते हुए देखते हैं (यहाँ तत्व 1 और 2 वाला स्टैक)। फिर अगले तत्व को पॉप करें और वहां पर रखें। 1. बाद में हम कहते हैं कि पहला पॉप स्टैक अब हमारा नया स्टैक 1 है। थोड़ा और अधिक कार्यात्मक बोलने के लिए - ये 2 तत्वों के ढेर द्वारा कार्यान्वित की जाने वाली सूचियाँ हैं जहाँ शीर्ष तत्व ist cdr और पहला / नीचे शीर्ष तत्व कार है । अन्य 2 ढेर की मदद कर रहे हैं।

Esp मुश्किल डालने का कार्य है, जैसा कि आप किसी भी अन्य तत्व को जोड़ने के लिए नेस्टेड ढेर में गहरा गोता लगाने के लिए है। यही कारण है कि स्टैक 2 है। स्टैक 2 हमेशा अंतरतम स्टैक होता है। जोड़ना तब बस एक तत्व को अंदर धकेलता है और फिर एक नए स्टैक 2 को धकेलता है (और यही कारण है कि हमें स्टैक 2 को हमारे डीक्यू ऑपरेशन में छूने की अनुमति नहीं है)।

— flolo
स्रोत

क्या आप यह समझाने की परवाह करेंगे कि यह कैसे काम करता है? शायद 'ए', 'बी', 'सी', 'डी' और फिर 4 बार पॉपिंग करते हुए ट्रेस आउट हो गया?

— MAK

1

@ आइसमैन: नो स्टैक 2 सही है। वे खो नहीं रहे हैं, क्योंकि स्टैक हमेशा स्टैक 1 में अंतरतम स्टैक को संदर्भित करता है, इसलिए वे अभी भी स्टैक 1 में निहित हैं।

— flolo

3

मैं मानता हूँ कि यह धोखा है :-)। यह 3 ढेर नहीं है, यह 3 स्टैक संदर्भ है। लेकिन एक सुखद पढ़ा।

— मार्क पीटर्स

1

इसकी एक चतुर योजना है, लेकिन अगर मैं इसे सही तरीके से समझूं, तो यह एन स्टैक की आवश्यकता को समाप्त कर देगा जब एन तत्वों को कतार में धकेल दिया जाएगा। सवाल 3 स्टैक के लिए पूछता है।

— मैक

2

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

— flolo

4

मैं यह दिखाने के लिए एक प्रमाण का प्रयास करने जा रहा हूं कि यह नहीं किया जा सकता है।

मान लीजिए कि एक कतार क्यू है जो 3 स्टैक, ए, बी और सी द्वारा सिम्युलेटेड है।

इस प्रकार के दावे

ASRT0: = इसके अलावा, मान लें कि Q, O (1) में {{कतार) में ऑपरेशन {क्यू, डीक्यू} का अनुकरण कर सकता है। इसका मतलब यह है कि हर कतार / डैक्यू ऑपरेशन के लिए स्टैक पुश / पॉप का एक विशिष्ट अनुक्रम मौजूद है।
सामान्यता के नुकसान के बिना, मान लें कि कतार संचालन नियतात्मक हैं।

बता दें कि क्यू में गिने जाने वाले तत्वों को कतार के उनके क्रम के आधार पर 1, 2, ... गिना जाता है, क्यू के पहले पंक्ति वाले तत्व को 1 के रूप में परिभाषित किया जा रहा है, 2 के रूप में दूसरा, और इसी तरह।

परिभाषित करें

Q(0) := Q की वह स्थिति जब Q में 0 तत्व होते हैं (और इस प्रकार A, B और C में 0 तत्व)
Q(1) := 1 कतार संचालन के बाद Q (और A, B और C) की स्थिति Q(0)
Q(n) := N कतार संचालन के बाद Q (और A, B और C) की स्थिति Q(0)

परिभाषित करें

|Q(n)| :=तत्वों की संख्या Q(n)(इसलिए |Q(n)| = n)
A(n) := जब Q की अवस्था हो तो स्टैक A की स्थिति Q(n)
|A(n)| := में तत्वों की संख्या A(n)

और स्टैक बी और सी के लिए इसी तरह की परिभाषाएं।

तुच्छता,

|Q(n)| = |A(n)| + |B(n)| + |C(n)|

---

|Q(n)| स्पष्ट रूप से n पर अनबाउंड है।

इसलिए, कम से कम एक |A(n)|, |B(n)|या|C(n)| एन पर अनबाउंड है।

WLOG1, मान लीजिए कि स्टैक ए अनबाउंड है और स्टैक बी और सी बंधे हैं।

परिभाषित करें * B_u :=B C_u :=का ऊपरी भाग * C की ऊपरी सीमा *K := B_u + C_u + 1

WLOG2, ऐसे n के लिए |A(n)| > K, से K तत्वों का चयन करें Q(n)। मान लीजिए कि उन तत्वों में से 1 A(n + x)सभी के लिए है x >= 0, अर्थात तत्व हमेशा स्टैक में है कोई फर्क नहीं पड़ता कि कितने कतार संचालन किए जाते हैं।

X := वह तत्व

तब हम परिभाषित कर सकते हैं

Abv(n) :=स्टैक में आइटमों की संख्या जो A(n)X के ऊपर है
Blo(n) :=ढेर के तत्वों की संख्या जो A(n)एक्स के नीचे है

| एक (एन) | = Abv (n) + ब्लो (n)

ASRT1 :=X से अलग करने के लिए आवश्यक पॉप की संख्या Q(n)कम से कम हैAbv(n)

से ( ASRT0) और ( ASRT1), ASRT2 := Abv(n)बाउंड होना चाहिए।

यदि Abv(n)निर्बाध है, तो यदि एक्स से छल करने के लिए 20 विकारों की आवश्यकता Q(n)होती है, तो इसे कम से कम आवश्यकता होगीAbv(n)/20 चबूतरे की । जो अबाधित है। 20 कोई भी स्थिर हो सकता है।

इसलिए,

ASRT3 := Blo(n) = |A(n)| - Abv(n)

निर्बाध होना चाहिए।

WLOG3, हम K तत्वों का चयन नीचे से कर सकते हैं A(n), और उनमें से एक A(n + x)सभी के लिए हैx >= 0

X(n) := वह तत्व, किसी भी दिए गए n के लिए

ASRT4 := Abv(n) >= |A(n)| - K

जब भी किसी तत्व की कतार लगती है Q(n)...

WLOG4, मान लीजिए कि B और C पहले से ही अपनी ऊपरी सीमा में भरे हुए हैं। मान लीजिए कि ऊपर के तत्वों के लिए ऊपरी सीमा पर X(n)पहुंच गया है। फिर, एक नया तत्व ए में प्रवेश करता है।

WLOG5, मान लीजिए कि परिणामस्वरूप, नए तत्व को नीचे दर्ज करना होगा X(n)।

ASRT5 := नीचे एक तत्व डालने के लिए आवश्यक पॉप की संख्या X(n) >= Abv(X(n))

से (ASRT4), Abv(n)n पर अनबाउंड है।

इसलिए, नीचे एक तत्व डालने के लिए आवश्यक पॉप की संख्या X(n)अनबाउंड है।

यह विरोधाभास है ASRT1, इसलिए, O(1)3 स्टैक के साथ एक कतार अनुकरण करना संभव नहीं है ।

अर्थात

कम से कम 1 स्टैक अनबाउंड होना चाहिए।

उस स्टैक में रहने वाले तत्व के लिए, इसके ऊपर के तत्वों की संख्या को बाध्य किया जाना चाहिए, या उस तत्व को हटाने के लिए dequeue ऑपरेशन अनबाउंड हो जाएगा।

हालांकि, यदि इसके ऊपर के तत्वों की संख्या बाध्य है, तो यह एक सीमा तक पहुंच जाएगी। कुछ बिंदु पर, इसके नीचे एक नया तत्व दर्ज करना होगा।

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

इसके नीचे एक नया तत्व दर्ज करने के लिए, क्योंकि इसके ऊपर तत्वों की एक अनबिके संख्या है, नए तत्व को नीचे रखने के लिए एक अनबाउंड पॉप की आवश्यकता है।

और इस प्रकार विरोधाभास।

5 WLOG (सामान्यता की हानि के बिना) बयान हैं। कुछ अर्थों में, उन्हें सहज रूप से सच समझा जा सकता है (लेकिन यह देखते हुए कि वे 5 हैं, इसमें कुछ समय लग सकता है)। औपचारिक प्रमाण कि कोई सामान्यता नहीं खोई जा सकती है, लेकिन यह बहुत लंबा है। वे चूक गए।

मैं मानता हूं कि इस तरह की चूक से डब्ल्यूएलओजी के बयानों पर सवाल उठ सकता है। बग के लिए एक प्रोग्रामर के व्यामोह के साथ, यदि आप चाहें तो कृपया डब्लूएलओजी कथनों को सत्यापित करें।

तीसरा स्टैक भी अप्रासंगिक है। क्या मायने रखता है कि वहाँ बंधे हुए ढेर का एक सेट है, और अनबाउंड ढेर का एक सेट है। एक उदाहरण के लिए आवश्यक न्यूनतम 2 स्टैक है। ढेर की संख्या, निश्चित रूप से, परिमित होनी चाहिए।

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

— डिंगफेंग क्यूक
स्रोत

2

मुझे लगता है कि सबूत उन मान्यताओं के लिए काम करता है - लेकिन मुझे यकीन नहीं है कि कतार के खाली होने के लिए सभी स्टैक को खाली करना होगा, या स्टैक के आकार का योग कतार के आकार के बराबर होना चाहिए।

— मिकब

3

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

— इंटरज्यूज

3

कभी-कभी तुच्छ चीजें उस तुच्छ नहीं होती हैं: | Q | = | ए | + | बी | + | सी | केवल सही है, यदि आप मानते हैं कि क्यू में हर प्रविष्टि के लिए आप ए, बी या सी में सटीक एक जोड़ते हैं, लेकिन यह हो सकता है कि थेर कुछ एल्गोरिथ्म है, जो हमेशा एक तत्व को दो बार दो स्टैक या तीनों में जोड़ते हैं। और अगर यह इस तरह से काम करता है, तो आप WLOG1 को अधिक समय तक नहीं पकड़ते हैं (उदाहरण के लिए C की प्रतिलिपि A की कल्पना करें (ऐसा नहीं है कि इसका कोई मतलब है, लेकिन शायद एक एल्गोरिथ्म है, एक अलग क्रम या जो भी हो ...)

— flolo

@flolo और @mikeb: आप दोनों सही हैं। | क्यू (एन) | के रूप में परिभाषित किया जाना चाहिए | A (n) | + | B (n) | + | C (n) | और तब | Q (n) | > = एन। इसके बाद, प्रमाण n के साथ काम करेगा, और ध्यान दें कि जब तक | Q (n) | बड़ा, निष्कर्ष लागू होता है।

— डिंगफेंग क्यूक

@interjay: आपके पास 3 अनबाउंड स्टैक और कोई बाउंड स्टैक नहीं हो सकता है फिर "B_u + C_u + 1" के बजाय, प्रमाण केवल "1" का उपयोग कर सकता है। असल में, अभिव्यक्ति "बंधे हुए ढेर + 1 में ऊपरी सीमा का योग" का प्रतिनिधित्व करती है, इस प्रकार बंधे हुए ढेर की संख्या मायने नहीं रखती है।

— डिंगफेंग क्यूक

3

नोट: यह वास्तविक समय (लगातार समय सबसे खराब स्थिति) के कार्यात्मक कार्यान्वयन के लिए एक टिप्पणी करने के लिए है, जो एकल-लिंक-सूचियों के साथ है। मैं प्रतिष्ठा के कारण टिप्पणी नहीं जोड़ सकता हूं, लेकिन यह अच्छा होगा यदि कोई इसे टिप्पणी में बदल सकता है, जो कि एंटीटी.हिमा द्वारा उत्तर में संलग्न है। तो फिर, यह एक टिप्पणी के लिए कुछ लंबा है।

@ antti.huima: लिंक की गई सूचियाँ स्टैक के समान नहीं हैं।

s1 = (1 2 3 4) --- 4 नोड्स के साथ एक लिंक्ड सूची, प्रत्येक दाईं ओर स्थित है, और 1, 2, 3 और 4 मानों को पकड़े हुए है
s2 = popped (s1) --- s2 अब है (2 3 4)

इस बिंदु पर, s2 पॉपपेड (s1) के बराबर है, जो स्टैक की तरह व्यवहार करता है। हालाँकि, s1 अभी भी संदर्भ के लिए उपलब्ध है!

s3 = popped (popped (s1)) --- s3 है (3 4)

हम अभी भी 1 प्राप्त करने के लिए s1 में जा सकते हैं, जबकि एक उचित स्टैक कार्यान्वयन में, तत्व 1 s1 से चला गया है!

इसका क्या मतलब है?

s1 स्टैक के शीर्ष का संदर्भ है
s2 स्टैक के दूसरे तत्व का संदर्भ है
s3 तीसरे का संदर्भ है ...

अब बनाई गई अतिरिक्त लिंक-सूचियाँ प्रत्येक संदर्भ / सूचक के रूप में कार्य करती हैं! ढेर की एक सीमित संख्या ऐसा नहीं कर सकती।

मैं कागजात / कोड में जो कुछ भी देखता हूं, सभी एल्गोरिदम संदर्भों को बनाए रखने के लिए लिंक्ड-सूचियों की इस संपत्ति का उपयोग करते हैं।

संपादित करें: मैं केवल 2 और 3 लिंक्ड-सूची एल्गोरिदम का उल्लेख कर रहा हूं, लिंक-सूचियों की इस संपत्ति का उपयोग करते हैं, जैसा कि मैंने उन्हें पहले पढ़ा (वे सरल दिखे)। यह दिखाने के लिए नहीं है कि वे लागू हैं या लागू नहीं हैं, बस यह समझाने के लिए कि लिंक-सूचियाँ आवश्यक रूप से समान नहीं हैं। जब मैं आज़ाद होता हूँ तो मैं 6 के साथ एक पढ़ता हूँ। @Welbog: सुधार के लिए धन्यवाद।

आलस्य भी इसी तरह से सूचक-कार्यक्षमता का अनुकरण कर सकता है।

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

— डिंगफेंग क्यूक
स्रोत

1

मैं एंटिटी के उत्तर में अन्य एल्गोरिदम से बात नहीं कर सकता, लेकिन छह-स्टैक निरंतर-समय समाधान ( eecs.usma.edu/webs/people/okasaki/jfp95/queue.hm.sml ) सूचियों की इस संपत्ति का उपयोग नहीं करता है , जैसा कि मैंने java.util.Stackवस्तुओं का उपयोग करके जावा में इसे फिर से लागू किया है । एकमात्र स्थान जहां इस सुविधा का उपयोग किया जाता है वह एक अनुकूलन है जो अपरिवर्तनीय स्टैक्स को निरंतर समय में "डुप्लिकेट" करने की अनुमति देता है, जो बेस जावा स्टैक नहीं कर सकते हैं (लेकिन जिन्हें जावा में लागू किया जा सकता है) क्योंकि वे परस्पर संरचना हैं।

— वेलबॉग

यदि यह एक अनुकूलन है जो कम्प्यूटेशनल जटिलता को कम नहीं करता है, तो यह निष्कर्ष को प्रभावित नहीं करना चाहिए। खुशी है कि आखिरकार इसका समाधान हो गया, अब इसे सत्यापित करने के लिए: लेकिन मुझे SML पढ़ना पसंद नहीं है। अपने जावा कोड को साझा करने का मन? (:

— डिंगफ़ेंग क्यूक

यह अंतिम समाधान नहीं है क्योंकि यह तीन के बजाय छह ढेर का उपयोग करता है, दुर्भाग्य से। हालांकि, यह साबित करना संभव हो सकता है कि छह स्टैक एक न्यूनतम समाधान है ...

— वेलबॉग

@Welbog! क्या आप अपने 6-स्टैक कार्यान्वयन को साझा कर सकते हैं? :) यह देखने के लिए अच्छा होगा :)

— Antti Huima

1

आप इसे दो स्टैक के साथ निरंतर समय में कर सकते हैं:

------------- --------------
            | |
------------- --------------

जोड़ना है O(1) और हटाना है O(1)यदि आप जिस पक्ष से लेना चाहते हैं वह खाली नहीं है और O(n)अन्यथा (दूसरे स्टैक को दो में विभाजित करें)।

चाल यह देखने के लिए है कि O(n)ऑपरेशन केवल हर O(n)बार किया जाएगा (यदि आप विभाजित करते हैं, उदाहरण के लिए हिस्सों में)। इसलिए, एक ऑपरेशन के लिए औसत समय है O(1)+O(n)/O(n) = O(1)।

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

— थॉमस अहले
स्रोत

मूल प्रश्न के रूप में: स्टैक को विभाजित करने के लिए वास्तव में एक अतिरिक्त मध्यवर्ती स्टैक की आवश्यकता होती है। हो सकता है कि आपके कार्य में तीन स्टैक शामिल हों।

— थॉमस अहले