ఉదాహరణలతో C ++ లో విలీన క్రమబద్ధీకరణను ఎలా అమలు చేయాలి

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

ఈ వ్యాసంలో క్రింది గమనికలు కవర్ చేయబడతాయి,

• అల్గోరిథంను విభజించి జయించండి
• విలీన విధమైన అల్గోరిథంను ఒక ఉదాహరణతో అర్థం చేసుకోవడం
• విలీనం క్రమబద్ధీకరణ కోసం సూడోకోడ్
• విలీనం క్రమబద్ధీకరణ కోసం C ++ లో ప్రోగ్రామ్
• విలీనం క్రమబద్ధీకరణకు సమయం సంక్లిష్టత

C ++ లో విలీనం క్రమబద్ధీకరణపై ఈ కథనంతో కదులుతోంది

అల్గోరిథంను విభజించి జయించండి

Icks బి ఎలా పనిచేస్తుందో మీకు ఇప్పటికే తెలిసి ఉంటే, మీరు విభజన గురించి తెలుసుకోవచ్చు మరియు వ్యూహాన్ని జయించవచ్చు. డివైడ్ అండ్ కాంక్వెర్ మూడు ప్రధాన దశలను కలిగి ఉంటుంది. ఈ దశలను అర్థం చేసుకోవడానికి హలో [] ఇండెక్స్ ‘ఎ’ ను ప్రారంభించి, ఇండెక్స్ ‘ఎన్’ ను ముగించాము, అందువల్ల మన శ్రేణిని ఈ క్రింది విధంగా వ్రాయవచ్చు హలో [a & hellip..n]

విభజించు- ఇచ్చిన సమస్యను ఉప సమస్యలు లేదా ఉప భాగాలుగా విభజించడం ప్రధాన కదలిక లేదా విభజన మరియు జయించడం యొక్క ప్రధాన దశ. ఇక్కడ క్యాచ్ ఏమిటంటే ఉప సమస్యలు అసలు సమస్యతో సమానంగా ఉండాలి మరియు పరిమాణంలో చిన్నవిగా ఉండాలి. మా విషయంలో మేము మా శ్రేణిని 2 భాగాలుగా విభజిస్తాము [a & hellip.m] [m + 1 & hellip..n] m a మరియు n సూచిక మధ్యలో ఉంది

జయించండి- మన సమస్యను ఉప సమస్యలుగా విభజించిన తర్వాత. మేము ఈ ఉప సమస్యలను పునరావృతంగా పరిష్కరిస్తాము.

కలపండి- ఈ దశలో, మేము మా ఉప సమస్యల యొక్క అన్ని పరిష్కారాలను తగిన విధంగా మిళితం చేస్తాము. మరో మాటలో చెప్పాలంటే, మేము 2 వేర్వేరు క్రమబద్ధీకరించిన శ్రేణులను కలిపి ఒక క్రమబద్ధీకరించిన శ్రేణిని ఏర్పరుస్తాము. అక్కడ మన క్రమబద్ధీకరించిన శ్రేణి ఉంది.

C ++ లో విలీనం క్రమబద్ధీకరణపై ఈ కథనంతో కదులుతోంది

విలీన క్రమబద్ధీకరణ అల్గోరిథంను ఉదాహరణతో అర్థం చేసుకోవడం

ఈ సమయంలో, విలీన క్రమబద్ధీకరణ ద్వారా ఏ విధానం ఉపయోగించబడుతుందో మాకు తెలుసు. కాబట్టి, ఒక ఉదాహరణను పరిశీలిద్దాం మరియు హలో [] నుండి క్రమబద్ధీకరించని శ్రేణికి క్రమబద్ధీకరించని ప్రతి దశకు వెళ్దాం.
ఉదాహరణ- హలో [10, 3, 7, 1, 15, 14, 9, 22]

పై చిత్రంలో, మేము క్రమబద్ధీకరించని శ్రేణిని పరిగణించాము మరియు క్రమబద్ధీకరించిన శ్రేణిని పొందటానికి విలీన క్రమాన్ని ఉపయోగించాము. ఇప్పుడు, ప్రతి దశను చూద్దాం మరియు మొత్తం అల్గోరిథం అర్థం చేసుకుందాం

1. మొదట, మేము శ్రేణిని పరిగణించాము హలో [10, 3, 7, 1, 15, 14, 9, 22] ఈ శ్రేణిలో మొత్తం 8 అంశాలు ఉన్నాయి

2. మునుపు విలీన క్రమబద్ధీకరణ మూలకాలను క్రమబద్ధీకరించడానికి విభజన మరియు జయించే విధానాన్ని ఉపయోగిస్తుంది. మేము మా శ్రేణి మధ్యలో ఉన్న m ను కనుగొన్నాము మరియు మా శ్రేణిని మధ్య నుండి విభజించాము, ఇక్కడ m = (a - n) / 2 'a' అనేది ఎడమవైపు మూలకం యొక్క సూచిక మరియు n అనేది మన శ్రేణి యొక్క కుడి మూలకం యొక్క సూచిక .

