சி ++ இல் வரிசைப்படுத்துதல் செயல்பாட்டை எவ்வாறு செயல்படுத்துவது?

இந்த கட்டுரை c ++ இல் வரிசைப்படுத்துதல் செயல்பாட்டை ஆராய உதவும், மேலும் செயல்பாட்டில் கருத்து குறித்த விரிவான ஆர்ப்பாட்டத்தை உங்களுக்கு வழங்கும்

வரிசைப்படுத்துதல் தரவுக்கு பயன்படுத்தப்படும் மிகவும் அடிப்படை மற்றும் பயனுள்ள செயல்பாடுகளில் ஒன்றாகும். இது ஒரு குறிப்பிட்ட பாணியில் தரவை ஒழுங்குபடுத்துவதை நோக்கமாகக் கொண்டுள்ளது, இது தேவைகளுக்கு ஏற்ப அதிகரிக்கும் அல்லது குறைக்கப்படலாம். சி ++ எஸ்.டி.எல் இல் ‘வரிசை ()’ என்ற பெயரில் ஒரு பில்டின் செயல்பாடு உள்ளது, இது வரிசையாக்க வழிமுறையை எளிதில் செய்ய அனுமதிக்கிறது. இந்த கட்டுரையில் நாம் C ++ இல் வரிசைப்படுத்துதல் செயல்பாட்டை ஆராய்வோம்,



பின்வரும் சுட்டிகள் இந்த கட்டுரையில் விவரிக்கப்படும்:



சி ++ இல் வரிசைப்படுத்துதல் செயல்பாடு குறித்த இந்த கட்டுரையுடன் நகரும்

வகைபடுத்து ( ) செயல்பாடு

இது அல்காரிதம் தலைப்பு கோப்பின் உள்ளமைக்கப்பட்ட செயல்பாடாகும், இது ஒரு வரிசை, திசையன்கள் போன்ற கொள்கலன்களை ஒரு குறிப்பிட்ட வரிசையில் வரிசைப்படுத்த பயன்படுகிறது. உள்நாட்டில் இந்த செயல்பாடு விரைவு-வரிசையாக செயல்படுத்தப்படுகிறது
குவிக்சோர்ட் என்பது ஒரு பிளவு மற்றும் வெற்றி வழிமுறையாகும். குவிக்சோர்ட் முதலில் ஒரு பெரிய உறுப்புகளின் பட்டியலை இரண்டு சிறிய துணை பட்டியல்களாகப் பிரிக்கிறது: கீழ் கூறுகள் மற்றும் உயர் கூறுகள். குவிகார்ட் பின்னர் துணை பட்டியல்களை மீண்டும் மீண்டும் வரிசைப்படுத்துகிறது.



படிகள் பின்வருமாறு:
1. பட்டியலிலிருந்து ஒரு பிவோட் எனப்படும் சீரற்ற உறுப்பை (பொதுவாக கடைசி உறுப்பு) தேர்ந்தெடுக்கவும்.
2. பிவோட்டை விட குறைவான மதிப்புகள் கொண்ட அனைத்து கூறுகளும் பிவோட்டுக்கு முன் வரும் வகையில் பட்டியலை மறுவரிசைப்படுத்துங்கள், அதே நேரத்தில் பிவோட்டை விட பெரிய மதிப்புகள் கொண்ட அனைத்து உறுப்புகளும் அதன் பின் வந்து சம மதிப்புகள் எந்த வழியிலும் செல்லலாம் இது செயல்முறை பகிர்வு செயல்பாடு என்று அழைக்கப்படுகிறது.
3. குறைவான உறுப்புகளின் துணைப் பட்டியலையும், அதிக உறுப்புகளின் துணைப் பட்டியலையும் மீண்டும் மீண்டும் வரிசைப்படுத்தி, மீண்டும் துணைப் பட்டியலில் ஒரு மையத்தைத் தேர்ந்தெடுத்து அவற்றைப் பிரிக்கவும்.
மறுநிகழ்வின் அடிப்படை வழக்கு அளவு பூஜ்ஜியம் அல்லது ஒன்றின் பட்டியல்கள் ஆகும், அவை ஒருபோதும் வரிசைப்படுத்தப்பட வேண்டியதில்லை, இதனால் அவற்றை இணைப்பதன் மூலம் எங்கள் பட்டியலை வரிசைப்படுத்துகிறோம்.

