వృత్తాకార బఫర్ లేదా వృత్తాకార క్యూ అనేది సాధారణ క్యూ యొక్క అధునాతన వెర్షన్, ఇక్కడ చివరి సూచిక మరియు టెయిల్ ఇండెక్స్ వృత్తాకార నిర్మాణంలో అనుసంధానించబడి ఉంటాయి. C++లో సర్క్యులర్ బఫర్ రెండు పద్ధతులను అనుసరిస్తుంది: enqueue() మరియు dequeue(). మేము ఈ పద్ధతుల ఆధారంగా వృత్తాకార బఫర్ లేదా వృత్తాకార క్యూ ఆపరేషన్‌ను చేస్తాము.
- ఎన్క్యూ() పద్ధతి బఫర్ నిండిందో లేదో తనిఖీ చేస్తుంది. లేకపోతే, ముగింపు సూచిక చివరిది అని ధృవీకరించండి. అలా అయితే, తోక విలువను 0కి సెట్ చేయండి. కాకపోతే, ఆ సూచిక వద్ద ఉన్న విలువతో టెయిల్ విలువను పెంచండి.
- dequeue() ఫంక్షన్ వృత్తాకార క్యూలో ముందు సూచిక నుండి విలువను తీసుకుంటుంది. క్యూ ఖాళీగా ఉంటే, ఒక సందేశం ఆ ఖాళీ క్యూను ప్రదర్శిస్తుంది. లేకపోతే, అది చివరి విలువను పొందుతుంది మరియు దానిని క్యూ నుండి తొలగిస్తుంది.
C++లో సర్క్యులర్ బఫర్‌ని అమలు చేయడానికి ప్రోగ్రామ్
పేర్కొన్న రెండు పద్ధతులను అనుసరించి, మేము C++లో వృత్తాకార బఫర్‌ను అమలు చేస్తాము. C++లో వృత్తాకార క్యూ అమలు కోసం అన్ని దశలను పరిశీలిద్దాం.
#include
నేమ్‌స్పేస్ stdని ఉపయోగించడం;
MyQueueని నిర్మించండి
{
int తల , తోక ;
int Qsize;
int * NewArr;
నా క్యూ ( పూర్తి సంఖ్య ) {
తల = తోక = -1 ;
Qsize = పరిమాణం;
NewArr = కొత్త int [ లు ] ;
}
enQueue శూన్యం ( పూర్ణాంక విలువ ) ;
int deQueue ( ) ;
షో క్యూ శూన్యం ( ) ;
} ;
కోడ్‌తో ప్రారంభించి, హెడ్ మరియు టెయిల్ వేరియబుల్స్‌ను ప్రారంభించేందుకు మేము ముందుగా “MyQueue” స్ట్రక్ట్‌ని క్రియేట్ చేస్తాము. హెడ్ వేరియబుల్ ముందు సూచికలను సూచిస్తుంది మరియు తోక శ్రేణి యొక్క వెనుక వెనుక సూచికలను సూచిస్తుంది. ఆ తర్వాత, 'Qsize' వేరియబుల్ ద్వారా సూచించబడే వృత్తాకార క్యూ పరిమాణం నిర్వచించబడుతుంది.
అప్పుడు, మేము వృత్తాకార క్యూ విలువలను నిల్వ చేసే 'NewArr' యొక్క డైనమిక్‌గా కేటాయించిన శ్రేణిని నిర్వచించాము. తరువాత, మేము MyQueue()ని పిలుస్తాము, ఇది కన్స్ట్రక్టర్ మరియు వృత్తాకార క్యూ పరిమాణం కోసం “sz” పరామితిని పాస్ చేస్తాము. MyQueue() కన్స్ట్రక్టర్ లోపల, మేము తల మరియు టెయిల్ పాయింటర్‌లకు “-1” విలువను కేటాయిస్తాము. ఈ ప్రతికూల విలువ క్యూ ఇప్పుడు ఖాళీగా ఉందని సూచిస్తుంది. ముందుకు వెళుతున్నప్పుడు, మేము వృత్తాకార క్యూ పరిమాణాన్ని సూచించే 'sz' విలువను కేటాయిస్తాము. పేర్కొన్న “sz” పరిమాణంలో పూర్ణాంకాల శ్రేణిని సృష్టించడానికి “NewArr” వృత్తాకార క్యూ కొత్త కీవర్డ్‌తో సెట్ చేయబడింది.
అప్పుడు, మేము enQueue() మరియు dequeue() ఫంక్షన్లను నిర్వచిస్తాము. ఎన్క్యూ() విలువలను తోక నుండి నిర్వచించబడిన వృత్తాకార క్యూలో చేర్చుతుంది. అయితే, వృత్తాకార క్యూ తలలోని మూలకాలు dequeue() ఫంక్షన్ ద్వారా తొలగించబడతాయి. showQueue() మెంబర్ ఫంక్షన్ వృత్తాకార క్యూ విలువలను ప్రదర్శిస్తుంది.
దశ 1: వృత్తాకార బఫర్‌లో మూలకాలను చొప్పించడానికి ఒక ఫంక్షన్‌ను సృష్టించండి
మునుపటి దశలో, మేము ప్రైవేట్ మెంబర్‌లు ప్రారంభించబడే తరగతిని సెట్ చేసాము మరియు ప్రైవేట్ మెంబర్ ఫంక్షన్‌లు సర్క్యులర్ క్యూను అమలు చేయడానికి సెట్ చేసాము. ఇప్పుడు, మేము వృత్తాకార క్యూను సృష్టించడానికి ఫంక్షన్‌ను సెట్ చేసాము మరియు అల్గోరిథం ఉపయోగించి వృత్తాకార క్యూ లోపల విలువలను ఇన్సర్ట్ చేస్తాము.
శూన్యం MyQueue::enQueue ( పూర్ణాంక విలువ ){
ఉంటే ( ( తల == 0 && తోక == Qsize - 1 ) || ( తోక == ( తల - 1 ) % ( Qsize - 1 ) ) )
{
కోట్ << ' \n క్యూ నిండిపోయింది' ;
తిరిగి ;
}
లేకపోతే ఉంటే ( తల == - 1 )
{
తల = తోక = 0 ;
NewArr [ తోక ] = వాల్;
}
లేకపోతే ఉంటే ( తోక == Qsize - 1 && తల ! = 0 )
{
తోక = 0 ;
NewArr [ తోక ] = వాల్;
}
లేకపోతే {
తోక ++;
NewArr [ తోక ] = వాల్;
}
}
ఇక్కడ, క్యూ ఖాళీగా ఉంటే లేదా అండర్‌ఫ్లో ఉన్నట్లయితే వృత్తాకార క్యూలో మూలకాన్ని చొప్పించడానికి 'MyQueue' తరగతి నుండి 'enqueue()'ఫంక్షన్‌ని పిలుస్తాము. “enqueue()” ఫంక్షన్ “val” పరామితితో పాస్ చేయబడింది మరియు వృత్తాకార క్యూ యొక్క తోక నుండి విలువను చొప్పించండి. దీని కోసం వృత్తాకార క్యూలో విలువలను చొప్పించడానికి మేము 'if-else' షరతును సెట్ చేసాము. మొదటి “if” స్టేట్‌మెంట్, “if ((హెడ్ == 0 && tail == Qsize – 1) || (tail == (head – 1) % (Qsize – 1)))” రెండు షరతులను తనిఖీ చేస్తుంది వృత్తాకార క్యూ యొక్క ప్రారంభ స్థానంలో మరియు తోక చివరి స్థానంలో ఉంది. అప్పుడు, తోక తల స్థానం వెనుక ఒక స్థానంలో ఉందో లేదో తనిఖీ చేస్తుంది. ఈ షరతుల్లో దేనినైనా నెరవేర్చినట్లయితే, క్యూ ఖాళీగా ఉండదు మరియు ప్రాంప్ట్ సందేశాన్ని రూపొందిస్తుంది.
తర్వాత, క్యూ ఖాళీగా ఉందో లేదో గుర్తించే “else-if” షరతును మేము కలిగి ఉన్నాము. అలా అయితే, విలువ క్యూలో చేర్చబడుతుంది. తల -1కి సమానంగా ఉంచబడినందున, క్యూ ఖాళీగా ఉందని మరియు విలువను వృత్తాకార క్యూలో చొప్పించాల్సిన అవసరం ఉందని చూపిస్తుంది. దీని కోసం, మేము తల మరియు తోకను 0కి సమానంగా సెట్ చేస్తాము. అప్పుడు, మేము 'NewArr' వృత్తాకార క్యూలో తోక స్థానం నుండి విలువను ఇన్సర్ట్ చేస్తాము.
అప్పుడు, మేము మా మూడవ “ఇఫ్-ఇఫ్” కండిషన్‌ను కలిగి ఉన్నాము, ఇది క్యూ యొక్క చివరి స్థానంలో తోక ఉందా మరియు తల క్యూ యొక్క ప్రారంభ స్థానం కాదా అని తనిఖీ చేస్తుంది. తోక ముగింపుకు చేరుకున్నప్పుడు మరియు ప్రారంభ స్థానం ఇప్పటికీ ఖాళీని కలిగి ఉన్నప్పుడు ఈ పరిస్థితి వర్తిస్తుంది. దీని కోసం, మేము తలని 0 వద్ద సెట్ చేయాలి మరియు తోక స్థానం నుండి మూలకం జోడించబడుతుంది. చివరగా, ఇచ్చిన షరతులన్నీ నెరవేరకపోతే, క్యూ ఖాళీగా ఉండదు లేదా నిండదు. ఈ సందర్భంలో, మేము తోకను 1కి పెంచుతాము మరియు కొత్త టెయిల్ స్థానం నుండి విలువ జోడించబడుతుంది.
దశ 2: సర్క్యులర్ బఫర్ నుండి మూలకాలను తొలగించడానికి ఒక ఫంక్షన్‌ను సృష్టించండి
ఎన్క్యూ() ఫంక్షన్‌ని ఉపయోగించి వృత్తాకార క్యూలో మూలకాలను సృష్టించడానికి మరియు ఇన్సర్ట్ చేయడానికి మేము మునుపటి కోడ్‌ని సెట్ చేసాము. ఇప్పుడు, వృత్తాకార బఫర్ ఓవర్‌ఫ్లో ఉంటే దాని నుండి మూలకాలను తొలగించే అమలును మేము నిర్వచించాము.
int MyQueue::deQueue ( ){
ఉంటే ( తల == - 1 )
{
కోట్ << ' \n క్యూ ఉచితం' ;
తిరిగి INT_MIN;
}
int MyData = NewArr [ తల ] ;
NewArr [ తల ] = -1 ;
ఉంటే ( తల == తోక )
{
తల = -1 ;
తోక = -1 ;
}
లేకపోతే ఉంటే ( తల == Qsize - 1 )
తల = 0 ;
లేకపోతే
తల ++;
తిరిగి MyData;
}
ఇచ్చిన కోడ్‌లో, హెడ్ ఇండెక్స్ నుండి ఎలిమెంట్‌ను తీసివేయడానికి మేము 'మైక్యూ' క్లాస్ నుండి dequeue() ఫంక్షన్‌ని పిలుస్తాము. కాబట్టి, క్యూ ఖాళీగా ఉందో లేదో తనిఖీ చేసే “if” స్టేట్‌మెంట్ మా వద్ద ఉంది. తల ఖాళీ క్యూను సూచించే '-1' విలువతో సెట్ చేయబడింది. క్యూ ఖాళీగా ఉందని సందేశం రూపొందించబడింది, ఆపై Int కోసం స్థిరమైన కనీస విలువ అయిన INT_MINని అందించండి. క్యూ ఖాళీగా ఉందో లేదో 'if' స్టేట్‌మెంట్ నిర్ణయిస్తుంది. దీని కోసం, మేము 'MyData' వేరియబుల్‌ని నిర్వచించాము మరియు క్యూ యొక్క తల వద్ద మూలకం యొక్క విలువను సెట్ చేస్తాము. అప్పుడు, మేము ఈ విలువ క్యూ నుండి తీసివేయబడిందని సూచించే -1 స్థానంలో తలని సెట్ చేస్తాము. దీని తరువాత, తల మరియు తోక సమానంగా ఉన్నాయో లేదో తనిఖీ చేస్తాము. రెండూ సమానంగా ఉంటే, మేము రెండింటికీ '-1' విలువను కేటాయిస్తాము, ఇది ఖాళీ వృత్తాకార క్యూను సూచిస్తుంది. చివరగా, క్యూ యొక్క చివరి సూచికలో తల ఉంటే dequeue() పనిచేస్తుందో లేదో తనిఖీ చేస్తాము. దీని కోసం, మేము దానిని '0' విలువతో సెట్ చేసాము, ఇది శ్రేణి ప్రారంభంలో లూప్ అవుతుంది. ఇచ్చిన షరతుల్లో ఏదీ నిజం కానట్లయితే, తల విలువ పెరుగుతుంది మరియు డీక్యూడ్ మూలకం తిరిగి ఇవ్వబడుతుంది.
దశ 3: సర్క్యులర్ బఫర్ యొక్క మూలకాలను చూపించడానికి ఒక ఫంక్షన్‌ను సృష్టించండి
ఈ విభాగంలో, 'NewArr' వృత్తాకార క్యూ యొక్క మూలకాలను ప్రదర్శించడానికి మేము showQueue() ఫంక్షన్‌ని పిలుస్తాము.
శూన్యం MyQueue::showQueue ( ){
ఉంటే ( తల == - 1 )
{
కోట్ << ' \n క్యూ ఉచితం' ;
తిరిగి ;
}
కోట్ << ' \n వృత్తాకార వరుస అంశాలు: ' ;
ఉంటే ( తోక > = తల )
{
కోసం ( int i = తల ; i < = తోక ; i++ )
కోట్ << NewArr [ i ] << '' ;
}
లేకపోతే
{
కోసం ( int i = తల ; i < Qsize; i++ )
కోట్ << NewArr [ i ] << '' ;
కోసం ( int i = 0 ; i < = తోక ; i++ )
కోట్ << NewArr [ i ] << '' ;
}
}
క్యూ యొక్క ఖాళీ స్థితి మొదట ధృవీకరించబడుతుంది. క్యూ ఖాళీగా ఉంటే వృత్తాకార క్యూ ఉచితం అనే సూచన ప్రదర్శించబడుతుంది. లేకపోతే, ఫంక్షన్ వృత్తాకార క్యూ యొక్క మూలకాలను చూపుతుంది. దీని కోసం, మేము తల కంటే ఎక్కువ లేదా సమానమైన తోకను కలిగి ఉన్న 'if' స్టేట్‌మెంట్‌ను నిర్వచించాము. వృత్తాకార క్యూ పూర్తి కానప్పుడు కేసును నిర్వహించడానికి ఈ షరతు సెట్ చేయబడింది.
ఈ సందర్భంలో, మేము తల నుండి తోక వరకు పునరావృతం చేయడానికి మరియు వృత్తాకార క్యూ యొక్క విలువలను ముద్రించడానికి 'ఫర్' లూప్‌ను ఉపయోగిస్తాము. వృత్తాకార క్యూ పూర్తయిన తర్వాతి సందర్భం. దీని కోసం, తోక తల కంటే తక్కువగా ఉన్న 'if' పరిస్థితిని ఉపయోగించి మేము తనిఖీ చేస్తాము. అప్పుడు, మేము రెండు లూప్‌లను ఉపయోగించాలి, ఇక్కడ మొదటిది తల నుండి క్యూ చివరి వరకు పునరావృతమవుతుంది మరియు రెండవది తోక ప్రారంభం నుండి పునరావృతమవుతుంది.
దశ 4: సర్క్యులర్ క్యూ ప్రోగ్రామ్ యొక్క ప్రధాన() ఫంక్షన్‌ను సృష్టించండి
చివరగా, మేము ప్రోగ్రామ్ యొక్క ప్రధాన() ఫంక్షన్‌ను సృష్టిస్తాము, ఇక్కడ మేము వృత్తాకార క్యూలో ఐదు పూర్ణాంకాలను చొప్పించి, క్యూ యొక్క పూర్ణాంకాలను ప్రదర్శిస్తాము. ఆ తర్వాత, మేము dequeue() ఫంక్షన్‌కి కాల్ చేయడం ద్వారా వృత్తాకార క్యూ నుండి తొలగించబడిన పూర్ణాంకాలను చూపుతాము. కొన్ని ఎలిమెంట్‌లను డీక్యూ చేసిన తర్వాత, ఎన్క్యూ() ఫంక్షన్‌ని ఉపయోగించి కొత్త ఎలిమెంట్‌లను ఇన్సర్ట్ చేయడం ద్వారా మేము క్యూను మళ్లీ నింపుతాము.
పూర్ణాంక ప్రధాన ( ){
MyQueue అది ( 5 ) ;
// మూలకాలను చొప్పించడం లో వృత్తాకార క్యూ
que.enQueue ( పదకొండు ) ;
que.enQueue ( 12 ) ;
que.enQueue ( 13 ) ;
que.enQueue ( 14 ) ;
que.enQueue ( పదిహేను ) ;
// ప్రదర్శన మూలకాలు ఉన్నాయి లో వృత్తాకార క్యూ
que.showQueue ( ) ;
// సర్క్యులర్ క్యూ నుండి ఎలిమెంట్‌లను తొలగిస్తోంది
కోట్ << ' \n తొలగించబడిన మూలకం = ' << que.deQueue ( ) ;
కోట్ << ' \n తొలగించబడిన మూలకం = ' << que.deQueue ( ) ;
que.showQueue ( ) ;
que.enQueue ( 16 ) ;
que.enQueue ( 17 ) ;
que.enQueue ( 18 ) ;
que.showQueue ( ) ;
తిరిగి 0 ;
}
అవుట్‌పుట్:
వృత్తాకార క్యూ అమలు ఫలితాలు C++ ప్రాంప్ట్ స్క్రీన్‌పై చూపబడతాయి.
ముగింపు
ముగింపులో, ఈ వ్యాసంలో వృత్తాకార బఫర్ అంశం లోతుగా వివరించబడింది. మేము ముందుగా వృత్తాకార బఫర్‌ను సృష్టించాము, ఆపై వృత్తాకార క్యూ నుండి ఎలా తొలగించాలో వివరించాము, ఆపై C++లో వృత్తాకార మూలకాలను ప్రదర్శించాము.