एक कतार क्या है?
पूंछ डेटा संरचनाएं हैं जिनका उपयोग पूर्व निर्धारित क्रम में तत्वों को संग्रहीत और पुनर्प्राप्त करने के लिए किया जाता है। यह एक रेखीय डेटा संरचना है जो स्टैक जैसा दिखता है और इसका पालन करता है फीफो (फर्स्ट-इन, फर्स्ट-आउट) नियम। इसकी तुलना एक प्रतीक्षा सूची या एक पंक्ति से की जा सकती है जहाँ पहले आने वाले व्यक्ति को पहले सेवा दी जाती है। मौजूदा घटकों को सामने से गिरा दिया जाता है कतार , और नए तत्वों को पीछे जोड़ा जाता है।
गोलंग में एक कतार का कार्यान्वयन
ए का कार्यान्वयन कतार गो में सरल और कुशल है और इसे निम्नलिखित चार विधियों का उपयोग करके लागू किया जा सकता है।
1: स्लाइस
गो में, ए टुकड़ा एक गतिशील सरणी है जो आकार में बदल सकती है। ए को लागू करने के लिए कतार इसका उपयोग करना टुकड़ा , हम के पीछे तत्वों को जोड़ सकते हैं टुकड़ा बिल्ट-इन एपेंड फ़ंक्शन का उपयोग करके और तत्वों को सामने से हटा दें टुकड़ा टुकड़ा करने की क्रिया का उपयोग करना।
गो के बिल्ट-इन स्लाइस के लिए धन्यवाद, यह दृष्टिकोण निर्माण करना आसान है और संलग्न करने और स्लाइसिंग संचालन के लिए अच्छा प्रदर्शन प्रदान करता है। हालाँकि, स्लाइसिंग विधि, जिसमें तत्वों को एक नई अंतर्निहित सरणी में कॉपी करना शामिल है, अक्षम हो सकती है यदि कतार फैलता है और बार-बार डीक्यूइंग ऑपरेशंस की आवश्यकता होती है।
निम्नलिखित कोड परिभाषित करता है कतार गो में एक स्लाइस का उपयोग करके कार्यान्वयन।
मुख्य पैकेज
आयात 'एफएमटी'
func main ( ) {
कतार := निर्माण ( [ ] इंटरफेस { } , 0 )
कतार = संलग्न ( कतार , 'अंग्रेज़ी' )
कतार = संलग्न ( कतार , 'उर्दू' )
कतार = संलग्न ( कतार , 'गणित' )
अगर केवल ( कतार ) > 0 {
वस्तु := कतार [ 0 ]
कतार = कतार [ 1 : ]
fmt. Println ( वस्तु )
}
अगर केवल ( कतार ) == 0 {
fmt. Println ( 'कतार खाली है' )
} अन्य {
fmt. Println ( कतार )
}
}
उपरोक्त गो कोड एक सीधा निर्माण करने के लिए एक स्लाइस का उपयोग करता है कतार डेटा संरचना। संलग्न () तत्वों को कतारबद्ध करने के लिए फ़ंक्शन का उपयोग किया जाता है कतार स्लाइस, और एक स्लाइस ऑपरेशन जो प्रारंभिक तत्व को हटाता है, उन्हें डीक्यू करने के लिए उपयोग किया जाता है। साथ fmt.Println () , dequeued तत्व मुद्रित होता है। कोड तब उपयोग करता है केवल() यह निर्धारित करने के लिए कार्य करें कि क्या कतार खाली है, और यदि यह है, तो यह लिखता है ' कतार fmt.Println () फ़ंक्शन का उपयोग करके 'खाली है'।
उत्पादन
2: लिंक्ड सूचियाँ
नोड जो सूची में निम्नलिखित नोड के लिए एक मान और एक संकेतक ले जाते हैं, एक लिंक की गई सूची बनाते हैं। दो बिंदुओं के साथ, एक सूची के सामने (सिर) की ओर इशारा करता है और दूसरा पीछे (पूंछ) की ओर इशारा करता है, हम एक को लागू कर सकते हैं कतार एक लिंक की गई सूची का उपयोग करना। कतार से किसी आइटम को हटाने (डीक्यूइंग) में सूची के सामने वाले नोड को हटाना शामिल है, जबकि कतार में एक आइटम जोड़ना (एनक्यूइंग) में सूची के पीछे एक नया नोड जोड़ना शामिल है।
यह विधि कुशल एनक्यूइंग और डीक्यूइंग ऑपरेशंस की अनुमति देती है क्योंकि स्लाइस-आधारित समाधान के विपरीत केवल हेड और टेल पॉइंटर्स को बदलने की आवश्यकता होती है, जहां तत्वों की प्रतिलिपि बनाने की आवश्यकता होती है।
लागू करने के लिए एक लिंक्ड सूची का प्रयोग करें कतार नीचे दिए गए कोड का उपयोग करके:
मुख्य पैकेजआयात 'एफएमटी'
नोड टाइप करें struct {
मूल्य इंटरफ़ेस { }
अगला * नोड
}
कतार टाइप करें struct {
सिर * नोड
पूँछ * नोड
}
func main ( ) {
कतार := और कतार { सिर : शून्य , पूँछ : शून्य }
newNode := और नोड { कीमत : 'अंग्रेज़ी' , अगला : शून्य }
कतार। पूँछ = newNode
कतार। सिर = newNode
newNode = और नोड { कीमत : 'उर्दू' , अगला : शून्य }
कतार। पूँछ . अगला = newNode
कतार। पूँछ = newNode
newNode = और नोड { कीमत : 'गणित' , अगला : शून्य }
कतार। पूँछ . अगला = newNode
कतार। पूँछ = newNode
अगर कतार। सिर != शून्य {
वस्तु := कतार। सिर . कीमत
कतार। सिर = कतार। सिर . अगला
fmt. Println ( वस्तु )
}
अगर कतार। सिर == शून्य {
fmt. Println ( 'कतार खाली है' )
}
}
नोड संरचना कतार में प्रत्येक आइटम का प्रतिनिधित्व करती है और इसमें दो फ़ील्ड होते हैं: आइटम के मान को संग्रहीत करने के लिए एक मान फ़ील्ड और कतार में अगले आइटम को इंगित करने के लिए अगला फ़ील्ड। कतार संरचना क्रमशः कतार के आगे और पीछे का ट्रैक रखने के लिए सिर और पूंछ गुणों का उपयोग करती है। पूँछ का पहले आइटम को हेड प्रॉपर्टी द्वारा दर्शाया जाता है, जबकि इसके अंतिम आइटम को टेल प्रॉपर्टी द्वारा दर्शाया जाता है।
सिर और पूंछ के पैरामीटर शुरू में सेट होते हैं शून्य जब एक नया कतार main() फ़ंक्शन में स्थापित है। हेड और टेल पॉइंटर्स को तीन नोड्स जोड़ने के लिए अपडेट किया गया है कतार मूल्यों के साथ 'अंग्रेजी', 'उर्दू', और 'गणित'। 'अंग्रेज़ी' आइटम तो है 'विकृत' (हटाया) के सामने से कतार इसके मूल्य को प्रदर्शित करके और हेड पॉइंटर को निम्न नोड में आगे बढ़ाना कतार . विपंक्ति के बाद, यदि सिर अशक्त हो जाता है, तो इसका मतलब है कि कतार खाली है, और संदेश ' कतार खाली है' छपा हुआ है।
उत्पादन
3: संरचनाएं
गो में, आप एक कस्टम डेटा स्ट्रक्चर बना सकते हैं जिसे कहा जाता है struct एक का प्रतिनिधित्व करने के लिए कतार . यह struct स्टोर करने के लिए फ़ील्ड हो सकते हैं कतार आइटम जोड़ने और हटाने के लिए तत्व और तरीके, जांचें कि क्या कतार खाली है, और वर्तमान कतार का आकार प्राप्त करें।
बनाने का यह तरीका कतार गो में उपयोग में आसान तरीकों के साथ एक सुविधाजनक और संक्षिप्त कार्यान्वयन प्रदान करता है जिसे अधिक सुविधाओं के साथ विस्तारित और अनुकूलित किया जा सकता है। यह एक लचीला दृष्टिकोण है जो कार्यान्वयन में बदलाव करने या जब भी आवश्यक हो नई क्षमताओं को जोड़ने की अनुमति देता है।
प्रथा बना रहा है struct with विधियों में अन्य दो तरीकों की तुलना में अतिरिक्त कोड लिखना शामिल है, जिससे जटिलता बढ़ सकती है। हालांकि, यह के कार्यान्वयन पर अधिक लचीलापन और नियंत्रण भी प्रदान करता है कतार .
निम्नलिखित उदाहरण एक प्रतिनिधित्व करने के लिए एक डेटा संरचना का निर्माण दिखाता है कतार गो में।
मुख्य पैकेजआयात 'एफएमटी'
कतार टाइप करें struct {
सामान [ ] इंटरफेस { }
}
समारोह ( क्यू * कतार ) कतारबद्ध करें ( आइटम इंटरफ़ेस { } ) {
क्यू। सामान = संलग्न ( क्यू। सामान , वस्तु )
}
समारोह ( क्यू * कतार ) विपंक्ति ( ) इंटरफेस { } {
अगर केवल ( क्यू। सामान ) == 0 {
वापस करना शून्य
}
वस्तु := क्यू। सामान [ 0 ]
क्यू। सामान = क्यू। सामान [ 1 : ]
वापस करना वस्तु
}
समारोह ( क्यू * कतार ) खाली है ( ) बूल {
वापस करना केवल ( क्यू। सामान ) == 0
}
समारोह ( क्यू * कतार ) आकार ( ) int यहाँ {
वापस करना केवल ( क्यू। सामान )
}
func main ( ) {
कतार := और कतार { सामान : निर्माण ( [ ] इंटरफेस { } , 0 ) }
कतार। कतारबद्ध करें ( 'अंग्रेज़ी' )
कतार। कतारबद्ध करें ( 'उर्दू' )
कतार। कतारबद्ध करें ( 'गणित' )
वस्तु := कतार। विपंक्ति ( )
fmt. Println ( वस्तु )
अगर कतार। खाली है ( ) {
fmt. Println ( 'कतार खाली है' )
}
आकार := कतार। आकार ( )
fmt. Println ( 'कतार का आकार:' , आकार )
}
उपरोक्त कोड में, आइटम को आइटम के स्लाइस के माध्यम से जोड़ा जाता है पंक्तिबद्ध करें () विधि, जो इसे अंत तक ले जाती है कतार . निम्नलिखित फर्स्ट-इन, फर्स्ट-आउट (FIFO) सिद्धांत, विपंक्ति () विधि किसी वस्तु को सामने से बाहर ले जाती है कतार और इसे वापस कर देता है। आइटम के टुकड़े की लंबाई के भाग के रूप में जाँच की जाती है खाली है() यह देखने के लिए विधि की जाँच करें कि क्या कतार खाली है। आइटम स्लाइस की लंबाई लौटाकर, आकार() विधि वर्तमान लौटाती है पूँछ का आकार।
मुख्य () फ़ंक्शन का उपयोग करता है कतार संरचना एक नया बनाने के लिए कतार , इसमें तत्व जोड़ें, इसमें से आइटम हटाएं, यह निर्धारित करें कि क्या कतार खाली है, और इसके आकार की गणना करें।
उत्पादन
4: चैनल
गो में, बिल्ट-इन चैनल प्रकार का उपयोग लागू करने के लिए किया जा सकता है कतार डेटा संरचना। चैनल को बफर आकार के साथ बनाया जा सकता है ताकि किसी भी समय कतारबद्ध किए जा सकने वाले तत्वों की संख्या को सीमित किया जा सके। में एक तत्व जोड़ने के लिए कतार , इसे का उपयोग करके चैनल को भेजा जा सकता है <- ऑपरेटर, कतार से किसी तत्व को हटाने के लिए, उसी ऑपरेटर का उपयोग करके चैनल से प्राप्त किया जा सकता है।
यह दृष्टिकोण उन स्थितियों में काफी उपयोगी हो सकता है जहां समवर्ती पहुंच कतार आवश्यक है, क्योंकि चैनल समवर्ती उपयोग के लिए स्वाभाविक रूप से सुरक्षित हैं।
यह याद रखना महत्वपूर्ण है कि गो चैनल टाइप किए गए हैं। इसका मतलब है कि आप चैनल के माध्यम से केवल एक विशिष्ट प्रकार के मान भेज सकते हैं, और आप चैनल से केवल उसी प्रकार के मान प्राप्त कर सकते हैं।
यह एक उदाहरण है कि एक चैनल का निर्माण करने के लिए कैसे उपयोग किया जाए कतार गो में डेटा संरचना।
मुख्य पैकेजआयात (
'एफएमटी'
'समय'
)
कतार टाइप करें struct {
आइटम चैनल इंटरफ़ेस { }
}
funcNewQue ( ) * कतार {
क्यू := और कतार {
सामान : निर्माण ( चान इंटरफ़ेस { } ) ,
}
जाओ क्यू। प्रक्रिया आइटम ( )
वापस करना क्यू
}
समारोह ( क्यू * कतार ) प्रक्रिया आइटम ( ) {
के लिए वस्तु := रेंज क्यू। सामान {
अगर वस्तु == 'अंग्रेज़ी' {
fmt. Println ( 'डेक्यूड:' , वस्तु )
}
}
}
समारोह ( क्यू * कतार ) कतारबद्ध करें ( आइटम इंटरफ़ेस { } ) {
क्यू। सामान <- वस्तु
}
funcmain ( ) {
कतार := न्यू क्यू ( )
कतार। कतारबद्ध करें ( 'अंग्रेज़ी' )
कतार। कतारबद्ध करें ( 'उर्दू' )
कतार। कतारबद्ध करें ( 'गणित' )
समय . नींद ( 2 * समय . दूसरा )
}
उपरोक्त कोड एक बनाता है कतार संरचना एक ही क्षेत्र के साथ सामान जो कि एक चैनल है इंटरफेस{} प्रकार। न्यू क्यू () फ़ंक्शन का एक नया उदाहरण बनाता है कतार और इसे इनिशियलाइज़ करता है 'सामान' एक नए असंबद्ध चैनल के साथ क्षेत्र। यह कतार में जोड़े गए आइटम को संसाधित करने के लिए एक नया गोरोइन भी शुरू करता है प्रक्रिया आइटम () समारोह। प्रक्रिया आइटम () फ़ंक्शन जांचता है कि प्राप्त आइटम बराबर है या नहीं 'अंग्रेज़ी' और केवल उस आइटम के लिए कंसोल को संदेश प्रिंट करता है। पंक्तिबद्ध करें () क्यू में नए आइटम जोड़ने के लिए फ़ंक्शन का उपयोग किया जाता है।
उत्पादन
निष्कर्ष
कतार गो में एक आवश्यक डेटा संरचना है जिसका उपयोग तत्वों को एक विशिष्ट क्रम में संग्रहीत करने और पुनः प्राप्त करने के लिए किया जाता है। ए का कार्यान्वयन कतार गो में थ्रेड-सुरक्षित है, जो उन्हें कार्यक्रमों में संगामिति लागू करने के लिए एक आदर्श विकल्प बनाता है। इसे स्लाइस, लिंक्ड लिस्ट, स्ट्रक्चर और चैनल का उपयोग करके लागू किया जा सकता है। ऊपर दिए गए दिशा-निर्देशों में पूर्ण विवरण पहले से ही प्रदान किया गया है।