சி ++ இல் குவிக்சார்ட் பற்றி நீங்கள் தெரிந்து கொள்ள வேண்டியது எல்லாம்

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

iterator java ஐ எவ்வாறு பயன்படுத்துவது

• குவிக்சோர்ட் அல்காரிதம் புரிந்துகொள்ளுதல்
• குவிக்சார்ட்டுக்கான சூடோகுறியீடு
• சி ++ இல் குவிக்சோர்ட்டின் திட்டம்
• நேர சிக்கலான குவிகார்ட்

குவிக்சோர்ட் அல்காரிதம் புரிந்துகொள்ளுதல்

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

1. முதலில், பயனரிடமிருந்து வரிசைப்படுத்தப்படாத வரிசையை நாங்கள் கேட்போம்.

2. எங்கள் வரிசைப்படுத்தப்படாத வரிசை கிடைத்ததும், வரிசையிலிருந்து ஒரு மைய மதிப்பைத் தேர்ந்தெடுக்க வேண்டும். நாம் எந்த மதிப்பையும் தேர்வு செய்யலாம்.

   
   
   

3. பிவோட் புள்ளியைத் தேர்ந்தெடுத்தவுடன், வரிசையின் மற்ற உறுப்புகளை நாம் ஒழுங்கமைக்க வேண்டும், பிவோட் மதிப்பை விடக் குறைவான அனைத்து உறுப்புகளும் பிவோட் மதிப்பின் வலதுபுறத்திலும், பிவோட்டை விட பெரிய அனைத்து கூறுகளையும் வைக்க வேண்டும். மதிப்பு மைய மதிப்பின் வலதுபுறத்தில் வைக்கப்பட வேண்டும்.

4. எங்கள் வரிசைப்படுத்தப்பட்ட வரிசையைப் பெறும் வரை நாங்கள் படி 3 ஐ செய்கிறோம்.

இப்போது, ​​ஒரு எடுத்துக்காட்டைக் கருத்தில் கொண்டு வழிமுறையை செயல்படுத்தி அது எவ்வாறு செயல்படுகிறது என்பதைப் பார்ப்போம்.

வணக்கம் [5, 4, 1, 11, 9, 6, 2, 3] இந்த எடுத்துக்காட்டுக்கு, முன்னிலை எப்போதும் பட்டியலின் சரியான உறுப்பு என்று கருதுவோம்.

ஒவ்வொரு அடியிலும் சென்று சிக்கலைத் தீர்க்க நாங்கள் பயன்படுத்திய தர்க்கத்தைப் புரிந்துகொள்வோம்.

சால்ட்ஸ்டாக் vs பொம்மை Vs செஃப்

• முதலில், ‘3’ ஐ எங்கள் மையமாகத் தேர்ந்தெடுத்து, வலதுபுறத்தில் ‘3’ ஐ விடக் குறைவான அனைத்து உறுப்புகளையும், ‘3’ ஐ விட பெரிய அனைத்து உறுப்புகளையும் வலதுபுறமாக அமைத்தோம்.

• இந்த கட்டத்தில், எங்களிடம் 2 துணை சிக்கல்கள் உள்ளன. முதலில் வலதுபுறத்தில் உள்ள துணை சிக்கலை தீர்க்கலாம். ஒன்றை எங்கள் மையமாகத் தேர்ந்தெடுத்து, ‘2’ ஐ வலதுபுறமாக வைத்தோம்.

• இரண்டாவது துணைப் பிரச்சினையைத் தீர்க்க, ‘6’ ஐ எங்கள் மையமாகத் தேர்ந்தெடுத்து, நாம் முன்பு விவாதித்தபடி கூறுகளை வைக்கிறோம்.

• எங்களிடம் மேலும் 2 துணைப்பிரிவுகள் உள்ளன. முதலாவது 4 ஐ மையமாகத் தேர்ந்தெடுப்பதன் மூலமும், இரண்டாவது 9 ஐ மையமாகத் தேர்ந்தெடுப்பதன் மூலமும் தீர்க்கப்படும். இறுதியாக, அடிக்கோடிட்ட குறியீட்டில் வைக்கப்பட்டுள்ள உறுப்புகளுடன் எங்கள் வரிசைப்படுத்தப்பட்ட வரிசை உள்ளது.

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

