C++ Unordered_Map :: Find() ఫంక్షన్

Unordered_Mapని అర్థం చేసుకోవడం ::Find()

unordered_map::find() ఫంక్షన్ 'unordered_map'లో పేర్కొన్న కీతో అనుబంధించబడిన మూలకాన్ని గుర్తించడానికి రూపొందించబడింది. వస్తువు స్థిరంగా-అర్హత పొందిందా లేదా అనేదానిపై ఆధారపడి దాని ప్రకటన మారుతుంది, దాని వినియోగంలో సౌలభ్యాన్ని అందిస్తుంది.

“క్రమించని_మ్యాప్” స్థిరంగా-అర్హత పొందనప్పుడు ఇది ఉపయోగించబడుతుంది. ఈ కోడ్ కనుగొనబడిన మూలకాన్ని సూచించే ఇటరేటర్‌ని అందిస్తుంది.

“క్రమించని_మ్యాప్” స్థిరంగా-అర్హత పొందినప్పుడు ఈ సంస్కరణ వర్తిస్తుంది. ఇది స్థిరమైన సంస్కరణకు సమానమైన ప్రవర్తనతో స్థిరమైన పునరావృత్తిని అందిస్తుంది.

పారామితులు:

ఇది 'k' అనే ఒకే పరామితిని తీసుకుంటుంది, ఇది 'unordered_map'లో శోధించవలసిన కీ.

రిటర్న్ విలువ:

రిటర్న్ విలువ 'క్రమించని_మ్యాప్' ఆబ్జెక్ట్ యొక్క అర్హతపై ఆధారపడి ఉంటుంది.

ఆబ్జెక్ట్ నిరంతరం అర్హత పొందకపోతే ఈ పద్ధతి స్థిరంగా లేని పునరావృత్తిని అందిస్తుంది.

వస్తువు స్థిరంగా-అర్హత కలిగి ఉంటే, పద్ధతి స్థిరమైన పునరావృత్తిని అందిస్తుంది.

సమయ సంక్లిష్టత:

std::unordered_map::find() యొక్క సమయ సంక్లిష్టత దాని సామర్థ్యాన్ని అర్థం చేసుకోవడానికి కీలకం:

సగటు సందర్భంలో, సమయ సంక్లిష్టత స్థిరంగా ఉంటుంది (O(1)), ఇది సాధారణ వినియోగ సందర్భాలలో అత్యంత ప్రభావవంతంగా ఉంటుంది.

చెత్త దృష్టాంతంలో, సమయ సంక్లిష్టత సరళంగా మారుతుంది (O(n)). అయితే, ఈ దృశ్యం ఆచరణలో చాలా అరుదు.

ఉదాహరణ 1:

unordered_map ::find() వినియోగం మరియు ప్రయోజనాలను వివరించడానికి ఒక ఆచరణాత్మక ఉదాహరణను అన్వేషిద్దాం. ఈ ఉదాహరణలో, అక్షరాలను కీలుగా మరియు సంబంధిత పూర్ణాంకాల విలువలతో “క్రమించని_మ్యాప్” సృష్టించబడుతుంది. ఫైండ్() ఫంక్షన్ 'p' కీతో లింక్ చేయబడిన మూలకాన్ని గుర్తిస్తుంది. 'ittr' ఇటరేటర్ కనుగొనబడిన మూలకానికి లింక్ చేయబడింది మరియు దాని డేటా కన్సోల్‌కు ముద్రించబడుతుంది. కింది కోడ్‌ను చూడండి:

కోడ్‌ని స్పష్టంగా మరియు బాగా అర్థం చేసుకోవడానికి దాన్ని విచ్ఛిన్నం చేద్దాం:

అవసరమైన హెడర్ ఫైల్‌లు చేర్చబడ్డాయి: ఇన్‌పుట్/అవుట్‌పుట్ ఆపరేషన్‌ల కోసం మరియు “unordered_map” కంటైనర్‌ను ఉపయోగించడం కోసం .

'std' నేమ్‌స్పేస్ కోడ్‌ను సులభతరం చేస్తుంది. ఇది ప్రామాణిక C++ లైబ్రరీలోని మూలకాలను “std::”తో ప్రిఫిక్స్ చేయకుండా వాటిని ఉపయోగించడానికి మిమ్మల్ని అనుమతిస్తుంది.