செருகும் வரிசை அல்லது குமிழி வரிசைப்படுத்தல் போன்ற பிற O (n log n) வழிமுறைகளை விட குவிக்சோர்ட் நடைமுறையில் வேகமாக உள்ளது. குவிக்சோர்டை ஒரு இடத்தில் பகிர்வு அல்காரிதம் மூலம் செயல்படுத்த முடியும், அதாவது முழு வரிசையையும் O (log n) கூடுதல் இடத்துடன் மட்டுமே செய்ய முடியும். குவிக்சோர்ட் ஒரு நிலையான வகை அல்ல.
அதன் சிக்கலானது பின்வருமாறு:
சிறந்த வழக்கு - O (n log n)
மோசமான வழக்கு - O (n ^ 2)
சராசரி வழக்கு - O (n log n)

தொடரியல்:
வரிசைப்படுத்து (முதல், கடைசி)
இங்கே,
முதல் - வரிசைப்படுத்தப்பட வேண்டிய வரம்பில் உள்ள முதல் தனிமத்தின் குறியீட்டு (சுட்டிக்காட்டி) ஆகும்.
கடைசியாக - வரிசைப்படுத்தப்பட வேண்டிய வரம்பில் உள்ள கடைசி உறுப்பின் குறியீடு (சுட்டிக்காட்டி) ஆகும்.
எடுத்துக்காட்டாக, ஒரு வரிசையின் கூறுகளை 1 முதல் 10 நிலைக்கு வரிசைப்படுத்த விரும்புகிறோம், நாங்கள் வரிசைப்படுத்துவோம் (arr, arr + 10) மற்றும் அது 10 கூறுகளை ஏறுவரிசையில் வரிசைப்படுத்தும்.
வருவாய் மதிப்பு
எதுவுமில்லை



சிக்கலான தன்மை

ஒரு வகை சிக்கலின் சராசரி N * log2 (N) ஆகும், அங்கு N = last - first.

தரவு வரம்பு
வரம்பில் உள்ள பொருள் [முதல், கடைசி) மாற்றியமைக்கப்பட்டுள்ளது.

விதிவிலக்குகள்
எக்ஸிகியூஷன் பாலிசி அறிக்கை பிழைகள் என பெயரிடப்பட்ட ஒரு டெம்ப்ளேட் அளவுருவுடன் கூடிய சுமைகள் பின்வருமாறு:
வழிமுறை நினைவகத்தை ஒதுக்கத் தவறினால், std :: bad_alloc ஒரு விதிவிலக்காக வீசப்படுகிறது.
வழிமுறையின் ஒரு பகுதியாக செயல்படுத்தப்பட்ட ஒரு செயல்பாட்டை செயல்படுத்தினால், அது ஒரு விதிவிலக்கு std :: ஐ நிறுத்துகிறது.

மதிப்பால் கடந்து செல்வதற்கும் ஜாவாவில் குறிப்பு மூலம் கடந்து செல்வதற்கும் உள்ள வேறுபாடு

சி ++ இல் வரிசைப்படுத்துதல் செயல்பாடு குறித்த இந்த கட்டுரையுடன் நகரும்

எடுத்துக்காட்டு - தரவை ஏறுவரிசையில் வரிசைப்படுத்த:

# பெயர்வெளியைப் பயன்படுத்துதல் std int main () {int வரிசை [] = {10, 35, 85, 93, 62, 77, 345, 43, 2, 10} int n = sizeof (வரிசை) / sizeof (வரிசை [0] ) // 'sizeof' மொத்த வரிசையின் அளவைக் கொடுக்கிறது, அதாவது ஒவ்வொரு எழுத்தின் அளவையும் * இல்லை. எழுத்துக்கள் // எனவே இல்லை. எழுத்துகளின் // வரிசையின் எந்த ஒரு எழுத்தின் அளவையும் கொண்டு நாம் அளவை (வரிசை) பிரிக்கிறோம் // இங்கே அது வரிசை [0] வரிசை (வரிசை, வரிசை + என்) கோட்<< 'nArray after sorting using ' 'default sort is : n' for (int i = 0 i < n ++i) cout << array[i] << ' ' return 0 } 

வெளியீடு:

வெளியீடு- சி ++ இல் செயல்பாடு வரிசைப்படுத்து - எடுரேகா

விளக்கம்

மேலே உள்ள எடுத்துக்காட்டில் இருந்து, அந்த வகை () செயல்பாடு இயல்பாக ஒரு வரிசையை ஏறுவரிசையில் வரிசைப்படுத்துகிறது.

சி ++ இல் வரிசைப்படுத்துதல் செயல்பாடு குறித்த இந்த கட்டுரையுடன் நகரும்

செலினியம் வெப் டிரைவரில் கலப்பின கட்டமைப்பு