சி ++ இல் குவிக்சார்ட்டிற்கான சூடோகுறியீடு

QuickSort (வரிசை [], தொடக்க_இண்டெக்ஸ், end_index) {if (start_index
 சி ++ இல் குவிக்சோர்ட்டின் திட்டம் 
நாங்கள் வழிமுறையைப் புரிந்துகொண்டு வழிமுறையின் செயல்பாடுகள் குறித்து ஆழமான புரிதலை வளர்த்தோம். C ++ இல் Quicksort ஐ செயல்படுத்தலாம் மற்றும் ஒரு வரிசையை வரிசைப்படுத்த ஒரு நிரலை எழுதுவோம்.
# பெயர்வெளியைப் பயன்படுத்தவும் (int j = start_index j க்கான வரிசை [end_index] int i = (start_index - 1)<= end_index- 1 j++) { if (array[j] <= pivot) { i++ swap_elements(&array[i], &array[j]) } } swap_elements(&array[i + 1], &array[end_index]) return (i + 1) } void quickSort(int array[], int start_index, int end_index) { if (start_index < end_index) { int partition_index = partition(array, start_index, end_index) quickSort(array, start_index, partition_index - 1) quickSort(array, partition_index + 1, end_index) } } void printArray(int array[], int number) { int i cout<<'Sorted Array: ' for (i = 0 i < number i++) cout << array[i] << ' ' cout << endl } int main() { int Hello[30] int i int NumberofElements cout<>NumberofElements செலவு<<'Enter the elements one by one: ' for(i=0i>வணக்கம் [i]} விரைவுசார்ட் (ஹலோ, 0, நம்பர்எஃப்மென்ட்ஸ் -1) பிரிண்ட்அரே (ஹலோ, நம்பர்எஃப்மென்ட்ஸ்) திரும்ப 0}
 வெளியீடு: 
 நேர சிக்கலானது 
எந்தவொரு வரிசையாக்க வழிமுறையின் மிக முக்கியமான அம்சத்தைப் பற்றி பேசலாம், அதாவது நேர சிக்கலானது. இது பல்வேறு காட்சிகளில் வழிமுறையின் செயல்திறனைப் பற்றி சொல்கிறது. எங்கள் வழிமுறைக்கு இந்த வழிமுறையைப் பயன்படுத்தலாமா என்பதை தீர்மானிக்க இந்த மதிப்புகள் நமக்கு உதவக்கூடும்.
வரிசை ஜாவாவில் அதிக மதிப்பைக் கண்டறியவும்
 சிறந்த வழக்கு- ஓ (என்)
 சராசரி வழக்கு- (nlogn)
 மிக மோசமான நிலையில்- ஓ (என்2)
இதன் மூலம், சி ++ கட்டுரையில் இந்த குவிக்சார்ட்டின் முடிவுக்கு வருகிறோம். நீங்கள் மேலும் அறிய விரும்பினால், பாருங்கள்   எடூரேகா, நம்பகமான ஆன்லைன் கற்றல் நிறுவனம். எடுரேகாவின் ஜாவா ஜே 2 இஇ மற்றும் எஸ்ஓஏ பயிற்சி மற்றும் சான்றிதழ் பாடநெறி, முக்கிய மற்றும் மேம்பட்ட ஜாவா கருத்தாக்கங்களுக்கும், ஹைபர்னேட் & ஸ்பிரிங் போன்ற பல்வேறு ஜாவா கட்டமைப்புகளுக்கும் பயிற்சி அளிக்க வடிவமைக்கப்பட்டுள்ளது.
 எங்களுக்கு ஒரு கேள்வி கிடைத்ததா? தயவுசெய்து இந்த வலைப்பதிவின் கருத்துகள் பிரிவில் குறிப்பிடவும், விரைவில் நாங்கள் உங்களைத் தொடர்புகொள்வோம்.