data structures - How to implement a queue in Go? -

वर्तमान जाओ पुस्तकालय कतार कंटेनर प्रदान नहीं करता है एक सरल कतार को लागू करने के लिए, मैं अंतर्निहित डेटा संरचना के रूप में सर्कल सरणी का उपयोग करता हूं। यह TAOCP में वर्णित एल्गोरिदम का पालन करता है:

  कतार में एक्स सम्मिलित करें X: X [R] & lt; -Y; आर एंड lt ;-( आर + 1)% एम; यदि आर = एफ तो ओवरफ्लो क्यू एक्स से वाई हटाएं: यदि एफ = आर तो अंडरफ्लो; Y & LT; -X [F]; एफ एंड एलटी ;- (एफ + 1)% एम। एफ: फ्रंट, आर: रियर, एम: ऐरे लंबाई  

निम्नलिखित कोड है:

  पैकेज मुख्य आयात ("fmt") प्रकार पंक्ति संरचना {लेनन इंट हेड, पूंछ इंटेल q [] int} func नया (एनआईटी) * क्यू {रिटर्न और क्यू {एन, 0, 0, मेक ([] इंट, एन)}} फ़्ंंक (पी * क्वू) एन्क्यू (एक्सएंडटी) बूल {पीके [पीटीईईएल] = एक्स P.tail = (p.tail + 1)% p.len return p.head! = P.tail} func (p * क्यू) Dequeue () (int, bool) {if p.head == p.tail { वापसी 0, झूठी} x: = pq [p.head] p.head = (p.head + 1)% p.len return x, true} func main () {q: = नया (10) i के लिए: = 1; मैं & lt; 13; I ++ {fmt.Println (i, q.Enqueue (i))} fmt.Println () i: = 1 के लिए; मैं & lt; 13; I ++ {fmt.Println (q.Dequeue ())}}  

लेकिन उत्पादन स्पष्ट रूप से गलत है:

1 सच्चे 2 सच्चे 3 सच 4 सच 5 सत्य 6 सच 7 सच 8 सच 9 सच 10 गलत 11 सच 12 सच

<पी> 11 सच 12 सच 0 गलत 0 झूठी झूठी 0 झूठी झूठी झूठी झूठी झूठी 0 झूठी झूठी 0 झूठी झूठी झूठी झूठी

मुझे लगता है कि मुझे कोड का काम ठीक से करने के लिए एक और क्षेत्र की आवश्यकता है। आप क्या सुझाव देते हैं?

सुधार कोड में एक छोटी सी कमी है: आकार n की एक सरणी में केवल n-1 तत्व हो सकते हैं।

  पैकेज मुख्य आयात ("fmt" ) क्यू संरचना {लेनन इंट हेड, पूंछ इंटी q [] इंट} फ़्ंंक न्यू (एएनएनटी) * क्यू {रिटर्न और क्यू {एन, 0, 0, मेक ([] इंट, एन)}} फ़ेन्क (पी * क्यूई) एन्क्यू (एक्सएंडटी) बूल {पीके [पीटीईईएल] = एक्स एनटीयल: = (पी.टीईईएल + 1)% पी। एलएएन ओके: = जर एनटीईएल! = पी। हेड {पी। आईईएल = एनटील ओके = सही} वापसी ठीक} फ़ंक (पी * क्वू) डेक्यू () (इंट, बूल) {अगर पी .head == पी। सेल {वापसी 0, गलत} x: = pq [p.head] p.head = (p .head + 1)% p.len return x, true} func main () {q: = i के लिए = (10): = 1; मैं & lt; 13; I ++ {fmt.Println (i, q.Enqueue (i))} fmt.Println () i: = 1 के लिए; मैं & lt; 13; I ++ {fmt.Println (q.Dequeue)}}  

जब एन्क्यू असफल हो जाता है, आप अभी वृद्धि कर रहे हैं p.tail , इसलिए अगली बार यह असफल नहीं दिखाई देगा - जो कि एकल झूठी बताते हैं अपने पहले लूप में (और दूसरे के लिए सब कुछ खराब करता है)। मूल एल्गोरिथ्म ओवरफ्लो का अर्थ है "सब कुछ देना", "बस नहीं चलते रहें जैसे कि कुछ भी अनछुवा नहीं हुआ"; -)।

आपको बस इतना करना चाहिए कि कमी P.tail अगर आपने उस विफलता की घटना की जांच की है - या स्थानीय अस्थायी में वेतनमान मान डाल दिया है और उसे p.tail पर ले जाने पर ही विफलता नहीं < / Em> होने वाली, जो अधिक सुरुचिपूर्ण हो सकती है इस तरह, असफल एन्क्यू करता है नहीं एन्केड नए मान, लेकिन कतार स्वयं (उस अतिप्रवाह मूल्य के बिना) अभी भी भात्रा के संचालन के लिए अर्थपूर्ण रूप से अक्षुण्ण और सही है।