எடுத்துக்காட்டு - தரவை இறங்கு வரிசையில் வரிசைப்படுத்த:

வரிசையின் தரவை இறங்கு வரிசையில் வரிசைப்படுத்த, மூன்றாவது அளவுருவை அறிமுகப்படுத்த வேண்டும், இது கூறுகள் வரிசைப்படுத்தப்பட வேண்டிய வரிசையை குறிப்பிட பயன்படுகிறது. தரவை இறங்கு வரிசையில் வரிசைப்படுத்த “அதிக ()” செயல்பாட்டைப் பயன்படுத்தலாம்.

# பெயர்வெளியைப் பயன்படுத்துதல் std int main () {int வரிசை [] = {41, 53, 4, 459, 60, 7, 23, 4, 232, 10} int n = sizeof (வரிசை) / sizeof (வரிசை [0] ) வரிசைப்படுத்து (வரிசை, வரிசை + n, அதிக ()) கோட்<< 'Array after sorting : n' for (int i = 0 i < n ++i) cout << array[i] << ' ' return 0 } 

வெளியீடு:

காலாவதியானது l அனேஷன்
இங்கே வரிசைப்படுத்து () செயல்பாடு அதிக உறுப்பை முன் வைக்கும் வகையில் ஒரு ஒப்பீடு செய்கிறது.

சி ++ இல் வரிசைப்படுத்துதல் செயல்பாடு குறித்த இந்த கட்டுரையுடன் நகரும்

பகுதி_ வரிசை

சி ++ எஸ்.டி.எல் எங்களுக்கு ஒரு பகுதி வரிசையாக்க செயல்பாட்டை வழங்குகிறது, செயல்பாடு வரிசைப்படுத்துதல் () செயல்பாட்டைப் போன்றது, ஆனால் வரிசை () செயல்பாட்டைப் போலல்லாமல் இது முழு வரம்பையும் வரிசைப்படுத்தப் பயன்படாது, மாறாக அதன் துணை பகுதியை மட்டும் வரிசைப்படுத்தப் பயன்படுகிறது. இது [முதல், கடைசி) வரம்பில் உள்ள உறுப்புகளை வரிசைப்படுத்துகிறது, இது நடுத்தர உறுப்புக்கு முந்தைய கூறுகள் ஏறுவரிசையில் வரிசைப்படுத்தப்படுகிறது, அதேசமயம் நடுத்தரத்திற்குப் பின் உள்ள கூறுகள் அப்படியே விடப்படுகின்றன.

முதல் நிலைக்கு வரிசைப்படுத்த ஒரு செயல்பாட்டு பொருளைப் பயன்படுத்தினால், மிகப்பெரிய உறுப்பைக் கண்டுபிடிக்க இதைப் பயன்படுத்தலாம்

உதாரணமாக

# அடங்கும் # அடங்கும் # பெயர்வெளியைப் பயன்படுத்துதல் std int main () {திசையன் vec = {10, 45, 60, 78, 23, 21, 30} திசையன் :: iterator iptr part_sort (vec.begin (), vec.begin () + 1, vec.end (), அதிக ()) iptr = vec.begin () cout<< 'The largest element is = ' << *iptr return 0 } 

வெளியீடு:

விளக்கம்:
மேலே உள்ள குறியீட்டை ஒரு தொடரில் மிகப் பெரிய எண்ணைக் கண்டுபிடிக்க பயன்படுத்தலாம், தொடரில் மிகச்சிறிய எண்ணைக் கண்டுபிடிக்க நாம் அதிக கட்டளையை அகற்ற வேண்டும்.

இவ்வாறு ‘சி ++ இல் வரிசைப்படுத்துதல் செயல்பாடு’ குறித்த இந்த கட்டுரையின் முடிவுக்கு வந்துள்ளோம். நீங்கள் மேலும் அறிய விரும்பினால், நம்பகமான ஆன்லைன் கற்றல் நிறுவனமான எடுரேகாவின் ஜாவா பயிற்சியைப் பாருங்கள். எடுரேகா ஹைபர்னேட் & ஸ்பிரிங் போன்ற பல்வேறு ஜாவா கட்டமைப்புகளுடன் கோர் மற்றும் மேம்பட்ட ஜாவா கருத்தாக்கங்களுக்கும் பயிற்சி அளிக்க வடிவமைக்கப்பட்டுள்ளது.

எங்களுக்கு ஒரு கேள்வி கிடைத்ததா? தயவுசெய்து இந்த வலைப்பதிவின் கருத்துகள் பிரிவில் குறிப்பிடவும், விரைவில் நாங்கள் உங்களைத் தொடர்புகொள்வோம்.