అక్షరాలు ('w', 'a', 'p', 'm', 's') కీలుగా మరియు సంబంధిత పూర్ణాంకాలతో (9, 6, 8, 3, 4) 'um' పేరుతో 'క్రమరహిత_మ్యాప్' సృష్టించబడింది. ) విలువలుగా.

“unordered_map”లోని “p” కీతో మూలకం కోసం వెతకడానికి find() ఫంక్షన్ ఉపయోగించబడుతుంది, ఇది “unomp”. 'ittr' ఇటరేటర్ గుర్తించబడిన మూలకాన్ని సూచిస్తుంది.

ఇటరేటర్ ద్వారా సూచించబడిన కంటెంట్ కన్సోల్‌కు ముద్రించబడుతుంది. ఇది ఈ సందర్భంలో కీ ('p') మరియు అనుబంధిత విలువ (8)ని ముద్రిస్తుంది.

ప్రోగ్రామ్ ముగుస్తుంది, విజయవంతమైన అమలును సూచించడానికి 0ని తిరిగి ఇస్తుంది.

మీ సూచన కోసం కోడ్ యొక్క అవుట్‌పుట్ క్రింది వాటిలో ఇవ్వబడింది:

ఈ కోడ్ unordered_map::find()ని సమర్థవంతంగా శోధించడానికి మరియు “unordered_map”లోని మూలకాలను యాక్సెస్ చేయడానికి ఉపయోగించే ఒక సాధారణ ఉదాహరణ. కనుగొనబడిన మూలకం యొక్క కీ మరియు అనుబంధిత విలువ రెండింటినీ యాక్సెస్ చేయడానికి ఇటరేటర్ అనుకూలమైన మార్గాన్ని అందిస్తుంది.

ఉదాహరణ 2:

ఇక్కడ unordered_map::find() ఫంక్షన్ యొక్క మరొక సాధారణ ఉదాహరణ. ఈ కోడ్ పూర్ణాంక కీలతో అనుబంధించబడిన బూలియన్ విలువలను నిల్వ చేయడానికి “unordered_map” వినియోగాన్ని ప్రదర్శిస్తుంది మరియు నిర్దిష్ట కీల ఉనికిని తనిఖీ చేయడానికి ఫైండ్() ఫంక్షన్‌ను ఉపయోగిస్తుంది. కింది కోడ్‌ని చూసి, అది ఎలా పని చేస్తుందో అర్థం చేసుకుందాం:

కోడ్ యొక్క వివరణాత్మక వివరణ ఇక్కడ ఉంది:

ఈ లైన్‌లో తరచుగా పోటీ ప్రోగ్రామింగ్‌లో ఉపయోగించే అత్యంత ప్రామాణికమైన C++ లైబ్రరీలను కవర్ చేసే హెడర్ ఫైల్ ఉంటుంది. అయితే, సాధారణ C++ డెవలప్‌మెంట్‌లో, నిర్దిష్ట హెడర్‌లను చేర్చాలని సిఫార్సు చేయబడింది.

పూర్ణాంకం కీలు మరియు బూలియన్ విలువలతో 'unomp' పేరుతో 'క్రమించని_మ్యాప్' సృష్టించబడింది.

కీ-విలువ జతలు “క్రమం చేయని_మ్యాప్”లోకి చొప్పించబడ్డాయి. ప్రతి కీ (పూర్ణాంకం) బూలియన్ విలువతో అనుబంధించబడి ఉంటుంది.

“unordered_map”లో నిర్దిష్ట కీల కోసం (67 మరియు 42) శోధించడానికి if-else షరతులో find() ఫంక్షన్ ఉపయోగించబడుతుంది. కీ కనుగొనబడితే, 'మూలకం కనుగొనబడింది' ముద్రించబడుతుంది. లేకపోతే, 'మూలకం కనుగొనబడలేదు' అని ముద్రించబడుతుంది. కింది అవుట్‌పుట్ చూడండి:

ఈ కోడ్ మ్యాప్‌లో నిర్దిష్ట కీల ఉనికిని లేదా లేకపోవడాన్ని గుర్తించడానికి “unordered_map” యొక్క ప్రాథమిక వినియోగాన్ని మరియు find() ఫంక్షన్‌ని ప్రదర్శిస్తుంది.

