సి ++ లో క్విక్స్‌పోర్ట్ గురించి మీరు తెలుసుకోవలసినది

అల్గోరిథంలను క్రమబద్ధీకరించడానికి చాలా ఉన్నాయి. మీ అనువర్తనానికి సరైన ఫిట్‌ను కనుగొనడం అనేది ఒక నిర్దిష్ట అల్గోరిథం యొక్క పనితీరు, సమయ సంక్లిష్టత, కోడ్ యొక్క పొడవు మొదలైన అంశాల గురించి సంక్షిప్త అవగాహన అవసరం. ఈ పోస్ట్‌లో, C ++ లో క్విక్‌సోర్ట్‌ను అమలు చేయడానికి అవసరమైన అన్ని ముఖ్యమైన అంశాలను ఈ క్రింది క్రమంలో పరిశీలిస్తాము:

• క్విక్స్‌పోర్ట్ అల్గోరిథం అర్థం చేసుకోవడం
• క్విక్స్‌పోర్ట్ కోసం సూడోకోడ్
• సి ++ లో క్విక్స్పోర్ట్ యొక్క ప్రోగ్రామ్
• సమయం సంక్లిష్టత క్విక్స్‌పోర్ట్

క్విక్స్‌పోర్ట్ అల్గోరిథం అర్థం చేసుకోవడం

లాగానే విలీనం క్రమబద్ధీకరించు , క్విక్‌సార్ట్ విభజన మరియు జయించే వ్యూహాన్ని అనుసరిస్తుంది. విభజన మరియు జయించే వ్యూహాన్ని ఉపయోగించడం ద్వారా మేము సమస్యను అనేక ఉప సమస్యలుగా విభజిస్తాము మరియు వాటిని పునరావృతంగా పరిష్కరిస్తాము. మొదట, మేము మొత్తం ప్రక్రియను దశల వారీగా అర్థం చేసుకుంటాము మరియు ఆ తరువాత, ఒక ఉదాహరణ సహాయంతో, మేము మొత్తం ప్రక్రియపై లోతైన అవగాహన పెంచుకుంటాము.

విండోస్ 7 లో php ని ఇన్‌స్టాల్ చేయండి

1. మొదట, మేము వినియోగదారు నుండి క్రమబద్ధీకరించని శ్రేణిని అడుగుతాము.

2. మన క్రమబద్ధీకరించని శ్రేణిని కలిగి ఉన్న తర్వాత, శ్రేణి నుండి పైవట్ విలువను ఎంచుకోవాలి. మేము ఏదైనా విలువను ఎంచుకోవచ్చు.

   
   
   

3. మేము పివోట్ పాయింట్‌ను ఎంచుకున్న తర్వాత, శ్రేణి యొక్క ఇతర అంశాలను ఈ విధంగా అమర్చాలి, పివట్ విలువ కంటే తక్కువ ఉన్న అన్ని మూలకాలను పివట్ విలువ యొక్క కుడి వైపున ఉంచాలి మరియు పివట్ కంటే ఎక్కువ అన్ని అంశాలు ఉండాలి విలువ పైవట్ విలువ యొక్క కుడి వైపున ఉంచాలి.

4. మన క్రమబద్ధీకరించిన శ్రేణిని పొందే వరకు మేము దశ 3 ని చేస్తాము.

ఇప్పుడు, ఒక ఉదాహరణను పరిశీలిద్దాం మరియు అల్గోరిథంను అమలు చేసి, అది ఎలా పనిచేస్తుందో చూద్దాం.

హలో [5, 4, 1, 11, 9, 6, 2, 3] ఈ ఉదాహరణ కోసం మేము ఎల్లప్పుడూ పైవట్‌ను జాబితా యొక్క కుడి మూలకంగా పరిగణిస్తాము.

ప్రతి దశను చూద్దాం మరియు సమస్యను పరిష్కరించడానికి మేము ఉపయోగించిన తర్కాన్ని అర్థం చేసుకుందాం.

