సి ++ లో క్రమబద్ధీకరణ ఫంక్షన్‌ను ఎలా అమలు చేయాలి?

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

ఈ వ్యాసంలో క్రింది గమనికలు కవర్ చేయబడతాయి:

• క్రమబద్ధీకరించు () ఫంక్షన్
• ఉదాహరణ- ఆరోహణ క్రమంలో డేటాను క్రమబద్ధీకరించడానికి
• ఉదాహరణ - అవరోహణ క్రమంలో డేటాను క్రమబద్ధీకరించడానికి
• పాక్షిక_సోర్ట్

C ++ లో క్రమబద్ధీకరణ పనితీరుపై ఈ కథనంతో కదులుతోంది

క్రమబద్ధీకరించు ( ) ఫంక్షన్

ఇది అల్గోరిథం హెడర్ ఫైల్ యొక్క అంతర్నిర్మిత ఫంక్షన్, ఇది ఒక శ్రేణి, వెక్టర్స్ వంటి కంటైనర్లను పేర్కొన్న క్రమంలో క్రమబద్ధీకరించడానికి ఉపయోగించబడుతుంది. అంతర్గతంగా ఈ ఫంక్షన్ త్వరిత-క్రమబద్ధీకరణగా అమలు చేయబడుతుంది
క్విక్సోర్ట్ ఒక విభజన మరియు జయించే అల్గోరిథం. క్విక్సోర్ట్ మొదట మూలకాల యొక్క పెద్ద జాబితాను రెండు చిన్న ఉప-జాబితాలుగా విభజిస్తుంది: దిగువ మూలకాలు మరియు అధిక మూలకాలు. క్విక్సోర్ట్ ఉప-జాబితాలను పునరావృతంగా క్రమబద్ధీకరిస్తుంది.

దశలు క్రింది విధంగా ఉన్నాయి:
1. జాబితా నుండి పైవట్ అని పిలువబడే యాదృచ్ఛిక మూలకాన్ని (సాధారణంగా చివరి మూలకం) ఎంచుకోండి.
2. పైవట్ కంటే తక్కువ విలువలతో ఉన్న అన్ని మూలకాలు పివట్ ముందు వచ్చే విధంగా జాబితాను క్రమాన్ని మార్చండి, అయితే పివట్ కంటే ఎక్కువ విలువలతో ఉన్న అన్ని మూలకాలు దాని తరువాత వస్తాయి మరియు సమాన విలువలు ఏ విధంగానైనా వెళ్ళవచ్చు ఈ ప్రక్రియను విభజన ఆపరేషన్ అంటారు.
3. తక్కువ మూలకాల యొక్క ఉప-జాబితాను మరియు ఎక్కువ మూలకాల యొక్క ఉప-జాబితాను పునరావృతంగా క్రమబద్ధీకరించండి, మళ్ళీ ఉప-జాబితాలో ఒక పైవట్‌ను ఎంచుకుని వాటిని విభజించండి.
పునరావృతం యొక్క మూల కేసు పరిమాణం సున్నా లేదా ఒకటి యొక్క జాబితాలు, వీటిని ఎప్పుడూ క్రమబద్ధీకరించాల్సిన అవసరం లేదు మరియు వాటిని కలపడం ద్వారా మన జాబితాను క్రమబద్ధీకరిస్తాము.

చొప్పించడం క్రమబద్ధీకరణ లేదా బబుల్ క్రమబద్ధీకరణ వంటి ఇతర O (n log n) అల్గోరిథంల కంటే క్విక్‌సోర్ట్ ఆచరణలో వేగంగా ఉంటుంది. క్విక్స్‌పోర్ట్‌ను ఇన్-ప్లేస్ విభజన అల్గోరిథంతో అమలు చేయవచ్చు, అంటే మొత్తం క్రమబద్ధీకరణ O (లాగ్ n) అదనపు స్థలంతో మాత్రమే చేయవచ్చు. క్విక్స్పోర్ట్ స్థిరమైన విధమైనది కాదు.
దీని సంక్లిష్టత క్రింది విధంగా ఉంది:
ఉత్తమ కేసు - O (n log n)
చెత్త కేసు - O (n ^ 2)
సగటు కేసు - O (n log n)