ఉదాహరణ 3:

రన్ టైమ్‌లో ఇన్‌పుట్ అందించడం ద్వారా విలువను కనుగొనడాన్ని ప్రదర్శించే మరొక ఉదాహరణను అన్వేషిద్దాం. ఈ సాధారణ ప్రోగ్రామ్ పేర్లను (కీలుగా) మరియు అనుబంధిత సంఖ్యా విలువలను (ఈ సందర్భంలో, కొన్ని లక్షణాలను సూచిస్తుంది) నిల్వ చేయడానికి “క్రమించని_మ్యాప్”ని ఉపయోగిస్తుంది. ఇది వినియోగదారుని పేరును నమోదు చేయమని, ఫైండ్() ఫంక్షన్‌ని ఉపయోగించి మ్యాప్‌లో ఆ పేరు కోసం శోధించమని మరియు పేరు కనుగొనబడితే అనుబంధిత విలువను ముద్రించమని అడుగుతుంది. మీ సూచన కోసం కోడ్ క్రింది వాటిలో ఇవ్వబడింది:

మీ అవగాహన కోసం క్రింది కోడ్ విచ్ఛిన్నం:

స్ట్రింగ్ కీలు (పేర్లు) మరియు ద్వంద్వ విలువలతో “unomp” పేరుతో “క్రమించని_మ్యాప్” సృష్టించబడింది.

స్క్రీన్‌పై పేరును నమోదు చేయమని వినియోగదారు ప్రాంప్ట్ చేయబడతారు మరియు ఇన్‌పుట్ “ఎవరు” స్ట్రింగ్ వేరియబుల్‌లో నిల్వ చేయబడుతుంది.

“unordered_map”లో నమోదు చేసిన పేరు కోసం వెతకడానికి find() ఫంక్షన్ ఉపయోగించబడుతుంది. ఫలితం 'fnd' ఇటరేటర్‌లో నిల్వ చేయబడుతుంది.

“fnd” ఇటరేటర్ “క్రమించని_మ్యాప్” (ముగింపు()) ముగింపుకు చేరుకున్నట్లయితే, పేరు కనుగొనబడలేదు మరియు “కనుగొనబడలేదు” అని ముద్రించబడిందని అర్థం. లేకపోతే, పేరు మరియు దాని అనుబంధ విలువ ముద్రించబడుతుంది. కోడ్ యొక్క అవుట్‌పుట్ ఇక్కడ ఉంది:

ఈ కోడ్ తప్పనిసరిగా “unordered_map”ని ఉపయోగించి సాధారణ పేరు శోధన సాధనంగా పనిచేస్తుంది. ఇది వినియోగదారు ఇన్‌పుట్‌ను తీసుకుంటుంది, మ్యాప్‌లో పేరు కోసం శోధిస్తుంది మరియు పేరు కనుగొనబడితే అనుబంధిత విలువను అందిస్తుంది.

ముగింపు

C++లోని unordered_map::find() ఫంక్షన్ “unordered_map” కంటైనర్‌లలోని మూలకాలను సమర్ధవంతంగా గుర్తించడానికి శక్తివంతమైన మెకానిజంను అందిస్తుంది. దాని స్థిరమైన సగటు సమయ సంక్లిష్టత కీ-విలువ జతలను వేగంగా యాక్సెస్ చేయవలసిన సందర్భాలలో శోధన కార్యకలాపాలకు ప్రాధాన్యతనిస్తుంది. అందించిన ఉదాహరణలు దాని ఆచరణాత్మక వినియోగాన్ని ప్రదర్శిస్తాయి, దాని సరళత మరియు ప్రభావాన్ని నొక్కిచెప్పాయి. ముగింపులో, unordered_map::find() ఫంక్షన్‌ను మాస్టరింగ్ చేయడం వలన 'క్రమించని_మ్యాప్' కంటైనర్‌ల యొక్క పూర్తి సామర్థ్యాన్ని ఉపయోగించుకునే C++ ప్రోగ్రామర్ సామర్థ్యాన్ని పెంచుతుంది, ఇది ఆప్టిమైజ్ చేయబడిన మరియు అధిక-పనితీరు గల అప్లికేషన్‌ల సృష్టికి దోహదపడుతుంది.