• మొదట, మేము ‘3’ ను మా పైవట్‌గా ఎంచుకున్నాము మరియు అన్ని మూలకాలను కుడివైపున ‘3’ కన్నా తక్కువ మరియు అన్ని మూలకాలను ‘3’ కంటే ఎక్కువ కుడి వైపున అమర్చాము.

• ఈ సమయంలో, మాకు 2 ఉప సమస్యలు ఉన్నాయి. మొదట కుడి వైపున ఉన్న ఉప సమస్యను పరిష్కరించుకుందాం. మేము ఒకదాన్ని మా ఇరుసుగా ఎంచుకుని, ‘2’ ను కుడి వైపున ఉంచాము.

• రెండవ ఉప సమస్యను పరిష్కరించడానికి మేము ‘6’ ను మా ఇరుసుగా ఎంచుకుంటాము మరియు మేము ఇంతకుముందు చర్చించినట్లుగా అంశాలను ఉంచాము.

• మాకు మరో 2 ఉప సమస్యలు ఉన్నాయి. మొదటిది 4 ను పివోట్‌గా ఎంచుకోవడం ద్వారా పరిష్కరించబడుతుంది మరియు రెండవది పివట్‌గా 9 ని ఎంచుకోవడం ద్వారా పరిష్కరించబడుతుంది. చివరగా, అండర్లైన్ ఇండెక్స్ వద్ద ఉంచిన మూలకాలతో మన క్రమబద్ధీకరించిన శ్రేణి ఉంది.

గమనిక- ఇక్కడ అర్థం చేసుకోవలసిన ముఖ్యమైన విషయం ఏమిటంటే, అన్ని ఆపరేషన్లు ఒకే శ్రేణిలో జరుగుతాయి. క్రొత్త శ్రేణులు సృష్టించబడవు.

సి ++ లో క్విక్స్‌పోర్ట్ కోసం సూడోకోడ్

క్విక్‌సోర్ట్ (శ్రేణి [], ప్రారంభ_ఇండెక్స్, ఎండ్_ఇండెక్స్) {if (start_index
 సి ++ లో క్విక్స్పోర్ట్ యొక్క ప్రోగ్రామ్ 
మేము అల్గోరిథం అర్థం చేసుకున్నాము మరియు అల్గోరిథం యొక్క పనిపై లోతైన అవగాహన పెంచుకున్నాము. C ++ లో క్విక్‌సోర్ట్‌ను అమలు చేద్దాం మరియు శ్రేణిని క్రమబద్ధీకరించడానికి ఒక ప్రోగ్రామ్‌ను వ్రాద్దాం.
# నేమ్‌స్పేస్‌ను ఉపయోగించడం చేర్చండి std void swap_elements (int * a, int * b) {int temp = * a * a = * b * b = temp} int విభజన (int array [], int start_index, int end_index) {int pivot = (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)
దీనితో, మేము C ++ వ్యాసంలో ఈ క్విక్‌సార్ట్ ముగింపుకు వచ్చాము. మీరు మరింత తెలుసుకోవాలనుకుంటే, చూడండి   విశ్వసనీయ ఆన్‌లైన్ లెర్నింగ్ సంస్థ ఎడురేకా చేత. ఎడురేకా యొక్క జావా J2EE మరియు SOA శిక్షణ మరియు ధృవీకరణ కోర్సు కోర్ మరియు అధునాతన జావా భావనలతో పాటు హైబర్నేట్ & స్ప్రింగ్ వంటి వివిధ జావా ఫ్రేమ్‌వర్క్‌ల కోసం మీకు శిక్షణ ఇవ్వడానికి రూపొందించబడింది.
 మాకు ప్రశ్న ఉందా? దయచేసి ఈ బ్లాగ్ యొక్క వ్యాఖ్యల విభాగంలో దీనిని ప్రస్తావించండి మరియు మేము వీలైనంత త్వరగా మిమ్మల్ని సంప్రదిస్తాము.