C లో చొప్పించే క్రమబద్ధీకరణ అంటే ఏమిటి?
చొప్పించే క్రమబద్ధీకరణ అని పిలువబడే క్రమబద్ధీకరణ పద్ధతి ప్రతి ఒక్క మూలకాన్ని శ్రేణిలో పునరావృతం చేస్తున్నప్పుడు ప్రక్కనే ఉన్న వాటితో సరిపోతుంది. సముచిత ప్రదేశంలో క్రమబద్ధీకరించబడిన సబ్‌రేలో ముందు ఉన్నదాని కంటే చిన్న మూలకం చొప్పించబడుతుంది.
మరింత వివరించడానికి, నేను ఒక శ్రేణిలో నాలుగు మూలకాల శ్రేణిని పరిగణించిన ఉదాహరణను ప్రదర్శించాను అర్[]= {5, 4, 60, 9} మరియు మేము ఈ మూలకాన్ని చొప్పించే క్రమాన్ని ఉపయోగించి ఆరోహణ క్రమంలో క్రమబద్ధీకరించాలనుకుంటున్నాము. కింది పరస్పర చర్యలు చొప్పించడం యొక్క పూర్తి డ్రై రన్‌ను వివరిస్తాయి:
పునరావృతం 1
| 5 | 4 | 60 | 9 |
మేము ఇప్పుడు arr[5, 4, 60, 9] వలె ఒక శ్రేణిని కలిగి ఉన్నాము, చొప్పించే క్రమబద్ధీకరణ యొక్క మొదటి పునరావృతంలో మేము మొదట 5 మరియు 4 వంటి మొదటి రెండు మూలకాలను పోల్చాము, arr [5] > arr[4] కాబట్టి శ్రేణిని ఆరోహణ క్రమంలో క్రమబద్ధీకరించడానికి మేము వాటిని మార్చుకుంటాము. ఇప్పుడు, శ్రేణి ఇలా ఉంటుంది:
| 4 | 5 | 60 | 9 |
పునరావృతం 2
| 4 | 5 | 60 | 9 |
రెండవ పునరావృతంలో, మేము arr[5] వంటి తదుపరి రెండు మూలకాలను arr[60]తో పోల్చాము.
arr[5] < arr[60] వలె ఇది ఇప్పటికే ఆరోహణ క్రమంలో క్రమబద్ధీకరించబడినందున మార్పిడి జరగదు. ఇప్పుడు, శ్రేణి అవుతుంది:
| 4 | 5 | 60 | 9 |
పునరావృతం 3
| 4 | 5 | 60 | 9 |
మూడవ పునరావృతం వలె, మేము arr[60] వంటి మూడవ మరియు నాల్గవ మూలకాలను arr[9]తో సరిపోల్చాము.
ఇప్పుడు, arr[60] > arr[9] కాబట్టి ఇచ్చిపుచ్చుకోవడం జరుగుతుంది, అప్పుడు శ్రేణి ఆరోహణ క్రమంలో క్రమబద్ధీకరించబడుతుంది.
| 4 | 5 | 9 | 60 |
శ్రేణి మూలకాన్ని ఆరోహణ లేదా అవరోహణ క్రమంలో సులభంగా క్రమబద్ధీకరించే C లో చొప్పించే క్రమబద్ధీకరణ ఇలా ఉంటుంది.
చొప్పించే క్రమబద్ధీకరణ యొక్క ఫ్లో-చార్ట్
చొప్పించే క్రమబద్ధీకరణ అల్గోరిథం యొక్క ఫ్లోచార్ట్ క్రిందిది:
C లో చొప్పించే క్రమబద్ధీకరణ యొక్క ఉదాహరణను అమలు చేస్తోంది
Cలో చొప్పించే క్రమబద్ధీకరణ పద్ధతిని రూపొందించడానికి మాకు ముందుగా అవరోహణ మరియు ఆరోహణ క్రమంలో క్రమబద్ధీకరించాల్సిన మూలకాల సేకరణ అవసరం. ఈ ఉదాహరణ ప్రయోజనాల కోసం మేము సంఖ్యల శ్రేణితో వ్యవహరిస్తున్నామని భావించండి. {5, 4, 60, 9} :
#శూన్యం చొప్పించడం_ఆరోహణ ( int arr1 [ ] , int n ) {
int i , j , నా_కీ ;
//for లూప్ i విలువలను 1 నుండి i
కోసం ( i = 1 ; i < n ; i ++ ) {
నా_కీ = arr1 [ i ] ;
j = i - 1 ;
అయితే ( j >= 0 && arr1 [ j ] > నా_కీ ) {
arr1 [ j + 1 ] = arr1 [ j ] ;
j = j - 1 ;
}
arr1 [ j + 1 ] = నా_కీ ;
}
}
శూన్యం చొప్పించడం_అవరోహణ ( int arr2 [ ] , int m ) {
int i , j , నా_కీ ;
//1 నుండి i
కోసం ( i = 1 ; i < m ; i ++ ) {
నా_కీ = arr2 [ i ] ;
j = i - 1 ;
అయితే ( j >= 0 && arr2 [ j ] < నా_కీ ) {
arr2 [ j + 1 ] = arr2 [ j ] ;
j = j - 1 ;
}
arr2 [ j + 1 ] = నా_కీ ;
}
}
int ప్రధాన ( ) {
//చొప్పించడం-అవరోహణ క్రమంలో క్రమబద్ధీకరించండి
int నా_అర్ [ ] = { 5 , 4 , 60 , 9 } ; //నాలుగు విలువలు కలిగిన my_arr[]ని ప్రారంభించండి
int m = పరిమాణం ( నా_అర్ ) / పరిమాణం ( నా_అర్ [ 0 ] ) ;
చొప్పించడం_అవరోహణ ( నా_అర్ , m ) ;
printf ( 'అవరోహణ క్రమంలో క్రమబద్ధీకరించబడిన శ్రేణి:' ) ;
కోసం ( int i = 0 ; i < m ; i ++ )
printf ( '%d' , నా_అర్ [ i ] ) ;
printf ( ' \n ' ) ;
//చొప్పించడం-ఆరోహణ క్రమంలో క్రమబద్ధీకరించండి
int n = పరిమాణం ( నా_అర్ ) / పరిమాణం ( నా_అర్ [ 0 ] ) ;
చొప్పించడం_ఆరోహణ ( arr2 , n ) ;
printf ( 'అరే ఆరోహణ క్రమంలో క్రమబద్ధీకరించబడింది:' ) ;
కోసం ( int i = 0 ; i < n ; i ++ )
printf ( '%d' , నా_అర్ [ i ] ) ;
printf ( ' \n ' ) ;
తిరిగి 0 ;
}
ఈ కోడ్‌లో, రెండు పద్ధతులు insertionsort_descending() , మరియు insertionsort_ascending() యొక్క శ్రేణి విలువలను తీసుకోండి my_arr[] . కోడ్ అప్పుడు ఉపయోగిస్తుంది a లూప్ కోసం శ్రేణి యొక్క మూలకాల ద్వారా పునరావృతం చేయడానికి.
శ్రేణులను అవరోహణ మరియు ఆరోహణ క్రమంలో క్రమబద్ధీకరించిన తర్వాత మేము రెండు ఫంక్షన్‌లను ప్రధాన ఫంక్షన్‌లో పిలుస్తాము. ఆ తర్వాత, క్రమబద్ధీకరించబడిన శ్రేణిని ప్రింట్ చేయడానికి for loopలు ఉపయోగించబడతాయి.
మేము ఈ ప్రోగ్రామ్‌ని అమలు చేసినప్పుడు, ఆశించిన అవుట్‌పుట్ దిగువన ఉంచబడుతుంది:
ముగింపు
చొప్పించే క్రమబద్ధీకరణ అనేది శ్రేణిని అవరోహణ లేదా ఆరోహణ క్రమంలో క్రమబద్ధీకరించడానికి శీఘ్ర మరియు సులభమైన మార్గం. చిన్న డేటాసెట్ల కోసం, ఈ సార్టింగ్ టెక్నిక్ బాగా పనిచేస్తుంది. మీరు పై గైడ్‌లో చూడగలిగినట్లుగా, అవరోహణ మరియు ఆరోహణ క్రమంలో చొప్పించే క్రమాన్ని సులభంగా అర్థం చేసుకోవడానికి C ప్రోగ్రామ్ యొక్క ఉదాహరణను అమలు చేయడం సులభం.