ఈ వివరాల ట్యుటోరియల్‌లో, మేము దాని పనిని చూపుతాము స్థిర_క్రమం() C++లో.
C++లో stable_sort() ఫంక్షన్‌ని ఎలా ఉపయోగించాలి
C++లో, ది స్థిర_క్రమం() అనేది ఒక ప్రామాణిక లైబ్రరీ అల్గోరిథం, ఇది మూలకాలను పెరుగుతున్న క్రమంలో అమర్చుతుంది మరియు సమానమైన మూలకాల కోసం అదే క్రమాన్ని ఉంచుతుంది. దీనర్థం, రెండు మూలకాలు సమానంగా ఉంటే, క్రమబద్ధీకరించే ముందు కంటైనర్‌లో మొదట కనిపించే మూలకం ఇప్పటికీ క్రమబద్ధీకరించబడిన జాబితాలో మొదటగా కనిపిస్తుంది. ఈ ఫంక్షన్ కంటైనర్‌ను పదేపదే విభజించడం ద్వారా పనిచేస్తుంది (శ్రేణులు, వెక్టర్స్, లింక్డ్ లిస్ట్‌లు), వాటిని విడిగా క్రమబద్ధీకరించడం మరియు క్రమబద్ధీకరించబడిన కంటైనర్‌ను పొందడానికి వాటిని విలీనం చేయడం. కింద వస్తుంది <అల్గోరిథం> శీర్షిక ఫైల్.
ఉపయోగించడానికి సాధారణ సింటాక్స్ స్థిర_క్రమం() C++లో ఉంది:
స్థిరమైన_క్రమం ( ముందుగా రాండమ్ యాక్సెస్ ఇటరేటర్ , RandomAccessIterator చివరిది ) ;
ఇక్కడ, ది ప్రధమ క్రమబద్ధీకరించవలసిన పరిధిలోని మొదటి మూలకాన్ని సూచించే ఇటరేటర్ మరియు ది చివరి క్రమబద్ధీకరించవలసిన పరిధిలోని చివరి మూలకం తర్వాత మూలకాన్ని సూచించే ఇటరేటర్.
ది స్థిర_క్రమం() ఫంక్షన్ [మొదటి, చివరి] పరిధిలోని ఎంట్రీలను క్రమబద్ధీకరించడానికి తగ్గని క్రమాన్ని ఉపయోగిస్తుంది, అనగా చిన్నది నుండి పెద్ద మూలకం వరకు. ఫంక్షన్ డిఫాల్ట్‌గా అంశాలను పోల్చి చూస్తుంది ఆపరేటర్ కంటే తక్కువ (<).
ఉదాహరణ 1
దిగువ ఉదాహరణ కోడ్‌ను పరిగణించండి, ఈ కోడ్‌లో, మేము సృష్టించాము వెక్టర్ జాబితా మరియు దానిని కొన్ని విలువలతో ప్రారంభించింది. తరువాత, మేము ఉపయోగించాము స్థిర_క్రమం() ఇచ్చిన వెక్టార్ విలువలను ఆరోహణ క్రమంలో క్రమబద్ధీకరించడానికి. క్రమబద్ధీకరించని మరియు క్రమబద్ధీకరించబడిన వెక్టర్‌లు పరిధి-ఆధారిత లూప్‌ని ఉపయోగించి కన్సోల్‌లో ముద్రించబడతాయి.
##
#
నేమ్‌స్పేస్ stdని ఉపయోగిస్తోంది ;
int ప్రధాన ( )
{
వెక్టర్ < int > జాబితా = { 5 , 2 , 25 , 4 , 9 , 33 , 38 , 26 } ;
కోట్ << 'క్రమబద్ధీకరించే ముందు సంఖ్యలు:' ;
ప్రతి ( జాబితా. ప్రారంభం ( ) , జాబితా. ముగింపు ( ) , [ ] ( int x ) {
కోట్ << x << '' ;
} ) ;
స్థిరమైన_క్రమం ( జాబితా. ప్రారంభం ( ) , జాబితా. ముగింపు ( ) ) ;
కోట్ << ' \n క్రమబద్ధీకరించిన తర్వాత సంఖ్యలు: ' ;
ప్రతి ( జాబితా. ప్రారంభం ( ) , జాబితా. ముగింపు ( ) , [ ] ( int x ) {
కోట్ << x << '' ;
} ) ;
తిరిగి 0 ;
}
ఉదాహరణ 2
క్రింద ఇవ్వబడిన ఉదాహరణలో, మేము పూర్ణాంక శ్రేణిని సృష్టించాము మరియు దానిని కొన్ని విలువలతో ప్రారంభించాము. అప్పుడు డిఫాల్ట్‌గా, ది స్థిర_క్రమం() మూలకాలను ఆరోహణ క్రమంలో క్రమబద్ధీకరిస్తుంది:
##
నేమ్‌స్పేస్ stdని ఉపయోగిస్తోంది ;
int ప్రధాన ( )
{
int అమరిక [ ] = { 12 , 7 , 7 , 1 , 8 , 7 , 3 , 4 , 22 , 0 } ;
int n = పరిమాణం ( అమరిక ) / పరిమాణం ( అమరిక [ 0 ] ) ;
కోట్ << 'అసలు శ్రేణి: \n ' ;
కోసం ( int i = 0 ; i < n ; ++ i ) {
కోట్ << అమరిక [ i ] << '' ;
}
స్థిరమైన_క్రమం ( అమరిక , అమరిక + n ) ;
కోట్ << ' \n క్రమబద్ధీకరించిన తర్వాత శ్రేణి: \n ' ;
కోసం ( int i = 0 ; i < n ; ++ i ) {
కోట్ << అమరిక [ i ] << '' ;
}
తిరిగి 0 ;
}
ఉదాహరణ 3
ది స్థిరమైన_క్రమం మూలకాన్ని క్రమబద్ధీకరించడానికి క్రమాన్ని పేర్కొనడానికి మూడవ పరామితిని తీసుకుంటుంది. దిగువ ఉదాహరణలో, మేము ఉపయోగించాము ఎక్కువ () తో ఫంక్షన్ స్థిర_క్రమం() శ్రేణి యొక్క మూలకాలను అవరోహణ క్రమంలో క్రమబద్ధీకరించడానికి
##
నేమ్‌స్పేస్ stdని ఉపయోగిస్తోంది ;
int ప్రధాన ( )
{
int అమరిక [ ] = { 12 , 7 , 7 , 1 , 8 , 7 , 3 , 4 , 22 , 0 } ;
int n = పరిమాణం ( అమరిక ) / పరిమాణం ( అమరిక [ 0 ] ) ;
కోట్ << 'అసలు శ్రేణి: \n ' ;
కోసం ( int i = 0 ; i < n ; ++ i ) {
కోట్ << అమరిక [ i ] << '' ;
}
స్థిరమైన_క్రమం ( అమరిక , అమరిక + n , ఎక్కువ < int > ( ) ) ;
కోట్ << ' \n క్రమబద్ధీకరించిన తర్వాత శ్రేణి: \n ' ;
కోసం ( int i = 0 ; i < n ; ++ i ) {
కోట్ << అమరిక [ i ] << '' ;
}
తిరిగి 0 ;
}
క్రింది గీత
ది స్థిర_క్రమం() C++లో ఫంక్షన్ అనేది ఒక కంటైనర్‌లోని మూలకాల యొక్క సాపేక్ష క్రమాన్ని అదే విలువలతో నిర్వహించేటప్పుడు తగ్గని క్రమంలో క్రమబద్ధీకరించడానికి ఉపయోగించే ఒక ప్రామాణిక లైబ్రరీ అల్గోరిథం. ఇది శ్రేణులు, వెక్టర్‌లు మరియు లింక్డ్ జాబితాల వంటి విభిన్న కంటైనర్‌లతో ఉపయోగించవచ్చు. అదనంగా, మూలకాలను క్రమబద్ధీకరించడానికి క్రమాన్ని పేర్కొనడానికి ఇది మూడవ పరామితిని తీసుకుంటుంది.