Paano Ipapatupad ang Pagsamahin sa Pagsunud-sunurin sa C ++ na may Mga Halimbawa

Magbibigay sa iyo ang artikulong ito ng isang detaield at komprehensibong kaalaman ng Pagsamahin ang Pagsunud-sunurin sa C ++, kung paano ito gumagana sa mga halimbawa.

Ano ang uri ng pagsasama? Ang merge sort ay isang algorithm ng pag-uuri na batay sa paghahambing na kabilang sa kategorya ng paghati at pagsakop. Ginagamit ang pag-uuri ng pagsasama upang pag-uri-uriin ang isang array batay sa diskarte sa paghati at pagsakop na kung saan ay masasakop nang maikli sa post na ito kasama ang iba pang mga konsepto tulad ng algorithm nito na may isang halimbawa. Titingnan din namin ang pagiging kumplikado ng oras ng pagsasama-sama ng uri sa C ++

Saklaw ang artikulong ito sa artikulong ito,





Nagpapatuloy sa artikulong ito sa Pagsamahin ang Pagsunud-sunurin sa C ++

Hatiin at lupigin ang algorithm

Kung pamilyar ka na sa kung paano gumagana ang quicksort maaari kang magkaroon ng kamalayan sa diskarte sa paghati at pagsakop. Ang Divide at Conquer ay nagsasangkot ng tatlong pangunahing mga hakbang. Para sa pag-unawa sa mga hakbang na ito isaalang-alang natin ang isang array Kamusta [] pagkakaroon ng panimulang index na ā€˜aā€™ at nagtatapos na index na ā€˜nā€™ kaya't maaari naming isulat ang aming array sa sumusunod na paraan Hello [a & hellip..n]



Hatiin- Ang pangunahing paglipat o ang pangunahing hakbang ng paghati at pagsakop ay upang hatiin ang ibinigay na problema sa mga sub-problema o sub-bahagi. Ang nahuli dito ay ang mga sub-problema ay dapat maging katulad ng orihinal na problema at mas maliit ang laki. Sa aming kaso hahatiin namin ang aming array sa 2 halves [a & hellip.m] [m + 1 & hellip..n] m ay namamalagi sa gitna ng a and n index

Mananakop- Kapag natapos na natin ang paghahati ng ating problema sa mga sub-problema. Malulutas namin ang mga subproblems na ito nang paulit-ulit.

Pagsamahin- Sa hakbang na ito, pinagsasama namin ang lahat ng mga solusyon sa aming mga sub-problema sa isang naaangkop na paraan. Sa madaling salita, pinagsasama namin ang 2 magkakaibang mga pinagsunod-sunod na array upang bumuo ng isang pinagsunod-sunod na array. Doon mayroon kaming pinagsunod-sunod na array.



Nagpapatuloy sa artikulong ito sa Pagsamahin ang Pagsunud-sunurin sa C ++

Pag-unawa sa Pagsasama-sama ng Pagsasaayos ng Algorithm sa isang Halimbawa

Sa puntong ito, alam namin kung anong diskarte ang gagamitin ng uri ng pagsasama. Kaya, isaalang-alang natin ang isang halimbawa at dumaan sa bawat hakbang mula sa Hello [] na hindi naisaayos sa isang pinagsunod-sunod na array.
Halimbawa- Kamusta [10, 3, 7, 1, 15, 14, 9, 22]

Merge-sort-in-C++

Sa imaheng nasa itaas, isinasaalang-alang namin ang isang hindi nasortadong array at ginamit ang pagsasama-sama ng uri upang makakuha ng isang pinagsunod-sunod na array. Ngayon, tingnan natin ang bawat hakbang at maunawaan ang buong algorithm

nagko-convert ng doble sa int java

1. Una, isinasaalang-alang namin ang isang array Kamusta [10, 3, 7, 1, 15, 14, 9, 22] sa array na ito mayroong kabuuang 8 elemento

2. Tulad ng nakita natin sa naunang pagsasama-sama ay gumagamit ng paghati at pagsakop sa diskarte upang pag-uri-uriin ang mga elemento. Natagpuan namin ang m na namamalagi sa gitna ng aming array at hinati ang aming array mula sa gitna kung saan ang m = (a - n) / 2 'a' ay ang index ng kaliwang elemento at ang n ang index ng pinaka-kanang elemento ng aming array .

