ఈ వ్యాసం C ప్రోగ్రామింగ్‌లో బబుల్ క్రమాన్ని అమలు చేయడానికి సులభమైన మార్గాన్ని చర్చిస్తుంది.
C ప్రోగ్రామింగ్‌లో బబుల్-సార్ట్ అంటే ఏమిటి?
లో బబుల్ క్రమబద్ధీకరణ , వినియోగదారు ప్రాధాన్యతను బట్టి మూలకాలు ఆరోహణ లేదా అవరోహణ క్రమంలో పదేపదే క్రమంలో అమర్చబడి ఉంటాయి. C లో సార్టింగ్ ప్రక్రియ మొదటి సూచికను శోధించడం మరియు మొదటి మరియు రెండవ మూలకాలను పోల్చడం ద్వారా ప్రారంభమవుతుంది. మొదటి సూచిక మూలకం రెండవదాని కంటే ఎక్కువగా ఉంటే, అవి మార్చబడతాయి. అన్ని మూలకాలు క్రమబద్ధీకరించబడే వరకు రెండవ సూచిక మూలకం మరియు మూడవ మూలకం కోసం అదే పోలిక మరియు మార్పిడి ప్రక్రియ పునరావృతమవుతుంది.
బబుల్ సార్ట్స్ ఎలా పని చేస్తుంది?
ఇక్కడ అమలు చేయడానికి దశల వారీ గైడ్ ఉంది బబుల్ క్రమబద్ధీకరణ C లో
ఇన్‌పుట్ శ్రేణిని పరిశీలిద్దాం {5, 3, 1, 4, 6} . ఉపయోగించి ఈ శ్రేణిని క్రమబద్ధీకరించడానికి బబుల్ క్రమబద్ధీకరణ , మేము ఈ క్రింది పాస్‌లను అనుసరిస్తాము:
మొదటి పాస్:
(5 3 1 4 6) -> (3 5 1 4 6), 5 > 3 నుండి మార్చుకోండి
(3 5 1 4 6) -> (3 1 5 4 6), 5 > 1 నుండి మార్చుకోండి
(3 1 5 4 6) -> (3 1 4 5 6), 5 > 4 నుండి మార్చుకోండి
(3 1 4 5 6) -> (3 1 4 5 6), అన్ని మూలకాలు క్రమంలో ఉన్నందున స్వాప్ లేదు.
రెండవ పాస్:
(3 1 4 5 6) -> (1 3 4 5 6), 3 > 1 నుండి మార్చుకోండి
(1 3 4 5 6) -> (1 3 4 5 6), అన్ని మూలకాలు క్రమంలో ఉన్నందున స్వాప్ లేదు.
మూడవ పాస్:
(1 3 4 5 6) -> (1 3 4 5 6), అన్ని మూలకాలు క్రమంలో ఉన్నందున స్వాప్ లేదు.
శ్రేణి క్రమబద్ధీకరించబడింది మరియు మార్పిడులు లేనందున అల్గోరిథం మూడవ పాస్ తర్వాత దీనిని గుర్తిస్తుంది.
C లో బబుల్ క్రమబద్ధీకరణ కార్యక్రమం
కిందిది అమలు చేయడం బబుల్ క్రమబద్ధీకరణ సి ప్రోగ్రామింగ్‌లో.
#int ప్రధాన ( ) {
int అమరిక [ 100 ] , n , x , మరియు , లు ;
printf ( 'దయచేసి శ్రేణి మూలకాల సంఖ్యను నమోదు చేయండి:' ) ;
స్కాన్ఎఫ్ ( '%d' , & n ) ;
printf ( 'దయచేసి మూలకాల విలువలను నమోదు చేయండి:' ) ;
కోసం ( x = 0 ; x < n ; x ++ )
స్కాన్ఎఫ్ ( '%d' , & అమరిక [ x ] ) ;
కోసం ( x = 0 ; x < n - 1 ; x ++ ) {
కోసం ( మరియు = 0 ; మరియు < n - x - 1 ; మరియు ++ ) {
ఉంటే ( అమరిక [ మరియు ] > అమరిక [ మరియు + 1 ] ) {
లు = అమరిక [ మరియు ] ;
అమరిక [ మరియు ] = అమరిక [ మరియు + 1 ] ;
అమరిక [ మరియు + 1 ] = లు ; }
}
}
printf ( 'బబుల్ క్రమాన్ని ఉపయోగించిన తర్వాత క్రమబద్ధీకరించబడిన శ్రేణి:' ) ;
కోసం ( x = 0 ; x < n ; x ++ )
{
printf ( '%d' , అమరిక [ x ] ) ;
}
తిరిగి 0 ;
}
ఎగువ C ప్రోగ్రామ్ మొదట 100 మూలకాల పరిమాణంతో శ్రేణిని ప్రారంభిస్తుంది మరియు క్రమబద్ధీకరించాల్సిన మూలకాల పరిమాణాన్ని నమోదు చేయమని వినియోగదారుని అడుగుతుంది, ఆపై వినియోగదారు నుండి మూలకాలను ఒక్కొక్కటిగా నమోదు చేస్తుంది. శ్రేణిలో నమోదు చేయబడిన విలువలు తప్పుడు క్రమంలో ఉన్నట్లయితే, కోడ్ మూలకాలను మార్చుకోవడం వలన నెస్టెడ్ లూప్‌లను ఉపయోగించి క్రమబద్ధీకరించబడతాయి. చివరగా, ఇది లూప్ కోసం ఉపయోగించి క్రమబద్ధీకరించబడిన శ్రేణిని ప్రింట్ చేస్తుంది.
అవుట్‌పుట్
ముగింపు
బబుల్ క్రమబద్ధీకరణ శ్రేణిలోని ప్రతి మూలకాన్ని దాని ప్రక్కనే ఉన్న మూలకంతో పోల్చడం మరియు చివరి మూలకం క్రమబద్ధీకరించబడే వరకు సరిపోల్చడం ద్వారా శ్రేణిని ఆరోహణ లేదా అవరోహణ క్రమంలో అమర్చడానికి ఉపయోగించే సార్టింగ్ అల్గోరిథం. పైన పేర్కొన్న మార్గదర్శకాలలో, మీరు ప్రాథమికంగా నేర్చుకుంటారు బబుల్ క్రమబద్ధీకరణ అల్గోరిథం మరియు సి ప్రోగ్రామింగ్‌లో దాని అమలు.