ఈ మార్గదర్శకం ఉపయోగించి శ్రేణుల క్రమబద్ధీకరణను వివరిస్తుంది qsort() C లో పని చేస్తుంది మరియు C ఉదాహరణ కోడ్‌ల ద్వారా దానిని అర్థం చేసుకోవడానికి కూడా మీకు సహాయపడుతుంది.
C లో qsort()
సి స్టాండర్డ్ లైబ్రరీ మాకు సౌకర్యాలు కల్పిస్తుంది qsort() శ్రేణులను క్రమబద్ధీకరించడానికి ఉపయోగించే ఫంక్షన్. ఇది ఏదైనా డేటా రకం శ్రేణితో పనిచేసే అత్యంత ఆప్టిమైజ్ చేయబడిన మరియు వేగవంతమైన ఫంక్షన్.
C లో qsort()ని ఉపయోగించి హెడర్-ఫైల్
ది qsort() పద్ధతి లోపల నిర్వచించబడింది stdlib.h హెడర్ ఫైల్, ఇది అమలు చేయడానికి ముందు తప్పనిసరిగా నిర్వచించబడాలి qsort() సి ప్రోగ్రామ్‌లో.
#
qsort() డిక్లరేషన్
యొక్క ప్రకటన qsort() ఫంక్షన్ క్రింది విధంగా ఉంది:
శూన్యం qsort ( శూన్యం * బేస్ , మూలకాల_సంఖ్య , మూలకం_పరిమాణం , పోలిక_ఫంక్షన్ )
qsort() ఫంక్షన్ యొక్క పారామితులు
యొక్క పారామితులు qsort() ఫంక్షన్ ఇవి:
ఆధారం: క్రమబద్ధీకరించాల్సిన శ్రేణిలోని మొదటి మూలకానికి పాయింటర్.
మూలకాల_సంఖ్య: క్రమబద్ధీకరించాల్సిన శ్రేణిలోని మూలకాల సంఖ్య.
మూలకం_పరిమాణం: శ్రేణిలోని ప్రతి మూలకం బైట్‌లలో పరిమాణం.
పోలిక_ఫంక్షన్: మూలకాల క్రమాన్ని నిర్వచించే పోలిక ఫంక్షన్‌కు పాయింటర్.
qsort()లో పోలిక ఫంక్షన్ అంటే ఏమిటి
పోలిక ఫంక్షన్ రెండు పారామీటర్‌లను తీసుకుంటుంది, రెండూ టైప్ కాన్స్ట్ శూన్యం*, ఇవి పోల్చబడుతున్న ఎలిమెంట్‌లను సూచిస్తాయి. మొదటి మూలకం వరుసగా ముందు, అదే స్థానంలో లేదా రెండవ మూలకం తర్వాత క్రమబద్ధీకరించబడాలా అనేదానిపై ఆధారపడి, ఫంక్షన్ 0 కంటే తక్కువ, సమానం లేదా అంతకంటే ఎక్కువ పూర్ణాంకాన్ని అందించాలి.
C లో qsort ఎలా పనిచేస్తుంది
ది qsort() ఫంక్షన్ క్రింది విధంగా పనిచేస్తుంది:
గమనిక: ఇక్కడ మేము ఒక పరిశీలిస్తున్నాము int arr[] = {5, 2, 8, 3, 1, 9};
1: ప్రారంభంలో, qsort ఫంక్షన్ కింది పారామితులతో పిలవబడుతుంది:
qsort ( అరె , 6 , పరిమాణం ( int ) , పోలిక_ఫంక్షన్ ) ;ఇక్కడ arr అనేది శ్రేణికి పాయింటర్, 6 అనేది శ్రేణిలోని మూలకాల సంఖ్య, sizeof(int) అనేది శ్రేణిలోని ప్రతి మూలకం యొక్క పరిమాణం మరియు comparison_function అనేది మూలకాలు క్రమబద్ధీకరించబడిన క్రమాన్ని నిర్ణయించే ఫంక్షన్.
2: qsort ఫంక్షన్ పైవట్ మూలకాన్ని ఎంచుకుంటుంది. అది ఎంపిక చేస్తుందని చెప్పండి 3 ఇరుసుగా.
3: qsort ఫంక్షన్ శ్రేణిని రెండు ఉప-శ్రేణులుగా విభజించింది: {2, 1} మరియు {5, 8, 9}. మొదటి ఉప-శ్రేణి పివోట్ కంటే తక్కువ లేదా సమానమైన మూలకాలను కలిగి ఉంటుంది మరియు రెండవ ఉప-శ్రేణి పైవట్ కంటే ఎక్కువ మూలకాలను కలిగి ఉంటుంది.
4: qsort ఫంక్షన్ ప్రతి ఉప-శ్రేణిపై పునరావృతంగా పిలుస్తుంది.
5: qsort ఫంక్షన్ ప్రతి ఉప-శ్రేణికి పైవట్‌లను ఎంచుకుంటుంది. ఇది 1 మరియు 8ని పివోట్‌లుగా ఎంచుకుంటుంది అనుకుందాం.
6: qsort ఫంక్షన్ ప్రతి ఉప-శ్రేణిని మరో రెండు ఉప-శ్రేణులుగా విభజించింది మరియు ఈ ఉప-శ్రేణులలో ప్రతిదానిపై పునరావృతంగా పిలుస్తుంది.
7: qsort ఫంక్షన్ క్రమబద్ధీకరించబడిన ఉప-శ్రేణులను తిరిగి ఒకే క్రమబద్ధీకరించబడిన శ్రేణిగా మిళితం చేస్తుంది: {1, 2} మరియు {5, 8, 9} {1, 2, 5, 8, 9} అవుతుంది.
8: మొత్తం క్రమబద్ధీకరించబడిన శ్రేణి తిరిగి ఇవ్వబడింది.
C ప్రోగ్రామింగ్‌లో qsort అమలు
కింది కోడ్ అమలును చూపుతుంది qsort సి ప్రోగ్రామింగ్‌లో ఫంక్షన్.
##
int సరిపోల్చండి ( స్థిరంగా శూన్యం * a1 , స్థిరంగా శూన్యం * b1 )
{
తిరిగి ( * ( int * ) a1 - * ( int * ) b1 ) ;
}
int ప్రధాన ( )
{
int i = 0 , ఒకదానిపై = 6 ;
int అమరిక [ ] = { 5 , 2 , 8 , 3 , 1 , 9 } ;
qsort ( అమరిక , ఒకదానిపై , పరిమాణం ( int ) , సరిపోల్చండి ) ;
printf ( 'qsort()ని ఉపయోగించి అర్రే యొక్క క్రమబద్ధీకరించబడిన అంశాలు: ' ) ;
కోసం ( i = 0 ; i < ఒకదానిపై ; i ++ ) {
printf ( '%d' , అమరిక [ i ] ) ; }
తిరిగి 0 ;
}
పై కోడ్‌లో, ముందుగా ఒక పోలిక ఫంక్షన్ రెండు పారామితులతో తయారు చేయబడింది a1 మరియు b1 . అప్పుడు ప్రధాన() నుండి అమలు ప్రారంభమవుతుంది. ప్రధానంగా, మేము i=0 మరియు num=6గా రెండు పూర్ణాంకాల వేరియబుల్‌లను ప్రారంభిస్తాము. అప్పుడు మేము ఆరు మూలకాలతో శ్రేణిని ప్రకటిస్తాము {5, 2, 8, 3, 1, 9} . దీని తరువాత qsort() అర్రే రకం యొక్క మూడు పారామితులను కలిగి ఉంటుంది, num పరామితి శ్రేణి యొక్క మొత్తం మూలకాలను చెబుతుంది, పరిమాణం (పూర్ణాంకం) శ్రేణి యొక్క మొత్తం పరిమాణాన్ని సూచిస్తుంది మరియు శ్రేణి మూలకాలను ఒక్కొక్కటిగా పోల్చడానికి సరిపోల్చడం ఉపయోగించబడుతుంది. అప్పుడు ఉపయోగించి క్రమబద్ధీకరించబడిన శ్రేణిని ప్రింట్ చేయండి printf() C లో ఫంక్షన్.
అవుట్‌పుట్
ముగింపు
qsort ఏ రకమైన శ్రేణులను క్రమబద్ధీకరించడానికి C ప్రోగ్రామింగ్‌లో శక్తివంతమైన ఫంక్షన్. పోలిక ఫంక్షన్ ఆధారంగా మూలకాలను ఆరోహణ లేదా అవరోహణ క్రమంలో క్రమబద్ధీకరించడానికి ఇది క్విక్‌సార్ట్ అల్గారిథమ్‌ను ఉపయోగిస్తుంది. C ప్రోగ్రామింగ్‌లో qsortని దశల వారీగా అమలు చేయడానికి పై గైడ్ మీకు సులభమైన మార్గాన్ని చూపుతుంది qsort అల్గోరిథం.