இந்த கட்டுரை 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 இல் குமிழி வரிசைப்படுத்தும் திட்டம்
பின்வருபவை செயல்படுத்துவது குமிழி வரிசை சி நிரலாக்கத்தில்.
#முழு எண்ணாக முக்கிய ( ) {
முழு எண்ணாக வரிசை [ 100 ] , n , எக்ஸ் , மற்றும் , கள் ;
printf ( 'வரிசை உறுப்புகளின் எண்ணிக்கையை உள்ளிடவும்:' ) ;
ஸ்கேன்எஃப் ( '%d' , & n ) ;
printf ( 'உறுப்புகளின் மதிப்புகளை உள்ளிடவும்:' ) ;
க்கான ( எக்ஸ் = 0 ; எக்ஸ் < n ; எக்ஸ் ++ )
ஸ்கேன்எஃப் ( '%d' , & வரிசை [ எக்ஸ் ] ) ;
க்கான ( எக்ஸ் = 0 ; எக்ஸ் < n - 1 ; எக்ஸ் ++ ) {
க்கான ( மற்றும் = 0 ; மற்றும் < n - எக்ஸ் - 1 ; மற்றும் ++ ) {
என்றால் ( வரிசை [ மற்றும் ] > வரிசை [ மற்றும் + 1 ] ) {
கள் = வரிசை [ மற்றும் ] ;
வரிசை [ மற்றும் ] = வரிசை [ மற்றும் + 1 ] ;
வரிசை [ மற்றும் + 1 ] = கள் ; }
}
}
printf ( 'குமிழி வரிசையைப் பயன்படுத்திய பிறகு வரிசைப்படுத்தப்பட்ட வரிசை:' ) ;
க்கான ( எக்ஸ் = 0 ; எக்ஸ் < n ; எக்ஸ் ++ )
{
printf ( '%d' , வரிசை [ எக்ஸ் ] ) ;
}
திரும்ப 0 ;
}
மேலே உள்ள C நிரல் முதலில் 100 உறுப்புகளின் அளவு கொண்ட ஒரு வரிசையைத் துவக்குகிறது மற்றும் வரிசைப்படுத்த வேண்டிய உறுப்புகளின் அளவை உள்ளிடுமாறு பயனரைக் கேட்கிறது, பின்னர் பயனரிடமிருந்து கூறுகளை ஒவ்வொன்றாக உள்ளிடுகிறது. ஒரு வரிசையில் உள்ளிடப்பட்ட மதிப்புகள் பின்னர் உள்ளமைக்கப்பட்ட சுழல்களைப் பயன்படுத்தி வரிசைப்படுத்தப்படுகின்றன, ஏனெனில் அவை தவறான வரிசையில் இருந்தால் குறியீடு உறுப்புகளை மாற்றும். இறுதியாக, இது லூப்பிற்காக வரிசைப்படுத்தப்பட்ட வரிசையை அச்சிடுகிறது.
வெளியீடு
முடிவுரை
குமிழி வரிசை அணிவரிசையின் ஒவ்வொரு உறுப்பையும் அதன் அருகில் உள்ள உறுப்புடன் ஒப்பிட்டு கடைசி உறுப்பு வரிசைப்படுத்தப்படும் வரை பொருத்துவதன் மூலம் வரிசையை ஏறுவரிசை அல்லது இறங்கு வரிசையில் வரிசைப்படுத்தப் பயன்படும் ஒரு வரிசையாக்க வழிமுறை ஆகும். மேலே குறிப்பிட்டுள்ள வழிகாட்டுதல்களில், நீங்கள் அடிப்படையை கற்றுக்கொள்வீர்கள் குமிழி வரிசை அல்காரிதம் மற்றும் சி நிரலாக்கத்தில் அதன் செயலாக்கம்.