సింటాక్స్:
క్రమబద్ధీకరించు (మొదటి, చివరి)
ఇక్కడ,
మొదటిది - క్రమబద్ధీకరించవలసిన పరిధిలోని మొదటి మూలకం యొక్క సూచిక (పాయింటర్).
చివరిది - క్రమబద్ధీకరించవలసిన పరిధిలోని చివరి మూలకం యొక్క సూచిక (పాయింటర్).
ఉదాహరణకు, మేము శ్రేణి ‘అర్ర్’ యొక్క మూలకాలను 1 నుండి 10 స్థానాలకు క్రమబద్ధీకరించాలనుకుంటున్నాము, మేము క్రమబద్ధీకరణను ఉపయోగిస్తాము (arr, arr + 10) మరియు ఇది ఆరోహణ క్రమంలో 10 అంశాలను క్రమబద్ధీకరిస్తుంది.
తిరిగి విలువ
ఏదీ లేదు

సంక్లిష్టత

జావా అనేది ఒక సంబంధం

ఒక విధమైన సంక్లిష్టత యొక్క సగటు N * log2 (N), ఇక్కడ N = చివరిది - మొదటిది.

డేటా పరిధి
పరిధిలోని వస్తువు [మొదటి, చివరి) సవరించబడింది.

మినహాయింపులు
టెంప్లేట్ పరామితితో ఓవర్‌లోడ్‌లు ఈ క్రింది విధంగా ఎగ్జిక్యూషన్పాలిసి రిపోర్ట్ లోపాలు:
అల్గోరిథం మెమరీని కేటాయించడంలో విఫలమైతే, std :: bad_alloc మినహాయింపుగా విసిరివేయబడుతుంది.
అల్గోరిథంలో భాగంగా అమలు చేయబడిన ఫంక్షన్ యొక్క అమలు అది మినహాయింపును విసిరితే std :: ముగించండి.

C ++ లో క్రమబద్ధీకరణ పనితీరుపై ఈ కథనంతో కదులుతోంది

ఉదాహరణ - ఆరోహణ క్రమంలో డేటాను క్రమబద్ధీకరించడానికి:

# నేమ్‌స్పేస్‌ను ఉపయోగించడం చేర్చండి std int main () {int array [] = {10, 35, 85, 93, 62, 77, 345, 43, 2, 10} int n = sizeof (array) / sizeof (array [0] ) // 'sizeof' మొత్తం శ్రేణి యొక్క పరిమాణాన్ని ఇస్తుంది, అంటే ప్రతి అక్షరం యొక్క పరిమాణం * లేదు. అక్షరాల // కాబట్టి సంఖ్య పొందడానికి. అక్షరాల // మేము శ్రేణి యొక్క ఏదైనా ఒక అక్షరం యొక్క పరిమాణంతో సైజుఆఫ్ (శ్రేణి) ను విభజిస్తాము // ఇక్కడ ఇది శ్రేణి [0] క్రమబద్ధీకరణ (శ్రేణి, శ్రేణి + ఎన్) కౌట్<< 'nArray after sorting using ' 'default sort is : n' for (int i = 0 i < n ++i) cout << array[i] << ' ' return 0 } 

అవుట్పుట్:

వివరణ

పై ఉదాహరణ నుండి, ఆ విధమైన () ఫంక్షన్ అప్రమేయంగా ఒక శ్రేణిని ఆరోహణ క్రమంలో క్రమబద్ధీకరిస్తుంది.

C ++ లో క్రమబద్ధీకరణ పనితీరుపై ఈ కథనంతో కదులుతోంది

ఉదాహరణ - డేటాను అవరోహణ క్రమంలో క్రమబద్ధీకరించడానికి:

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

