C ++ ప్రాధాన్యత_క్యూని ఉపయోగించడానికి, ప్రోగ్రామ్ ఇలాంటి కోడ్‌తో ప్రారంభం కావాలి:
#చేర్చండి
#చేర్చండి
ఉపయోగించి నేమ్‌స్పేస్గంటలు;
ఇది ప్రోగ్రామ్‌లోని క్యూ లైబ్రరీని కలిగి ఉంటుంది.
చదవడం కొనసాగించడానికి, రీడర్ C ++ గురించి ప్రాథమిక జ్ఞానం కలిగి ఉండాలి.
వ్యాసం కంటెంట్
- ప్రాథమిక నిర్మాణం
- ముఖ్యమైన సభ్యుల విధులు
- ఇతర ప్రాధాన్యత క్యూ విధులు
- స్ట్రింగ్ డేటా
- ఇతర ప్రాధాన్య క్యూ నిర్మాణాలు
- ముగింపు
ప్రాథమిక నిర్మాణం
డేటా స్ట్రక్చర్‌ను ఉపయోగించడానికి ముందు ముందుగా నిర్మించాలి. ఇక్కడ నిర్మాణం అంటే లైబ్రరీ యొక్క క్యూ క్లాస్ నుండి ఒక వస్తువును తక్షణం అందించడం. క్యూ వస్తువుకు ప్రోగ్రామర్ ఇచ్చిన పేరు ఉండాలి. ప్రాధాన్యత క్యూను సృష్టించడానికి సరళమైన వాక్యనిర్మాణం:
ప్రాధాన్యత_ క్యూ<రకం>క్యూ పేరు;
ఈ వాక్యనిర్మాణంతో, గొప్ప విలువ ముందుగా తొలగించబడుతుంది. తక్షణం ఒక ఉదాహరణ:
ప్రాధాన్యత_ క్యూ<int>pq;లేదా
ప్రాధాన్యత_ క్యూ<చార్>pq;
వెక్టర్ మరియు డెక్యూ C ++ లో రెండు డేటా నిర్మాణాలు. వాటిలో దేనితోనైనా ఒక ప్రాధాన్యత_క్యూ సృష్టించవచ్చు. వెక్టర్ స్ట్రక్చర్ నుండి ప్రాధాన్య క్యూను సృష్టించడానికి వాక్యనిర్మాణం:
ప్రాధాన్యత_ క్యూ<రకం, వెక్టర్<ఒకే రకం>, సరిపోల్చండి>pq;ఈ తక్షణం యొక్క ఉదాహరణ:
ప్రాధాన్యత_ క్యూ<int, వెక్టర్<int>, తక్కువ<int> >pq;డిక్లరేషన్ చివరిలో> మరియు> మధ్య అంతరాన్ని గమనించండి. ఇది >> తో గందరగోళాన్ని నివారించడానికి. డిఫాల్ట్ పోలిక కోడ్ తక్కువగా ఉంటుంది, అంటే గొప్పది, మరియు మొదటి విలువ కాదు, మొదట తీసివేయబడుతుంది. కాబట్టి, సృష్టి ప్రకటనను ఇలా వ్రాయవచ్చు:
ప్రాధాన్యత_ క్యూ<int, వెక్టర్<int> >pq;ముందుగా కనీస విలువను తీసివేయాలంటే, ఆ ప్రకటన ఇలా ఉండాలి:
ప్రాధాన్యత_ క్యూ<int, వెక్టర్<int>, ఎక్కువ<int> >pq;ముఖ్యమైన సభ్యుల విధులు
పుష్ () ఫంక్షన్
ఈ ఫంక్షన్ ఒక విలువను, దాని వాదన అయిన, privacy_queue లోకి నెట్టివేస్తుంది. ఇది శూన్యతను తిరిగి ఇస్తుంది. కింది కోడ్ దీనిని వివరిస్తుంది:
pq.పుష్(10);
pq.పుష్(30);
pq.పుష్(ఇరవై);
pq.పుష్(యాభై);
pq.పుష్(40);
ఈ ప్రాధాన్యత_క్యూ 10, 30, 20, 50, 40 క్రమంలో 5 పూర్ణాంక విలువలను పొందింది. ఈ మూలకాలన్నీ ప్రాధాన్యత క్యూ నుండి బయటకు రావాలంటే, అవి 50, 40, 30, క్రమంలో వస్తాయి. 20, 10.
పాప్ () ఫంక్షన్
ఈ ఫంక్షన్ ప్రాధాన్యత_క్యూ నుండి అత్యధిక ప్రాధాన్యత కలిగిన విలువను తీసివేస్తుంది. పోలిక కోడ్ ఎక్కువగా ఉంటే, అది చిన్న విలువతో మూలకాన్ని తీసివేస్తుంది. ఒకవేళ మళ్లీ పిలిస్తే, అది మిగిలిన మూలకాల చిన్న విలువతో తదుపరి మూలకాన్ని తొలగిస్తుంది; మళ్లీ పిలవబడుతుంది, ఇది తదుపరి అతిచిన్న విలువను తొలగిస్తుంది మరియు మొదలైనవి. ఇది శూన్యతను తిరిగి ఇస్తుంది. కింది కోడ్ దీనిని వివరిస్తుంది:
pq.పుష్('కు');pq.పుష్('సి');pq.పుష్('b');pq.పుష్('మరియు');pq.పుష్('d');
మెంబర్ ఫంక్షన్‌కు కాల్ చేయడానికి, ఆబ్జెక్ట్ పేరును ఒక డాట్, ఆపై ఫంక్షన్‌తో అనుసరించాల్సి ఉంటుందని గమనించండి.
టాప్ () ఫంక్షన్
ది పాప్ () ఫంక్షన్ తదుపరి ప్రాధాన్యత యొక్క తదుపరి విలువను తొలగిస్తుంది, కానీ దానిని తిరిగి ఇవ్వదు పాప్ () శూన్యమైన ఫంక్షన్. ఉపయోగించడానికి టాప్ () తదుపరి తొలగించాల్సిన అత్యధిక ప్రాధాన్యత విలువను తెలుసుకోవడానికి ఫంక్షన్. ది టాప్ () ఫంక్షన్ ప్రాధాన్యత_క్యూలో అత్యధిక ప్రాధాన్యత విలువ యొక్క కాపీని అందిస్తుంది. కింది కోడ్, అత్యధిక ప్రాధాన్యత కలిగిన తదుపరి విలువ అతి తక్కువ విలువ, ఇక్కడ దీనిని వివరిస్తుంది
pq.పుష్('కు');pq.పుష్('సి');pq.పుష్('b');pq.పుష్('మరియు');pq.పుష్('d');
చార్ch1=pq.టాప్();pq.పాప్();
చార్ch2=pq.టాప్();pq.పాప్();
చార్ch3=pq.టాప్();pq.పాప్();
చార్ch4=pq.టాప్();pq.పాప్();
చార్ch5=pq.టాప్();pq.పాప్();
ఖరీదు<<ch1<<''<<ch2<<''<<ch3<<''<<ch4<<''<<ch5<<' n';
అవుట్‌పుట్ ‘a’ ‘b’ ‘c’ ‘d’ ‘e’.
ఖాళీ () ఫంక్షన్
ఒక ప్రోగ్రామర్ ఉపయోగిస్తే టాప్ () ఖాళీ ప్రాధాన్యత_క్యూలో ఫంక్షన్, విజయవంతమైన సంకలనం తర్వాత, అతను ఒక దోష సందేశాన్ని అందుకుంటాడు:
కాబట్టి, ఉపయోగించడానికి ముందు ప్రాధాన్యత క్యూ ఖాళీగా లేనట్లయితే ఎల్లప్పుడూ తనిఖీ చేయండి టాప్ () ఫంక్షన్ ది ఖాళీ () సభ్యుని ఫంక్షన్ బూల్‌ని అందిస్తుంది, నిజం, క్యూ ఖాళీగా ఉంటే, మరియు క్యూ ఖాళీగా లేనట్లయితే తప్పు. కింది కోడ్ దీనిని వివరిస్తుంది:
ప్రాధాన్యత_ క్యూ<int>pq;inti1= 10; inti2= 30; inti3= ఇరవై; inti4= యాభై; inti5= 40;
pq.పుష్(i1);pq.పుష్(i2);pq.పుష్(i3);pq.పుష్(i4);pq.పుష్(i5);
అయితే(!pq.ఖాళీ())
{
ఖరీదు <<pq.టాప్() << '';
pq.పాప్();
}
ఖరీదు << ' n';
ఇతర ప్రాధాన్యత క్యూ విధులు
పరిమాణం () ఫంక్షన్
ఈ ఫంక్షన్ ప్రాధాన్య కోడ్ యొక్క పొడవును అందిస్తుంది, కింది కోడ్ వివరిస్తుంది:
inti1= 10; inti2= 30; inti3= ఇరవై; inti4= యాభై; inti5= 40;
pq.పుష్(i1);pq.పుష్(i2);pq.పుష్(i3);pq.పుష్(i4);pq.పుష్(i5);
intలెన్=pq.పరిమాణం();
ఖరీదు <<లెన్<< ' n';
అవుట్‌పుట్ 5.
స్వాప్ () ఫంక్షన్
రెండు ప్రాధాన్యత_అంశాలు ఒకే రకం మరియు పరిమాణంలో ఉంటే, కింది కోడ్ చూపిన విధంగా వాటిని ఈ ఫంక్షన్ ద్వారా మార్చుకోవచ్చు:
inti1= 10; inti2= 30; inti3= ఇరవై; inti4= యాభై; inti5= 40;
pq1.పుష్(i1);pq1.పుష్(i2);pq1.పుష్(i3);pq1.పుష్(i4);pq1.పుష్(i5);
ప్రాధాన్యత_ క్యూ<int>pqA;
intఅది 1= 1; intఅది 2= 3; intit3= 2; intit4= 5; intit5= 4;
pqA.పుష్(అది 1);pqA.పుష్(అది 2);pqA.పుష్(it3);pqA.పుష్(it4);pqA.పుష్(it5);
pq1.మార్పిడి(pqA);
అయితే(!pq1.ఖాళీ())
{
ఖరీదు <<pq1.టాప్() << '';
pq1.పాప్();
} ఖరీదు<<' n';
అయితే(!pqA.ఖాళీ())
{
ఖరీదు <<pqA.టాప్() << '';
pqA.పాప్();
} ఖరీదు<<' n';
అవుట్‌పుట్:
& emsp; 5 & emsp; 4 & emsp; 3 & emsp; 2 & emsp; 1
& emsp; 50 & emsp; 40 & emsp; 30 & emsp; 20 & emsp; 10
ది ఎంప్లేస్ () ఫక్షన్
ది ఎంప్లేస్ () ఫంక్షన్ పుష్ ఫంక్షన్‌ని పోలి ఉంటుంది. కింది కోడ్ దీనిని వివరిస్తుంది:
inti1= 10; inti2= 30; inti3= ఇరవై; inti4= యాభై; inti5= 40;
pq1.ఎంప్లేస్(i1);pq1.ఎంప్లేస్(i2);pq1.ఎంప్లేస్(i3);pq1.ఎంప్లేస్(i4);pq1.ఎంప్లేస్(i5);
అయితే(!pq1.ఖాళీ())
{
ఖరీదు <<pq1.టాప్() << '';
pq1.పాప్();
} ఖరీదు<<' n';
అవుట్‌పుట్:
50 40 30 20 10
స్ట్రింగ్ డేటా
స్ట్రింగ్‌లను పోల్చినప్పుడు, స్ట్రింగ్ క్లాస్‌ని ఉపయోగించాలి మరియు స్ట్రింగ్ లిటరల్స్ యొక్క ప్రత్యక్ష ఉపయోగం కాదు, ఎందుకంటే ఇది పాయింటర్లను పోల్చి చూస్తుంది మరియు అసలు స్ట్రింగ్‌లను కాదు. కింది కోడ్ స్ట్రింగ్ క్లాస్ ఎలా ఉపయోగించబడుతుందో చూపుతుంది:
#చేర్చండిప్రాధాన్యత_ క్యూ<స్ట్రింగ్>pq1;
స్ట్రింగ్ s1=స్ట్రింగ్('పెన్'), s2=స్ట్రింగ్('పెన్సిల్'), ఎస్ 3=స్ట్రింగ్('వ్యాయామ పుస్తకము'), ఎస్ 4=స్ట్రింగ్('టెక్స్ట్ బుక్'), s5=స్ట్రింగ్('పాలకుడు');
pq1.పుష్(s1);pq1.పుష్(s2);pq1.పుష్(s3);pq1.పుష్(s4);pq1.పుష్(s5);
అయితే(!pq1.ఖాళీ())
{
ఖరీదు <<pq1.టాప్() << '';
pq1.పాప్();
} ఖరీదు<<' n';
అవుట్‌పుట్:
& emsp; టెక్స్ట్ బుక్ & emsp; పాలకుడు & emsp; పెన్సిల్ & emsp; పెన్ & emsp; వ్యాయామ పుస్తకం
ఇతర ప్రాధాన్య క్యూ నిర్మాణాలు
వెక్టర్ నుండి స్పష్టమైన సృష్టి
కింది కోడ్ చూపిన విధంగా ఒక వెక్టర్ నుండి ఒక ప్రాధాన్యత క్యూ స్పష్టంగా సృష్టించబడుతుంది:
వెక్టర్<int>vtr= {10,30,ఇరవై,యాభై,40};
ప్రాధాన్యత_ క్యూ<int>pq(vtr.ప్రారంభించండి(), vtr.ముగింపు());
అయితే(!pq.ఖాళీ())
{
ఖరీదు <<pq.టాప్() << '';
pq.పాప్();
} ఖరీదు<<' n';
అవుట్‌పుట్: 50 40 30 20 10. ఈసారి, వెక్టర్ హెడర్ కూడా చేర్చాలి. కన్స్ట్రక్టర్ ఫంక్షన్ కోసం వాదనలు వెక్టర్ యొక్క ప్రారంభ మరియు ముగింపు పాయింటర్లను తీసుకుంటాయి. వెక్టర్ కోసం డేటా రకం మరియు ప్రాధాన్యత_క్యూ కోసం డేటా రకం ఒకే విధంగా ఉండాలి.
కనీస విలువకు ప్రాధాన్యతనివ్వడానికి, కన్స్ట్రక్టర్ కోసం ప్రకటన ఇలా ఉంటుంది:
ప్రాధాన్యత_ క్యూ<int, వెక్టర్<int>, ఎక్కువ>int> >pq(vtr.ప్రారంభించండి(), vtr.ముగింపు()); శ్రేణి నుండి స్పష్టమైన సృష్టి
కింది కోడ్ చూపిన విధంగా ఒక శ్రేణి నుండి ఒక ప్రాధాన్యత క్యూని స్పష్టంగా సృష్టించవచ్చు:
ప్రాధాన్యత_ క్యూ<int>pq(అర, అర+5);
అయితే(!pq.ఖాళీ())
{
ఖరీదు <<pq.టాప్() << '';
pq.పాప్();
} ఖరీదు<<' n';
అవుట్‌పుట్: 50 40 30 20 10. కన్స్ట్రక్టర్ ఫంక్షన్ కోసం వాదనలు శ్రేణి యొక్క ప్రారంభ మరియు ముగింపు పాయింటర్లను తీసుకుంటాయి. arr స్టార్టర్ పాయింటర్‌ను తిరిగి ఇస్తుంది, arr+5 అరేను దాటి పాయింటర్‌ను తిరిగి ఇస్తుంది మరియు 5 అనేది అర్రే సైజు. శ్రేణి కోసం డేటా రకం మరియు ప్రాధాన్యత_క్యూ కోసం డేటా రకం ఒకే విధంగా ఉండాలి.
కనీస విలువకు ప్రాధాన్యతనివ్వడానికి, కన్స్ట్రక్టర్ కోసం ప్రకటన ఇలా ఉంటుంది:
ప్రాధాన్యత_ క్యూ<int, వెక్టర్<int>, ఎక్కువ<int> >pq(అర, అర+5);గమనిక: C ++ లో, ప్రాధాన్యత_క్యూ నిజానికి ఒక కంటైనర్ మాత్రమే కాదు, అడాప్టర్ అని పిలువబడుతుంది.
అనుకూల పోలిక కోడ్
ప్రాధాన్యత క్యూలో అన్ని విలువలు ఆరోహణ లేదా అన్ని అవరోహణలు మాత్రమే ప్రాధాన్యత క్యూ కోసం మాత్రమే కాదు. ఉదాహరణకు, గరిష్ట కుప్ప కోసం 11 పూర్ణాంకాల జాబితా:
88, 86, 87, 84, 82, 79,74, 80, 81 ,,, 64, 69
అత్యధిక విలువ 88. దీని తరువాత రెండు సంఖ్యలు ఉన్నాయి: 86 మరియు 87, ఇవి 88 కన్నా తక్కువ. మిగిలిన సంఖ్యలు ఈ మూడు సంఖ్యల కంటే తక్కువగా ఉంటాయి, కానీ నిజంగా క్రమంలో లేవు. జాబితాలో రెండు ఖాళీ కణాలు ఉన్నాయి. 84 మరియు 82 సంఖ్యలు 86 కన్నా తక్కువ. 79 మరియు 74 సంఖ్యలు 87 కన్నా తక్కువ. 80 మరియు 81 సంఖ్యలు 84 కన్నా తక్కువ. 64 మరియు 69 సంఖ్యలు 79 కంటే తక్కువ.
సంఖ్యల ప్లేస్‌మెంట్ గరిష్ట-కుప్ప ప్రమాణాలను అనుసరిస్తుంది-తర్వాత చూడండి. ప్రాధాన్యత_క్యూ కోసం అటువంటి పథకాన్ని అందించడానికి, ప్రోగ్రామర్ తన స్వంత పోలిక కోడ్‌ను అందించాలి - తర్వాత చూడండి.
ముగింపు
C ++ ప్రాధాన్యత_క్యూ అనేది ఫస్ట్-ఇన్-ఫస్ట్-అవుట్ క్యూ. మెంబర్ ఫంక్షన్, పుష్ (), క్యూలో కొత్త విలువను జోడిస్తుంది. మెంబర్ ఫంక్షన్, టాప్ (), క్యూలో టాప్ వాల్యూ చదువుతుంది. మెంబర్ ఫంక్షన్, పాప్ (), క్యూ యొక్క అగ్ర విలువను తిరిగి ఇవ్వకుండా తొలగిస్తుంది. మెంబర్ ఫంక్షన్, ఖాళీ (), క్యూ ఖాళీగా ఉందో లేదో తనిఖీ చేస్తుంది. అయితే, ప్రాధాన్యత_క్యూ క్యూ నుండి భిన్నంగా ఉంటుంది, దానిలో, ఇది కొంత ప్రాధాన్యత అల్గోరిథంను అనుసరిస్తుంది. ఇది మొదటి నుండి చివరి వరకు లేదా కనీసం మొదటి నుండి చివరి వరకు గొప్పగా ఉంటుంది. ప్రమాణాలు (అల్గోరిథం) కూడా ప్రోగ్రామర్ ద్వారా నిర్వచించబడతాయి.