3. మొదటి డివిజన్ తరువాత, మనకు 4 భాగాలు కలిగిన 2 భాగాలు ఉన్నాయి. మొదటి సగం [10, 3, 7, 1] చూద్దాం.

4. మేము [10, 3, 7, 1] ను 2 భాగాలుగా [10, 3] మరియు [7, 1] గా విభజిస్తాము. ఆ తరువాత మేము వాటిని మరింత [10], [3], [7], [1] గా విభజిస్తాము. మేము m ను లెక్కించలేనందున మరింత విభజన సాధ్యం కాదు. ఒకే మూలకాన్ని కలిగి ఉన్న జాబితా ఎల్లప్పుడూ క్రమబద్ధీకరించబడుతుంది.

5. విలీనం ఎలా జరుగుతుంది? తెలుసుకుందాం. మొదటి [10] మరియు [3] పోల్చబడింది మరియు ఆరోహణ క్రమంలో విలీనం చేయబడింది [3, 10] మనకు లభించే విధంగా [1, 7]

6. ఆ తరువాత, మేము [3, 10] మరియు [1, 7] ను పోల్చాము. ఒకసారి పోల్చినప్పుడు మేము వాటిని ఆరోహణ క్రమంలో విలీనం చేస్తాము మరియు మనకు [1, 3, 7, 10] లభిస్తుంది.

7. [15, 14, 9, 2] కూడా విభజించబడింది మరియు అదే విధంగా కలిపి [9, 14, 15, 22].

8. చివరి దశలో మన క్రమబద్ధీకరించిన శ్రేణిని ఇవ్వడానికి [15, 14, 9, 2] [9, 14, 15, 22] ను పోల్చి చూస్తాము.అనగా [1, 3, 7, 9, 10, 14, 15, 22].

C ++ లో విలీనం క్రమబద్ధీకరణపై ఈ కథనంతో కదులుతోంది

విలీనం క్రమబద్ధీకరణ కోసం సూడోకోడ్

మిగిలి ఉంటే ప్రారంభించండి
విలీనంసోర్ట్ () ఫంక్షన్ మన శ్రేణిని ఒకే మూలకం అయ్యేవరకు విభజించడానికి పునరావృతంగా పిలుస్తుంది మరియు క్రమబద్ధీకరించిన శ్రేణులను విలీనం చేయడానికి ఫంక్షన్ విలీనం () ఉపయోగించబడుతుంది.
  C ++ లో విలీనం క్రమబద్ధీకరణపై ఈ కథనంతో కదులుతోంది
 C ++ లో క్రమబద్ధీకరణ ప్రోగ్రామ్‌ను విలీనం చేయండి 
# చేర్చండి లాస్టిండెక్స్) {if (ఫస్ట్ఇండెక్స్size int హలో [పరిమాణం], నేను కౌట్<<'Enter the elements of the array one by one:n' for(i=0 i>హలో [i] విలీనసార్ట్ (హలో, 0, పరిమాణం - 1) కౌట్<<'The Sorted List isn' for(i=0 i
 అవుట్పుట్- 
C ++ లో విలీనం క్రమబద్ధీకరణపై ఈ కథనంతో కదులుతోంది
 సమయం సంక్లిష్టత 
మేము అల్గోరిథంల గురించి మాట్లాడేటప్పుడు పరిగణించవలసిన ముఖ్యమైన అంశం సమయం సంక్లిష్టత. విలీన క్రమబద్ధీకరణ ఇతర సార్టింగ్ అల్గారిథమ్‌లతో పోలిస్తే గొప్ప సమయ సంక్లిష్టతను కలిగి ఉంటుంది.
జావాలో విలువ ద్వారా పాస్ చేయండి
చెత్త కేసు నడుస్తున్న సమయం- O (n log n) 
ఉత్తమ కేసు నడుస్తున్న సమయం- O (n log n) 
సగటు నడుస్తున్న సమయం- O (n log n)
దీనితో, మేము C ++ వ్యాసంలో ఈ విలీన క్రమబద్ధీకరణకు వచ్చాము. మీరు మరింత తెలుసుకోవాలనుకుంటే, చూడండి   విశ్వసనీయ ఆన్‌లైన్ లెర్నింగ్ సంస్థ ఎడురేకా చేత. ఎడురేకా యొక్క జావా J2EE మరియు SOA శిక్షణ మరియు ధృవీకరణ కోర్సు కోర్ మరియు అధునాతన జావా భావనలతో పాటు హైబర్నేట్ & స్ప్రింగ్ వంటి వివిధ జావా ఫ్రేమ్‌వర్క్‌ల కోసం మీకు శిక్షణ ఇవ్వడానికి రూపొందించబడింది.
 మాకు ప్రశ్న ఉందా? దయచేసి ఈ బ్లాగ్ యొక్క వ్యాఖ్యల విభాగంలో దీనిని ప్రస్తావించండి మరియు మేము వీలైనంత త్వరగా మిమ్మల్ని సంప్రదిస్తాము.