ఈ సమగ్ర గైడ్‌లో, మేము ప్రోగ్రామ్‌తో C++లో “lexicographical_compare()” ఫంక్షన్‌ని ప్రదర్శిస్తాము.
C++లో “lexicographical_compare()” ఫంక్షన్ అంటే ఏమిటి
C++లో, “లెక్సికోగ్రాఫికల్_కంపేర్()” ఫంక్షన్ అనేది ఒక క్రమంలో (లెక్సికోగ్రాఫికల్ ఆర్డర్)లోని ఎలిమెంట్‌లను పోల్చడానికి మరియు క్రమబద్ధీకరించడానికి చాలా ప్రభావవంతమైన ఆపరేషన్. ఇది పరిధులు మరియు స్ట్రింగ్‌ల వంటి శ్రేణులను పోల్చడం వల్ల వచ్చే సంబంధిత క్రమాన్ని నిర్ణయించే సౌకర్యాన్ని అందిస్తుంది. ''ని ఉపయోగించడం ద్వారా ఈ ఫంక్షన్ C++లో అందుబాటులో ఉంటుంది <అల్గోరిథం> ”హెడర్ ఫైల్.
వాక్యనిర్మాణం
C++లో “lexicographical_compare()” ఫంక్షన్ యొక్క సింటాక్స్ ఇక్కడ ఉంది:
టెంప్లేట్ < తరగతి ఇన్‌పుట్‌ఇటర్1, తరగతి ఇన్‌పుట్‌ఇటర్2 >
బూల్ lexicographical_compare ( InputIter1 first1, InputIter1 last1, InputIter2 first2, InputIter2 last2 ) ;
పైన అందించిన కోడ్ ప్రకారం, ' lexicographical_compare() 'ఫంక్షన్ రెండు జతల పరిధులను అంగీకరిస్తుంది' మొదటి 1 'మరియు' చివరి 1 'మొదటి శ్రేణికి ఇన్‌పుట్ ఇటరేటర్లు మరియు ' మొదటి 2 'మరియు' చివరి 2 ”రెండో శ్రేణికి ఇన్‌పుట్ ఇటరేటర్లు. ఇది లెక్సికోగ్రాఫికల్ క్రమంలో రెండు శ్రేణి మూలకాలకు సరిపోలుతుంది.
రిటర్న్ రకం: ఇది బూలియన్ విలువను అందిస్తుంది (నిజం లేదా తప్పు). మొదటి పరిధి రెండవ పరిధి కంటే నిఘంటుపరంగా చిన్నది అయినప్పుడు అది ఒప్పు అని తిరిగి వస్తుంది లేకుంటే తప్పుని అందిస్తుంది.
మినహాయింపులు: పోలిక సమయంలో లోపం కనుగొనబడితే అది మినహాయింపును విసురుతుంది.
lexicographical_compare() ఫంక్షన్ C++ని ఉపయోగించి వెక్టర్లను ఎలా క్రమబద్ధీకరించాలి
మూలకం యొక్క క్రమాన్ని కనుగొనడానికి క్రమబద్ధీకరణ పద్ధతులలో “lexicographical_compare()” ఫంక్షన్ తరచుగా ఉపయోగించబడుతుంది. ఇది పరిధి పూర్తయ్యే వరకు మూలకాల యొక్క సంబంధిత క్రమానికి సరిపోలుతుంది.
లెక్సికోగ్రాపికల్_కంపేర్() ఫంక్షన్ క్రమబద్ధీకరణ మరియు స్ట్రింగ్ వెక్టర్లను సరిపోల్చడానికి ఉదాహరణ
'ని ప్రదర్శించే అందించిన ఉదాహరణను చూద్దాం. క్రమబద్ధీకరించు() 'తో పద్ధతి' lexicographical_compare() ”:
##
#
ఉపయోగించి నేమ్‌స్పేస్ std ;
ఇక్కడ:
- '
” అనేది ఇన్‌పుట్ మరియు అవుట్‌పుట్ ఆపరేషన్‌ల కోసం ఉపయోగించబడుతుంది.
' <వెక్టర్> ” అనేది C++ ప్రామాణిక లైబ్రరీ కంటైనర్ క్లాస్ మరియు డైనమిక్ అర్రే సామర్థ్యాలను అందించే టెంప్లేట్‌లను పట్టుకోవడానికి ఉపయోగించబడుతుంది.
- ' <అల్గోరిథం> 'లెక్సికోగ్రాఫికల్_కంపేర్()' ఫంక్షన్ కోసం 'సార్ట్()' పద్ధతిని యాక్సెస్ చేయడానికి హెడర్ ఫైల్ ఉపయోగించబడుతుంది.
- ' నేమ్‌స్పేస్ stdని ఉపయోగిస్తోంది ” అనేది “std” ఉపసర్గను స్పష్టంగా పేర్కొనకుండా నేమ్‌స్పేస్ నుండి అన్ని పేర్లను ఉపయోగించే నిర్దేశకంగా సూచించబడుతుంది.
తరువాత, లోపల ' ప్రధాన () 'ఫంక్షన్, మేము రెండు వెక్టర్లను ప్రారంభించాము' vect1 'మరియు' vect2 ” అదే తీగతో. దీని తరువాత, ఉపయోగించబడింది ' క్రమబద్ధీకరించు() 'రెండు వెక్టర్స్ యొక్క లెక్సికోగ్రాఫికల్ క్రమంలో మూలకాలను క్రమబద్ధీకరించే పద్ధతి' vect1.begin() 'మరియు' vector1.end() ”ఇటరేటర్లు “వెక్ట్1” మరియు “ కోసం శ్రేణి vect2.begin() 'మరియు' vect2.end() 'vect2' కోసం 'పరిధి. అప్పుడు, ' lexicographical_compare() 'రెండు వెక్టర్స్ కోసం నాలుగు ఆర్గ్యుమెంట్‌లను తీసుకునే ఫంక్షన్.
ఫలితాలు ఇలా సేవ్ చేయబడతాయి ' బూల్ '' అని టైప్ చేయండి ఫలితం ”వేరియబుల్ మరియు “vect1” పరిధి నిఘంటుపరంగా “vect2” పరిధి కంటే తక్కువగా ఉంటే ఒప్పు అని తిరిగి ఇవ్వండి మరియు లేకపోతే తప్పు. చివరగా, వర్తించు ' ఉంటే ” ఫలితాలను ప్రదర్శించడానికి ప్రకటన. ఒకవేళ ' ఫలితం ” నిజమే అంటే “వెక్ట్1” నిఘంటుపరంగా “ > 'వెక్ట్2' కంటే. లేకపోతే, ఇతర షరతు అమలు చేయబడుతుంది:
int ప్రధాన ( ) {వెక్టర్ < స్ట్రింగ్ > vect1 = { 'వసంత' , 'వేసవి' , 'శరదృతువు' , 'శీతాకాలం' } ;
వెక్టర్ < స్ట్రింగ్ > vect2 = { 'వసంత' , 'వేసవి' } ;
క్రమబద్ధీకరించు ( vect1. ప్రారంభం ( ) , vect1. ముగింపు ( ) ) ;
క్రమబద్ధీకరించు ( vect2. ప్రారంభం ( ) , vect2. ముగింపు ( ) ) ;
// lexicographical_compare()ని ఉపయోగించి రెండు వెక్టర్లను సరిపోల్చండి
బూల్ ఫలితం = lexicographical_compare (
vect1. ప్రారంభం ( ) , vect1. ముగింపు ( ) ,
vect2. ప్రారంభం ( ) , vect2. ముగింపు ( )
) ;
ఉంటే ( ఫలితం ) {
కోట్ << 'vect1 నిఘంటువు పరంగా vect2 కంటే ఎక్కువ' << endl ;
} లేకపోతే ఉంటే ( lexicographical_compare (
vect2. ప్రారంభం ( ) , vect2. ముగింపు ( ) ,
vect1. ప్రారంభం ( ) , vect1. ముగింపు ( )
) ) {
కోట్ << 'Vect1 నిఘంటువు vect2 కంటే తక్కువ' << endl ;
} లేకపోతే {
కోట్ << 'vect1 అనేది నిఘంటువుపరంగా vect2కి సమానం' << endl ;
}
తిరిగి 0 ;
}
అవుట్‌పుట్
అంతే! మీరు ' గురించి తెలుసుకున్నారు lexicographical_compare() C++లో ఫంక్షన్.
ముగింపు
C++లో, లెక్సికల్ క్రమంలో మూలకాల క్రమాన్ని క్రమబద్ధీకరించడానికి మరియు సరిపోల్చడానికి “lexicographical_compare()” ఫంక్షన్ ఉపయోగించబడుతుంది. సాపేక్ష క్రమాన్ని కనుగొనడానికి “lexicograpgical_compare()” పద్ధతితో సార్టింగ్ అల్గోరిథం విస్తృతంగా అమలు చేయబడుతుంది. ఈ ట్యుటోరియల్‌లో, మేము C++లో “lexicographical_compare()” ఫంక్షన్‌ని ప్రదర్శించాము.