# నేమ్‌స్పేస్‌ను ఉపయోగించడం చేర్చండి std int main () {int array [] = {41, 53, 4, 459, 60, 7, 23, 4, 232, 10} int n = sizeof (array) / sizeof (array [0] ) క్రమబద్ధీకరించు (శ్రేణి, శ్రేణి + n, ఎక్కువ ()) కౌట్<< 'Array after sorting : n' for (int i = 0 i < n ++i) cout << array[i] << ' ' return 0 } 

అవుట్పుట్:

ఎక్స్ l anation
ఇక్కడ క్రమబద్ధీకరించు () ఫంక్షన్ ముందు ఎక్కువ మూలకాన్ని ఉంచే విధంగా పోలిక చేస్తుంది.

C ++ లో క్రమబద్ధీకరణ పనితీరుపై ఈ కథనంతో కదులుతోంది

పాక్షిక_సోర్ట్

C ++ STL మాకు పాక్షిక సార్టింగ్ ఫంక్షన్‌ను అందిస్తుంది, ఫంక్షన్ సార్టింగ్ () ఫంక్షన్‌తో సమానంగా ఉంటుంది, అయితే సార్ట్ () ఫంక్షన్‌లా కాకుండా ఇది మొత్తం పరిధిని క్రమబద్ధీకరించడానికి ఉపయోగించబడదు, దానిలో ఉప-భాగాన్ని మాత్రమే క్రమబద్ధీకరించడానికి ఉపయోగిస్తారు. ఇది మూలకాలను [మొదటి, చివరి) పరిధిలో క్రమబద్ధీకరిస్తుంది, ఈ విధంగా మధ్య మూలకానికి ముందు ఉన్న మూలకాలు ఆరోహణ క్రమంలో క్రమబద్ధీకరించబడతాయి, అయితే మధ్యస్థం తరువాత మూలకాలు అలాగే ఉంటాయి.

మొదటి స్థానం కోసం క్రమబద్ధీకరించడానికి మేము ఒక ఫంక్షన్ ఆబ్జెక్ట్‌ని ఉపయోగిస్తే అది అతిపెద్ద మూలకాన్ని కనుగొనటానికి ఉపయోగపడుతుంది

జావాలో గరిష్ట కుప్ప అమలు

ఉదాహరణ

# చేర్చండి # చేర్చు + 1, vec.end (), ఎక్కువ ()) iptr = vec.begin () cout<< 'The largest element is = ' << *iptr return 0 } 

అవుట్పుట్:

వివరణ:
శ్రేణిలోని గొప్ప సంఖ్యను కనుగొనడానికి పై శ్రేణిని ఉపయోగించవచ్చు, సిరీస్‌లోని అతిచిన్న సంఖ్యను కనుగొనడానికి మనం ఎక్కువ ఆదేశాన్ని తొలగించాలి.

ఈ విధంగా ‘సి ++ లో ఫంక్షన్‌ను క్రమబద్ధీకరించు’ అనే ఈ వ్యాసం ముగింపుకు వచ్చాము. మీరు మరింత తెలుసుకోవాలనుకుంటే, విశ్వసనీయ ఆన్‌లైన్ లెర్నింగ్ సంస్థ ఎడురేకా చేత జావా శిక్షణను చూడండి. ఎడురేకా హైబర్నేట్ & స్ప్రింగ్ వంటి వివిధ జావా ఫ్రేమ్‌వర్క్‌లతో పాటు కోర్ మరియు అడ్వాన్స్‌డ్ జావా కాన్సెప్ట్‌ల కోసం మీకు శిక్షణ ఇవ్వడానికి కోర్సు రూపొందించబడింది.

మాకు ప్రశ్న ఉందా? దయచేసి ఈ బ్లాగ్ యొక్క వ్యాఖ్యల విభాగంలో దీనిని ప్రస్తావించండి మరియు మేము వీలైనంత త్వరగా మిమ్మల్ని సంప్రదిస్తాము.