Menu

Sloučit řazení v C ++ s příklady

merge sort c with examples

Vyzkoušejte Náš Nástroj Pro Odstranění Problémů

Technika sloučení C ++ sloučení.

Algoritmus sloučení řazení používá „ rozděl a panuj „Strategie, ve které rozdělíme problém na dílčí problémy a řešíme tyto dílčí problémy jednotlivě.

Tyto dílčí problémy se poté spojí nebo sloučí a vytvoří jednotné řešení.

=> Přečtěte si zde populární sérii školení C ++.

Sloučit třídění

Co se naučíte:

třídění výběru v c ++

Přehled

Sloučení se provádí pomocí následujících kroků:

# 1) Seznam, který má být seřazen, je rozdělen na dvě pole stejné délky rozdělením seznamu na prostřední prvek. Pokud je počet prvků v seznamu 0 nebo 1, je seznam považován za seřazený.

#dva) Každý podseznam je tříděn jednotlivě pomocí rekurzivního řazení sloučení.

# 3) Seřazené podseznamy se poté sloučí nebo sloučí dohromady a vytvoří kompletní seřazený seznam.

Obecný algoritmus

Obecný pseudokód pro techniku ​​sloučení je uveden níže.

Deklarujte pole Arr o délce N
Pokud N = 1, Arr je již seřazen
Pokud N> 1,
Vlevo = 0, vpravo = N-1
Najděte prostřední = (vlevo + vpravo) / 2
Volejte merge_sort (Arr, vlevo, uprostřed) => třídit první polovinu rekurzivně
Volejte merge_sort (Arr, prostřední + 1, pravý) => třídit druhou polovinu rekurzivně
Voláním sloučení (Arr, vlevo, uprostřed, vpravo) sloučíte seřazená pole ve výše uvedených krocích.
Výstup

Jak je ukázáno ve výše uvedeném pseudokódu, v algoritmu sloučení řazení rozdělíme pole na polovinu a každou polovinu roztřídíme rekurzivně pomocí sloučení. Jakmile jsou dílčí pole tříděna jednotlivě, jsou dvě dílčí pole sloučena dohromady a vytvoří kompletní seřazené pole.

Pseudokód pro sloučení

Následuje pseudokód pro techniku ​​sloučení. Nejprve máme postup sloučení, abychom rekurzivně rozdělili pole na poloviny. Pak máme slučovací rutinu, která sloučí seřazená menší pole a získá kompletní seřazené pole.

procedure mergesort( array,N ) array – list of elements to be sorted N – number of elements in the list begin if ( N == 1 ) return array var array1 as array = a(0) ... a(N/2) var array2 as array = a(N/2+1) ... a(N) array1 = mergesort(array1) array2 = mergesort(array2) return merge( array1, array2 ) end procedure procedure merge(array1, array2 ) array1 – first array array2 – second array begin var c as array while ( a and b have elements ) if ( array1(0) > array2(0) ) add array2 (0) to the end of c remove array2 (0) from array2 else add array1 (0) to the end of c remove array1 (0) from array1 end if end while while ( a has elements ) add a(0) to the end of c remove a(0) from a end while while ( b has elements ) add b(0) to the end of c remove b(0) from b end while return c end procedure

Pojďme si nyní ilustrovat techniku ​​sloučení sloučením na příkladu.

Ilustrace

sloučit řazení Ilustrace

Výše uvedený obrázek lze zobrazit v tabulce níže:

SložitNezařazený seznamrozdělitSeřazený seznam
1{12, 23,2,43,51,35,19,4}{12,23,2,43}
{51,35,19,4}		{}
dva{12,23,2,43}
{51,35,19,4}		{12.23} {2.43}
{51.35} {19.4}		{}
3{12.23} {2.43}
{51.35} {19.4}		{12.23} {2.43}
{35,51} {4,19}		{12.23} {2.43}
{35,51} {4,19}
4{12.23} {2.43}
{35,51} {4,19}		{2,12,23,43}
{4,19,35,51}		{2,12,23,43}
{4,19,35,51}
5{2,12,23,43}
{4,19,35,51}		{2,4,12,19,23,35,43,51}{2,4,12,19,23,35,43,51}
6{}{}{2,4,12,19,23,35,43,51}

Jak je znázorněno ve výše uvedeném znázornění, nejprve je pole rozděleno na dvě dílčí pole délky 4. Každé dílčí pole je dále rozděleno na další dvě dílčí pole délky 2. Každé dílčí pole je poté dále rozděleno na dílčí pole po jednom prvku. Celý tento proces je procesem „Rozdělte“.

Jakmile jsme pole rozdělili na dílčí pole každého jednotlivého prvku, musíme nyní tato pole sloučit v seřazeném pořadí.