3. Matapos ang unang dibisyon, mayroon kaming 2 bahagi na binubuo ng 4 na elemento bawat isa. Tingnan natin ang unang kalahati [10, 3, 7, 1].

4. Hinahati namin ang [10, 3, 7, 1] sa 2 bahagi [10, 3] at [7, 1]. Pagkatapos nito ay hinati namin ang mga ito sa [10], [3], [7], [1]. Ang karagdagang paghati ay hindi posible dahil hindi namin makalkula ang m. ang isang listahan na naglalaman ng isang solong elemento ay palaging itinuturing na pinagsunod-sunod.

5. Paano nagaganap ang pagsasama? Alamin Natin. Ang una [10] at [3] ay inihambing at pinagsama sa pataas na pagkakasunud-sunod [3, 10] sa parehong paraan na nakukuha natin [1, 7]

6. Pagkatapos nito, ihinahambing namin ang [3, 10] at [1, 7]. Kapag inihambing pinagsasama namin ang mga ito sa pataas na pagkakasunud-sunod at Nakukuha namin ang [1, 3, 7, 10].

7. Ang [15, 14, 9, 2] ay nahahati din at pinagsama sa isang katulad na paraan upang mabuo ang [9, 14, 15, 22].

8. Sa huling hakbang ihinahambing at pinagsasama namin ang [15, 14, 9, 2] [9, 14, 15, 22] upang bigyan kami ng aming pinagsunod-sunod na hanayie [1, 3, 7, 9, 10, 14, 15, 22].

Nagpapatuloy sa artikulong ito sa Pagsamahin ang Pagsunud-sunurin sa C ++

Pseudocode para sa Pagsamahin ang Pagsunud-sunurin

Magsimula kung iniwan

Ang function na mergeSort () recursively ay tumatawag sa sarili upang hatiin ang aming array hanggang sa maging isang solong elemento at ang function merge () ay ginagamit upang pagsamahin ang mga pinagsunod-sunod na arrays.

Nagpapatuloy sa artikulong ito sa Pagsamahin ang Pagsunud-sunurin sa C ++

Pagsamahin ang pag-uuri ng programa sa C ++

#include #include #include using namespace std void merge (int a [], int Firstindex, int m, int Lastindex) // pagsasama-sama ng mga sub-array na nilikha habang ang dibisyon ay walang bisa na pagsasama-sama (int a [], int Firstindex, int Lastindex) {kung (Firstindexsize int Kamusta [laki], cout ko<<'Enter the elements of the array one by one:n' for(i=0 i>Kumusta [i] mergeSort (Kumusta, 0, laki - 1) cout<<'The Sorted List isn' for(i=0 i

Output-

Nagpapatuloy sa artikulong ito sa Pagsamahin ang Pagsunud-sunurin sa C ++

Pagiging kumplikado ng Oras

Ang pagiging kumplikado ng oras ay isang mahalagang aspeto na isasaalang-alang kapag pinag-uusapan natin ang tungkol sa mga algorithm. Ang pagsasama-sama ng pag-uuri ay itinuturing na mayroong mahusay na pagiging kumplikado ng oras kumpara sa iba pang mga pag-uuri ng mga algorithm.

Pinakamasamang kaso na tumatakbo- O (n log n)
Pinakamahusay na oras ng pagpapatakbo ng kaso- O (n log n)
Average na oras ng pagtakbo- O (n log n)

Sa pamamagitan nito, natapos na namin ang pagsasanib na Pagsunud-sunurin sa artikulong C ++. Kung nais mong matuto nang higit pa, tingnan ang ni Edureka, isang pinagkakatiwalaang kumpanya sa pag-aaral sa online. Ang kurso sa pagsasanay at sertipikasyon ng Java J2EE at SOA ng Edureka ay idinisenyo upang sanayin ka para sa parehong core at advanced na mga konsepto ng Java kasama ang iba't ibang mga balangkas ng Java tulad ng Hibernate & Spring.

May tanong ba sa amin? Mangyaring banggitin ito sa seksyon ng mga komento ng blog na ito at babalikan ka namin sa lalong madaling panahon.