క్యూ అంటే ఏమిటి?
తోకలు ముందుగా నిర్ణయించిన క్రమంలో మూలకాలను నిల్వ చేయడానికి మరియు తిరిగి పొందడానికి ఉపయోగించే డేటా నిర్మాణాలు. ఇది స్టాక్‌ను పోలి ఉండే మరియు దానికి కట్టుబడి ఉండే లీనియర్ డేటా స్ట్రక్చర్ FIFO (ఫస్ట్-ఇన్, ఫస్ట్-అవుట్) పాలన. ఇది వెయిటింగ్ లిస్ట్‌తో లేదా ముందుగా వచ్చిన వ్యక్తికి ముందుగా సర్వీస్ చేసే లైన్‌తో పోల్చవచ్చు. ఇప్పటికే ఉన్న భాగాలు ముందు నుండి పడిపోతాయి క్యూ , మరియు కొత్త మూలకాలు వెనుకకు జోడించబడతాయి.
గోలాంగ్‌లో క్యూ అమలు
యొక్క అమలు a క్యూ ఇన్ గో సరళమైనది మరియు సమర్థవంతమైనది మరియు క్రింది నాలుగు పద్ధతులను ఉపయోగించి అమలు చేయవచ్చు.
1: ముక్కలు
గోలో, ఎ ముక్క పరిమాణంలో మారగల డైనమిక్ శ్రేణి. అమలు చేయడానికి a క్యూ a ఉపయోగించి ముక్క , మేము మూలకాలను వెనుకకు జోడించవచ్చు ముక్క అంతర్నిర్మిత అనుబంధం ఫంక్షన్‌ని ఉపయోగించి మరియు ముందు నుండి మూలకాలను తీసివేయండి ముక్క స్లైసింగ్ ఉపయోగించి.
ఈ విధానం నిర్మించడం సులభం మరియు Go యొక్క అంతర్నిర్మిత స్లైస్‌ల కారణంగా అనుబంధం మరియు స్లైసింగ్ కార్యకలాపాలకు మంచి పనితీరును అందిస్తుంది. అయినప్పటికీ, కొత్త అంతర్లీన శ్రేణికి మూలకాలను కాపీ చేయడంతో కూడిన స్లైసింగ్ పద్ధతి అసమర్థంగా మారవచ్చు క్యూ విస్తరిస్తుంది మరియు పదేపదే డీక్యూయింగ్ ఆపరేషన్లు అవసరం.
కింది కోడ్ నిర్వచిస్తుంది క్యూ గోలో స్లైస్‌ని ఉపయోగించి అమలు చేయడం.
ప్యాకేజీ ప్రధాన
దిగుమతి 'fmt'
ఫంక్ మెయిన్ ( ) {
క్యూ := తయారు ( [ ] ఇంటర్ఫేస్ { } , 0 )
క్యూ = జోడించు ( క్యూ , 'ఆంగ్ల' )
క్యూ = జోడించు ( క్యూ , 'ఉర్దూ' )
క్యూ = జోడించు ( క్యూ , 'గణితం' )
ఉంటే మాత్రమే ( క్యూ ) > 0 {
అంశం := క్యూ [ 0 ]
క్యూ = క్యూ [ 1 : ]
fmt Println ( అంశం )
}
ఉంటే మాత్రమే ( క్యూ ) == 0 {
fmt Println ( 'క్యూ ఖాళీగా ఉంది' )
} లేకపోతే {
fmt Println ( క్యూ )
}
}
పై గో కోడ్ సూటిగా నిర్మించడానికి స్లైస్‌ని ఉపయోగిస్తుంది క్యూ డేటా నిర్మాణం. ది అనుబంధం() ఎలిమెంట్స్‌లోకి ఎన్క్యూ చేయడానికి ఫంక్షన్ ఉపయోగించబడుతుంది క్యూ స్లైస్, మరియు ప్రారంభ మూలకాన్ని తొలగించే స్లైస్ ఆపరేషన్ వాటిని డీక్యూ చేయడానికి ఉపయోగించబడుతుంది. తో fmt.Println() , డీక్యూడ్ ఎలిమెంట్ ప్రింట్ చేయబడింది. కోడ్ అప్పుడు ఉపయోగిస్తుంది మాత్రమే() క్యూ ఖాళీగా ఉందో లేదో నిర్ణయించడానికి ఫంక్షన్, మరియు అది ఉంటే, అది ' క్యూ fmt.Println() ఫంక్షన్‌ని ఉపయోగించి ఖాళీగా ఉంది.
అవుట్‌పుట్
2: లింక్డ్ జాబితాలు
జాబితాలోని క్రింది నోడ్‌కు విలువ మరియు పాయింటర్‌ను కలిగి ఉండే నోడ్‌లు లింక్ చేయబడిన జాబితాను రూపొందించాయి. రెండు పాయింటర్‌లతో, ఒకటి జాబితా యొక్క ముందు (తల) వైపుకు మరియు మరొకటి వెనుక (తోక) వైపు చూపుతూ, మేము ఒక క్యూ లింక్ చేయబడిన జాబితాను ఉపయోగించడం. క్యూ నుండి ఒక అంశాన్ని తీసివేయడం (డీక్యూయింగ్) జాబితా ముందు భాగంలో ఉన్న నోడ్‌ను తీసివేయడం, క్యూలో ఒక అంశాన్ని జోడించడం (ఎన్క్యూయింగ్) జాబితా వెనుక భాగంలో కొత్త నోడ్‌ను జోడించడం.
ఈ పద్ధతి సమర్థవంతమైన ఎన్క్యూయింగ్ మరియు డీక్యూయింగ్ ఆపరేషన్‌లను అనుమతిస్తుంది ఎందుకంటే ఎలిమెంట్లను కాపీ చేయాల్సిన స్లైస్-బేస్డ్ సొల్యూషన్‌కు విరుద్ధంగా హెడ్ మరియు టెయిల్ పాయింటర్‌లను మాత్రమే మార్చాలి.
అమలు చేయడానికి లింక్ చేయబడిన జాబితాను ఉపయోగించండి a క్యూ దిగువ అందించిన కోడ్‌ని ఉపయోగించడం ద్వారా:
ప్యాకేజీ ప్రధానదిగుమతి 'fmt'
నోడ్ టైప్ చేయండి నిర్మాణం {
విలువ ఇంటర్ఫేస్ { }
తరువాత * నోడ్
}
క్యూ టైప్ చేయండి నిర్మాణం {
తల * నోడ్
తోక * నోడ్
}
ఫంక్ మెయిన్ ( ) {
క్యూ := & క్యూ { తల : శూన్యం , తోక : శూన్యం }
కొత్త నోడ్ := & నోడ్ { విలువ : 'ఆంగ్ల' , తరువాత : శూన్యం }
క్యూ. తోక = కొత్త నోడ్
క్యూ. తల = కొత్త నోడ్
కొత్త నోడ్ = & నోడ్ { విలువ : 'ఉర్దూ' , తరువాత : శూన్యం }
క్యూ. తోక . తరువాత = కొత్త నోడ్
క్యూ. తోక = కొత్త నోడ్
కొత్త నోడ్ = & నోడ్ { విలువ : 'గణితం' , తరువాత : శూన్యం }
క్యూ. తోక . తరువాత = కొత్త నోడ్
క్యూ. తోక = కొత్త నోడ్
ఉంటే క్యూ. తల != శూన్యం {
అంశం := క్యూ. తల . విలువ
క్యూ. తల = క్యూ. తల . తరువాత
fmt Println ( అంశం )
}
ఉంటే క్యూ. తల == శూన్యం {
fmt Println ( 'క్యూ ఖాళీగా ఉంది' )
}
}
నోడ్ నిర్మాణం క్యూలోని ప్రతి అంశాన్ని సూచిస్తుంది మరియు రెండు ఫీల్డ్‌లను కలిగి ఉంటుంది: అంశం విలువను నిల్వ చేయడానికి ఒక విలువ ఫీల్డ్ మరియు క్యూలో తదుపరి అంశాన్ని సూచించడానికి తదుపరి ఫీల్డ్. క్యూ నిర్మాణం వరుసగా క్యూ ముందు మరియు వెనుక భాగాలను ట్రాక్ చేయడానికి తల మరియు తోక లక్షణాలను ఉపయోగిస్తుంది. ది తోక యొక్క మొదటి అంశం హెడ్ ప్రాపర్టీ ద్వారా సూచించబడుతుంది, అయితే దాని చివరి అంశం టెయిల్ ప్రాపర్టీ ద్వారా సూచించబడుతుంది.
తల మరియు తోక పారామితులు మొదట సెట్ చేయబడ్డాయి శూన్యం ఎప్పుడు కొత్తది క్యూ ప్రధాన() ఫంక్షన్‌లో స్థాపించబడింది. మూడు నోడ్‌లను జోడించడానికి హెడ్ మరియు టెయిల్ పాయింటర్‌లు అప్‌డేట్ చేయబడ్డాయి క్యూ విలువలతో 'ఇంగ్లీష్', 'ఉర్దూ', మరియు 'గణితం'. ది 'ఆంగ్ల' అంశం అప్పుడు 'డీక్యూడ్' (తొలగించబడింది) ముందు నుండి క్యూ దాని విలువను ప్రదర్శించడం ద్వారా మరియు హెడ్ పాయింటర్‌ను కింది నోడ్‌కు ముందుకు తీసుకెళ్లడం ద్వారా క్యూ . డీక్యూయింగ్ తర్వాత, తల శూన్యంగా మారితే, క్యూ ఖాళీగా ఉందని అర్థం మరియు సందేశం “ క్యూ ఖాళీగా ఉంది” అని ముద్రించబడింది.
అవుట్‌పుట్
3: నిర్మాణాలు
గోలో, మీరు a అనే కస్టమ్ డేటా నిర్మాణాన్ని సృష్టించవచ్చు నిర్మాణం ప్రాతినిధ్యం వహించడానికి a క్యూ . ఈ నిర్మాణం నిల్వ చేయడానికి ఫీల్డ్‌లను కలిగి ఉండవచ్చు క్యూ అంశాలను జోడించడానికి మరియు తీసివేయడానికి అంశాలు మరియు పద్ధతులు, క్యూ ఖాళీగా ఉందో లేదో తనిఖీ చేయండి మరియు ప్రస్తుత క్యూ పరిమాణాన్ని పొందండి.
సృష్టించే ఈ మార్గం a క్యూ in Go మరింత ఫీచర్లతో విస్తరించి అనుకూలీకరించగల సులభమైన మరియు ఉపయోగించడానికి సులభమైన పద్ధతులతో అనుకూలమైన మరియు సంగ్రహించబడిన అమలును అందిస్తుంది. ఇది అనువైన విధానం, ఇది అమలులో మార్పులు చేయడానికి లేదా అవసరమైనప్పుడు కొత్త సామర్థ్యాలను జోడించడానికి అనుమతిస్తుంది.
ఒక ఆచారాన్ని సృష్టిస్తోంది నిర్మాణం పద్ధతులతో ఇతర రెండు మార్గాలతో పోలిస్తే అదనపు కోడ్‌ను వ్రాయడం ఉంటుంది, ఇది సంక్లిష్టతను పెంచుతుంది. అయినప్పటికీ, ఇది మరింత సౌలభ్యాన్ని మరియు అమలుపై నియంత్రణను అందిస్తుంది క్యూ .
కింది ఉదాహరణ aని సూచించడానికి డేటా నిర్మాణాన్ని సృష్టించడాన్ని చూపుతుంది క్యూ గో లో.
ప్యాకేజీ ప్రధానదిగుమతి 'fmt'
క్యూ టైప్ చేయండి నిర్మాణం {
అంశాలు [ ] ఇంటర్ఫేస్ { }
}
ఫంక్ ( q * క్యూ ) ఎన్క్యూ ( అంశం ఇంటర్ఫేస్ { } ) {
q. అంశాలు = జోడించు ( q. అంశాలు , అంశం )
}
ఫంక్ ( q * క్యూ ) డీక్యూ ( ) ఇంటర్ఫేస్ { } {
ఉంటే మాత్రమే ( q. అంశాలు ) == 0 {
తిరిగి శూన్యం
}
అంశం := q. అంశాలు [ 0 ]
q. అంశాలు = q. అంశాలు [ 1 : ]
తిరిగి అంశం
}
ఫంక్ ( q * క్యూ ) ఖాళీగా ఉంది ( ) బూల్ {
తిరిగి మాత్రమే ( q. అంశాలు ) == 0
}
ఫంక్ ( q * క్యూ ) పరిమాణం ( ) int {
తిరిగి మాత్రమే ( q. అంశాలు )
}
ఫంక్ మెయిన్ ( ) {
క్యూ := & క్యూ { అంశాలు : తయారు ( [ ] ఇంటర్ఫేస్ { } , 0 ) }
క్యూ. ఎన్క్యూ ( 'ఆంగ్ల' )
క్యూ. ఎన్క్యూ ( 'ఉర్దూ' )
క్యూ. ఎన్క్యూ ( 'గణితం' )
అంశం := క్యూ. డీక్యూ ( )
fmt Println ( అంశం )
ఉంటే క్యూ. ఖాళీగా ఉంది ( ) {
fmt Println ( 'క్యూ ఖాళీగా ఉంది' )
}
పరిమాణం := క్యూ. పరిమాణం ( )
fmt Println ( 'క్యూ పరిమాణం:' , పరిమాణం )
}
పై కోడ్‌లో, అంశం ద్వారా ఐటెమ్ స్లైస్‌కి ఒక అంశం జోడించబడింది ఎన్క్యూ() పద్దతి, ఇది ముగింపుకు తరలిస్తుంది క్యూ . అనుసరించి ఫస్ట్-ఇన్, ఫస్ట్-అవుట్ (FIFO) సూత్రం, ది డీక్యూ() పద్ధతి ఒక వస్తువును ముందు నుండి బయటకు తీస్తుంది క్యూ మరియు దానిని తిరిగి ఇస్తుంది. అంశం యొక్క స్లైస్ యొక్క పొడవు దానిలో భాగంగా తనిఖీ చేయబడుతుంది ఖాళీ () లేదో చూడటానికి పద్ధతి యొక్క తనిఖీ క్యూ ఖాళీగా ఉంది. అంశాల స్లైస్ యొక్క పొడవును తిరిగి ఇవ్వడం ద్వారా, ది పరిమాణం() పద్ధతి కరెంట్‌ను అందిస్తుంది తోక యొక్క పరిమాణం.
ప్రధాన() ఫంక్షన్‌ని ఉపయోగిస్తుంది క్యూ నిర్మాణం ఒక కొత్త సృష్టించడానికి క్యూ , దానికి ఎలిమెంట్లను జోడించండి, దాని నుండి అంశాలను తీసివేయండి, లేదో నిర్ణయించండి క్యూ ఖాళీగా ఉంది మరియు దాని పరిమాణాన్ని లెక్కించండి.
అవుట్‌పుట్
4: ఛానెల్‌లు
గోలో, అంతర్నిర్మిత ఛానెల్ రకాన్ని అమలు చేయడానికి ఉపయోగించవచ్చు a క్యూ డేటా నిర్మాణం. ఏ సమయంలోనైనా క్రమీకరించబడే మూలకాల సంఖ్యను పరిమితం చేయడానికి బఫర్ పరిమాణంతో ఛానెల్‌ని సృష్టించవచ్చు. ఒక మూలకాన్ని జోడించడానికి క్యూ , దీనిని ఉపయోగించి ఛానెల్‌కు పంపవచ్చు <- ఆపరేటర్, క్యూ నుండి ఒక మూలకాన్ని తీసివేయడానికి, అదే ఆపరేటర్‌ని ఉపయోగించి ఛానెల్ నుండి దాన్ని స్వీకరించవచ్చు.
కు ఏకకాలంలో యాక్సెస్ ఉన్న సందర్భాల్లో ఈ విధానం చాలా ఉపయోగకరంగా ఉంటుంది క్యూ ఛానెల్‌లు ఏకకాలిక ఉపయోగం కోసం అంతర్లీనంగా సురక్షితమైనవి కాబట్టి ఇది అవసరం.
గో ఛానెల్‌లు టైప్ చేయబడతాయని గుర్తుంచుకోవడం చాలా ముఖ్యం. దీని అర్థం మీరు ఛానెల్ ద్వారా నిర్దిష్ట రకం విలువలను మాత్రమే పంపగలరు మరియు మీరు ఛానెల్ నుండి అదే రకమైన విలువలను మాత్రమే స్వీకరించగలరు.
ఇది ఒక ఛానెల్‌ని నిర్మించడానికి ఎలా ఉపయోగించాలో ఒక ఉదాహరణ క్యూ గోలో డేటా నిర్మాణం.
ప్యాకేజీ ప్రధానదిగుమతి (
'fmt'
'సమయం'
)
క్యూ టైప్ చేయండి నిర్మాణం {
వస్తువుల చానిన్‌టర్‌ఫేస్ { }
}
funcNewQueue ( ) * క్యూ {
q := & క్యూ {
అంశాలు : తయారు ( చాన్ ఇంటర్ఫేస్ { } ) ,
}
వెళ్ళండి q. ప్రాసెస్ అంశాలు ( )
తిరిగి q
}
ఫంక్ ( q * క్యూ ) ప్రాసెస్ అంశాలు ( ) {
కోసం అంశం := పరిధి q. అంశాలు {
ఉంటే అంశం == 'ఆంగ్ల' {
fmt Println ( 'డీక్యూడ్:' , అంశం )
}
}
}
ఫంక్ ( q * క్యూ ) ఎన్క్యూ ( అంశం ఇంటర్ఫేస్ { } ) {
q. అంశాలు <- అంశం
}
ఫంక్మెయిన్ ( ) {
క్యూ := కొత్త క్యూ ( )
క్యూ. ఎన్క్యూ ( 'ఆంగ్ల' )
క్యూ. ఎన్క్యూ ( 'ఉర్దూ' )
క్యూ. ఎన్క్యూ ( 'గణితం' )
సమయం . నిద్రించు ( 2 * సమయం . రెండవ )
}
పై కోడ్ aని సృష్టిస్తుంది క్యూ నిర్మాణం ఒకే ఫీల్డ్‌తో అంశాలు యొక్క ఛానెల్ ఇంటర్ఫేస్{} రకం. ది కొత్త క్యూ() ఫంక్షన్ యొక్క కొత్త ఉదాహరణను సృష్టిస్తుంది క్యూ మరియు దాని ప్రారంభిస్తుంది 'అంశాలు' కొత్త అన్‌బఫర్డ్ ఛానెల్‌తో ఫీల్డ్. ఇది ఉపయోగించి క్యూలో జోడించిన ఐటెమ్‌లను ప్రాసెస్ చేయడానికి కొత్త గోరూటిన్‌ను కూడా ప్రారంభిస్తుంది ప్రక్రియ అంశాలు() ఫంక్షన్. ది ప్రక్రియ అంశాలు() అందుకున్న అంశం సమానంగా ఉంటే ఫంక్షన్ తనిఖీ చేస్తుంది 'ఆంగ్ల' మరియు ఆ అంశం కోసం మాత్రమే కన్సోల్‌కు సందేశాన్ని ముద్రిస్తుంది. ది ఎన్క్యూ() క్యూలో కొత్త అంశాలను జోడించడానికి ఫంక్షన్ ఉపయోగించబడుతుంది.
అవుట్‌పుట్
ముగింపు
క్యూ అనేది ఒక నిర్దిష్ట క్రమంలో ఎలిమెంట్లను నిల్వ చేయడానికి మరియు తిరిగి పొందడానికి ఉపయోగించే గోలో అవసరమైన డేటా నిర్మాణం. యొక్క అమలు a క్యూ గోలో థ్రెడ్-సురక్షితమైనది, ప్రోగ్రామ్‌లలో సమ్మతిని అమలు చేయడానికి వాటిని ఆదర్శవంతమైన ఎంపికగా చేస్తుంది. ఇది స్లైస్‌లు, లింక్డ్ లిస్ట్‌లు, స్ట్రక్చర్‌లు మరియు ఛానెల్‌లను ఉపయోగించి అమలు చేయవచ్చు. పైన పేర్కొన్న మార్గదర్శకాలలో పూర్తి వివరాలు ఇప్పటికే అందించబడ్డాయి.