Jak je znázorněno na obrázku výše, uvažujeme každé dílčí pole jednoho prvku a nejdříve je kombinujeme, abychom vytvořili dílčí pole dvou prvků v seřazeném pořadí. Dále se setřídí seřazené podskupiny délky dva a zkombinují se tak, aby vytvořily dvě podskupiny délky každé čtyři. Pak zkombinujeme tato dvě dílčí pole a vytvoříme kompletní seřazené pole.

Iterativní sloučení řazení

Algoritmus nebo technika sloučení, kterou jsme viděli výše, používá rekurzi. Je také známý jako „ rekurzivní sloučení “.

Víme, že rekurzivní funkce používají zásobník volání funkcí k uložení přechodného stavu volající funkce. Ukládá také další informace o účetnictví pro parametry atd. A představuje režijní náklady, pokud jde o ukládání aktivačního záznamu volání funkce a obnovení provádění.

Všech těchto režií se můžeme zbavit, pokud místo rekurzivních použijeme iterativní funkce. Výše uvedený algoritmus sloučení lze také snadno převést na iterativní kroky pomocí smyček a rozhodování.

Stejně jako rekurzivní řazení sloučení má iterativní sloučení také složitost O (nlogn), a proto je výkonný, fungují navzájem na stejné úrovni. Jednoduše jsme schopni snížit režijní náklady.

V tomto kurzu jsme se soustředili na rekurzivní řazení sloučení a dále implementujeme rekurzivní řazení sloučení pomocí jazyků C ++ a Java.

Níže je uvedena implementace techniky sloučení pomocí C ++.

#include using namespace std; void merge(int *,int, int , int ); void merge_sort(int *arr, int low, int high) { int mid; if (low num; cout<<'Enter '<myarray(i); } merge_sort(myarray, 0, num-1); cout<<'Sorted array '; for (int i = 0; i < num; i++) { cout<

Výstup:

Zadejte počet prvků, které mají být tříděny: 10

Zadejte 10 prvků k seřazení: 101 10 2 43 12 54 34 64 89 76

Seřazené pole

2 10 12 34 43 54 64 76 89 101

V tomto programu jsme definovali dvě funkce, Sloučit třídění a jít . Ve funkci merge_sort rozdělíme pole na dvě stejná pole a voláme funkci sloučení na každém z těchto dílčích polí. Ve funkci sloučení provedeme skutečné třídění na těchto dílčích polích a poté je sloučíme do jednoho kompletního seřazeného pole.

Dále implementujeme techniku ​​Sloučit řazení v jazyce Java.

class MergeSort { void merge(int arr(), int beg, int mid, int end) { int left = mid - beg + 1; int right = end - mid; int Left_arr() = new int (left); int Right_arr() = new int (right); for (int i=0; i

Výstup:

Vstupní pole

101 10 2 43 12 54 34 64 89 76

Pole seřazeno pomocí sloučení

2 10 12 34 43 54 64 76 89 101

I v implementaci Java používáme stejnou logiku, jakou jsme použili v implementaci C ++.

Sloučit řazení je efektivní způsob třídění seznamů a většinou se používá k třídění propojených seznamů. Jelikož využívá metodu rozdělení a dobývání, technika sloučení je stejně efektivní pro menší i větší pole.

Analýza složitosti algoritmu řazení sloučení

Víme, že abychom mohli provádět třídění pomocí sloučení, nejprve rozdělíme pole na dvě stejné poloviny. To představuje „log n“, což je logaritmická funkce a počet provedených kroků je maximálně log (n + 1).

Dále k nalezení prostředního prvku pole potřebujeme jeden krok, tj. O (1).

Poté, abychom sloučili dílčí pole do pole n prvků, vezmeme O (n) dobu běhu.

Celkový čas pro provedení sloučení tedy bude n (log n + 1), což nám dá časovou složitost O (n * logn).

Nejhorší časová složitostO (n * log n)
Nejlepší časová složitostO (n * log n)
Průměrná časová složitostO (n * log n)
Složitost prostoruNa)

Časová složitost pro sloučení je stejná ve všech třech případech (nejhorší, nejlepší a průměrná), protože vždy rozdělí pole na dílčí pole a poté sloučí dílčí pole s lineárním časem.

Sloučení sloučení vždy zabírá stejné množství prostoru jako netříděná pole. Pokud je tedy seznam, který se má třídit, pole, nemělo by se sloučení použít pro velká pole. Sloučené řazení však lze efektivněji použít pro řazení propojených seznamů.

Závěr

Sloučit sloučení používá strategii „rozděl a panuj“, která rozděluje pole nebo seznam do mnoha dílčích polí a třídí je jednotlivě a poté se sloučí do úplného seřazeného pole.

Sloučené řazení funguje rychleji než jiné metody řazení a také funguje efektivně pro menší a větší pole.

V našem nadcházejícím kurzu prozkoumáme více informací o rychlém řazení!

=> Zde si všimněte výcvikového průvodce pro začátečníky v C ++.

Doporučené čtení

^