C இல் செருகும் வரிசை என்றால் என்ன?
செருகும் வரிசை எனப்படும் வரிசையாக்க முறையானது, ஒரு வரிசை முழுவதும் திரும்பும்போது ஒவ்வொரு உறுப்புக்கும் அருகில் உள்ள உறுப்புகளுடன் பொருந்துகிறது. முந்தையதை விட சிறிய உறுப்பு, வரிசைப்படுத்தப்பட்ட துணைக்குழுவில் பொருத்தமான இடத்தில் செருகப்படுகிறது.
மேலும் விளக்குவதற்கு, நான் ஒரு வரிசையின் நான்கு உறுப்புகளின் வரிசையை கருத்தில் கொண்ட ஒரு உதாரணத்தை நிரூபித்துள்ளேன். arr[]= {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} :
#வெற்றிடமானது செருகுதல்_ஏறும் ( முழு எண்ணாக arr1 [ ] , முழு எண்ணாக n ) {
முழு எண்ணாக நான் , ஜே , என்_சாவி ;
//for loop என்பது i மதிப்புகளை 1 முதல் i
க்கான ( நான் = 1 ; நான் < n ; நான் ++ ) {
என்_சாவி = arr1 [ நான் ] ;
ஜே = நான் - 1 ;
போது ( ஜே >= 0 && arr1 [ ஜே ] > என்_சாவி ) {
arr1 [ ஜே + 1 ] = arr1 [ ஜே ] ;
ஜே = ஜே - 1 ;
}
arr1 [ ஜே + 1 ] = என்_சாவி ;
}
}
வெற்றிடமானது உட்செலுத்துதல்_இறங்கும் ( முழு எண்ணாக arr2 [ ] , முழு எண்ணாக மீ ) {
முழு எண்ணாக நான் , ஜே , என்_சாவி ;
//இன்னொரு லூப் ஆனது i மதிப்புகளை 1 முதல் i
க்கான ( நான் = 1 ; நான் < மீ ; நான் ++ ) {
என்_சாவி = arr2 [ நான் ] ;
ஜே = நான் - 1 ;
போது ( ஜே >= 0 && arr2 [ ஜே ] < என்_சாவி ) {
arr2 [ ஜே + 1 ] = arr2 [ ஜே ] ;
ஜே = ஜே - 1 ;
}
arr2 [ ஜே + 1 ] = என்_சாவி ;
}
}
முழு எண்ணாக முக்கிய ( ) {
//செருகு - இறங்கு வரிசையுடன் வரிசைப்படுத்தவும்
முழு எண்ணாக my_arr [ ] = { 5 , 4 , 60 , 9 } ; //நான்கு மதிப்புகள் கொண்ட my_arr[] ஐ துவக்கவும்
முழு எண்ணாக மீ = அளவு ( my_arr ) / அளவு ( my_arr [ 0 ] ) ;
உட்செலுத்துதல்_இறங்கும் ( my_arr , மீ ) ;
printf ( 'வரிசை இறங்கு வரிசையில் வரிசைப்படுத்தப்பட்டது:' ) ;
க்கான ( முழு எண்ணாக நான் = 0 ; நான் < மீ ; நான் ++ )
printf ( '%d' , my_arr [ நான் ] ) ;
printf ( ' \n ' ) ;
//செருகல்-ஏறுவரிசையுடன் வரிசைப்படுத்தவும்
முழு எண்ணாக n = அளவு ( my_arr ) / அளவு ( my_arr [ 0 ] ) ;
செருகுதல்_ஏறும் ( arr2 , n ) ;
printf ( 'ஏறுவரிசையில் வரிசைப்படுத்தப்பட்ட வரிசை:' ) ;
க்கான ( முழு எண்ணாக நான் = 0 ; நான் < n ; நான் ++ )
printf ( '%d' , my_arr [ நான் ] ) ;
printf ( ' \n ' ) ;
திரும்ப 0 ;
}
இந்த குறியீட்டில், இரண்டு முறைகள் உட்செலுத்துதல்_இறங்கும்() , மற்றும் உட்செலுத்துதல்_ஏறும்() வரிசை மதிப்புகளை எடுத்துக் கொள்ளுங்கள் my_arr[] . குறியீடு பின்னர் a ஐப் பயன்படுத்துகிறது வளையத்திற்கு வரிசையின் கூறுகள் மூலம் மீண்டும் செய்யவும்.
வரிசைகளை இறங்கு மற்றும் ஏறுவரிசையில் வரிசைப்படுத்தியவுடன் இரண்டு செயல்பாடுகளையும் முக்கிய செயல்பாட்டில் அழைக்கிறோம். அதன் பிறகு, வரிசைப்படுத்தப்பட்ட வரிசையை அச்சிட for loops பயன்படுத்தப்படுகிறது.
இந்த நிரலை இயக்கும்போது, எதிர்பார்க்கப்படும் வெளியீடு கீழே வைக்கப்படும்:
முடிவுரை
உட்செலுத்துதல் வரிசையானது ஒரு வரிசையை இறங்கு அல்லது ஏறுவரிசையில் வரிசைப்படுத்த விரைவான மற்றும் எளிதான வழியாகும். சிறிய தரவுத்தொகுப்புகளுக்கு, இந்த வரிசையாக்க நுட்பம் சிறப்பாக செயல்படுகிறது. மேலே உள்ள வழிகாட்டியில் நீங்கள் பார்ப்பது போல், இறங்கு மற்றும் ஏறுவரிசையில் உள்ள செருகும் வரிசையை எளிதாகப் புரிந்துகொள்ள, C நிரலின் உதாரணத்தைச் செயல்படுத்துவது எளிது.