C++ జంటల వెక్టర్‌ను ప్రదర్శించడానికి మరియు జతల వెక్టర్‌ను క్రమబద్ధీకరించడానికి సదుపాయాన్ని అందిస్తుంది. C++లో ఒక కంటైనర్ ఉంది, అది ఒకదానికొకటి మ్యాప్ చేయబడిన 'జత' మరియు 'వెక్టర్ ఆఫ్ జతల' అని పిలువబడే రెండు విలువలను కలిగి ఉంటుంది, ఇది ఈ జతలలో చాలా వరకు ఉన్న వెక్టర్. సార్టింగ్ అంటే అవసరాలకు అనుగుణంగా డేటాను ఆరోహణ లేదా అవరోహణ క్రమంలో అమర్చడం. ఇక్కడ, C++ ప్రోగ్రామింగ్‌లో జతల వెక్టర్‌ను ఎలా క్రమబద్ధీకరించాలో నేర్చుకుంటాము. మేము C++లో 'ఆరోహణ' మరియు 'అవరోహణ' ఆర్డర్‌లలో జతల వెక్టర్‌ను క్రమబద్ధీకరించవచ్చు. “sort()” పద్ధతిని ఉపయోగించడం ద్వారా మనం జతల వెక్టర్‌ను సులభంగా క్రమబద్ధీకరించవచ్చు. జతల వెక్టర్‌ను క్రమబద్ధీకరించడానికి ఇక్కడ కొన్ని కోడ్‌లను చేద్దాం.
ఉదాహరణ 1:
ఇక్కడ 'bits/stdc++.h' అనే హెడర్ ఫైల్‌ని చేర్చడం ద్వారా కోడ్‌ను ప్రారంభిద్దాం. ఈ హెడర్ ఫైల్‌ని కలిగి ఉన్న తర్వాత, అవసరమైన అన్ని లైబ్రరీలను కలిగి ఉన్నందున మేము మరిన్ని హెడర్ ఫైల్‌లను చేర్చాల్సిన అవసరం లేదు. అప్పుడు, మేము “std” నేమ్‌స్పేస్‌ని జోడించి, “main()” ఫంక్షన్‌ని పిలుస్తాము.
ఇప్పుడు, మేము 'my_vect' పేరుతో 'పెయిర్ల వెక్టర్'ని ప్రకటిస్తాము మరియు 'int' డేటా రకాన్ని ఉంచుతాము కాబట్టి ఈ జతలలో మనం నమోదు చేసే డేటా 'పూర్ణాంకం' డేటా రకం. దీని క్రింద, మేము “my_arr1[]” మరియు “my_arr2[]” పేర్లతో రెండు శ్రేణులను ప్రారంభిస్తాము. ఇక్కడ, మేము ఈ శ్రేణి విలువలతో జతల మొదటి మరియు రెండవ విలువలను ప్రారంభిస్తాము. అప్పుడు, మేము ఈ విలువలను జతల వెక్టర్‌లోకి నమోదు చేయడానికి “ఫర్” లూప్‌ని ఉపయోగిస్తాము. ఇక్కడ, మేము వెక్టార్ చివరిలో విలువలను చొప్పించడంలో సహాయపడే “పుష్_బ్యాక్()” ఫంక్షన్‌ని ఉపయోగిస్తాము. ఈ ఫంక్షన్ లోపల, మేము “make_pair” ఎంపికను ఉంచుతాము, ఇది “my_arr1” మరియు “my_arr2” యొక్క రెండు విలువల జత ఆబ్జెక్ట్‌ను నిర్మించడానికి ఉపయోగించబడుతుంది.
దీని తరువాత, మేము మళ్ళీ 'ఫర్' లూప్‌ని ఉపయోగించడం ద్వారా జతల వెక్టర్‌ను ప్రింట్ చేస్తాము. ఇక్కడ, జతల వెక్టర్ యొక్క మొదటి మరియు రెండవ విలువలను పొందడానికి 'మొదటి' మరియు 'రెండవ' కీలకపదాలు జోడించబడతాయి. ఇది ఇక్కడ క్రమబద్ధీకరించకుండా జతల వెక్టర్‌ను ప్రింట్ చేస్తుంది. ఇప్పుడు, మేము జతల వెక్టర్‌ను క్రమబద్ధీకరించడానికి “sort()” ఫంక్షన్‌ని ఉపయోగిస్తాము. ఇక్కడ, 'బిగిన్()' మరియు 'ఎండ్()' ఫంక్షన్‌లు ఈ 'సార్ట్()' ఫంక్షన్‌కు జతల వెక్టర్ యొక్క ప్రారంభ మరియు ముగింపును ఆమోదించినట్లుగా ఉపయోగించబడతాయి.
క్రమబద్ధీకరించిన తర్వాత, మేము 'కౌట్'ని ఉపయోగించడం ద్వారా జంటల వెక్టర్‌ను మళ్లీ ప్రింట్ చేస్తాము మరియు మొదటి మరియు రెండవ కీలకపదాలను 'my_vec[i]'తో ఉంచుతాము. ఇప్పుడు, జతల క్రమబద్ధీకరించబడిన వెక్టర్ కూడా ఇక్కడ ముద్రించబడింది.
కోడ్ 1:
#includeనేమ్‌స్పేస్ stdని ఉపయోగించడం;
పూర్ణాంక ప్రధాన ( )
{
వెక్టర్ < జత < మీరు, మీరు > > నా_వెక్ట్;
int my_arr1 [ ] = { 49 , ఇరవై , పదిహేను , 56 } ;
int my_arr2 [ ] = { 37 , ఇరవై , 90 , 55 } ;
int num = పరిమాణం ( my_arr1 ) / పరిమాణం ( my_arr1 [ 0 ] ) ;
కోసం ( int i = 0 ; i < ఉందొ లేదో అని i++ )
my_vect.push_back ( తయారు_జత ( my_arr1 [ i ] ,my_arr2 [ i ] ) ) ;
కోట్ << 'జతల వెక్టర్‌ను క్రమబద్ధీకరించే ముందు:' << endl;
కోసం ( int i = 0 ; i < ఉందొ లేదో అని i++ )
{
కోట్ << నా_వెక్ట్ [ i ] .ప్రధమ << ''
<< నా_వెక్ట్ [ i ] .రెండవ << endl;
}
క్రమబద్ధీకరించు ( my_vect.begin ( ) , my_vect.end ( ) ) ;
కోట్ << ' \n జతల వెక్టర్‌ను క్రమబద్ధీకరించిన తర్వాత: ' << endl ;
కోసం ( int i = 0 ; i < ఉందొ లేదో అని i++ )
{
కోట్ << నా_వెక్ట్ [ i ] .ప్రధమ << ''
<< నా_వెక్ట్ [ i ] .రెండవ << endl;
}
తిరిగి 0 ;
}
అవుట్‌పుట్:
క్రమబద్ధీకరించడానికి ముందు జతల వెక్టర్ మొదట ప్రదర్శించబడుతుంది. అప్పుడు, మేము ఈ జంటల వెక్టర్‌పై సార్టింగ్ టెక్నిక్‌ని వర్తింపజేస్తాము. అప్పుడు, జతల క్రమబద్ధీకరించబడిన వెక్టర్ కూడా ఇక్కడ ప్రదర్శించబడుతుంది. జత యొక్క మొదటి మూలకం ఆధారంగా జతల వెక్టర్ ఆరోహణ క్రమంలో క్రమబద్ధీకరించబడిందని మనం చూడవచ్చు.
ఉదాహరణ 2:
ఈ ఉదాహరణలో, మేము ఇప్పుడు “వెక్టార్_1” అని పిలువబడే “పెయిర్ల వెక్టర్”ని సృష్టిస్తాము మరియు “పూర్ణాంక” డేటా రకాన్ని కేటాయిస్తాము అంటే ఈ జతలలో మనం నమోదు చేసే సమాచారం “పూర్ణాంకం” డేటా రకానికి చెందినదని అర్థం. “first_arr[]” మరియు “second_arr[]” పేర్లతో రెండు శ్రేణులు కింది వాటిలో ప్రారంభించబడ్డాయి. ఇక్కడ, మేము మొదటి మరియు రెండవ జతల విలువల కోసం ఈ శ్రేణుల విలువలను ప్రారంభిస్తాము.
తరువాత, మేము ఈ విలువలను 'ఫర్' లూప్ ఉపయోగించి జతల వెక్టర్‌లోకి నమోదు చేస్తాము. “make_pair” ఎంపిక, “first_arr[]” మరియు “second_arr[]” శ్రేణుల నుండి రెండు విలువల జత వస్తువును రూపొందించడానికి ఉపయోగించబడుతుంది, ఇది “push_back()” పద్ధతిలో ఉంచబడుతుంది, ఇది వెక్టర్ ముగింపు.
తరువాత, జంటల వెక్టర్‌ను అవుట్‌పుట్ చేయడానికి మేము మరోసారి 'ఫర్' లూప్‌ని ఉపయోగిస్తాము. జతల వెక్టర్ యొక్క మొదటి మరియు రెండవ విలువలను పొందడానికి, 'మొదటి' మరియు 'రెండవ' కీలకపదాలు చొప్పించబడతాయి. ఈ సమయంలో ఎటువంటి క్రమబద్ధీకరణ లేకుండా ఇది జత వెక్టర్‌ను అవుట్‌పుట్ చేస్తుంది. మేము ఇప్పుడు అవరోహణ క్రమంలో 'sort()' ఫంక్షన్‌ని ఉపయోగించడం ద్వారా 'జతల వెక్టర్'ని క్రమబద్ధీకరిస్తాము. ఈ ఫంక్షన్‌లో, మేము “rbegin()” మరియు “rend()” ఫంక్షన్‌లను ఉంచుతాము, కనుక ఇది సార్టింగ్‌ను రివర్స్ చేస్తుంది మరియు జత విలువల ముగింపు నుండి ప్రారంభమవుతుంది. ఇది వాటిని అవరోహణ క్రమంలో అమర్చుతుంది.
క్రమబద్ధీకరణను అనుసరించి, 'కౌట్'లో 'వెక్టర్_1[i]'తో మొదటి మరియు రెండవ కీలకపదాలను చొప్పించి, మరోసారి 'ఫర్' లూప్‌ని ఉపయోగించిన తర్వాత జంటల వెక్టర్‌ను అవుట్‌పుట్ చేయడానికి 'కౌట్'ని ఉపయోగిస్తాము. ఇక్కడే జతల క్రమబద్ధీకరించబడిన వెక్టర్ కూడా ముద్రించబడుతుంది.
కోడ్ 2:
#నేమ్‌స్పేస్ stdని ఉపయోగించడం;
పూర్ణాంక ప్రధాన ( )
{
వెక్టర్ < జత < మీరు, మీరు > > వెక్టర్_1;
int మొదటి_arr [ ] = { 77 , 29 , 97 , పదిహేను } ;
int second_arr [ ] = { 35 , 89 , 64 , 25 } ;
int s = పరిమాణం ( మొదటి_arr ) / పరిమాణం ( మొదటి_arr [ 0 ] ) ;
కోసం ( int i = 0 ; i < లు; i++ )
వెక్టర్_1.పుష్_బ్యాక్ ( తయారు_జత ( మొదటి_arr [ i ] , second_arr [ i ] ) ) ;
కోట్ << 'క్రమబద్ధీకరణకు ముందు:' << endl;
కోసం ( int i = 0 ; i < లు; i++ ) {
కోట్ << వెక్టర్_1 [ i ] .ప్రధమ << '' << వెక్టర్_1 [ i ] .రెండవ
<< endl;
}
క్రమబద్ధీకరించు ( vector_1.rbegin ( ) , vector_1.rend ( ) ) ;
కోట్ << endl << 'క్రమబద్ధీకరించిన తర్వాత:' << endl;
కోసం ( int i = 0 ; i < లు; i++ ) {
కోట్ << వెక్టర్_1 [ i ] .ప్రధమ << '' << వెక్టర్_1 [ i ] .రెండవ
<< endl;
}
తిరిగి 0 ;
}
అవుట్‌పుట్:
జంటల ప్రీ-సార్ట్ వెక్టార్ మొదట ఇక్కడ చూపబడింది, దాని తర్వాత సార్టింగ్ ప్రక్రియ వర్తింపజేసిన తర్వాత జంటల క్రమబద్ధీకరించబడిన వెక్టర్ ఇక్కడ చూపబడుతుంది. మనం చూడగలిగినట్లుగా, ప్రతి జత యొక్క ప్రారంభ మూలకం జతల వెక్టర్ అవరోహణ క్రమంలో ఎలా క్రమబద్ధీకరించబడుతుందో నిర్ణయిస్తుంది.
ఉదాహరణ 3:
ఇక్కడ, మేము వెక్టార్ సంఖ్యలను క్రమబద్ధీకరించడానికి 'sortBySecElement' పేరుతో 'bool' రకం ఫంక్షన్‌ని సృష్టిస్తాము. ఈ ఫంక్షన్‌లో, మేము 'value1.second అప్పుడు, మేము జతల వెక్టర్‌ను సృష్టించే కింది వాటిలో “ప్రధాన()” ప్రారంభించబడుతుంది. కిందివి “new_array1[]” మరియు “new_aray2[]” అనే రెండు శ్రేణులను ప్రారంభిస్తాయి. ఇక్కడ, మేము ఈ శ్రేణులలో జతల విలువలను ఇన్సర్ట్ చేస్తాము. తరువాత, మేము ఈ విలువలను జతల వెక్టర్‌లోకి ఇన్‌పుట్ చేయడానికి “ఫర్” లూప్‌ని ఉపయోగిస్తాము. వెక్టార్ చివరిలో ఐటెమ్‌లను ఇన్సర్ట్ చేయడంలో సహాయపడే “పుష్_బ్యాక్()” పద్ధతి లోపల, “make_pair” ఎంపిక “new_array1[]” మరియు “new_array2[ నుండి రెండు విలువల జత వస్తువును సృష్టించడానికి ఉపయోగించబడుతుంది. ]” శ్రేణులు. మేము మరొక 'ఫర్' లూప్ ఉపయోగించి జతల వెక్టర్‌ను అవుట్‌పుట్ చేస్తాము. జతల వెక్టర్ యొక్క మొదటి మరియు రెండవ విలువలను పొందడానికి 'మొదటి' మరియు 'రెండవ' కీవర్డ్‌లు చొప్పించబడతాయి. ఈ దశలో క్రమబద్ధీకరణ జరగదు మరియు జత వెక్టర్ అవుట్‌పుట్ చేయబడింది. క్రమబద్ధీకరించడానికి మనం ఇప్పుడు “sort()” ఫంక్షన్‌ని ఉపయోగిస్తాము. జంటల వెక్టార్ యొక్క ప్రారంభం మరియు ముగింపు ఈ సందర్భంలో 'బిగిన్()' మరియు 'ఎండ్()' ఫంక్షన్ల ద్వారా 'సార్ట్()' ఫంక్షన్‌కు సరఫరా చేయబడతాయి. మేము ఈ “sort()” ఫంక్షన్‌లో గతంలో సృష్టించిన “sortBySecElement” ఫంక్షన్‌ను కూడా ఉంచుతాము, ఇక్కడ మేము వెక్టర్ యొక్క రెండవ మూలకం నుండి జతల వెక్టర్‌ను క్రమబద్ధీకరించే నమూనాను ఆరోహణ క్రమంలో సెట్ చేస్తాము. ఇప్పుడు, మేము మళ్ళీ 'ఫర్' లూప్‌ని ఉపయోగిస్తాము. ఆపై, క్రమబద్ధీకరించిన తర్వాత మళ్లీ జతల వెక్టర్‌ను ఉత్పత్తి చేయడానికి మొదటి మరియు రెండవ కీలకపదాలు “cout”లో “new_vec[i]”తో చొప్పించబడతాయి. ఆరోహణ క్రమంలో జతల క్రమబద్ధీకరించబడిన వెక్టర్ ఇప్పుడు ముద్రించబడిన ప్రదేశం కూడా ఇక్కడే. కోడ్ 3: అవుట్‌పుట్: ఇక్కడ, జతల యొక్క క్రమబద్ధీకరించబడిన వెక్టర్ ప్రదర్శించబడుతుంది మరియు జతల రెండవ విలువల ప్రకారం సార్టింగ్ జరుగుతుంది. జతల యొక్క రెండవ మూలకం ఆరోహణ క్రమంలో నిల్వ చేయబడుతుంది మరియు ఇక్కడ ప్రదర్శించబడుతుంది. ఈ గైడ్ అంతా C++లోని “జతల క్రమబద్ధీకరణ వెక్టర్” గురించినది. మేము 'జతల వెక్టర్'ని క్రమబద్ధీకరించకుండా అలాగే 'జతల వెక్టర్'ని ఆరోహణ మరియు అవరోహణ క్రమంలో క్రమబద్ధీకరించకుండా అన్వేషించాము. మేము C++ ప్రోగ్రామింగ్‌లో ఈ జతల మొదటి మరియు రెండవ సంఖ్యల ప్రకారం “పెయిర్ల వెక్టర్”ని క్రమబద్ధీకరించే ఉదాహరణలతో దీనిని వివరించాము. ఈ సార్టింగ్ చేయడంలో “sort()” పద్ధతి సహాయపడుతుందని మేము తెలుసుకున్నాము.
నేమ్‌స్పేస్ stdని ఉపయోగించడం;
bool sortBySecElement ( const జత < మీరు, మీరు > & విలువ1,
const జత < మీరు, మీరు > & విలువ2 )
{
తిరిగి ( విలువ1.సెకను < విలువ2.సెకను ) ;
}
పూర్ణాంక ప్రధాన ( )
{
వెక్టర్ < జత < మీరు, మీరు > > కొత్త_విషయం
int new_arr1 [ ] = { 3. 4 , 29 , 65 , 48 } ;
int new_arr2 [ ] = { 67 , 19 , 54 , 7 } ;
int value = పరిమాణం ( కొత్త_arr1 ) / పరిమాణం ( కొత్త_arr1 [ 0 ] ) ;
కోసం ( int i = 0 ; i < విలువ; i++ )
new_vec.push_back ( తయారు_జత ( కొత్త_arr1 [ i ] ,new_arr2 [ i ] ) ) ;
కోట్ << 'క్రమబద్ధీకరణకు ముందు:' << endl ;
కోసం ( int i = 0 ; i < విలువ; i++ )
{
కోట్ << కొత్త_విషయం [ i ] .ప్రధమ << ''
<< కొత్త_విషయం [ i ] .రెండవ << endl;
}
క్రమబద్ధీకరించు ( new_vec.begin ( ) , new_vec.end ( ) , sortBySecElement ) ;
కోట్ << endl << 'క్రమబద్ధీకరించిన తర్వాత:' << endl ;
కోసం ( int i = 0 ; i < విలువ; i++ )
{
కోట్ << కొత్త_విషయం [ i ] .ప్రధమ << ''
<< కొత్త_విషయం [ i ] .రెండవ << endl;
}
తిరిగి 0 ;
}
ముగింపు