Kiwiki - Príspevky používateľa [sk]

Triedenie výberom

2021-04-19T15:56:06Z

Filip Tomek: /* Heap Sort */

[[Kategória:Algoritmy triedenia]]
{{Draft}}
{{Skripta programovanie}}
__TOC__
==Heap Sort==

===Prehľad===
''Heap Sort'' je triediaci algoritmus, ktorý podobne ako ''Selection sort'', rozeľuje pole na zotriedenú a nezotriedenú časť, pričom nezotriedená časť predstavuje dátovú štruktúru [[Hromada|binárna hromada]]. Celé triedenie spočíva v tom, že si zo vstupného poľa vytvoríme binárnu hromadu a následne postupným vyberaním a mazaním všetkých jej prvkov toto pole utriedime.

Hromada, ktorú využíva algoritmus ''Heap Sort'', musí spĺňať nasledovné podmienky (ak indexujeme pole od 0):
:1. Vrchol hromady (''koreň'') je vždy prvý prvok v poli (v našom prípade prvok na 0-tej pozícii).
:2. Pre ľubovoľný prvok (''uzol''), uložený na indexe <math>i</math> z intervalu <math> \langle 0 \ ; \ \text{dĺžka} - 1 \rangle </math>, platia nasledovné rovnice:
:: <math>
\begin{align}
\text{ľavý potomok} &= 2i + 1 && (1) \\
\text{pravý potomok} &= 2i + 2 && (2) \\
\text{rodič} &= \left \lfloor \frac{i - 1}{2} \right \rfloor \quad (\text {okrem} \ i = 0) && (3)
\end{align}
</math>
:3. Každý prvok (''uzol'') v hromade musí mať väčšiu, alebo rovnakú hodnotu ako jeho potomkovia (vlastnosť ''MAX HEAP'' - ak triedime pole vzostupne, v opačnom prípade by sme použili ''MIN HEAP'').

===Algoritmus Heapify===
[[Súbor:Heapify.png|Vizualizácia algoritmu ''Heapify'': Index ''i'' je iteračná premenná (pozri pseudokód). Ľavý a pravý potomok i-teho prvku je označený ako ''ĽP'' a ''PP''. Prvky zafarbené na modro vyjadrujú pravú podhromadu i-teho prvku a prvky zafarbené na zeleno vyjadrujú ľavú podhromadu i-teho prvku. Chronlogický postup algoritmu je znázornený číslicami 1 až 3.|699px|náhľad|vpravo]]
''Heapify'' je kľúčovým podprogramom triediaceho algoritmu ''Heap Sort'', vďaka ktorému vieme efektíve zabezpečiť procedúry: vytvorenie hromady z poľa a zmazanie hromady.

Princíp algoritmu ''Heapify'' spočíva v tom, že ak máme i-ty prvok v poli (v kompletnom binárnom strome), ktorého potomkovia tvoria dve samostatné podhromady, potom tieto dve podhromady preusporiadame do jednej hromady, pričom i-ty prvok bude jej vrcholom.

====Vlastnosti algoritmu====
* '''dátová štruktúra:''' hromada (reprezentovaná ako: pole)
* '''časová zložitosť:''' lineárna <math>O(n)</math>
* '''priestorová zložitosť:''' konštantná <math>O(1)</math> pri iteračnej verzii, <math>O(log(n))</math> pri rekurzívnej verzii

====Základné časti algoritmu====
# Určenie potomka i-teho prvku s maximálnou hodnotou.
# Porovnanie hodnoty maximálneho potomka s hodnotou rodiča (i-tym prvkom).
# Ak je hodnota maximálneho potomka väčšia ako hodnota rodiča, tak výmena potomka a rodiča.
# Ak nastane výmena, skontrolovanie ovplyvneného potomka (podhromady).

====Slovný opis algoritmu====
Na vstupe prijmeme ''pole'' a index ''i'', v ktorom chceme vytvoriť hromadu (''Max Heap''). Musí byť splnená podmienka, že oba potomkovia i-teho prvku tvoria dve samostatné podhromady.
Najskôr skontrolujeme, či ''prvok'' na indexe ''i'' má nejakých potomkov (využijeme rovnice (1) a (2) z časti "Prehľad"). Ak nemá žiadnych potomkov, funkcia skončí, pretože ''i'' predstavuje vrchol jednoprvkovej hromady. Ak má práve jedného potomka, tento potomok je zároveň aj jeho maximálnym potomkom. Ak má práve dvoch potomkov, tak porovnáme ich hodnoty a vyberieme z nich maximálneho potomka. Následne skontrolujeme veľkosť maximálneho potomka a jeho rodiča (prvok na indexe ''i''). Ak je rodič väčší, funkcia skončí, pretože želaná hromada už je utvorená. Ak nie, vymeníme rodiča a maximálneho potomka. Ak nastala výmena, musíme skontrolovať ovplyvnenú podhromadu, tj. zopakovať tento sled krokov pre podhromadu, ktorej vrchol bude v maximálnom potomkovi i-teho prvku.

Z hľadiska implementácie môžeme vytvoriť '''iteračnú''' aj '''rekurzívnu''' verziu.

====Pseudokód====
<tabs>
<tab name="Iteračná verzia" block>
Nech funkcia Heapify má nasledovný prototyp: <code>Heapify(pole[], dlzka, i)</code>
:1. Je <code>2 * i + 1 < dlzka</code> ? Ak áno, pokračuj krokom 1.1., inak skonči.
:::1.1. Nech: <code>lavy = 2 * i + 1</code>
:::1.2. Nech: <code>pravy = 2 * i + 2</code>
:::1.3. Je <code>pravy < dlzka</code> a zároveň <code>pole[pravy] > pole[lavy]</code> ?
:::::Ak áno:
:::::::1.3.1. Nech: <code>max = pravy</code>
:::::Ak nie:
:::::::1.3.1. Nech: <code>max = lavy</code>
:::1.4. Je <code>pole[max] > pole[i]</code> ?
:::::Ak áno:
:::::::1.4.1. Vymeň: <code>pole[max]</code> a <code>pole[i]</code>
:::::::1.4.2. <code>i = max</code>
:::::Ak nie:
:::::::1.4.1 Skonči.
:::1.5. Skoč na krok 1.

</tab>

<tab name="Rekurzívna verzia" block>
Nech funkcia Heapify má nasledovný prototyp: <code>Heapify(pole[], dlzka, i)</code>
:1. Nech: <code>lavy = 2 * i + 1</code>
:2. Nech: <code>pravy = 2 * i + 2</code>
:3. Nech: <code>max = i</code>
:4. Je <code>lavy < dlzka</code> a zároveň <code>pole[lavy] > pole[i]</code> ?
::: Ak áno:
:::::4.1. Nech: <code>max = lavy</code>
::: Ak nie:
:::::4.1. Pokračuj krokom 5.
:5. Je <code>pravy < dlzka</code> a zároveň <code>pole[pravy] > pole[i]</code> ?
::: Ak áno:
:::::5.1. Nech: <code>max = pravy</code>
::: Ak nie:
:::::5.1. Pokračuj krokom 6.
:6. Je <code>pole[max] > pole[i]</code> ?
::: Ak áno:
::::: 6.1. Vymeň: <code>pole[i] a pole[max]</code>
::::: 6.2. Rekurzívne zavolaj: <code>Heapify(pole[], dlzka, max)</code>
::: Ak nie:
::::: 6.1. Skonči volanie.
</tab>
</tabs>

===Algoritmus Heap Sort===
''Heap Sort'' pri triedení vykonáva dve základné úlohy: Vytvorenie maximálnej binárnej hromady zo vstupného poľa a postupné mazanie jednotlivých prvkov z hromady. Pri oboch procedúrach využíva algoritmus ''Heapify''.

====Vlastnosti algoritmu====
* '''vhodný pre dátové štruktúry:''' pole
* '''časová náročnosť:''' vždy linearitmická <math> O(n\log(n)) </math>, vďaka ktorej dokáže efektívne triediť veľmi veľké polia

[[Súbor:HeapSort.png|Vizualizácia priebehu algoritmu ''Heap Sort'': Algoritus je znázornený pomocou ''poľa'', ktoré triedime a binárnej hromady, ktorú dané pole reprezentuje. Indexy ''i'' a ''j'' sú sú iteračné premenné (pozri pseudokód). Indexy ľavého a pravého potomka i-teho prvku sú označené ako ''ĽP'' a ''PP''. Vrchol celej hromady je označený ako ''V''. Prvky zafarbené na modro vyjadrujú pravú podhromadu i-teho prvku a prvky zafarbené na zeleno vyjadrujú ľavú pohromadu i-teho prvku. Nevyfarbené prvky vyjadrujú prvky, ktoré boli zmazané. Chronologický priebeh je označený číslicami 1 až 12. |500px|náhľad|vpravo]]

* '''priestorová náročnosť:''' konštantná <math>O(1)</math> pri iteračnej verzii, logaritmická <math>O(\log(n))</math> pri rekurzívnej verzii.
* '''druh triedenia:''' triedenie výberom (komparačný algoritmus)
* '''stabilita triedenia:''' nestabilný
* '''miesto triedenia:''' vnútorné triedenie

====Základné časti algoritmu====
# Vytvorenie binárnej hromady z poľa.
# Zmazanie binárnej hromady.

====Slovný opis====
=====Vytvorenie hromady=====
Pri vytváraní hromady využijeme algoritmus ''Heapify'', pričom hromadu vytvoríme spôsobom zospodu na vrch.

Najskôr si určíme rodiča posledného potomka. Využijeme rovnicu (3) z časti "Prehľad", ktorú si jemne upravíme:
<center><math> \text{posledný rodič:} \ \ i = \left \lfloor \frac{\text{posledný index } - \ 1}{2} \right \rfloor = \left \lfloor\frac{\text{dĺžka } - \ 2}{2} \right \rfloor = \left \lfloor \frac{\text{dĺžka}}{2}\right \rfloor - 1 </math></center>
Následne zavoláme ''Heapify'' na podhromadu s vrcholom na indexe ''i''. Potom postupne zmenšujeme index ''i'' o ''1'' a opakovane naňho voláme ''Heapify'' až do chvíle, kým neprídeme na začiatok poľa. Touto procedúrou preusporiadavame spodné jednoprvkové podhromady do 3-prvkových podhromád, tie do 7-prvkových podhromád ... až kým nedostaneme jednu N-prvkovú hromadu, kde ''N'' je počet prvkov v poli. Schematicky by sme to mohli napísať takto:
<center><math> \text{pre } i \text{ z intervalu } \left \langle \left \lfloor \frac {\text{dĺžka}}{2} \right \rfloor - 1 \quad ; \quad 0 \right \rangle :\ \text{Heapify( pole[], dĺžka, i )}</math></center>

=====Zmazanie hromady=====
Pri mazaní hromady vykonáme dve operácie. Ako prvé vymeníme prvok na vrchu hromady s koncovým prvkom hromady. Prvok čo je na konci poľa považujeme už za zmazaný, preto veľkosť hromady znížime o 1. Ďalej, aby sme splnili podmienky pre maximálnu binárnu hromadu, zavoláme funkciu ''Heapify'' na celú hromadu (vrch hromady je 0-tý prvok v poli). Tento proces opakujeme, pokým v hromade neostanú žiadne prvky.

Poznámka: Pri triediacom algoritme nemusíme mazať celú hromadu, stačí nám, keď v hromade ostane jeden prvok, pretože vtedy bude vstupné pole už utriedené.

Schematicky by sme to mohli zapísať takto:
<center><math>\text{pre } j \text{ z intervalu } \left \langle \text{dĺžka - 1} \quad ; \quad 0 \right ) : \ \ \text{Vymeň(pole[0], pole[$j$])} \ \ a \ \ \text{Heapify(pole[], dĺžka, 0)} </math></center>

Z hľadiska implementácie môžeme vytvoriť '''iteračnú''' aj '''rekurzívnu''' verziu, čo závisí len od toho, ako je implementovaná funkcia ''Heapify''.

====Pseudokód====
Nech funkcia ''Heap Sort'' má nasledovný prototyp: <code>HeapSort(pole[], dlzka)</code>

:1. Nech: <code>i = dlzka / 2 - 1</code>, kde "/" predstavuje celočíslené delenie.
:2. Je <code>i >= 0</code> ? Ak áno, pokračuj krokom 2.1., inak skoč na krok 3.
:::2.1. Zavolaj funkciu: <code>Heapify(pole[], dlzka, i)</code>
:::2.2. <code>i = i - 1</code>
:::2.3. Skoč na krok 2.
:3. Nech: <code>j = dlzka - 1</code>
:4 Je <code> j > 0</code> ? Ak áno, pokračuj krokom 4.1, inak skonči.
:::4.1. Vymeň: <code>pole[0]</code> a <code>pole[j]</code>
:::4.2. Zavolaj funkciu: <code>Heapify(pole[], j, 0)</code>
:::4.3. <code>j = j - 1</code>
:::4.4. Skoč na krok 4.

===Implementácia algoritmov Heapify a HeapSort v rôznych programovacích jazykoch===
<tabs>
<tab name="Iteračná C" block>
<syntaxhighlight lang="C">

#include <stdio.h>

void Vymen(int *a, int *b);
void Heapify(int pole[], int dlzka, int index);
void HeapSort(int pole[], int dlzka);

int main()
{
int pole[]= {10, 5, 2, 9, 8, 7, 1, 3, 4, 0, -1};
int dlzka = sizeof(pole) / sizeof(pole[0]);

HeapSort(pole, dlzka);

for (int i = 0; i < dlzka; ++i)
{
printf("%d ", pole[i]);
}
}

void Vymen(int *a, int *b)
{
int tmp = *a;
*a = *b;
*b = tmp;
}

void Heapify(int pole[], int dlzka, int index)
{
int pravy, lavy, max;

while(2 * index + 1 < dlzka)
{
lavy = 2 * index + 1;
pravy = 2 * index + 2;

// určenie potomka s maximálnou hodnotou
if(pravy < dlzka && pole[pravy] > pole[lavy])
{
max = pravy;
}
else
{
max = lavy;
}

// porovnanie maximálneho potomka s rodičom
if(pole[max] > pole[index])
{

Vymen(&pole[max], &pole[index]);
index = max;
}
else
{
return;
}
}
}

void HeapSort(int pole[], int dlzka)
{
// vytvor maximálnu hromadu (procedúra BuildMaxHeap)
for (int i = dlzka / 2 - 1 ; i >= 0; --i)
{
Heapify(pole, dlzka, i);
}

// zmaž všetky prvky z hromady
for (int j = dlzka - 1; j > 0; --j)
{
Vymen(&pole[0], &pole[j]);
Heapify(pole, j, 0);
}
}
</syntaxhighlight>
</tab>
<tab name="Rekurzívna C" block>
<syntaxhighlight lang="C">
#include <stdio.h>

void Vymen(int *a, int *b);
void Heapify(int pole[], int dlzka, int index);
void HeapSort(int pole[], int dlzka);

int main()
{
int pole[]= {10, 5, 2, 9, 8, 7, 1, 3, 4, 0, -1, -1};
int dlzka = sizeof(pole) / sizeof(pole[0]);

HeapSort(pole, dlzka);

for (int i = 0; i < dlzka; ++i)
{
printf("%d ", pole[i]);
}
}

void Vymen(int *a, int *b)
{
int tmp = *a;
*a = *b;
*b = tmp;
}

void Heapify(int pole[], int dlzka, int index)
{

int lavy = 2 * index + 1;
int pravy = 2 * index + 2;
int max = index;

// určenie potomka s maximálnou hodnotou
if(lavy < dlzka && pole[lavy] >= pole[pravy])
{
max = lavy;
}

if(pravy < dlzka && pole[pravy] > pole[lavy])
{
max = pravy;
}

// porovnanie maximálneho potomka s rodičom
if(pole[max] > pole[index])
{
Vymen(&pole[max], &pole[index]);
Heapify(pole, dlzka, max);
}
}

void HeapSort(int pole[], int dlzka)
{
// vytvor maximálnu hromadu (procedúra BuildMaxHeap)
for (int i = dlzka / 2 - 1 ; i >= 0; --i)
{
Heapify(pole, dlzka, i);
}

// zmaž všetky prvky z hromady
for (int j = dlzka - 1; j > 0; --j)
{
Vymen(&pole[0], &pole[j]);
Heapify(pole, j, 0);
}
}
</syntaxhighlight>
</tab>

<tab name="Iterácia C++" block>
<syntaxhighlight lang="C++">
#include <iostream>

using std::cout;
using std::endl;

void Vymen(int &a, int &b);
void Heapify(int pole[], int dlzka, int index);
void HeapSort(int pole[], int dlzka);

int main()
{
int pole[]= {10, 5, 2, 9, 8, 7, 1, 3, 4, 0, -1};
int dlzka = sizeof(pole) / sizeof(pole[0]);

HeapSort(pole, dlzka);

cout<<"Výsledné utriedené pole:"<<endl;

for(auto i: pole)
{
cout<<i<<" ";
}
}

void Vymen(int &a, int &b)
{
int tmp = a;
a = b;
b = tmp;
}

void Heapify(int pole[], int dlzka, int index)
{
int pravy, lavy, max;

while(2 * index + 1 < dlzka)
{
lavy = 2 * index + 1;
pravy = 2 * index + 2;

// určenie potomka s maximálnou hodnotou
if(pravy < dlzka && pole[pravy] > pole[lavy])
{
max = pravy;
}
else
{
max = lavy;
}

// porovnanie maximálneho potomka s rodičom
if(pole[max] > pole[index])
{

Vymen(pole[max], pole[index]);
index = max;
}
else
{
return;
}
}
}

void HeapSort(int pole[], int dlzka)
{
// vytvor maximálnu hromadu (procedúra BuildMaxHeap)
for (int i = dlzka / 2 - 1 ; i >= 0; --i)
{
Heapify(pole, dlzka, i);
}

// zmaž všetky prvky z hromady
for (int j = dlzka - 1; j > 0; --j)
{
Vymen(pole[0], pole[j]);
Heapify(pole, j, 0);
}
}
</syntaxhighlight>
</tab>

<tab name="Iterácia Java" block>
<syntaxhighlight lang="Java">
class HeapSortIT {
void swap(int[] pole, int a, int b) {
int tmp = pole[a];
pole[a] = pole[b];
pole[b] = tmp;
}

void heapify(int[] pole, int n) {
for (int i = 1; i < n; i++) {

/* Ak je potomok väčší ako rodič */
if (pole[i] > pole[(i - 1) / 2]) {
int j = i;

/* Vymieňaj elementy (rodič, potomok), dokým je rodič menší ako potomok */
while (pole[j] > pole[(j - 1) / 2]) {
swap(pole, j, (j - 1) / 2);
j = (j - 1) / 2;
}
}
}
}

void sort(int[] pole) {
int n = pole.length;

heapify(pole, n);

for (int i = n - 1; i > 0; i--) {
int j = 0, index;

/* Vymeň prvý a posledný prvok */
swap(pole, 0, i);

do {
index = 2 * j + 1;

/* Ak je ľavý potomok menši ako pravý, presuň 'index' na pravého potomka */
if (index < i - 1 && pole[index] < pole[index + 1])
index++;

/* Ak je rodič menší ako potomok, tak ho vymeň s potomkom, ktorý má väčšiu hodnotu */
if (index < i && pole[j] < pole[index])
swap(pole, j, index);

j = index;
} while (index < i);
}
}
}

public class Main {

static void printArray(int[] pole) {
int n = pole.length;

for (int i : pole)
System.out.print(i + " ");

System.out.println();
}

public static void main(String[] args) {
int[] pole = {12, 11, 13, 5, 6, 7};
int n = pole.length;

System.out.println("Pole pred zoradenim: ");
printArray(pole);

HeapSortIT hs = new HeapSortIT();
hs.sort(pole);

System.out.println("Pole po zoradeni: ");
printArray(pole);
}
}
</syntaxhighlight>
</tab>

<tab name="Rekurzia Java" block>
<syntaxhighlight lang="Java">
class HeapSortRE {
void swap(int[] pole, int a, int b) {
int tmp = pole[a];
pole[a] = pole[b];
pole[b] = tmp;
}

void heapify(int[] pole, int n, int i) {
int max = i; // rodič
int l = 2 * i + 1; // ľavý potomok
int p = 2 * i + 2; // pravý potomok

/* Ak je ľavý potomok väčší ako rodič */
if (l < n && pole[l] > pole[max])
max = l;

/* Ak je pravý potomok väčší ako rodič */
if (p < n && pole[p] > pole[max])
max = p;

/* Ak sa rodič v priebehu funkcie zmenil */
if (max != i) {
swap(pole, i, max);

heapify(pole, n, max);
}
}

public void sort(int[] pole) {
int n = pole.length;

/* Vytvorenie hromadu */
for (int i = n / 2 - 1; i >= 0 ; i--)
heapify(pole, n, i);

/* Extrahovanie jednotlivých elemetov z hromady */
for (int i = n - 1; i > 0; i--) {
/* Presuň aktuálneho rodiča na koniec */
swap(pole, 0, i);

/* Zavolanie heapify na zredukovanú hromadu */
heapify(pole, i, 0);
}
}
}

public class Main {

static void printArray(int[] pole) {
int n = pole.length;

for (int i : pole)
System.out.print(i + " ");

System.out.println();
}

public static void main(String[] args) {
int[] pole = {12, 11, 13, 5, 6, 7};
int n = pole.length;

System.out.println("Pole pred zoradenim: ");
printArray(pole);

HeapSortRE hs = new HeapSortRE();
hs.sort(pole);

System.out.println("Pole po zoradeni: ");
printArray(pole);
}
}
</syntaxhighlight>
</tab>

<tab name="Iterácia Python3" block>
<syntaxhighlight lang="Python3">
def heapify(pole, n):
for i in range(n):

# Ak je potomok väčší ako rodič
if pole[i] > pole[int((i - 1) / 2)]:
j = i

# Vymieňaj elementy (rodič, potomok), dokým je rodič menší ako potomok
while pole[j] > pole[int((j - 1) / 2)]:
pole[j], pole[int((j - 1) / 2)] = pole[int((j - 1) / 2)], pole[j] # swap
j = int((j - 1) / 2)

def sort(pole, n):
heapify(pole, n)

for i in range(n - 1, 0, -1):

# Vymeň prvý a posledný prvok
pole[0], pole[i] = pole[i], pole[0] # swap

j, index = 0, 0

while True:
index = 2 * j + 1

# Ak je ľavý potomok menši ako pravý, presuň 'index' na pravého potomka
if index < (i - 1) and pole[index] < pole[index + 1]:
index += 1

# Ak je rodič menší ako potomok, tak ho vymeň s potomkom, ktorý má väčšiu hodnotu
if index = i:
break

def printArray(pole, n):
for i in range(n):
print(pole[i], end=" ")

if __name__ == '__main__':
pole = [12, 11, 13, 5, 6, 7]
n = len(pole)

print("Zadane pole:")
printArray(pole, n)

sort(pole, n)

print("\nZoradene pole:")
printArray(pole, n)

</syntaxhighlight>
</tab>

<tab name="Rekurzia Python3" block>
<syntaxhighlight lang="Python3">
def heapify(pole, n, i):
max = i # rodic
l = 2 * i + 1 # lavy potomok
p = 2 * i + 2 # pravy potomok

# Ak je ľavý potomok väčší ako rodič
if l < n and pole[max] < pole[l]:
max = l

# Ak je pravý potomok väčší ako rodič
if p < n and pole[max] < pole[p]:
max = p

# Ak sa rodič v priebehu funkcie zmenil
if max != i:
pole[i], pole[max] = pole[max], pole[i] # swap

heapify(pole, n, max)

def sort(pole):
n = len(pole)

# Vytvorenie hromady
for i in range(n // 2 - 1, -1, -1):
heapify(pole, n, i)

# Extrahovanie jednotlivých elementov z hromady
for i in range(n - 1, 0, -1):
pole[i], pole[0] = pole[0], pole[i] # swap
heapify(pole, i, 0)

def printArray(pole):
n = len(pole)

for i in range(n):
print(pole[i], end=" ")

if __name__ == '__main__':
pole = [12, 11, 13, 5, 6, 7]

print("Zadane pole:")
printArray(pole)

sort(pole)

print("\nZoradene pole:")
printArray(pole)
</syntaxhighlight>
</tab>
</tabs>

==Selection Sort==
[[Súbor:SelectionSort.png|600px|náhľad|vpravo|Vizualizácia algoritmu SelectionSort]]
===Prehľad===
Selection Sort je triediaci algoritmus, ktorý si rozdelí pole na dve časti: zotriedenú a nezotriedenú. Následne opakovane vyberá minimum v nezotriedenej časti (ak triedime vzostupne), ktoré umiestni na koniec utrienej časti.
===Vlastnosti algoritmu===
* vhodný pre dátové štruktúry: pole
* časová náročnosť: vždy kvadratická <math> O(n^2) </math>, čo znamená, že algoritmus je určený na triedenie veľmi malých polí (rádovo 10, 20 prvkov), vďaka minimálnej réžii a jednoduchej implementácii, avšak pre väčšie polia sa stáva veľmi neefektívny
* priestorová náročnosť: vždy konštantná <math>O(1)</math>
* druh triedenia: triedenie výberom (komparačný algoritmus)
* stabilita triedenia: nestabilný
* miesto triedenia: vnútorné triedenie

===Základné časti algoritmu===
# Vonkajší cyklus: nastavenie hornej hranice utriedenej časti.
# Vnútorný cyklus: hľadanie minima ....

===Slovný opis algoritmu===
===Pseudokód===
Nech má funkcia Selection Sort nasledovný prototyp: <code>SelectionSort(pole[], dlzka)</code>
:1. Nech: <code>min = pole[0]</code>
:2. Nech <code>i = 1</code>
:3. Je <code>i < dlzka</code> ? Ak áno, pokračuj krokom 3.1., inak skonči.
:::3.1. Nech: <code>j = i</code>
:::3.2. Je <code> j < dlzka</code> ? Ak áno, pokračuj krokom 3.2.1. , inak skoč na krok 3.3.
:::::3.2.1. Je <code>pole[j] < min</code> ?
:::::::Ak áno:
:::::::::3.2.1.1. <code>min = pole[j]</code>
:::::::::3.2.1.2. Skoč na krok 3.2.
:::::::Ak nie:
:::::::::3.2.1.1. Skoč na krok 3.2.
:::3.3. Vymeň: <code>pole[i]</code> a <code>pole[min]</code>
:::3.4. Skoč na krok 3.2.

==Odkazy==
Heap Sort:

https://en.wikipedia.org/wiki/Heapsort

https://www.tutorialspoint.com/design_and_analysis_of_algorithms/design_and_analysis_of_algorithms_heapify_method.htm

https://www.geeksforgeeks.org/heap-sort/

https://www.geeksforgeeks.org/iterative-heap-sort/

https://www.youtube.com/watch?v=H5kAcmGOn4Q

Triedenie výberom

2021-04-19T15:51:50Z

Filip Tomek: /* Algoritmus Heap Sort */

[[Kategória:Algoritmy triedenia]]
{{Draft}}
{{Skripta programovanie}}
__TOC__
==Heap Sort==

===Prehľad===
''Heap Sort'' je triediaci algoritmus, ktorý podobne ako ''Selection sort'', rozeľuje pole na zotriedenú a nezotriedenú časť, pričom nezotriedená časť predstavuje dátovú štruktúru [[Hromada|binárna hromada]]. Celé triedenie spočíva v tom, že si zo vstupného poľa vytvoríme binárnu hromadu a následne postupným vyberaním a mazaním všetkých jej prvkov toto pole utriedime.

Hromada, ktorú využíva algoritmus ''Heap Sort'', musí spĺňať nasledovné podmienky (ak indexujeme pole od 0):
:1. Vrchol hromady (''koreň'') je vždy prvý prvok v poli (v našom prípade prvok na 0-tej pozícii).
:2. Pre ľubovoľný prvok (''uzol''), uložený na indexe <math>i</math> z intervalu <math> \langle 0 \ ; \ \text{dĺžka} - 1 \rangle </math>, platia nasledovné rovnice:
:: <math>
\begin{align}
\text{ľavý potomok} &= 2i + 1 && (1) \\
\text{pravý potomok} &= 2i + 2 && (2) \\
\text{rodič} &= \left \lfloor \frac{i - 1}{2} \right \rfloor \quad (\text {okrem} \ i = 0) && (3)
\end{align}
</math>
:3. Každý prvok (''uzol'') v hromade musí mať väčšiu, alebo rovnakú hodnotu ako jeho potomkovia (vlastnosť ''MAX HEAP'' - ak triedime pole vzostupne, v opačnom prípade by sme použili ''MIN HEAP'').

===Algoritmus Heapify===
[[Súbor:Heapify.png|Vizualizácia algoritmu Heapify: Index i je iteračná premenná (pozri pseudokód). Ľavý a pravý potomok i-teho prvku je označený ako ĽP a PP. Prvky zafarbené na modro vyjadrujú pravú podhromadu i-teho prvku a prvky zafarbené na zeleno vyjadrujú ľavú podhromadu i-teho prvku. Chronlogický postup algoritmu je znázornený číslicami 1 až 3.|699px|náhľad|vpravo]]
''Heapify'' je kľúčovým podprogramom triediaceho algoritmu ''Heap Sort'', vďaka ktorému vieme efektíve zabezpečiť procedúry: vytvorenie hromady z poľa a zmazanie hromady.

Princíp algoritmu ''Heapify'' spočíva v tom, že ak máme i-ty prvok v poli (v kompletnom binárnom strome), ktorého potomkovia tvoria dve samostatné podhromady, potom tieto dve podhromady preusporiadame do jednej hromady, pričom i-ty prvok bude jej vrcholom.

====Vlastnosti algoritmu====
* '''dátová štruktúra:''' hromada (reprezentovaná ako: pole)
* '''časová zložitosť:''' lineárna <math>O(n)</math>
* '''priestorová zložitosť:''' konštantná <math>O(1)</math> pri iteračnej verzii, <math>O(log(n))</math> pri rekurzívnej verzii

====Základné časti algoritmu====
# Určenie potomka i-teho prvku s maximálnou hodnotou.
# Porovnanie hodnoty maximálneho potomka s hodnotou rodiča (i-tym prvkom).
# Ak je hodnota maximálneho potomka väčšia ako hodnota rodiča, tak výmena potomka a rodiča.
# Ak nastane výmena, skontrolovanie ovplyvneného potomka (podhromady).

====Slovný opis algoritmu====
Na vstupe prijmeme ''pole'' a index ''i'', v ktorom chceme vytvoriť hromadu (''Max Heap''). Musí byť splnená podmienka, že oba potomkovia i-teho prvku tvoria dve samostatné podhromady.
Najskôr skontrolujeme, či ''prvok'' na indexe ''i'' má nejakých potomkov (využijeme rovnice (1) a (2) z časti "Prehľad"). Ak nemá žiadnych potomkov, funkcia skončí, pretože ''i'' predstavuje vrchol jednoprvkovej hromady. Ak má práve jedného potomka, tento potomok je zároveň aj jeho maximálnym potomkom. Ak má práve dvoch potomkov, tak porovnáme ich hodnoty a vyberieme z nich maximálneho potomka. Následne skontrolujeme veľkosť maximálneho potomka a jeho rodiča (prvok na indexe ''i''). Ak je rodič väčší, funkcia skončí, pretože želaná hromada už je utvorená. Ak nie, vymeníme rodiča a maximálneho potomka. Ak nastala výmena, musíme skontrolovať ovplyvnenú podhromadu, tj. zopakovať tento sled krokov pre podhromadu, ktorej vrchol bude v maximálnom potomkovi i-teho prvku.

Z hľadiska implementácie môžeme vytvoriť '''iteračnú''' aj '''rekurzívnu''' verziu.

====Pseudokód====
<tabs>
<tab name="Iteračná verzia" block>
Nech funkcia Heapify má nasledovný prototyp: <code>Heapify(pole[], dlzka, i)</code>
:1. Je <code>2 * i + 1 < dlzka</code> ? Ak áno, pokračuj krokom 1.1., inak skonči.
:::1.1. Nech: <code>lavy = 2 * i + 1</code>
:::1.2. Nech: <code>pravy = 2 * i + 2</code>
:::1.3. Je <code>pravy < dlzka</code> a zároveň <code>pole[pravy] > pole[lavy]</code> ?
:::::Ak áno:
:::::::1.3.1. Nech: <code>max = pravy</code>
:::::Ak nie:
:::::::1.3.1. Nech: <code>max = lavy</code>
:::1.4. Je <code>pole[max] > pole[i]</code> ?
:::::Ak áno:
:::::::1.4.1. Vymeň: <code>pole[max]</code> a <code>pole[i]</code>
:::::::1.4.2. <code>i = max</code>
:::::Ak nie:
:::::::1.4.1 Skonči.
:::1.5. Skoč na krok 1.

</tab>

<tab name="Rekurzívna verzia" block>
Nech funkcia Heapify má nasledovný prototyp: <code>Heapify(pole[], dlzka, i)</code>
:1. Nech: <code>lavy = 2 * i + 1</code>
:2. Nech: <code>pravy = 2 * i + 2</code>
:3. Nech: <code>max = i</code>
:4. Je <code>lavy < dlzka</code> a zároveň <code>pole[lavy] > pole[i]</code> ?
::: Ak áno:
:::::4.1. Nech: <code>max = lavy</code>
::: Ak nie:
:::::4.1. Pokračuj krokom 5.
:5. Je <code>pravy < dlzka</code> a zároveň <code>pole[pravy] > pole[i]</code> ?
::: Ak áno:
:::::5.1. Nech: <code>max = pravy</code>
::: Ak nie:
:::::5.1. Pokračuj krokom 6.
:6. Je <code>pole[max] > pole[i]</code> ?
::: Ak áno:
::::: 6.1. Vymeň: <code>pole[i] a pole[max]</code>
::::: 6.2. Rekurzívne zavolaj: <code>Heapify(pole[], dlzka, max)</code>
::: Ak nie:
::::: 6.1. Skonči volanie.
</tab>
</tabs>

===Algoritmus Heap Sort===
''Heap Sort'' pri triedení vykonáva dve základné úlohy: Vytvorenie maximálnej binárnej hromady zo vstupného poľa a postupné mazanie jednotlivých prvkov z hromady. Pri oboch procedúrach využíva algoritmus ''Heapify''.

====Vlastnosti algoritmu====
* '''vhodný pre dátové štruktúry:''' pole
* '''časová náročnosť:''' vždy linearitmická <math> O(n\log(n)) </math>, vďaka ktorej dokáže efektívne triediť veľmi veľké polia

[[Súbor:HeapSort.png|Vizualizácia priebehu algoritmu Heap Sort: Algoritus je znázornený pomocou poľa, ktoré triedime a binárnej hromady, ktorú dané pole reprezentuje. Indexy i a j sú sú iteračné premenné (pozri pseudokód). Indexy ľavého a pravého potomka i-teho prvku sú označené ako ĽP a PP. Vrchol celej hromady je označený ako V. Prvky zafarbené na modro vyjadrujú pravú podhromadu i-teho prvku a prvky zafarbené na zeleno vyjadrujú ľavú pohromadu i-teho prvku. Nevyfarbené prvky vyjadrujú prvky, ktoré boli zmazané. Chronologický priebeh je označený číslicami 1 až 12. |500px|náhľad|vpravo]]

* '''priestorová náročnosť:''' konštantná <math>O(1)</math> pri iteračnej verzii, logaritmická <math>O(\log(n))</math> pri rekurzívnej verzii.
* '''druh triedenia:''' triedenie výberom (komparačný algoritmus)
* '''stabilita triedenia:''' nestabilný
* '''miesto triedenia:''' vnútorné triedenie

====Základné časti algoritmu====
# Vytvorenie binárnej hromady z poľa.
# Zmazanie binárnej hromady.

====Slovný opis====
=====Vytvorenie hromady=====
Pri vytváraní hromady využijeme algoritmus ''Heapify'', pričom hromadu vytvoríme spôsobom zospodu na vrch.

Najskôr si určíme rodiča posledného potomka. Využijeme rovnicu (3) z časti "Prehľad", ktorú si jemne upravíme:
<center><math> \text{posledný rodič:} \ \ i = \left \lfloor \frac{\text{posledný index } - \ 1}{2} \right \rfloor = \left \lfloor\frac{\text{dĺžka } - \ 2}{2} \right \rfloor = \left \lfloor \frac{\text{dĺžka}}{2}\right \rfloor - 1 </math></center>
Následne zavoláme ''Heapify'' na podhromadu s vrcholom na indexe ''i''. Potom postupne zmenšujeme index ''i'' o ''1'' a opakovane naňho voláme ''Heapify'' až do chvíle, kým neprídeme na začiatok poľa. Touto procedúrou preusporiadavame spodné jednoprvkové podhromady do 3-prvkových podhromád, tie do 7-prvkových podhromád ... až kým nedostaneme jednu N-prvkovú hromadu, kde ''N'' je počet prvkov v poli. Schematicky by sme to mohli napísať takto:
<center><math> \text{pre } i \text{ z intervalu } \left \langle \left \lfloor \frac {\text{dĺžka}}{2} \right \rfloor - 1 \quad ; \quad 0 \right \rangle :\ \text{Heapify( pole[], dĺžka, i )}</math></center>

=====Zmazanie hromady=====
Pri mazaní hromady vykonáme dve operácie. Ako prvé vymeníme prvok na vrchu hromady s koncovým prvkom hromady. Prvok čo je na konci poľa považujeme už za zmazaný, preto veľkosť hromady znížime o 1. Ďalej, aby sme splnili podmienky pre maximálnu binárnu hromadu, zavoláme funkciu ''Heapify'' na celú hromadu (vrch hromady je 0-tý prvok v poli). Tento proces opakujeme, pokým v hromade neostanú žiadne prvky.

Poznámka: Pri triediacom algoritme nemusíme mazať celú hromadu, stačí nám, keď v hromade ostane jeden prvok, pretože vtedy bude vstupné pole už utriedené.

Schematicky by sme to mohli zapísať takto:
<center><math>\text{pre } j \text{ z intervalu } \left \langle \text{dĺžka - 1} \quad ; \quad 0 \right ) : \ \ \text{Vymeň(pole[0], pole[$j$])} \ \ a \ \ \text{Heapify(pole[], dĺžka, 0)} </math></center>

Z hľadiska implementácie môžeme vytvoriť '''iteračnú''' aj '''rekurzívnu''' verziu, čo závisí len od toho, ako je implementovaná funkcia ''Heapify''.

====Pseudokód====
Nech funkcia ''Heap Sort'' má nasledovný prototyp: <code>HeapSort(pole[], dlzka)</code>

:1. Nech: <code>i = dlzka / 2 - 1</code>, kde "/" predstavuje celočíslené delenie.
:2. Je <code>i >= 0</code> ? Ak áno, pokračuj krokom 2.1., inak skoč na krok 3.
:::2.1. Zavolaj funkciu: <code>Heapify(pole[], dlzka, i)</code>
:::2.2. <code>i = i - 1</code>
:::2.3. Skoč na krok 2.
:3. Nech: <code>j = dlzka - 1</code>
:4 Je <code> j > 0</code> ? Ak áno, pokračuj krokom 4.1, inak skonči.
:::4.1. Vymeň: <code>pole[0]</code> a <code>pole[j]</code>
:::4.2. Zavolaj funkciu: <code>Heapify(pole[], j, 0)</code>
:::4.3. <code>j = j - 1</code>
:::4.4. Skoč na krok 4.

===Implementácia algoritmov Heapify a HeapSort v rôznych programovacích jazykoch===
<tabs>
<tab name="Iteračná C" block>
<syntaxhighlight lang="C">

#include <stdio.h>

void Vymen(int *a, int *b);
void Heapify(int pole[], int dlzka, int index);
void HeapSort(int pole[], int dlzka);

int main()
{
int pole[]= {10, 5, 2, 9, 8, 7, 1, 3, 4, 0, -1};
int dlzka = sizeof(pole) / sizeof(pole[0]);

HeapSort(pole, dlzka);

for (int i = 0; i < dlzka; ++i)
{
printf("%d ", pole[i]);
}
}

void Vymen(int *a, int *b)
{
int tmp = *a;
*a = *b;
*b = tmp;
}

void Heapify(int pole[], int dlzka, int index)
{
int pravy, lavy, max;

while(2 * index + 1 < dlzka)
{
lavy = 2 * index + 1;
pravy = 2 * index + 2;

// určenie potomka s maximálnou hodnotou
if(pravy < dlzka && pole[pravy] > pole[lavy])
{
max = pravy;
}
else
{
max = lavy;
}

// porovnanie maximálneho potomka s rodičom
if(pole[max] > pole[index])
{

Vymen(&pole[max], &pole[index]);
index = max;
}
else
{
return;
}
}
}

void HeapSort(int pole[], int dlzka)
{
// vytvor maximálnu hromadu (procedúra BuildMaxHeap)
for (int i = dlzka / 2 - 1 ; i >= 0; --i)
{
Heapify(pole, dlzka, i);
}

// zmaž všetky prvky z hromady
for (int j = dlzka - 1; j > 0; --j)
{
Vymen(&pole[0], &pole[j]);
Heapify(pole, j, 0);
}
}
</syntaxhighlight>
</tab>
<tab name="Rekurzívna C" block>
<syntaxhighlight lang="C">
#include <stdio.h>

void Vymen(int *a, int *b);
void Heapify(int pole[], int dlzka, int index);
void HeapSort(int pole[], int dlzka);

int main()
{
int pole[]= {10, 5, 2, 9, 8, 7, 1, 3, 4, 0, -1, -1};
int dlzka = sizeof(pole) / sizeof(pole[0]);

HeapSort(pole, dlzka);

for (int i = 0; i < dlzka; ++i)
{
printf("%d ", pole[i]);
}
}

void Vymen(int *a, int *b)
{
int tmp = *a;
*a = *b;
*b = tmp;
}

void Heapify(int pole[], int dlzka, int index)
{

int lavy = 2 * index + 1;
int pravy = 2 * index + 2;
int max = index;

// určenie potomka s maximálnou hodnotou
if(lavy < dlzka && pole[lavy] >= pole[pravy])
{
max = lavy;
}

if(pravy < dlzka && pole[pravy] > pole[lavy])
{
max = pravy;
}

// porovnanie maximálneho potomka s rodičom
if(pole[max] > pole[index])
{
Vymen(&pole[max], &pole[index]);
Heapify(pole, dlzka, max);
}
}

void HeapSort(int pole[], int dlzka)
{
// vytvor maximálnu hromadu (procedúra BuildMaxHeap)
for (int i = dlzka / 2 - 1 ; i >= 0; --i)
{
Heapify(pole, dlzka, i);
}

// zmaž všetky prvky z hromady
for (int j = dlzka - 1; j > 0; --j)
{
Vymen(&pole[0], &pole[j]);
Heapify(pole, j, 0);
}
}
</syntaxhighlight>
</tab>

<tab name="Iterácia Java" block>
<syntaxhighlight lang="Java">
class HeapSortIT {
void swap(int[] pole, int a, int b) {
int tmp = pole[a];
pole[a] = pole[b];
pole[b] = tmp;
}

void heapify(int[] pole, int n) {
for (int i = 1; i < n; i++) {

/* Ak je potomok väčší ako rodič */
if (pole[i] > pole[(i - 1) / 2]) {
int j = i;

/* Vymieňaj elementy (rodič, potomok), dokým je rodič menší ako potomok */
while (pole[j] > pole[(j - 1) / 2]) {
swap(pole, j, (j - 1) / 2);
j = (j - 1) / 2;
}
}
}
}

void sort(int[] pole) {
int n = pole.length;

heapify(pole, n);

for (int i = n - 1; i > 0; i--) {
int j = 0, index;

/* Vymeň prvý a posledný prvok */
swap(pole, 0, i);

do {
index = 2 * j + 1;

/* Ak je ľavý potomok menši ako pravý, presuň 'index' na pravého potomka */
if (index < i - 1 && pole[index] < pole[index + 1])
index++;

/* Ak je rodič menší ako potomok, tak ho vymeň s potomkom, ktorý má väčšiu hodnotu */
if (index < i && pole[j] < pole[index])
swap(pole, j, index);

j = index;
} while (index < i);
}
}
}

public class Main {

static void printArray(int[] pole) {
int n = pole.length;

for (int i : pole)
System.out.print(i + " ");

System.out.println();
}

public static void main(String[] args) {
int[] pole = {12, 11, 13, 5, 6, 7};
int n = pole.length;

System.out.println("Pole pred zoradenim: ");
printArray(pole);

HeapSortIT hs = new HeapSortIT();
hs.sort(pole);

System.out.println("Pole po zoradeni: ");
printArray(pole);
}
}
</syntaxhighlight>
</tab>

<tab name="Rekurzia Java" block>
<syntaxhighlight lang="Java">
class HeapSortRE {
void swap(int[] pole, int a, int b) {
int tmp = pole[a];
pole[a] = pole[b];
pole[b] = tmp;
}

void heapify(int[] pole, int n, int i) {
int max = i; // rodič
int l = 2 * i + 1; // ľavý potomok
int p = 2 * i + 2; // pravý potomok

/* Ak je ľavý potomok väčší ako rodič */
if (l < n && pole[l] > pole[max])
max = l;

/* Ak je pravý potomok väčší ako rodič */
if (p < n && pole[p] > pole[max])
max = p;

/* Ak sa rodič v priebehu funkcie zmenil */
if (max != i) {
swap(pole, i, max);

heapify(pole, n, max);
}
}

public void sort(int[] pole) {
int n = pole.length;

/* Vytvorenie hromadu */
for (int i = n / 2 - 1; i >= 0 ; i--)
heapify(pole, n, i);

/* Extrahovanie jednotlivých elemetov z hromady */
for (int i = n - 1; i > 0; i--) {
/* Presuň aktuálneho rodiča na koniec */
swap(pole, 0, i);

/* Zavolanie heapify na zredukovanú hromadu */
heapify(pole, i, 0);
}
}
}

public class Main {

static void printArray(int[] pole) {
int n = pole.length;

for (int i : pole)
System.out.print(i + " ");

System.out.println();
}

public static void main(String[] args) {
int[] pole = {12, 11, 13, 5, 6, 7};
int n = pole.length;

System.out.println("Pole pred zoradenim: ");
printArray(pole);

HeapSortRE hs = new HeapSortRE();
hs.sort(pole);

System.out.println("Pole po zoradeni: ");
printArray(pole);
}
}
</syntaxhighlight>
</tab>

<tab name="Iterácia Python3" block>
<syntaxhighlight lang="Python3">
def heapify(pole, n):
for i in range(n):

# Ak je potomok väčší ako rodič
if pole[i] > pole[int((i - 1) / 2)]:
j = i

# Vymieňaj elementy (rodič, potomok), dokým je rodič menší ako potomok
while pole[j] > pole[int((j - 1) / 2)]:
pole[j], pole[int((j - 1) / 2)] = pole[int((j - 1) / 2)], pole[j] # swap
j = int((j - 1) / 2)

def sort(pole, n):
heapify(pole, n)

for i in range(n - 1, 0, -1):

# Vymeň prvý a posledný prvok
pole[0], pole[i] = pole[i], pole[0] # swap

j, index = 0, 0

while True:
index = 2 * j + 1

# Ak je ľavý potomok menši ako pravý, presuň 'index' na pravého potomka
if index < (i - 1) and pole[index] < pole[index + 1]:
index += 1

# Ak je rodič menší ako potomok, tak ho vymeň s potomkom, ktorý má väčšiu hodnotu
if index = i:
break

def printArray(pole, n):
for i in range(n):
print(pole[i], end=" ")

if __name__ == '__main__':
pole = [12, 11, 13, 5, 6, 7]
n = len(pole)

print("Zadane pole:")
printArray(pole, n)

sort(pole, n)

print("\nZoradene pole:")
printArray(pole, n)

</syntaxhighlight>
</tab>

<tab name="Rekurzia Python3" block>
<syntaxhighlight lang="Python3">
def heapify(pole, n, i):
max = i # rodic
l = 2 * i + 1 # lavy potomok
p = 2 * i + 2 # pravy potomok

# Ak je ľavý potomok väčší ako rodič
if l < n and pole[max] < pole[l]:
max = l

# Ak je pravý potomok väčší ako rodič
if p < n and pole[max] < pole[p]:
max = p

# Ak sa rodič v priebehu funkcie zmenil
if max != i:
pole[i], pole[max] = pole[max], pole[i] # swap

heapify(pole, n, max)

def sort(pole):
n = len(pole)

# Vytvorenie hromady
for i in range(n // 2 - 1, -1, -1):
heapify(pole, n, i)

# Extrahovanie jednotlivých elementov z hromady
for i in range(n - 1, 0, -1):
pole[i], pole[0] = pole[0], pole[i] # swap
heapify(pole, i, 0)

def printArray(pole):
n = len(pole)

for i in range(n):
print(pole[i], end=" ")

if __name__ == '__main__':
pole = [12, 11, 13, 5, 6, 7]

print("Zadane pole:")
printArray(pole)

sort(pole)

print("\nZoradene pole:")
printArray(pole)
</syntaxhighlight>
</tab>
</tabs>

==Selection Sort==
[[Súbor:SelectionSort.png|600px|náhľad|vpravo|Vizualizácia algoritmu SelectionSort]]
===Prehľad===
Selection Sort je triediaci algoritmus, ktorý si rozdelí pole na dve časti: zotriedenú a nezotriedenú. Následne opakovane vyberá minimum v nezotriedenej časti (ak triedime vzostupne), ktoré umiestni na koniec utrienej časti.
===Vlastnosti algoritmu===
* vhodný pre dátové štruktúry: pole
* časová náročnosť: vždy kvadratická <math> O(n^2) </math>, čo znamená, že algoritmus je určený na triedenie veľmi malých polí (rádovo 10, 20 prvkov), vďaka minimálnej réžii a jednoduchej implementácii, avšak pre väčšie polia sa stáva veľmi neefektívny
* priestorová náročnosť: vždy konštantná <math>O(1)</math>
* druh triedenia: triedenie výberom (komparačný algoritmus)
* stabilita triedenia: nestabilný
* miesto triedenia: vnútorné triedenie

===Základné časti algoritmu===
# Vonkajší cyklus: nastavenie hornej hranice utriedenej časti.
# Vnútorný cyklus: hľadanie minima ....

===Slovný opis algoritmu===
===Pseudokód===
Nech má funkcia Selection Sort nasledovný prototyp: <code>SelectionSort(pole[], dlzka)</code>
:1. Nech: <code>min = pole[0]</code>
:2. Nech <code>i = 1</code>
:3. Je <code>i < dlzka</code> ? Ak áno, pokračuj krokom 3.1., inak skonči.
:::3.1. Nech: <code>j = i</code>
:::3.2. Je <code> j < dlzka</code> ? Ak áno, pokračuj krokom 3.2.1. , inak skoč na krok 3.3.
:::::3.2.1. Je <code>pole[j] < min</code> ?
:::::::Ak áno:
:::::::::3.2.1.1. <code>min = pole[j]</code>
:::::::::3.2.1.2. Skoč na krok 3.2.
:::::::Ak nie:
:::::::::3.2.1.1. Skoč na krok 3.2.
:::3.3. Vymeň: <code>pole[i]</code> a <code>pole[min]</code>
:::3.4. Skoč na krok 3.2.

==Odkazy==
Heap Sort:

https://en.wikipedia.org/wiki/Heapsort

https://www.tutorialspoint.com/design_and_analysis_of_algorithms/design_and_analysis_of_algorithms_heapify_method.htm

https://www.geeksforgeeks.org/heap-sort/

https://www.geeksforgeeks.org/iterative-heap-sort/

https://www.youtube.com/watch?v=H5kAcmGOn4Q

Triedenie výberom

2021-04-19T15:45:40Z

Filip Tomek: /* Algoritmus Heapify */

[[Kategória:Algoritmy triedenia]]
{{Draft}}
{{Skripta programovanie}}
__TOC__
==Heap Sort==

===Prehľad===
''Heap Sort'' je triediaci algoritmus, ktorý podobne ako ''Selection sort'', rozeľuje pole na zotriedenú a nezotriedenú časť, pričom nezotriedená časť predstavuje dátovú štruktúru [[Hromada|binárna hromada]]. Celé triedenie spočíva v tom, že si zo vstupného poľa vytvoríme binárnu hromadu a následne postupným vyberaním a mazaním všetkých jej prvkov toto pole utriedime.

Hromada, ktorú využíva algoritmus ''Heap Sort'', musí spĺňať nasledovné podmienky (ak indexujeme pole od 0):
:1. Vrchol hromady (''koreň'') je vždy prvý prvok v poli (v našom prípade prvok na 0-tej pozícii).
:2. Pre ľubovoľný prvok (''uzol''), uložený na indexe <math>i</math> z intervalu <math> \langle 0 \ ; \ \text{dĺžka} - 1 \rangle </math>, platia nasledovné rovnice:
:: <math>
\begin{align}
\text{ľavý potomok} &= 2i + 1 && (1) \\
\text{pravý potomok} &= 2i + 2 && (2) \\
\text{rodič} &= \left \lfloor \frac{i - 1}{2} \right \rfloor \quad (\text {okrem} \ i = 0) && (3)
\end{align}
</math>
:3. Každý prvok (''uzol'') v hromade musí mať väčšiu, alebo rovnakú hodnotu ako jeho potomkovia (vlastnosť ''MAX HEAP'' - ak triedime pole vzostupne, v opačnom prípade by sme použili ''MIN HEAP'').

===Algoritmus Heapify===
[[Súbor:Heapify.png|Vizualizácia algoritmu Heapify: Index i je iteračná premenná (pozri pseudokód). Ľavý a pravý potomok i-teho prvku je označený ako ĽP a PP. Prvky zafarbené na modro vyjadrujú pravú podhromadu i-teho prvku a prvky zafarbené na zeleno vyjadrujú ľavú podhromadu i-teho prvku. Chronlogický postup algoritmu je znázornený číslicami 1 až 3.|699px|náhľad|vpravo]]
''Heapify'' je kľúčovým podprogramom triediaceho algoritmu ''Heap Sort'', vďaka ktorému vieme efektíve zabezpečiť procedúry: vytvorenie hromady z poľa a zmazanie hromady.

Princíp algoritmu ''Heapify'' spočíva v tom, že ak máme i-ty prvok v poli (v kompletnom binárnom strome), ktorého potomkovia tvoria dve samostatné podhromady, potom tieto dve podhromady preusporiadame do jednej hromady, pričom i-ty prvok bude jej vrcholom.

====Vlastnosti algoritmu====
* '''dátová štruktúra:''' hromada (reprezentovaná ako: pole)
* '''časová zložitosť:''' lineárna <math>O(n)</math>
* '''priestorová zložitosť:''' konštantná <math>O(1)</math> pri iteračnej verzii, <math>O(log(n))</math> pri rekurzívnej verzii

====Základné časti algoritmu====
# Určenie potomka i-teho prvku s maximálnou hodnotou.
# Porovnanie hodnoty maximálneho potomka s hodnotou rodiča (i-tym prvkom).
# Ak je hodnota maximálneho potomka väčšia ako hodnota rodiča, tak výmena potomka a rodiča.
# Ak nastane výmena, skontrolovanie ovplyvneného potomka (podhromady).

====Slovný opis algoritmu====
Na vstupe prijmeme ''pole'' a index ''i'', v ktorom chceme vytvoriť hromadu (''Max Heap''). Musí byť splnená podmienka, že oba potomkovia i-teho prvku tvoria dve samostatné podhromady.
Najskôr skontrolujeme, či ''prvok'' na indexe ''i'' má nejakých potomkov (využijeme rovnice (1) a (2) z časti "Prehľad"). Ak nemá žiadnych potomkov, funkcia skončí, pretože ''i'' predstavuje vrchol jednoprvkovej hromady. Ak má práve jedného potomka, tento potomok je zároveň aj jeho maximálnym potomkom. Ak má práve dvoch potomkov, tak porovnáme ich hodnoty a vyberieme z nich maximálneho potomka. Následne skontrolujeme veľkosť maximálneho potomka a jeho rodiča (prvok na indexe ''i''). Ak je rodič väčší, funkcia skončí, pretože želaná hromada už je utvorená. Ak nie, vymeníme rodiča a maximálneho potomka. Ak nastala výmena, musíme skontrolovať ovplyvnenú podhromadu, tj. zopakovať tento sled krokov pre podhromadu, ktorej vrchol bude v maximálnom potomkovi i-teho prvku.

Z hľadiska implementácie môžeme vytvoriť '''iteračnú''' aj '''rekurzívnu''' verziu.

====Pseudokód====
<tabs>
<tab name="Iteračná verzia" block>
Nech funkcia Heapify má nasledovný prototyp: <code>Heapify(pole[], dlzka, i)</code>
:1. Je <code>2 * i + 1 < dlzka</code> ? Ak áno, pokračuj krokom 1.1., inak skonči.
:::1.1. Nech: <code>lavy = 2 * i + 1</code>
:::1.2. Nech: <code>pravy = 2 * i + 2</code>
:::1.3. Je <code>pravy < dlzka</code> a zároveň <code>pole[pravy] > pole[lavy]</code> ?
:::::Ak áno:
:::::::1.3.1. Nech: <code>max = pravy</code>
:::::Ak nie:
:::::::1.3.1. Nech: <code>max = lavy</code>
:::1.4. Je <code>pole[max] > pole[i]</code> ?
:::::Ak áno:
:::::::1.4.1. Vymeň: <code>pole[max]</code> a <code>pole[i]</code>
:::::::1.4.2. <code>i = max</code>
:::::Ak nie:
:::::::1.4.1 Skonči.
:::1.5. Skoč na krok 1.

</tab>

<tab name="Rekurzívna verzia" block>
Nech funkcia Heapify má nasledovný prototyp: <code>Heapify(pole[], dlzka, i)</code>
:1. Nech: <code>lavy = 2 * i + 1</code>
:2. Nech: <code>pravy = 2 * i + 2</code>
:3. Nech: <code>max = i</code>
:4. Je <code>lavy < dlzka</code> a zároveň <code>pole[lavy] > pole[i]</code> ?
::: Ak áno:
:::::4.1. Nech: <code>max = lavy</code>
::: Ak nie:
:::::4.1. Pokračuj krokom 5.
:5. Je <code>pravy < dlzka</code> a zároveň <code>pole[pravy] > pole[i]</code> ?
::: Ak áno:
:::::5.1. Nech: <code>max = pravy</code>
::: Ak nie:
:::::5.1. Pokračuj krokom 6.
:6. Je <code>pole[max] > pole[i]</code> ?
::: Ak áno:
::::: 6.1. Vymeň: <code>pole[i] a pole[max]</code>
::::: 6.2. Rekurzívne zavolaj: <code>Heapify(pole[], dlzka, max)</code>
::: Ak nie:
::::: 6.1. Skonči volanie.
</tab>
</tabs>

===Algoritmus Heap Sort===
Heapsort pri triedení vykonáva dve základné úlohy: Vytvorenie maximálnej binárnej hromady zo vstupného poľa a postupné mazanie jednotlivých prvkov z hromady. Pri oboch procedúrach využíva algoritmus Heapify.

====Vlastnosti algoritmu====
* vhodný pre dátové štruktúry: pole
* časová náročnosť: vždy linearitmická <math> O(n\log(n)) </math>, vďaka ktorej dokáže efektívne triediť veľmi veľké polia

[[Súbor:HeapSort.png|Vizualizácia priebehu algoritmu Heap Sort: Algoritus je znázornený pomocou poľa, ktoré triedime a binárnej hromady, ktorú dané pole reprezentuje. Indexy i a j sú sú iteračné premenné (pozri pseudokód). Indexy ľavého a pravého potomka i-teho prvku sú označené ako ĽP a PP. Vrchol celej hromady je označený ako V. Prvky zafarbené na modro vyjadrujú pravú podhromadu i-teho prvku a prvky zafarbené na zeleno vyjadrujú ľavú pohromadu i-teho prvku. Nevyfarbené prvky vyjadrujú prvky, ktoré boli zmazané. Chronologický priebeh je označený číslicami 1 až 12. |500px|náhľad|vpravo]]

* priestorová náročnosť: konštantná <math>O(1)</math> pri iteračnej verzii, logaritmická <math>O(\log(n))</math> pri rekurzívnej verzii.
* druh triedenia: triedenie výberom (komparačný algoritmus)
* stabilita triedenia: nestabilný
* miesto triedenia: vnútorné triedenie

====Základné časti algoritmu====
# Vytvorenie binárnej hromady z poľa.
# Zmazanie binárnej hromady.

====Slovný opis====
=====Vytvorenie hromady=====
Pri vytváraní hromady využijeme algoritmus Heapify, pričom hromadu vytvoríme spôsobom zospodu na vrch.

Najskôr si určíme rodiča posledného potomka. Využijeme rovnicu (3) z časti prehľad, ktorú si jemne upravíme:
<center><math> \text{posledný rodič:} \ \ i = \left \lfloor \frac{\text{posledný index } - \ 1}{2} \right \rfloor = \left \lfloor\frac{\text{dĺžka } - \ 2}{2} \right \rfloor = \left \lfloor \frac{\text{dĺžka}}{2}\right \rfloor - 1 </math></center>
Následne zavoláme Heapify na podhromadu s vrcholom na indexe i. Potom postupne zmenšujeme index i o 1 a opakovane naňho voláme Heapify až do chvíle, kým neprídeme na začiatok poľa. Touto procedúrou preusporiadavame spodné jednoprvkové podhromady do 3-prvkových pohromád, tie do 7-prvkových podhromád ... až kým nedostaneme jednu N-prvkovú hromadu, kde N je počet prvkov v poli. Schematicky by sme to mohli napísať takto:
<center><math> \text{pre } i \text{ z intervalu } \left \langle \left \lfloor \frac {\text{dĺžka}}{2} \right \rfloor - 1 \quad ; \quad 0 \right \rangle :\ \text{Heapify( pole[], dĺžka, i )}</math></center>

=====Zmazanie hromady=====
Pri mazaní hromady vykonáme dve operácie. Ako prvé vymeníme prvok na vrchu hromady s koncovým prvkom hromady. Prvok čo je na konci poľa považujeme už za zmazaný, preto veľkosť hromady znížime o 1. Ďalej, aby sme splnili podmienky pre maximálnu binárnu hromadu, zavoláme funkciu Heapify na celú hromadu (vrch hromady je 0-tý prvok v poli). Tento proces opakujeme, pokiaľ v hromade neostanú žiadne prvky.

Poznámka: Pri triediacom algoritme nemusíme mazať celú hromadu, stačí nám, keď v hromade ostane jeden prvok, pretože vtedy bude vstupné pole už utriedené.

Schematicky by sme to mohli zapísať takto:
<center><math>\text{pre } j \text{ z intervalu } \left \langle \text{dĺžka - 1} \quad ; \quad 0 \right ) : \ \ \text{Vymeň(pole[0], pole[$j$])} \ \ a \ \ \text{Heapify(pole[], dĺžka, 0)} </math></center>

Z hľadiska implementácie môžeme vytvoriť rekurzívnu aj iteračnú verziu, čo závisí len od toho, ako je implementovaná funkcia Heapify.

====Pseudokód====
Nech funkcia Heap Sort má nasledovný prototyp: <code>HeapSort(pole[], dlzka)</code>

:1. Nech: <code>i = dlzka / 2 - 1</code>, kde "/" predstavuje celočíslené delenie.
:2. Je <code>i >= 0</code> ? Ak áno, pokračuj krokom 2.1., inak skoč na krok 3.
:::2.1. Zavolaj funkciu: <code>Heapify(pole[], dlzka, i)</code>
:::2.2. <code>i = i - 1</code>
:::2.3. Skoč na krok 2.
:3. Nech: <code>j = dlzka - 1</code>
:4 Je <code> j > 0</code> ? Ak áno, pokračuj krokom 4.1, inak skonči.
:::4.1. Vymeň: <code>pole[0]</code> a <code>pole[j]</code>
:::4.2. Zavolaj funkciu: <code>Heapify(pole[], j, 0)</code>
:::4.3. <code>j = j - 1</code>
:::4.4. Skoč na krok 4.

===Implementácia algoritmov Heapify a HeapSort v rôznych programovacích jazykoch===
<tabs>
<tab name="Iteračná C" block>
<syntaxhighlight lang="C">

#include <stdio.h>

void Vymen(int *a, int *b);
void Heapify(int pole[], int dlzka, int index);
void HeapSort(int pole[], int dlzka);

int main()
{
int pole[]= {10, 5, 2, 9, 8, 7, 1, 3, 4, 0, -1};
int dlzka = sizeof(pole) / sizeof(pole[0]);

HeapSort(pole, dlzka);

for (int i = 0; i < dlzka; ++i)
{
printf("%d ", pole[i]);
}
}

void Vymen(int *a, int *b)
{
int tmp = *a;
*a = *b;
*b = tmp;
}

void Heapify(int pole[], int dlzka, int index)
{
int pravy, lavy, max;

while(2 * index + 1 < dlzka)
{
lavy = 2 * index + 1;
pravy = 2 * index + 2;

// určenie potomka s maximálnou hodnotou
if(pravy < dlzka && pole[pravy] > pole[lavy])
{
max = pravy;
}
else
{
max = lavy;
}

// porovnanie maximálneho potomka s rodičom
if(pole[max] > pole[index])
{

Vymen(&pole[max], &pole[index]);
index = max;
}
else
{
return;
}
}
}

void HeapSort(int pole[], int dlzka)
{
// vytvor maximálnu hromadu (procedúra BuildMaxHeap)
for (int i = dlzka / 2 - 1 ; i >= 0; --i)
{
Heapify(pole, dlzka, i);
}

// zmaž všetky prvky z hromady
for (int j = dlzka - 1; j > 0; --j)
{
Vymen(&pole[0], &pole[j]);
Heapify(pole, j, 0);
}
}
</syntaxhighlight>
</tab>
<tab name="Rekurzívna C" block>
<syntaxhighlight lang="C">
#include <stdio.h>

void Vymen(int *a, int *b);
void Heapify(int pole[], int dlzka, int index);
void HeapSort(int pole[], int dlzka);

int main()
{
int pole[]= {10, 5, 2, 9, 8, 7, 1, 3, 4, 0, -1, -1};
int dlzka = sizeof(pole) / sizeof(pole[0]);

HeapSort(pole, dlzka);

for (int i = 0; i < dlzka; ++i)
{
printf("%d ", pole[i]);
}
}

void Vymen(int *a, int *b)
{
int tmp = *a;
*a = *b;
*b = tmp;
}

void Heapify(int pole[], int dlzka, int index)
{

int lavy = 2 * index + 1;
int pravy = 2 * index + 2;
int max = index;

// určenie potomka s maximálnou hodnotou
if(lavy < dlzka && pole[lavy] >= pole[pravy])
{
max = lavy;
}

if(pravy < dlzka && pole[pravy] > pole[lavy])
{
max = pravy;
}

// porovnanie maximálneho potomka s rodičom
if(pole[max] > pole[index])
{
Vymen(&pole[max], &pole[index]);
Heapify(pole, dlzka, max);
}
}

void HeapSort(int pole[], int dlzka)
{
// vytvor maximálnu hromadu (procedúra BuildMaxHeap)
for (int i = dlzka / 2 - 1 ; i >= 0; --i)
{
Heapify(pole, dlzka, i);
}

// zmaž všetky prvky z hromady
for (int j = dlzka - 1; j > 0; --j)
{
Vymen(&pole[0], &pole[j]);
Heapify(pole, j, 0);
}
}
</syntaxhighlight>
</tab>

<tab name="Iterácia Java" block>
<syntaxhighlight lang="Java">
class HeapSortIT {
void swap(int[] pole, int a, int b) {
int tmp = pole[a];
pole[a] = pole[b];
pole[b] = tmp;
}

void heapify(int[] pole, int n) {
for (int i = 1; i < n; i++) {

/* Ak je potomok väčší ako rodič */
if (pole[i] > pole[(i - 1) / 2]) {
int j = i;

/* Vymieňaj elementy (rodič, potomok), dokým je rodič menší ako potomok */
while (pole[j] > pole[(j - 1) / 2]) {
swap(pole, j, (j - 1) / 2);
j = (j - 1) / 2;
}
}
}
}

void sort(int[] pole) {
int n = pole.length;

heapify(pole, n);

for (int i = n - 1; i > 0; i--) {
int j = 0, index;

/* Vymeň prvý a posledný prvok */
swap(pole, 0, i);

do {
index = 2 * j + 1;

/* Ak je ľavý potomok menši ako pravý, presuň 'index' na pravého potomka */
if (index < i - 1 && pole[index] < pole[index + 1])
index++;

/* Ak je rodič menší ako potomok, tak ho vymeň s potomkom, ktorý má väčšiu hodnotu */
if (index < i && pole[j] < pole[index])
swap(pole, j, index);

j = index;
} while (index < i);
}
}
}

public class Main {

static void printArray(int[] pole) {
int n = pole.length;

for (int i : pole)
System.out.print(i + " ");

System.out.println();
}

public static void main(String[] args) {
int[] pole = {12, 11, 13, 5, 6, 7};
int n = pole.length;

System.out.println("Pole pred zoradenim: ");
printArray(pole);

HeapSortIT hs = new HeapSortIT();
hs.sort(pole);

System.out.println("Pole po zoradeni: ");
printArray(pole);
}
}
</syntaxhighlight>
</tab>

<tab name="Rekurzia Java" block>
<syntaxhighlight lang="Java">
class HeapSortRE {
void swap(int[] pole, int a, int b) {
int tmp = pole[a];
pole[a] = pole[b];
pole[b] = tmp;
}

void heapify(int[] pole, int n, int i) {
int max = i; // rodič
int l = 2 * i + 1; // ľavý potomok
int p = 2 * i + 2; // pravý potomok

/* Ak je ľavý potomok väčší ako rodič */
if (l < n && pole[l] > pole[max])
max = l;

/* Ak je pravý potomok väčší ako rodič */
if (p < n && pole[p] > pole[max])
max = p;

/* Ak sa rodič v priebehu funkcie zmenil */
if (max != i) {
swap(pole, i, max);

heapify(pole, n, max);
}
}

public void sort(int[] pole) {
int n = pole.length;

/* Vytvorenie hromadu */
for (int i = n / 2 - 1; i >= 0 ; i--)
heapify(pole, n, i);

/* Extrahovanie jednotlivých elemetov z hromady */
for (int i = n - 1; i > 0; i--) {
/* Presuň aktuálneho rodiča na koniec */
swap(pole, 0, i);

/* Zavolanie heapify na zredukovanú hromadu */
heapify(pole, i, 0);
}
}
}

public class Main {

static void printArray(int[] pole) {
int n = pole.length;

for (int i : pole)
System.out.print(i + " ");

System.out.println();
}

public static void main(String[] args) {
int[] pole = {12, 11, 13, 5, 6, 7};
int n = pole.length;

System.out.println("Pole pred zoradenim: ");
printArray(pole);

HeapSortRE hs = new HeapSortRE();
hs.sort(pole);

System.out.println("Pole po zoradeni: ");
printArray(pole);
}
}
</syntaxhighlight>
</tab>

<tab name="Iterácia Python3" block>
<syntaxhighlight lang="Python3">
def heapify(pole, n):
for i in range(n):

# Ak je potomok väčší ako rodič
if pole[i] > pole[int((i - 1) / 2)]:
j = i

# Vymieňaj elementy (rodič, potomok), dokým je rodič menší ako potomok
while pole[j] > pole[int((j - 1) / 2)]:
pole[j], pole[int((j - 1) / 2)] = pole[int((j - 1) / 2)], pole[j] # swap
j = int((j - 1) / 2)

def sort(pole, n):
heapify(pole, n)

for i in range(n - 1, 0, -1):

# Vymeň prvý a posledný prvok
pole[0], pole[i] = pole[i], pole[0] # swap

j, index = 0, 0

while True:
index = 2 * j + 1

# Ak je ľavý potomok menši ako pravý, presuň 'index' na pravého potomka
if index < (i - 1) and pole[index] < pole[index + 1]:
index += 1

# Ak je rodič menší ako potomok, tak ho vymeň s potomkom, ktorý má väčšiu hodnotu
if index = i:
break

def printArray(pole, n):
for i in range(n):
print(pole[i], end=" ")

if __name__ == '__main__':
pole = [12, 11, 13, 5, 6, 7]
n = len(pole)

print("Zadane pole:")
printArray(pole, n)

sort(pole, n)

print("\nZoradene pole:")
printArray(pole, n)

</syntaxhighlight>
</tab>

<tab name="Rekurzia Python3" block>
<syntaxhighlight lang="Python3">
def heapify(pole, n, i):
max = i # rodic
l = 2 * i + 1 # lavy potomok
p = 2 * i + 2 # pravy potomok

# Ak je ľavý potomok väčší ako rodič
if l < n and pole[max] < pole[l]:
max = l

# Ak je pravý potomok väčší ako rodič
if p < n and pole[max] < pole[p]:
max = p

# Ak sa rodič v priebehu funkcie zmenil
if max != i:
pole[i], pole[max] = pole[max], pole[i] # swap

heapify(pole, n, max)

def sort(pole):
n = len(pole)

# Vytvorenie hromady
for i in range(n // 2 - 1, -1, -1):
heapify(pole, n, i)

# Extrahovanie jednotlivých elementov z hromady
for i in range(n - 1, 0, -1):
pole[i], pole[0] = pole[0], pole[i] # swap
heapify(pole, i, 0)

def printArray(pole):
n = len(pole)

for i in range(n):
print(pole[i], end=" ")

if __name__ == '__main__':
pole = [12, 11, 13, 5, 6, 7]

print("Zadane pole:")
printArray(pole)

sort(pole)

print("\nZoradene pole:")
printArray(pole)
</syntaxhighlight>
</tab>
</tabs>

==Selection Sort==
[[Súbor:SelectionSort.png|600px|náhľad|vpravo|Vizualizácia algoritmu SelectionSort]]
===Prehľad===
Selection Sort je triediaci algoritmus, ktorý si rozdelí pole na dve časti: zotriedenú a nezotriedenú. Následne opakovane vyberá minimum v nezotriedenej časti (ak triedime vzostupne), ktoré umiestni na koniec utrienej časti.
===Vlastnosti algoritmu===
* vhodný pre dátové štruktúry: pole
* časová náročnosť: vždy kvadratická <math> O(n^2) </math>, čo znamená, že algoritmus je určený na triedenie veľmi malých polí (rádovo 10, 20 prvkov), vďaka minimálnej réžii a jednoduchej implementácii, avšak pre väčšie polia sa stáva veľmi neefektívny
* priestorová náročnosť: vždy konštantná <math>O(1)</math>
* druh triedenia: triedenie výberom (komparačný algoritmus)
* stabilita triedenia: nestabilný
* miesto triedenia: vnútorné triedenie

===Základné časti algoritmu===
# Vonkajší cyklus: nastavenie hornej hranice utriedenej časti.
# Vnútorný cyklus: hľadanie minima ....

===Slovný opis algoritmu===
===Pseudokód===
Nech má funkcia Selection Sort nasledovný prototyp: <code>SelectionSort(pole[], dlzka)</code>
:1. Nech: <code>min = pole[0]</code>
:2. Nech <code>i = 1</code>
:3. Je <code>i < dlzka</code> ? Ak áno, pokračuj krokom 3.1., inak skonči.
:::3.1. Nech: <code>j = i</code>
:::3.2. Je <code> j < dlzka</code> ? Ak áno, pokračuj krokom 3.2.1. , inak skoč na krok 3.3.
:::::3.2.1. Je <code>pole[j] < min</code> ?
:::::::Ak áno:
:::::::::3.2.1.1. <code>min = pole[j]</code>
:::::::::3.2.1.2. Skoč na krok 3.2.
:::::::Ak nie:
:::::::::3.2.1.1. Skoč na krok 3.2.
:::3.3. Vymeň: <code>pole[i]</code> a <code>pole[min]</code>
:::3.4. Skoč na krok 3.2.

==Odkazy==
Heap Sort:

https://en.wikipedia.org/wiki/Heapsort

https://www.tutorialspoint.com/design_and_analysis_of_algorithms/design_and_analysis_of_algorithms_heapify_method.htm

https://www.geeksforgeeks.org/heap-sort/

https://www.geeksforgeeks.org/iterative-heap-sort/

https://www.youtube.com/watch?v=H5kAcmGOn4Q

Triedenie výberom

2021-04-19T15:41:35Z

Filip Tomek: /* Prehľad */

[[Kategória:Algoritmy triedenia]]
{{Draft}}
{{Skripta programovanie}}
__TOC__
==Heap Sort==

===Prehľad===
''Heap Sort'' je triediaci algoritmus, ktorý podobne ako ''Selection sort'', rozeľuje pole na zotriedenú a nezotriedenú časť, pričom nezotriedená časť predstavuje dátovú štruktúru [[Hromada|binárna hromada]]. Celé triedenie spočíva v tom, že si zo vstupného poľa vytvoríme binárnu hromadu a následne postupným vyberaním a mazaním všetkých jej prvkov toto pole utriedime.

Hromada, ktorú využíva algoritmus ''Heap Sort'', musí spĺňať nasledovné podmienky (ak indexujeme pole od 0):
:1. Vrchol hromady (''koreň'') je vždy prvý prvok v poli (v našom prípade prvok na 0-tej pozícii).
:2. Pre ľubovoľný prvok (''uzol''), uložený na indexe <math>i</math> z intervalu <math> \langle 0 \ ; \ \text{dĺžka} - 1 \rangle </math>, platia nasledovné rovnice:
:: <math>
\begin{align}
\text{ľavý potomok} &= 2i + 1 && (1) \\
\text{pravý potomok} &= 2i + 2 && (2) \\
\text{rodič} &= \left \lfloor \frac{i - 1}{2} \right \rfloor \quad (\text {okrem} \ i = 0) && (3)
\end{align}
</math>
:3. Každý prvok (''uzol'') v hromade musí mať väčšiu, alebo rovnakú hodnotu ako jeho potomkovia (vlastnosť ''MAX HEAP'' - ak triedime pole vzostupne, v opačnom prípade by sme použili ''MIN HEAP'').

===Algoritmus Heapify===
[[Súbor:Heapify.png|Vizualizácia algoritmu Heapify: Index i je iteračná premenná (pozri pseudokód). Ľavý a pravý potomok i-teho prvku je označený ako ĽP a PP. Prvky zafarbené na modro vyjadrujú pravú podhromadu i-teho prvku a prvky zafarbené na zeleno vyjadrujú ľavú podhromadu i-teho prvku. Chronlogický postup algoritmu je znázornený číslicami 1 až 3.|699px|náhľad|vpravo]]
Heapify je kľúčovým podprogramom triediaceho algoritmu Heap Sort, vďaka ktorému vieme efektíve zabezpečiť procedúry: vytvorenie hromady z poľa a zmazanie hromady.

Princíp algoritmu Heapify spočíva v tom, že ak máme i-ty prvok v poli (v kompletnom binárnom strome), ktorého potomkovia tvoria dve samostatné podhromady, potom tieto dve podhromady preusporiadame do jednej hromady, pričom i-ty prvok bude jej vrcholom.

====Vlastnosti algoritmu====
* dátová štruktúra: hromada (reprezentovaná ako: pole)
* časová zložitosť: lineárna <math>O(n)</math>
* priestorová zložitosť: konštantná <math>O(1)</math> pri iteračnej verzii, <math>O(log(n))</math> pri rekurzívnej verzii

====Základné časti algoritmu====
# Určenie potomka i-teho prvku s maximálnou hodnotou.
# Porovnanie hodnoty maximálneho potomka s hodnotou rodiča (i-tym prvkom).
# Ak je hodnota maximálneho potomka väčšia ako hodnota rodiča, tak výmena potomka a rodiča.
# Ak nastane výmena, skontrolovanie ovplyvneného potomka (podhromady).

====Slovný opis algoritmu====
Na vstupe prijmeme pole a index i, v ktorom chceme vytvoriť hromadu (Max Heap). Musí byť splnená podmienka, že oba potomkovia i-teho prvku tvoria dve samostatné podhromady.
Najskôr skontrolujeme, či prvok na indexe i má nejakých potomkov (využijeme rovnice (1) a (2) z časti "Prehľad"). Ak nemá žiadnych potomkov, funkcia skončí, pretože i predstavuje vrchol jednoprvkovej hromady. Ak má práve jedného potomka, tento potomok je zároveň aj jeho maximálnym potomkom. Ak má práve dvoch potomkov, tak porovnáme ich hodnoty a vyberieme z nich maximálneho potomka. Následne skontrolujeme veľkosť maximálneho potomka a jeho rodiča (prvok na indexe i). Ak je rodič väčší, funkcia skončí, pretože želaná hromada už je utvorená. Ak nie, vymeníme rodiča a maximálneho potomka. Ak nastala výmena, musíme skontrolovať ovplyvnenú podhromadu, tj. zopakovať tento sled krokov pre podhromadu, ktorej vrchol bude v maximálnom potomkovi i-teho prvku.

Z hľadiska implementácie môžeme vytvoriť iteračnú aj rekurzívnu verziu.

====Pseudokód====
<tabs>
<tab name="Iteračná verzia" block>
Nech funkcia Heapify má nasledovný prototyp: <code>Heapify(pole[], dlzka, i)</code>
:1. Je <code>2 * i + 1 < dlzka</code> ? Ak áno, pokračuj krokom 1.1., inak skonči.
:::1.1. Nech: <code>lavy = 2 * i + 1</code>
:::1.2. Nech: <code>pravy = 2 * i + 2</code>
:::1.3. Je <code>pravy < dlzka</code> a zároveň <code>pole[pravy] > pole[lavy]</code> ?
:::::Ak áno:
:::::::1.3.1. Nech: <code>max = pravy</code>
:::::Ak nie:
:::::::1.3.1. Nech: <code>max = lavy</code>
:::1.4. Je <code>pole[max] > pole[i]</code> ?
:::::Ak áno:
:::::::1.4.1. Vymeň: <code>pole[max]</code> a <code>pole[i]</code>
:::::::1.4.2. <code>i = max</code>
:::::Ak nie:
:::::::1.4.1 Skonči.
:::1.5. Skoč na krok 1.

</tab>

<tab name="Rekurzívna verzia" block>
Nech funkcia Heapify má nasledovný prototyp: <code>Heapify(pole[], dlzka, i)</code>
:1. Nech: <code>lavy = 2 * i + 1</code>
:2. Nech: <code>pravy = 2 * i + 2</code>
:3. Nech: <code>max = i</code>
:4. Je <code>lavy < dlzka</code> a zároveň <code>pole[lavy] > pole[i]</code> ?
::: Ak áno:
:::::4.1. Nech: <code>max = lavy</code>
::: Ak nie:
:::::4.1. Pokračuj krokom 5.
:5. Je <code>pravy < dlzka</code> a zároveň <code>pole[pravy] > pole[i]</code> ?
::: Ak áno:
:::::5.1. Nech: <code>max = pravy</code>
::: Ak nie:
:::::5.1. Pokračuj krokom 6.
:6. Je <code>pole[max] > pole[i]</code> ?
::: Ak áno:
::::: 6.1. Vymeň: <code>pole[i] a pole[max]</code>
::::: 6.2. Rekurzívne zavolaj: <code>Heapify(pole[], dlzka, max)</code>
::: Ak nie:
::::: 6.1. Skonči volanie.
</tab>
</tabs>

===Algoritmus Heap Sort===
Heapsort pri triedení vykonáva dve základné úlohy: Vytvorenie maximálnej binárnej hromady zo vstupného poľa a postupné mazanie jednotlivých prvkov z hromady. Pri oboch procedúrach využíva algoritmus Heapify.

====Vlastnosti algoritmu====
* vhodný pre dátové štruktúry: pole
* časová náročnosť: vždy linearitmická <math> O(n\log(n)) </math>, vďaka ktorej dokáže efektívne triediť veľmi veľké polia

[[Súbor:HeapSort.png|Vizualizácia priebehu algoritmu Heap Sort: Algoritus je znázornený pomocou poľa, ktoré triedime a binárnej hromady, ktorú dané pole reprezentuje. Indexy i a j sú sú iteračné premenné (pozri pseudokód). Indexy ľavého a pravého potomka i-teho prvku sú označené ako ĽP a PP. Vrchol celej hromady je označený ako V. Prvky zafarbené na modro vyjadrujú pravú podhromadu i-teho prvku a prvky zafarbené na zeleno vyjadrujú ľavú pohromadu i-teho prvku. Nevyfarbené prvky vyjadrujú prvky, ktoré boli zmazané. Chronologický priebeh je označený číslicami 1 až 12. |500px|náhľad|vpravo]]

* priestorová náročnosť: konštantná <math>O(1)</math> pri iteračnej verzii, logaritmická <math>O(\log(n))</math> pri rekurzívnej verzii.
* druh triedenia: triedenie výberom (komparačný algoritmus)
* stabilita triedenia: nestabilný
* miesto triedenia: vnútorné triedenie

====Základné časti algoritmu====
# Vytvorenie binárnej hromady z poľa.
# Zmazanie binárnej hromady.

====Slovný opis====
=====Vytvorenie hromady=====
Pri vytváraní hromady využijeme algoritmus Heapify, pričom hromadu vytvoríme spôsobom zospodu na vrch.

Najskôr si určíme rodiča posledného potomka. Využijeme rovnicu (3) z časti prehľad, ktorú si jemne upravíme:
<center><math> \text{posledný rodič:} \ \ i = \left \lfloor \frac{\text{posledný index } - \ 1}{2} \right \rfloor = \left \lfloor\frac{\text{dĺžka } - \ 2}{2} \right \rfloor = \left \lfloor \frac{\text{dĺžka}}{2}\right \rfloor - 1 </math></center>
Následne zavoláme Heapify na podhromadu s vrcholom na indexe i. Potom postupne zmenšujeme index i o 1 a opakovane naňho voláme Heapify až do chvíle, kým neprídeme na začiatok poľa. Touto procedúrou preusporiadavame spodné jednoprvkové podhromady do 3-prvkových pohromád, tie do 7-prvkových podhromád ... až kým nedostaneme jednu N-prvkovú hromadu, kde N je počet prvkov v poli. Schematicky by sme to mohli napísať takto:
<center><math> \text{pre } i \text{ z intervalu } \left \langle \left \lfloor \frac {\text{dĺžka}}{2} \right \rfloor - 1 \quad ; \quad 0 \right \rangle :\ \text{Heapify( pole[], dĺžka, i )}</math></center>

=====Zmazanie hromady=====
Pri mazaní hromady vykonáme dve operácie. Ako prvé vymeníme prvok na vrchu hromady s koncovým prvkom hromady. Prvok čo je na konci poľa považujeme už za zmazaný, preto veľkosť hromady znížime o 1. Ďalej, aby sme splnili podmienky pre maximálnu binárnu hromadu, zavoláme funkciu Heapify na celú hromadu (vrch hromady je 0-tý prvok v poli). Tento proces opakujeme, pokiaľ v hromade neostanú žiadne prvky.

Poznámka: Pri triediacom algoritme nemusíme mazať celú hromadu, stačí nám, keď v hromade ostane jeden prvok, pretože vtedy bude vstupné pole už utriedené.

Schematicky by sme to mohli zapísať takto:
<center><math>\text{pre } j \text{ z intervalu } \left \langle \text{dĺžka - 1} \quad ; \quad 0 \right ) : \ \ \text{Vymeň(pole[0], pole[$j$])} \ \ a \ \ \text{Heapify(pole[], dĺžka, 0)} </math></center>

Z hľadiska implementácie môžeme vytvoriť rekurzívnu aj iteračnú verziu, čo závisí len od toho, ako je implementovaná funkcia Heapify.

====Pseudokód====
Nech funkcia Heap Sort má nasledovný prototyp: <code>HeapSort(pole[], dlzka)</code>

:1. Nech: <code>i = dlzka / 2 - 1</code>, kde "/" predstavuje celočíslené delenie.
:2. Je <code>i >= 0</code> ? Ak áno, pokračuj krokom 2.1., inak skoč na krok 3.
:::2.1. Zavolaj funkciu: <code>Heapify(pole[], dlzka, i)</code>
:::2.2. <code>i = i - 1</code>
:::2.3. Skoč na krok 2.
:3. Nech: <code>j = dlzka - 1</code>
:4 Je <code> j > 0</code> ? Ak áno, pokračuj krokom 4.1, inak skonči.
:::4.1. Vymeň: <code>pole[0]</code> a <code>pole[j]</code>
:::4.2. Zavolaj funkciu: <code>Heapify(pole[], dlzka, i)</code>
:::4.3. <code>j = j - 1</code>
:::4.4. Skoč na krok 4.

===Implementácia algoritmov Heapify a HeapSort v rôznych programovacích jazykoch===
<tabs>
<tab name="Iteračná C" block>
<syntaxhighlight lang="C">

#include <stdio.h>

void Vymen(int *a, int *b);
void Heapify(int pole[], int dlzka, int index);
void HeapSort(int pole[], int dlzka);

int main()
{
int pole[]= {10, 5, 2, 9, 8, 7, 1, 3, 4, 0, -1};
int dlzka = sizeof(pole) / sizeof(pole[0]);

HeapSort(pole, dlzka);

for (int i = 0; i < dlzka; ++i)
{
printf("%d ", pole[i]);
}
}

void Vymen(int *a, int *b)
{
int tmp = *a;
*a = *b;
*b = tmp;
}

void Heapify(int pole[], int dlzka, int index)
{
int pravy, lavy, max;

while(2 * index + 1 < dlzka)
{
lavy = 2 * index + 1;
pravy = 2 * index + 2;

// určenie potomka s maximálnou hodnotou
if(pravy < dlzka && pole[pravy] > pole[lavy])
{
max = pravy;
}
else
{
max = lavy;
}

// porovnanie maximálneho potomka s rodičom
if(pole[max] > pole[index])
{

Vymen(&pole[max], &pole[index]);
index = max;
}
else
{
return;
}
}
}

void HeapSort(int pole[], int dlzka)
{
// vytvor maximálnu hromadu (procedúra BuildMaxHeap)
for (int i = dlzka / 2 - 1 ; i >= 0; --i)
{
Heapify(pole, dlzka, i);
}

// zmaž všetky prvky z hromady
for (int j = dlzka - 1; j > 0; --j)
{
Vymen(&pole[0], &pole[j]);
Heapify(pole, j, 0);
}
}
</syntaxhighlight>
</tab>
<tab name="Rekurzívna C" block>
<syntaxhighlight lang="C">
#include <stdio.h>

void Vymen(int *a, int *b);
void Heapify(int pole[], int dlzka, int index);
void HeapSort(int pole[], int dlzka);

int main()
{
int pole[]= {10, 5, 2, 9, 8, 7, 1, 3, 4, 0, -1, -1};
int dlzka = sizeof(pole) / sizeof(pole[0]);

HeapSort(pole, dlzka);

for (int i = 0; i < dlzka; ++i)
{
printf("%d ", pole[i]);
}
}

void Vymen(int *a, int *b)
{
int tmp = *a;
*a = *b;
*b = tmp;
}

void Heapify(int pole[], int dlzka, int index)
{

int lavy = 2 * index + 1;
int pravy = 2 * index + 2;
int max = index;

// určenie potomka s maximálnou hodnotou
if(lavy < dlzka && pole[lavy] >= pole[pravy])
{
max = lavy;
}

if(pravy < dlzka && pole[pravy] > pole[lavy])
{
max = pravy;
}

// porovnanie maximálneho potomka s rodičom
if(pole[max] > pole[index])
{
Vymen(&pole[max], &pole[index]);
Heapify(pole, dlzka, max);
}
}

void HeapSort(int pole[], int dlzka)
{
// vytvor maximálnu hromadu (procedúra BuildMaxHeap)
for (int i = dlzka / 2 - 1 ; i >= 0; --i)
{
Heapify(pole, dlzka, i);
}

// zmaž všetky prvky z hromady
for (int j = dlzka - 1; j > 0; --j)
{
Vymen(&pole[0], &pole[j]);
Heapify(pole, j, 0);
}
}
</syntaxhighlight>
</tab>

<tab name="Iterácia Java" block>
<syntaxhighlight lang="Java">
class HeapSortIT {
void swap(int[] pole, int a, int b) {
int tmp = pole[a];
pole[a] = pole[b];
pole[b] = tmp;
}

void heapify(int[] pole, int n) {
for (int i = 1; i < n; i++) {

/* Ak je potomok väčší ako rodič */
if (pole[i] > pole[(i - 1) / 2]) {
int j = i;

/* Vymieňaj elementy (rodič, potomok), dokým je rodič menší ako potomok */
while (pole[j] > pole[(j - 1) / 2]) {
swap(pole, j, (j - 1) / 2);
j = (j - 1) / 2;
}
}
}
}

void sort(int[] pole) {
int n = pole.length;

heapify(pole, n);

for (int i = n - 1; i > 0; i--) {
int j = 0, index;

/* Vymeň prvý a posledný prvok */
swap(pole, 0, i);

do {
index = 2 * j + 1;

/* Ak je ľavý potomok menši ako pravý, presuň 'index' na pravého potomka */
if (index < i - 1 && pole[index] < pole[index + 1])
index++;

/* Ak je rodič menší ako potomok, tak ho vymeň s potomkom, ktorý má väčšiu hodnotu */
if (index < i && pole[j] < pole[index])
swap(pole, j, index);

j = index;
} while (index < i);
}
}
}

public class Main {

static void printArray(int[] pole) {
int n = pole.length;

for (int i : pole)
System.out.print(i + " ");

System.out.println();
}

public static void main(String[] args) {
int[] pole = {12, 11, 13, 5, 6, 7};
int n = pole.length;

System.out.println("Pole pred zoradenim: ");
printArray(pole);

HeapSortIT hs = new HeapSortIT();
hs.sort(pole);

System.out.println("Pole po zoradeni: ");
printArray(pole);
}
}
</syntaxhighlight>
</tab>

<tab name="Rekurzia Java" block>
<syntaxhighlight lang="Java">
class HeapSortRE {
void swap(int[] pole, int a, int b) {
int tmp = pole[a];
pole[a] = pole[b];
pole[b] = tmp;
}

void heapify(int[] pole, int n, int i) {
int max = i; // rodič
int l = 2 * i + 1; // ľavý potomok
int p = 2 * i + 2; // pravý potomok

/* Ak je ľavý potomok väčší ako rodič */
if (l < n && pole[l] > pole[max])
max = l;

/* Ak je pravý potomok väčší ako rodič */
if (p < n && pole[p] > pole[max])
max = p;

/* Ak sa rodič v priebehu funkcie zmenil */
if (max != i) {
swap(pole, i, max);

heapify(pole, n, max);
}
}

public void sort(int[] pole) {
int n = pole.length;

/* Vytvorenie hromadu */
for (int i = n / 2 - 1; i >= 0 ; i--)
heapify(pole, n, i);

/* Extrahovanie jednotlivých elemetov z hromady */
for (int i = n - 1; i > 0; i--) {
/* Presuň aktuálneho rodiča na koniec */
swap(pole, 0, i);

/* Zavolanie heapify na zredukovanú hromadu */
heapify(pole, i, 0);
}
}
}

public class Main {

static void printArray(int[] pole) {
int n = pole.length;

for (int i : pole)
System.out.print(i + " ");

System.out.println();
}

public static void main(String[] args) {
int[] pole = {12, 11, 13, 5, 6, 7};
int n = pole.length;

System.out.println("Pole pred zoradenim: ");
printArray(pole);

HeapSortRE hs = new HeapSortRE();
hs.sort(pole);

System.out.println("Pole po zoradeni: ");
printArray(pole);
}
}
</syntaxhighlight>
</tab>

<tab name="Iterácia Python3" block>
<syntaxhighlight lang="Python3">
def heapify(pole, n):
for i in range(n):

# Ak je potomok väčší ako rodič
if pole[i] > pole[int((i - 1) / 2)]:
j = i

# Vymieňaj elementy (rodič, potomok), dokým je rodič menší ako potomok
while pole[j] > pole[int((j - 1) / 2)]:
pole[j], pole[int((j - 1) / 2)] = pole[int((j - 1) / 2)], pole[j] # swap
j = int((j - 1) / 2)

def sort(pole, n):
heapify(pole, n)

for i in range(n - 1, 0, -1):

# Vymeň prvý a posledný prvok
pole[0], pole[i] = pole[i], pole[0] # swap

j, index = 0, 0

while True:
index = 2 * j + 1

# Ak je ľavý potomok menši ako pravý, presuň 'index' na pravého potomka
if index < (i - 1) and pole[index] < pole[index + 1]:
index += 1

# Ak je rodič menší ako potomok, tak ho vymeň s potomkom, ktorý má väčšiu hodnotu
if index = i:
break

def printArray(pole, n):
for i in range(n):
print(pole[i], end=" ")

if __name__ == '__main__':
pole = [12, 11, 13, 5, 6, 7]
n = len(pole)

print("Zadane pole:")
printArray(pole, n)

sort(pole, n)

print("\nZoradene pole:")
printArray(pole, n)

</syntaxhighlight>
</tab>

<tab name="Rekurzia Python3" block>
<syntaxhighlight lang="Python3">
def heapify(pole, n, i):
max = i # rodic
l = 2 * i + 1 # lavy potomok
p = 2 * i + 2 # pravy potomok

# Ak je ľavý potomok väčší ako rodič
if l < n and pole[max] < pole[l]:
max = l

# Ak je pravý potomok väčší ako rodič
if p < n and pole[max] < pole[p]:
max = p

# Ak sa rodič v priebehu funkcie zmenil
if max != i:
pole[i], pole[max] = pole[max], pole[i] # swap

heapify(pole, n, max)

def sort(pole):
n = len(pole)

# Vytvorenie hromady
for i in range(n // 2 - 1, -1, -1):
heapify(pole, n, i)

# Extrahovanie jednotlivých elementov z hromady
for i in range(n - 1, 0, -1):
pole[i], pole[0] = pole[0], pole[i] # swap
heapify(pole, i, 0)

def printArray(pole):
n = len(pole)

for i in range(n):
print(pole[i], end=" ")

if __name__ == '__main__':
pole = [12, 11, 13, 5, 6, 7]

print("Zadane pole:")
printArray(pole)

sort(pole)

print("\nZoradene pole:")
printArray(pole)
</syntaxhighlight>
</tab>
</tabs>

==Selection Sort==
[[Súbor:SelectionSort.png|600px|náhľad|vpravo|Vizualizácia algoritmu SelectionSort]]
===Prehľad===
Selection Sort je triediaci algoritmus, ktorý si rozdelí pole na dve časti: zotriedenú a nezotriedenú. Následne opakovane vyberá minimum v nezotriedenej časti (ak triedime vzostupne), ktoré umiestni na koniec utrienej časti.
===Vlastnosti algoritmu===
* vhodný pre dátové štruktúry: pole
* časová náročnosť: vždy kvadratická <math> O(n^2) </math>, čo znamená, že algoritmus je určený na triedenie veľmi malých polí (rádovo 10, 20 prvkov), vďaka minimálnej réžii a jednoduchej implementácii, avšak pre väčšie polia sa stáva veľmi neefektívny
* priestorová náročnosť: vždy konštantná <math>O(1)</math>
* druh triedenia: triedenie výberom (komparačný algoritmus)
* stabilita triedenia: nestabilný
* miesto triedenia: vnútorné triedenie

===Základné časti algoritmu===
# Vonkajší cyklus: nastavenie hornej hranice utriedenej časti.
# Vnútorný cyklus: hľadanie minima ....

===Slovný opis algoritmu===
===Pseudokód===
Nech má funkcia Selection Sort nasledovný prototyp: <code>SelectionSort(pole[], dlzka)</code>
:1. Nech: <code>min = pole[0]</code>
:2. Nech <code>i = 1</code>
:3. Je <code>i < dlzka</code> ? Ak áno, pokračuj krokom 3.1., inak skonči.
:::3.1. Nech: <code>j = i</code>
:::3.2. Je <code> j < dlzka</code> ? Ak áno, pokračuj krokom 3.2.1. , inak skoč na krok 3.3.
:::::3.2.1. Je <code>pole[j] < min</code> ?
:::::::Ak áno:
:::::::::3.2.1.1. <code>min = pole[j]</code>
:::::::::3.2.1.2. Skoč na krok 3.2.
:::::::Ak nie:
:::::::::3.2.1.1. Skoč na krok 3.2.
:::3.3. Vymeň: <code>pole[i]</code> a <code>pole[min]</code>
:::3.4. Skoč na krok 3.2.

==Odkazy==
Heap Sort:

https://en.wikipedia.org/wiki/Heapsort

https://www.tutorialspoint.com/design_and_analysis_of_algorithms/design_and_analysis_of_algorithms_heapify_method.htm

https://www.geeksforgeeks.org/heap-sort/

https://www.geeksforgeeks.org/iterative-heap-sort/

https://www.youtube.com/watch?v=H5kAcmGOn4Q

Triedenie výberom

2021-04-11T10:00:31Z

Filip Tomek:

[[Kategória:Algoritmy triedenia]]
{{Draft}}
{{Skripta programovanie}}
__TOC__
==Heap Sort==

===Prehľad===
Heap Sort je triediaci algoritmus, ktorý podobne ako Selection sort rozeľuje pole na zotriedenú a nezotriedenú časť, pričom nezotriedená časť predstavuje dátovú štruktúru [[Hromada|binárna hromada]]. Celé triedenie spočíva v tom, že si zo vstupného poľa vytvoríme binárnu hromadu a následne postupným vyberaním a mazaním všetkých jej prvkov toto pole utriedime.

Hromada, ktorú využíva algoritmus Heap Sort, musí spĺňať nasledovné podmienky (ak indexujeme pole od 0):
:1. Vrchol hromady (koreň) je vždy prvý prvok v poli (v našom prípade prvok na 0-tej pozícii).
:2. Pre ľubovoľný prvok (uzol), uložený na indexe <math>i</math> z intervalu <math> \langle 0 \ ; \ \text{dĺžka} - 1 \rangle </math>, platia nasledovné rovnice:
:: <math>
\begin{align}
\text{ľavý potomok} &= 2i + 1 && (1) \\
\text{pravý potomok} &= 2i + 2 && (2) \\
\text{rodič} &= \left \lfloor \frac{i - 1}{2} \right \rfloor \quad (\text {okrem} \ i = 0) && (3)
\end{align}
</math>
:3. Každý prvok (uzol) v hromade musí mať väčšiu, alebo rovnakú hodnotu ako jeho potomkovia (MAX HEAP - ak triedime pole vzostupne, v opačnom prípade by sme použili MIN HEAP).

===Algoritmus Heapify===
[[Súbor:Heapify.png|vizualizácia|699px|náhľad|vpravo]]
Heapify je kľúčovým podprogramom triediaceho algoritmu Heap Sort, vďaka ktorému vieme efektíve zabezpečiť vytvorenie hromady z poľa a zmazanie hromady.

Princíp algoritmu Heapify spočíva v tom, že ak máme i-ty prvok v poli (v kompletnom binárnom strome), ktorého potomkovia tvoria dve samostatné podhromady, potom tieto dve podhromady zlúčime do jednej hromady, pričom i-ty prvok bude jej vrcholom.

====Vlastnosti algoritmu====
* dátová štruktúra: hromada (reprezentovaná ako: pole, strom)
* časová zložitosť: lineárna <math>O(n)</math>
* priestorová zložitosť: konštantná <math>O(1)</math> pri iteračnej verzii, <math>O(log(n))</math> pri rekurzívnej verzii

====Základné časti algoritmu====
# Určenie potomka s maximálnou hodnotou i-teho prvku.
# Porovnanie maximálneho potomka s rodičom (i-tym prvkom).
# Ak je potomok väčší ako rodič, tak výmena potomka a rodiča.
# Ak nastala výmena, skontrolovanie ovplyvneného potomka (podhromady).

====Slovný opis algoritmu====
Na vstupe prijmeme pole a index i, v ktorom chceme vytvoriť hromadu (Max Heap). Najskôr skontrolujeme, či prvok na indexe i má nejakých potomkov (využijeme rovnice (1) a (2) z časti "Prehľad"). Ak nemá žiadnych potomkov, funkcia skončí, pretože i predstavuje vrchol jednoprvkovej hromady. Ak má práve jedného potomka, tento potomok je zároveň jeho maximálnym potomkom. Ak má práve dvoch potomkov, tak porovnáme ich hodnoty a vyberieme z nich maximálneho potomka. Následne skontrolujeme veľkosť maximálneho potomka a jeho rodiča (prvok na indexe i). Ak je rodič väčší, funkcia skončí, pretože želaná hromada už je utvorená. Ak nie, vymeníme rodiča a maximálneho potomka. Ak nastala výmena, musíme skontrolovať ovplyvnenú podhromadu, tj. zopakovať tento sled krokov pre podhromadu, ktorej vrchol bude v maximálnom potomkovi i-teho prvku.

Z hľadiska implementácie môžeme vytvoriť iteračnú aj rekurzívnu verziu.

====Pseudokód====
<tabs>
<tab name="Iteračná verzia" block>
Nech funkcia Heapify má nasledovný prototyp: <code>Heapify(pole[], dlzka, i)</code>
:1. Je <code>2 * i + 1 < dlzka</code> ? Ak áno, pokračuj krokom 1.1., inak skonči.
:::1.1. Nech: <code>lavy = 2 * i + 1</code>
:::1.2. Nech: <code>pravy = 2 * i + 2</code>
:::1.3. Je <code>pravy < dlzka</code> a zároveň <code>pole[pravy] > pole[lavy]</code> ?
:::::Ak áno:
:::::::1.3.1. Nech: <code>max = pravy</code>
:::::Ak nie:
:::::::1.3.1. Nech: <code>max = lavy</code>
:::1.4. Je <code>pole[max] > pole[i]</code> ?
:::::Ak áno:
:::::::1.4.1. Vymeň: <code>pole[max]</code> a <code>pole[i]</code>
:::::::1.4.2. <code>i = max</code>
:::::Ak nie:
:::::::1.4.1 Skonči.
:::1.5. Skoč na krok 1.

</tab>

<tab name="Rekurzívna verzia" block>
Nech funkcia Heapify má nasledovný prototyp: <code>Heapify(pole[], dlzka, i)</code>
:1. Je <code>pole[2 * i + 1] >= pole[2 * i + 2]</code> ?
::: Ak áno:
:::::1.1. Nech: <code>max = pole[2 * i + 1]</code>
::: Ak nie:
:::::1.1. Nech: <code>max = pole[2 * i + 2]</code>
:2. Je <code>pole[max] > pole[i]</code> ?
::: Ak áno:
::::: 2.1. Vymeň: <code>pole[i] a pole[max]</code>
::::: 2.2. Rekurzívne zavolaj: <code>Heapify(pole[], dlzka, max)</code>
::: Ak nie:
::::: 2.1. Skonči volanie.
</tab>
</tabs>

===Algoritmus Heap Sort===
Heapsort pri triedení vykonáva dve základné úlohy: Vytvorenie maximálnej binárnej hromady zo vstupného poľa a mazanie jednotlivých prvkov z hromady. Pri oboch procedúrach využíva algoritmus Heapify

====Vlastnosti algoritmu====
* vhodný pre dátové štruktúry: pole
* časová náročnosť: vždy linearitmická <math> O(n\log(n)) </math>, vďaka ktorej dokáže efektívne triediť veľmi veľké polia

[[Súbor:HeapSort.png|500px|náhľad|vpravo]]

* priestorová náročnosť: konštantná <math>O(1)</math> pri iteračnej verzii, logaritmická <math>O(\log(n))</math> pri rekurzívnej verzii.
* druh triedenia: triedenie výberom (komparačný algoritmus)
* stabilita triedenia: nestabilný
* miesto triedenia: vnútorné triedenie

====Základné časti algoritmu====
# vytvorenie hromady
# zmazanie hromady

====Slovný opis====
=====Vytvorenie hromady=====
Pri vytváraní hromady využijeme algoritmus heapify, pričom hromadu vytvoríme spôsobom zospodu na vrch. Najskôr si určíme prvok ktorý je najspodnejší a najviac vpravo a zároveň má aspoň jedného potomka. Tento prvok určíme veľmi jednoducho, pretože zpberieme posledný prvok v poli, a pomocou rovnice 3, ktorú si jemne upravíme mu nájdeme rodiča: <center><math> \text{posledný rodič} = \left \lfloor \frac{\text{posledný index } - 1}{2} \right \rfloor = \left \lfloor\frac{\text{dĺžka } - 2}{2} \right \rfloor = \left \lfloor \frac{\text{dĺžka}}{2}\right \rfloor - 1 </math></center>
Následne zavoláme Heapify na podhromadu s vrcholom posledného rodiča. Potom zmenšíme o 1 a opakujeme tento proces , až kým neprídeme na začiatok. Schematicky by sme to mohli napísať takto:
<center><math> \text{pre } i \text{ z intervalu } \left \langle \left \lfloor \frac {\text{dĺžka}}{2} \right \rfloor - 1 \quad ; \quad 0 \right \rangle :\ \text{heapify( pole[], dĺžka, i )}</math></center>

=====Zmazanie hromady=====
Pri mazaní hromady vykonáme dve operácie. Ako prvé vymeníme prvok na vrchu hromady s koncovým prvkom hromady. Prvok čo je na komci považujeme za zmazaný, preto veľkosť hromady znížime o 1. Následne musíme zabezpečiť zachovanie pravidiel pre hromadu, takže zavoláme funkciu Heapify na celú hromadu (index i bude vrch hromady, čiže 0-tý prvok v poli). Tento proces opakujeme, poikiaľ v hromade neostanú žiadne prvky.

Poznámka: v našom prípade nemusíme mazať celú hromadu, ale iba do chvíle, keď nám neostane 1 prvok.

Schematicky by sme to mohli zapísať takto:
<center><math>\text{pre } j \text{ z intervalu } \left \langle \text{dĺžka - 1} \quad ; \quad 0 \right \rangle : \ \ \text{vymeň(pole[0], pole[$j$])} \ \ a \ \ \text{heapify(pole[], dĺžka, 0)} </math></center>

====Pseudokód====
Nech funkcia Heap Sort má nasledovný prototyp: <code>HeapSort(pole[], dlzka)</code>

:1. Nech: <code>i = dlzka / 2 - 1</code>, kde "/" predstavuje celočíslené delenie.
:2. Je <code>i >= 0</code> ? Ak áno, pokračuj krokom 2.1., inak skoč na krok 3.
:::2.1. Zavolaj funkciu <code>Heapify(pole[], dlzka, i)</code>
:::2.2. Skoč na krok 2.
:3. Nech: <code>j = dlzka - 1</code>
:4 Je <code> j > 0</code> ? Ak áno, pokračuj krokom 4.1, inak skonči.
:::4.1. Vymeň: <code>pole[0]</code> a <code>pole[j]</code>
:::4.2. Zavolaj funkciu <code>Heapify(pole[], dlzka, i)</code>
:::4.3. Skoč na krok 4.

===Implementácia algoritmov Heapify a HeapSort v rôznych programovacích jazykoch===
<tabs>
<tab name="Iteračná C" block>
<syntaxhighlight lang="C">

#include <stdio.h>

void Vymen(int *a, int *b);
void Heapify(int pole[], int dlzka, int index);
void HeapSort(int pole[], int dlzka);

int main()
{
int pole[]= {10, 5, 2, 9, 8, 7, 1, 3, 4, 0, -1};
int dlzka = sizeof(pole) / sizeof(pole[0]);

HeapSort(pole, dlzka);

for (int i = 0; i < dlzka; ++i)
{
printf("%d ", pole[i]);
}
}

void Vymen(int *a, int *b)
{
int tmp = *a;
*a = *b;
*b = tmp;
}

void Heapify(int pole[], int dlzka, int index)
{
int pravy, lavy, max;

while(2 * index + 1 < dlzka)
{
lavy = 2 * index + 1;
pravy = 2 * index + 2;

// určenie potomka s maximálnou hodnotou
if(pravy < dlzka && pole[pravy] > pole[lavy])
{
max = pravy;
}
else
{
max = lavy;
}

// porovnanie maximálneho potomka s rodičom
if(pole[max] > pole[index])
{

Vymen(&pole[max], &pole[index]);
index = max;
}
else
{
return;
}
}
}

void HeapSort(int pole[], int dlzka)
{
// vytvor maximálnu hromadu (procedúra BuildMaxHeap)
for (int i = dlzka / 2 - 1 ; i >= 0; --i)
{
Heapify(pole, dlzka, i);
}

// zmaž všetky prvky z hromady
for (int j = dlzka - 1; j > 0; --j)
{
Vymen(&pole[0], &pole[j]);
Heapify(pole, j, 0);
}
}
</syntaxhighlight>
</tab>
<tab name="Rekurzívna C" block>
<syntaxhighlight lang="C">
#include <stdio.h>

void Vymen(int *a, int *b);
void Heapify(int pole[], int dlzka, int index);
void HeapSort(int pole[], int dlzka);

int main()
{
int pole[]= {10, 5, 2, 9, 8, 7, 1, 3, 4, 0, -1, -1};
int dlzka = sizeof(pole) / sizeof(pole[0]);

HeapSort(pole, dlzka);

for (int i = 0; i < dlzka; ++i)
{
printf("%d ", pole[i]);
}
}

void Vymen(int *a, int *b)
{
int tmp = *a;
*a = *b;
*b = tmp;
}

void Heapify(int pole[], int dlzka, int index)
{

int lavy = 2 * index + 1;
int pravy = 2 * index + 2;
int max = index;

// určenie potomka s maximálnou hodnotou
if(lavy < dlzka && pole[lavy] >= pole[pravy])
{
max = lavy;
}

if(pravy < dlzka && pole[pravy] > pole[lavy])
{
max = pravy;
}

// porovnanie maximálneho potomka s rodičom
if(pole[max] > pole[index])
{
Vymen(&pole[max], &pole[index]);
Heapify(pole, dlzka, max);
}
}

void HeapSort(int pole[], int dlzka)
{
// vytvor maximálnu hromadu (procedúra BuildMaxHeap)
for (int i = dlzka / 2 - 1 ; i >= 0; --i)
{
Heapify(pole, dlzka, i);
}

// zmaž všetky prvky z hromady
for (int j = dlzka - 1; j > 0; --j)
{
Vymen(&pole[0], &pole[j]);
Heapify(pole, j, 0);
}
}
</syntaxhighlight>
</tab>

<tab name="Iterácia Java" block>
<syntaxhighlight lang="Java">
class HeapSortIT {
void swap(int[] pole, int a, int b) {
int tmp = pole[a];
pole[a] = pole[b];
pole[b] = tmp;
}

void heapify(int[] pole, int n) {
for (int i = 1; i < n; i++) {

/* Ak je potomok väčší ako rodič */
if (pole[i] > pole[(i - 1) / 2]) {
int j = i;

/* Vymieňaj elementy (rodič, potomok), dokým je rodič menší ako potomok */
while (pole[j] > pole[(j - 1) / 2]) {
swap(pole, j, (j - 1) / 2);
j = (j - 1) / 2;
}
}
}
}

void sort(int[] pole) {
int n = pole.length;

heapify(pole, n);

for (int i = n - 1; i > 0; i--) {
int j = 0, index;

/* Vymeň prvý a posledný prvok */
swap(pole, 0, i);

do {
index = 2 * j + 1;

/* Ak je ľavý potomok menši ako pravý, presuň 'index' na pravého potomka */
if (index < i - 1 && pole[index] < pole[index + 1])
index++;

/* Ak je rodič menší ako potomok, tak ho vymeň s potomkom, ktorý má väčšiu hodnotu */
if (index < i && pole[j] < pole[index])
swap(pole, j, index);

j = index;
} while (index < i);
}
}
}

public class Main {

static void printArray(int[] pole) {
int n = pole.length;

for (int i : pole)
System.out.print(i + " ");

System.out.println();
}

public static void main(String[] args) {
int[] pole = {12, 11, 13, 5, 6, 7};
int n = pole.length;

System.out.println("Pole pred zoradenim: ");
printArray(pole);

HeapSortIT hs = new HeapSortIT();
hs.sort(pole);

System.out.println("Pole po zoradeni: ");
printArray(pole);
}
}
</syntaxhighlight>
</tab>

<tab name="Rekurzia Java" block>
<syntaxhighlight lang="Java">
class HeapSortRE {
void swap(int[] pole, int a, int b) {
int tmp = pole[a];
pole[a] = pole[b];
pole[b] = tmp;
}

void heapify(int[] pole, int n, int i) {
int max = i; // rodič
int l = 2 * i + 1; // ľavý potomok
int p = 2 * i + 2; // pravý potomok

/* Ak je ľavý potomok väčší ako rodič */
if (l < n && pole[l] > pole[max])
max = l;

/* Ak je pravý potomok väčší ako rodič */
if (p < n && pole[p] > pole[max])
max = p;

/* Ak sa rodič v priebehu funkcie zmenil */
if (max != i) {
swap(pole, i, max);

heapify(pole, n, max);
}
}

public void sort(int[] pole) {
int n = pole.length;

/* Vytvorenie hromadu */
for (int i = n / 2 - 1; i >= 0 ; i--)
heapify(pole, n, i);

/* Extrahovanie jednotlivých elemetov z hromady */
for (int i = n - 1; i > 0; i--) {
/* Presuň aktuálneho rodiča na koniec */
swap(pole, 0, i);

/* Zavolanie heapify na zredukovanú hromadu */
heapify(pole, i, 0);
}
}
}

public class Main {

static void printArray(int[] pole) {
int n = pole.length;

for (int i : pole)
System.out.print(i + " ");

System.out.println();
}

public static void main(String[] args) {
int[] pole = {12, 11, 13, 5, 6, 7};
int n = pole.length;

System.out.println("Pole pred zoradenim: ");
printArray(pole);

HeapSortRE hs = new HeapSortRE();
hs.sort(pole);

System.out.println("Pole po zoradeni: ");
printArray(pole);
}
}
</syntaxhighlight>
</tab>

<tab name="Iterácia Python3" block>
<syntaxhighlight lang="Python3">
def heapify(pole, n):
for i in range(n):

# Ak je potomok väčší ako rodič
if pole[i] > pole[int((i - 1) / 2)]:
j = i

# Vymieňaj elementy (rodič, potomok), dokým je rodič menší ako potomok
while pole[j] > pole[int((j - 1) / 2)]:
pole[j], pole[int((j - 1) / 2)] = pole[int((j - 1) / 2)], pole[j] # swap
j = int((j - 1) / 2)

def sort(pole, n):
heapify(pole, n)

for i in range(n - 1, 0, -1):

# Vymeň prvý a posledný prvok
pole[0], pole[i] = pole[i], pole[0] # swap

j, index = 0, 0

while True:
index = 2 * j + 1

# Ak je ľavý potomok menši ako pravý, presuň 'index' na pravého potomka
if index < (i - 1) and pole[index] < pole[index + 1]:
index += 1

# Ak je rodič menší ako potomok, tak ho vymeň s potomkom, ktorý má väčšiu hodnotu
if index = i:
break

def printArray(pole, n):
for i in range(n):
print(pole[i], end=" ")

if __name__ == '__main__':
pole = [12, 11, 13, 5, 6, 7]
n = len(pole)

print("Zadane pole:")
printArray(pole, n)

sort(pole, n)

print("\nZoradene pole:")
printArray(pole, n)

</syntaxhighlight>
</tab>

<tab name="Rekurzia Python3" block>
<syntaxhighlight lang="Python3">
def heapify(pole, n, i):
max = i # rodic
l = 2 * i + 1 # lavy potomok
p = 2 * i + 2 # pravy potomok

# Ak je ľavý potomok väčší ako rodič
if l < n and pole[max] < pole[l]:
max = l

# Ak je pravý potomok väčší ako rodič
if p < n and pole[max] < pole[p]:
max = p

# Ak sa rodič v priebehu funkcie zmenil
if max != i:
pole[i], pole[max] = pole[max], pole[i] # swap

heapify(pole, n, max)

def sort(pole):
n = len(pole)

# Vytvorenie hromady
for i in range(n // 2 - 1, -1, -1):
heapify(pole, n, i)

# Extrahovanie jednotlivých elementov z hromady
for i in range(n - 1, 0, -1):
pole[i], pole[0] = pole[0], pole[i] # swap
heapify(pole, i, 0)

def printArray(pole):
n = len(pole)

for i in range(n):
print(pole[i], end=" ")

if __name__ == '__main__':
pole = [12, 11, 13, 5, 6, 7]

print("Zadane pole:")
printArray(pole)

sort(pole)

print("\nZoradene pole:")
printArray(pole)
</syntaxhighlight>
</tab>
</tabs>

==Selection Sort==
Coming soon :)

==Odkazy==
Heap Sort:

https://en.wikipedia.org/wiki/Heapsort

https://www.tutorialspoint.com/design_and_analysis_of_algorithms/design_and_analysis_of_algorithms_heapify_method.htm

https://www.geeksforgeeks.org/heap-sort/

https://www.geeksforgeeks.org/iterative-heap-sort/

https://www.youtube.com/watch?v=H5kAcmGOn4Q

Triedenie výberom

2021-04-11T10:00:06Z

Filip Tomek: /* Odkazy */

[[Kategória:Algoritmy triedenia]]
{{Draft}}
{{Skripta programovanie}}
__TOC__
==Tento článok je v prvotnom štádiu konštrukcie, zatiaľ je to len hromada myšlienok :)==
odtiaľto sa odrazíme: https://en.wikipedia.org/wiki/Heapsort

==Heap Sort==

===Prehľad===
Heap Sort je triediaci algoritmus, ktorý podobne ako Selection sort rozeľuje pole na zotriedenú a nezotriedenú časť, pričom nezotriedená časť predstavuje dátovú štruktúru [[Hromada|binárna hromada]]. Celé triedenie spočíva v tom, že si zo vstupného poľa vytvoríme binárnu hromadu a následne postupným vyberaním a mazaním všetkých jej prvkov toto pole utriedime.

Hromada, ktorú využíva algoritmus Heap Sort, musí spĺňať nasledovné podmienky (ak indexujeme pole od 0):
:1. Vrchol hromady (koreň) je vždy prvý prvok v poli (v našom prípade prvok na 0-tej pozícii).
:2. Pre ľubovoľný prvok (uzol), uložený na indexe <math>i</math> z intervalu <math> \langle 0 \ ; \ \text{dĺžka} - 1 \rangle </math>, platia nasledovné rovnice:
:: <math>
\begin{align}
\text{ľavý potomok} &= 2i + 1 && (1) \\
\text{pravý potomok} &= 2i + 2 && (2) \\
\text{rodič} &= \left \lfloor \frac{i - 1}{2} \right \rfloor \quad (\text {okrem} \ i = 0) && (3)
\end{align}
</math>
:3. Každý prvok (uzol) v hromade musí mať väčšiu, alebo rovnakú hodnotu ako jeho potomkovia (MAX HEAP - ak triedime pole vzostupne, v opačnom prípade by sme použili MIN HEAP).

===Algoritmus Heapify===
[[Súbor:Heapify.png|vizualizácia|699px|náhľad|vpravo]]
Heapify je kľúčovým podprogramom triediaceho algoritmu Heap Sort, vďaka ktorému vieme efektíve zabezpečiť vytvorenie hromady z poľa a zmazanie hromady.

Princíp algoritmu Heapify spočíva v tom, že ak máme i-ty prvok v poli (v kompletnom binárnom strome), ktorého potomkovia tvoria dve samostatné podhromady, potom tieto dve podhromady zlúčime do jednej hromady, pričom i-ty prvok bude jej vrcholom.

====Vlastnosti algoritmu====
* dátová štruktúra: hromada (reprezentovaná ako: pole, strom)
* časová zložitosť: lineárna <math>O(n)</math>
* priestorová zložitosť: konštantná <math>O(1)</math> pri iteračnej verzii, <math>O(log(n))</math> pri rekurzívnej verzii

====Základné časti algoritmu====
# Určenie potomka s maximálnou hodnotou i-teho prvku.
# Porovnanie maximálneho potomka s rodičom (i-tym prvkom).
# Ak je potomok väčší ako rodič, tak výmena potomka a rodiča.
# Ak nastala výmena, skontrolovanie ovplyvneného potomka (podhromady).

====Slovný opis algoritmu====
Na vstupe prijmeme pole a index i, v ktorom chceme vytvoriť hromadu (Max Heap). Najskôr skontrolujeme, či prvok na indexe i má nejakých potomkov (využijeme rovnice (1) a (2) z časti "Prehľad"). Ak nemá žiadnych potomkov, funkcia skončí, pretože i predstavuje vrchol jednoprvkovej hromady. Ak má práve jedného potomka, tento potomok je zároveň jeho maximálnym potomkom. Ak má práve dvoch potomkov, tak porovnáme ich hodnoty a vyberieme z nich maximálneho potomka. Následne skontrolujeme veľkosť maximálneho potomka a jeho rodiča (prvok na indexe i). Ak je rodič väčší, funkcia skončí, pretože želaná hromada už je utvorená. Ak nie, vymeníme rodiča a maximálneho potomka. Ak nastala výmena, musíme skontrolovať ovplyvnenú podhromadu, tj. zopakovať tento sled krokov pre podhromadu, ktorej vrchol bude v maximálnom potomkovi i-teho prvku.

Z hľadiska implementácie môžeme vytvoriť iteračnú aj rekurzívnu verziu.

====Pseudokód====
<tabs>
<tab name="Iteračná verzia" block>
Nech funkcia Heapify má nasledovný prototyp: <code>Heapify(pole[], dlzka, i)</code>
:1. Je <code>2 * i + 1 < dlzka</code> ? Ak áno, pokračuj krokom 1.1., inak skonči.
:::1.1. Nech: <code>lavy = 2 * i + 1</code>
:::1.2. Nech: <code>pravy = 2 * i + 2</code>
:::1.3. Je <code>pravy < dlzka</code> a zároveň <code>pole[pravy] > pole[lavy]</code> ?
:::::Ak áno:
:::::::1.3.1. Nech: <code>max = pravy</code>
:::::Ak nie:
:::::::1.3.1. Nech: <code>max = lavy</code>
:::1.4. Je <code>pole[max] > pole[i]</code> ?
:::::Ak áno:
:::::::1.4.1. Vymeň: <code>pole[max]</code> a <code>pole[i]</code>
:::::::1.4.2. <code>i = max</code>
:::::Ak nie:
:::::::1.4.1 Skonči.
:::1.5. Skoč na krok 1.

</tab>

<tab name="Rekurzívna verzia" block>
Nech funkcia Heapify má nasledovný prototyp: <code>Heapify(pole[], dlzka, i)</code>
:1. Je <code>pole[2 * i + 1] >= pole[2 * i + 2]</code> ?
::: Ak áno:
:::::1.1. Nech: <code>max = pole[2 * i + 1]</code>
::: Ak nie:
:::::1.1. Nech: <code>max = pole[2 * i + 2]</code>
:2. Je <code>pole[max] > pole[i]</code> ?
::: Ak áno:
::::: 2.1. Vymeň: <code>pole[i] a pole[max]</code>
::::: 2.2. Rekurzívne zavolaj: <code>Heapify(pole[], dlzka, max)</code>
::: Ak nie:
::::: 2.1. Skonči volanie.
</tab>
</tabs>

===Algoritmus Heap Sort===
Heapsort pri triedení vykonáva dve základné úlohy: Vytvorenie maximálnej binárnej hromady zo vstupného poľa a mazanie jednotlivých prvkov z hromady. Pri oboch procedúrach využíva algoritmus Heapify

====Vlastnosti algoritmu====
* vhodný pre dátové štruktúry: pole
* časová náročnosť: vždy linearitmická <math> O(n\log(n)) </math>, vďaka ktorej dokáže efektívne triediť veľmi veľké polia

[[Súbor:HeapSort.png|500px|náhľad|vpravo]]

* priestorová náročnosť: konštantná <math>O(1)</math> pri iteračnej verzii, logaritmická <math>O(\log(n))</math> pri rekurzívnej verzii.
* druh triedenia: triedenie výberom (komparačný algoritmus)
* stabilita triedenia: nestabilný
* miesto triedenia: vnútorné triedenie

====Základné časti algoritmu====
# vytvorenie hromady
# zmazanie hromady

====Slovný opis====
=====Vytvorenie hromady=====
Pri vytváraní hromady využijeme algoritmus heapify, pričom hromadu vytvoríme spôsobom zospodu na vrch. Najskôr si určíme prvok ktorý je najspodnejší a najviac vpravo a zároveň má aspoň jedného potomka. Tento prvok určíme veľmi jednoducho, pretože zpberieme posledný prvok v poli, a pomocou rovnice 3, ktorú si jemne upravíme mu nájdeme rodiča: <center><math> \text{posledný rodič} = \left \lfloor \frac{\text{posledný index } - 1}{2} \right \rfloor = \left \lfloor\frac{\text{dĺžka } - 2}{2} \right \rfloor = \left \lfloor \frac{\text{dĺžka}}{2}\right \rfloor - 1 </math></center>
Následne zavoláme Heapify na podhromadu s vrcholom posledného rodiča. Potom zmenšíme o 1 a opakujeme tento proces , až kým neprídeme na začiatok. Schematicky by sme to mohli napísať takto:
<center><math> \text{pre } i \text{ z intervalu } \left \langle \left \lfloor \frac {\text{dĺžka}}{2} \right \rfloor - 1 \quad ; \quad 0 \right \rangle :\ \text{heapify( pole[], dĺžka, i )}</math></center>

=====Zmazanie hromady=====
Pri mazaní hromady vykonáme dve operácie. Ako prvé vymeníme prvok na vrchu hromady s koncovým prvkom hromady. Prvok čo je na komci považujeme za zmazaný, preto veľkosť hromady znížime o 1. Následne musíme zabezpečiť zachovanie pravidiel pre hromadu, takže zavoláme funkciu Heapify na celú hromadu (index i bude vrch hromady, čiže 0-tý prvok v poli). Tento proces opakujeme, poikiaľ v hromade neostanú žiadne prvky.

Poznámka: v našom prípade nemusíme mazať celú hromadu, ale iba do chvíle, keď nám neostane 1 prvok.

Schematicky by sme to mohli zapísať takto:
<center><math>\text{pre } j \text{ z intervalu } \left \langle \text{dĺžka - 1} \quad ; \quad 0 \right \rangle : \ \ \text{vymeň(pole[0], pole[$j$])} \ \ a \ \ \text{heapify(pole[], dĺžka, 0)} </math></center>

====Pseudokód====
Nech funkcia Heap Sort má nasledovný prototyp: <code>HeapSort(pole[], dlzka)</code>

:1. Nech: <code>i = dlzka / 2 - 1</code>, kde "/" predstavuje celočíslené delenie.
:2. Je <code>i >= 0</code> ? Ak áno, pokračuj krokom 2.1., inak skoč na krok 3.
:::2.1. Zavolaj funkciu <code>Heapify(pole[], dlzka, i)</code>
:::2.2. Skoč na krok 2.
:3. Nech: <code>j = dlzka - 1</code>
:4 Je <code> j > 0</code> ? Ak áno, pokračuj krokom 4.1, inak skonči.
:::4.1. Vymeň: <code>pole[0]</code> a <code>pole[j]</code>
:::4.2. Zavolaj funkciu <code>Heapify(pole[], dlzka, i)</code>
:::4.3. Skoč na krok 4.

===Implementácia algoritmov Heapify a HeapSort v rôznych programovacích jazykoch===
<tabs>
<tab name="Iteračná C" block>
<syntaxhighlight lang="C">

#include <stdio.h>

void Vymen(int *a, int *b);
void Heapify(int pole[], int dlzka, int index);
void HeapSort(int pole[], int dlzka);

int main()
{
int pole[]= {10, 5, 2, 9, 8, 7, 1, 3, 4, 0, -1};
int dlzka = sizeof(pole) / sizeof(pole[0]);

HeapSort(pole, dlzka);

for (int i = 0; i < dlzka; ++i)
{
printf("%d ", pole[i]);
}
}

void Vymen(int *a, int *b)
{
int tmp = *a;
*a = *b;
*b = tmp;
}

void Heapify(int pole[], int dlzka, int index)
{
int pravy, lavy, max;

while(2 * index + 1 < dlzka)
{
lavy = 2 * index + 1;
pravy = 2 * index + 2;

// určenie potomka s maximálnou hodnotou
if(pravy < dlzka && pole[pravy] > pole[lavy])
{
max = pravy;
}
else
{
max = lavy;
}

// porovnanie maximálneho potomka s rodičom
if(pole[max] > pole[index])
{

Vymen(&pole[max], &pole[index]);
index = max;
}
else
{
return;
}
}
}

void HeapSort(int pole[], int dlzka)
{
// vytvor maximálnu hromadu (procedúra BuildMaxHeap)
for (int i = dlzka / 2 - 1 ; i >= 0; --i)
{
Heapify(pole, dlzka, i);
}

// zmaž všetky prvky z hromady
for (int j = dlzka - 1; j > 0; --j)
{
Vymen(&pole[0], &pole[j]);
Heapify(pole, j, 0);
}
}
</syntaxhighlight>
</tab>
<tab name="Rekurzívna C" block>
<syntaxhighlight lang="C">
#include <stdio.h>

void Vymen(int *a, int *b);
void Heapify(int pole[], int dlzka, int index);
void HeapSort(int pole[], int dlzka);

int main()
{
int pole[]= {10, 5, 2, 9, 8, 7, 1, 3, 4, 0, -1, -1};
int dlzka = sizeof(pole) / sizeof(pole[0]);

HeapSort(pole, dlzka);

for (int i = 0; i < dlzka; ++i)
{
printf("%d ", pole[i]);
}
}

void Vymen(int *a, int *b)
{
int tmp = *a;
*a = *b;
*b = tmp;
}

void Heapify(int pole[], int dlzka, int index)
{

int lavy = 2 * index + 1;
int pravy = 2 * index + 2;
int max = index;

// určenie potomka s maximálnou hodnotou
if(lavy < dlzka && pole[lavy] >= pole[pravy])
{
max = lavy;
}

if(pravy < dlzka && pole[pravy] > pole[lavy])
{
max = pravy;
}

// porovnanie maximálneho potomka s rodičom
if(pole[max] > pole[index])
{
Vymen(&pole[max], &pole[index]);
Heapify(pole, dlzka, max);
}
}

void HeapSort(int pole[], int dlzka)
{
// vytvor maximálnu hromadu (procedúra BuildMaxHeap)
for (int i = dlzka / 2 - 1 ; i >= 0; --i)
{
Heapify(pole, dlzka, i);
}

// zmaž všetky prvky z hromady
for (int j = dlzka - 1; j > 0; --j)
{
Vymen(&pole[0], &pole[j]);
Heapify(pole, j, 0);
}
}
</syntaxhighlight>
</tab>

<tab name="Iterácia Java" block>
<syntaxhighlight lang="Java">
class HeapSortIT {
void swap(int[] pole, int a, int b) {
int tmp = pole[a];
pole[a] = pole[b];
pole[b] = tmp;
}

void heapify(int[] pole, int n) {
for (int i = 1; i < n; i++) {

/* Ak je potomok väčší ako rodič */
if (pole[i] > pole[(i - 1) / 2]) {
int j = i;

/* Vymieňaj elementy (rodič, potomok), dokým je rodič menší ako potomok */
while (pole[j] > pole[(j - 1) / 2]) {
swap(pole, j, (j - 1) / 2);
j = (j - 1) / 2;
}
}
}
}

void sort(int[] pole) {
int n = pole.length;

heapify(pole, n);

for (int i = n - 1; i > 0; i--) {
int j = 0, index;

/* Vymeň prvý a posledný prvok */
swap(pole, 0, i);

do {
index = 2 * j + 1;

/* Ak je ľavý potomok menši ako pravý, presuň 'index' na pravého potomka */
if (index < i - 1 && pole[index] < pole[index + 1])
index++;

/* Ak je rodič menší ako potomok, tak ho vymeň s potomkom, ktorý má väčšiu hodnotu */
if (index < i && pole[j] < pole[index])
swap(pole, j, index);

j = index;
} while (index < i);
}
}
}

public class Main {

static void printArray(int[] pole) {
int n = pole.length;

for (int i : pole)
System.out.print(i + " ");

System.out.println();
}

public static void main(String[] args) {
int[] pole = {12, 11, 13, 5, 6, 7};
int n = pole.length;

System.out.println("Pole pred zoradenim: ");
printArray(pole);

HeapSortIT hs = new HeapSortIT();
hs.sort(pole);

System.out.println("Pole po zoradeni: ");
printArray(pole);
}
}
</syntaxhighlight>
</tab>

<tab name="Rekurzia Java" block>
<syntaxhighlight lang="Java">
class HeapSortRE {
void swap(int[] pole, int a, int b) {
int tmp = pole[a];
pole[a] = pole[b];
pole[b] = tmp;
}

void heapify(int[] pole, int n, int i) {
int max = i; // rodič
int l = 2 * i + 1; // ľavý potomok
int p = 2 * i + 2; // pravý potomok

/* Ak je ľavý potomok väčší ako rodič */
if (l < n && pole[l] > pole[max])
max = l;

/* Ak je pravý potomok väčší ako rodič */
if (p < n && pole[p] > pole[max])
max = p;

/* Ak sa rodič v priebehu funkcie zmenil */
if (max != i) {
swap(pole, i, max);

heapify(pole, n, max);
}
}

public void sort(int[] pole) {
int n = pole.length;

/* Vytvorenie hromadu */
for (int i = n / 2 - 1; i >= 0 ; i--)
heapify(pole, n, i);

/* Extrahovanie jednotlivých elemetov z hromady */
for (int i = n - 1; i > 0; i--) {
/* Presuň aktuálneho rodiča na koniec */
swap(pole, 0, i);

/* Zavolanie heapify na zredukovanú hromadu */
heapify(pole, i, 0);
}
}
}

public class Main {

static void printArray(int[] pole) {
int n = pole.length;

for (int i : pole)
System.out.print(i + " ");

System.out.println();
}

public static void main(String[] args) {
int[] pole = {12, 11, 13, 5, 6, 7};
int n = pole.length;

System.out.println("Pole pred zoradenim: ");
printArray(pole);

HeapSortRE hs = new HeapSortRE();
hs.sort(pole);

System.out.println("Pole po zoradeni: ");
printArray(pole);
}
}
</syntaxhighlight>
</tab>

<tab name="Iterácia Python3" block>
<syntaxhighlight lang="Python3">
def heapify(pole, n):
for i in range(n):

# Ak je potomok väčší ako rodič
if pole[i] > pole[int((i - 1) / 2)]:
j = i

# Vymieňaj elementy (rodič, potomok), dokým je rodič menší ako potomok
while pole[j] > pole[int((j - 1) / 2)]:
pole[j], pole[int((j - 1) / 2)] = pole[int((j - 1) / 2)], pole[j] # swap
j = int((j - 1) / 2)

def sort(pole, n):
heapify(pole, n)

for i in range(n - 1, 0, -1):

# Vymeň prvý a posledný prvok
pole[0], pole[i] = pole[i], pole[0] # swap

j, index = 0, 0

while True:
index = 2 * j + 1

# Ak je ľavý potomok menši ako pravý, presuň 'index' na pravého potomka
if index < (i - 1) and pole[index] < pole[index + 1]:
index += 1

# Ak je rodič menší ako potomok, tak ho vymeň s potomkom, ktorý má väčšiu hodnotu
if index = i:
break

def printArray(pole, n):
for i in range(n):
print(pole[i], end=" ")

if __name__ == '__main__':
pole = [12, 11, 13, 5, 6, 7]
n = len(pole)

print("Zadane pole:")
printArray(pole, n)

sort(pole, n)

print("\nZoradene pole:")
printArray(pole, n)

</syntaxhighlight>
</tab>

<tab name="Rekurzia Python3" block>
<syntaxhighlight lang="Python3">
def heapify(pole, n, i):
max = i # rodic
l = 2 * i + 1 # lavy potomok
p = 2 * i + 2 # pravy potomok

# Ak je ľavý potomok väčší ako rodič
if l < n and pole[max] < pole[l]:
max = l

# Ak je pravý potomok väčší ako rodič
if p < n and pole[max] < pole[p]:
max = p

# Ak sa rodič v priebehu funkcie zmenil
if max != i:
pole[i], pole[max] = pole[max], pole[i] # swap

heapify(pole, n, max)

def sort(pole):
n = len(pole)

# Vytvorenie hromady
for i in range(n // 2 - 1, -1, -1):
heapify(pole, n, i)

# Extrahovanie jednotlivých elementov z hromady
for i in range(n - 1, 0, -1):
pole[i], pole[0] = pole[0], pole[i] # swap
heapify(pole, i, 0)

def printArray(pole):
n = len(pole)

for i in range(n):
print(pole[i], end=" ")

if __name__ == '__main__':
pole = [12, 11, 13, 5, 6, 7]

print("Zadane pole:")
printArray(pole)

sort(pole)

print("\nZoradene pole:")
printArray(pole)
</syntaxhighlight>
</tab>
</tabs>

==Selection Sort==
Coming soon :)

==Odkazy==
Heap Sort:

https://en.wikipedia.org/wiki/Heapsort

https://www.tutorialspoint.com/design_and_analysis_of_algorithms/design_and_analysis_of_algorithms_heapify_method.htm

https://www.geeksforgeeks.org/heap-sort/

https://www.geeksforgeeks.org/iterative-heap-sort/

https://www.youtube.com/watch?v=H5kAcmGOn4Q

Triedenie výberom

2021-04-11T09:59:04Z

Filip Tomek: /* Odkazy */

[[Kategória:Algoritmy triedenia]]
{{Draft}}
{{Skripta programovanie}}
__TOC__
==Tento článok je v prvotnom štádiu konštrukcie, zatiaľ je to len hromada myšlienok :)==
odtiaľto sa odrazíme: https://en.wikipedia.org/wiki/Heapsort

==Heap Sort==

===Prehľad===
Heap Sort je triediaci algoritmus, ktorý podobne ako Selection sort rozeľuje pole na zotriedenú a nezotriedenú časť, pričom nezotriedená časť predstavuje dátovú štruktúru [[Hromada|binárna hromada]]. Celé triedenie spočíva v tom, že si zo vstupného poľa vytvoríme binárnu hromadu a následne postupným vyberaním a mazaním všetkých jej prvkov toto pole utriedime.

Hromada, ktorú využíva algoritmus Heap Sort, musí spĺňať nasledovné podmienky (ak indexujeme pole od 0):
:1. Vrchol hromady (koreň) je vždy prvý prvok v poli (v našom prípade prvok na 0-tej pozícii).
:2. Pre ľubovoľný prvok (uzol), uložený na indexe <math>i</math> z intervalu <math> \langle 0 \ ; \ \text{dĺžka} - 1 \rangle </math>, platia nasledovné rovnice:
:: <math>
\begin{align}
\text{ľavý potomok} &= 2i + 1 && (1) \\
\text{pravý potomok} &= 2i + 2 && (2) \\
\text{rodič} &= \left \lfloor \frac{i - 1}{2} \right \rfloor \quad (\text {okrem} \ i = 0) && (3)
\end{align}
</math>
:3. Každý prvok (uzol) v hromade musí mať väčšiu, alebo rovnakú hodnotu ako jeho potomkovia (MAX HEAP - ak triedime pole vzostupne, v opačnom prípade by sme použili MIN HEAP).

===Algoritmus Heapify===
[[Súbor:Heapify.png|vizualizácia|699px|náhľad|vpravo]]
Heapify je kľúčovým podprogramom triediaceho algoritmu Heap Sort, vďaka ktorému vieme efektíve zabezpečiť vytvorenie hromady z poľa a zmazanie hromady.

Princíp algoritmu Heapify spočíva v tom, že ak máme i-ty prvok v poli (v kompletnom binárnom strome), ktorého potomkovia tvoria dve samostatné podhromady, potom tieto dve podhromady zlúčime do jednej hromady, pričom i-ty prvok bude jej vrcholom.

====Vlastnosti algoritmu====
* dátová štruktúra: hromada (reprezentovaná ako: pole, strom)
* časová zložitosť: lineárna <math>O(n)</math>
* priestorová zložitosť: konštantná <math>O(1)</math> pri iteračnej verzii, <math>O(log(n))</math> pri rekurzívnej verzii

====Základné časti algoritmu====
# Určenie potomka s maximálnou hodnotou i-teho prvku.
# Porovnanie maximálneho potomka s rodičom (i-tym prvkom).
# Ak je potomok väčší ako rodič, tak výmena potomka a rodiča.
# Ak nastala výmena, skontrolovanie ovplyvneného potomka (podhromady).

====Slovný opis algoritmu====
Na vstupe prijmeme pole a index i, v ktorom chceme vytvoriť hromadu (Max Heap). Najskôr skontrolujeme, či prvok na indexe i má nejakých potomkov (využijeme rovnice (1) a (2) z časti "Prehľad"). Ak nemá žiadnych potomkov, funkcia skončí, pretože i predstavuje vrchol jednoprvkovej hromady. Ak má práve jedného potomka, tento potomok je zároveň jeho maximálnym potomkom. Ak má práve dvoch potomkov, tak porovnáme ich hodnoty a vyberieme z nich maximálneho potomka. Následne skontrolujeme veľkosť maximálneho potomka a jeho rodiča (prvok na indexe i). Ak je rodič väčší, funkcia skončí, pretože želaná hromada už je utvorená. Ak nie, vymeníme rodiča a maximálneho potomka. Ak nastala výmena, musíme skontrolovať ovplyvnenú podhromadu, tj. zopakovať tento sled krokov pre podhromadu, ktorej vrchol bude v maximálnom potomkovi i-teho prvku.

Z hľadiska implementácie môžeme vytvoriť iteračnú aj rekurzívnu verziu.

====Pseudokód====
<tabs>
<tab name="Iteračná verzia" block>
Nech funkcia Heapify má nasledovný prototyp: <code>Heapify(pole[], dlzka, i)</code>
:1. Je <code>2 * i + 1 < dlzka</code> ? Ak áno, pokračuj krokom 1.1., inak skonči.
:::1.1. Nech: <code>lavy = 2 * i + 1</code>
:::1.2. Nech: <code>pravy = 2 * i + 2</code>
:::1.3. Je <code>pravy < dlzka</code> a zároveň <code>pole[pravy] > pole[lavy]</code> ?
:::::Ak áno:
:::::::1.3.1. Nech: <code>max = pravy</code>
:::::Ak nie:
:::::::1.3.1. Nech: <code>max = lavy</code>
:::1.4. Je <code>pole[max] > pole[i]</code> ?
:::::Ak áno:
:::::::1.4.1. Vymeň: <code>pole[max]</code> a <code>pole[i]</code>
:::::::1.4.2. <code>i = max</code>
:::::Ak nie:
:::::::1.4.1 Skonči.
:::1.5. Skoč na krok 1.

</tab>

<tab name="Rekurzívna verzia" block>
Nech funkcia Heapify má nasledovný prototyp: <code>Heapify(pole[], dlzka, i)</code>
:1. Je <code>pole[2 * i + 1] >= pole[2 * i + 2]</code> ?
::: Ak áno:
:::::1.1. Nech: <code>max = pole[2 * i + 1]</code>
::: Ak nie:
:::::1.1. Nech: <code>max = pole[2 * i + 2]</code>
:2. Je <code>pole[max] > pole[i]</code> ?
::: Ak áno:
::::: 2.1. Vymeň: <code>pole[i] a pole[max]</code>
::::: 2.2. Rekurzívne zavolaj: <code>Heapify(pole[], dlzka, max)</code>
::: Ak nie:
::::: 2.1. Skonči volanie.
</tab>
</tabs>

===Algoritmus Heap Sort===
Heapsort pri triedení vykonáva dve základné úlohy: Vytvorenie maximálnej binárnej hromady zo vstupného poľa a mazanie jednotlivých prvkov z hromady. Pri oboch procedúrach využíva algoritmus Heapify

====Vlastnosti algoritmu====
* vhodný pre dátové štruktúry: pole
* časová náročnosť: vždy linearitmická <math> O(n\log(n)) </math>, vďaka ktorej dokáže efektívne triediť veľmi veľké polia

[[Súbor:HeapSort.png|500px|náhľad|vpravo]]

* priestorová náročnosť: konštantná <math>O(1)</math> pri iteračnej verzii, logaritmická <math>O(\log(n))</math> pri rekurzívnej verzii.
* druh triedenia: triedenie výberom (komparačný algoritmus)
* stabilita triedenia: nestabilný
* miesto triedenia: vnútorné triedenie

====Základné časti algoritmu====
# vytvorenie hromady
# zmazanie hromady

====Slovný opis====
=====Vytvorenie hromady=====
Pri vytváraní hromady využijeme algoritmus heapify, pričom hromadu vytvoríme spôsobom zospodu na vrch. Najskôr si určíme prvok ktorý je najspodnejší a najviac vpravo a zároveň má aspoň jedného potomka. Tento prvok určíme veľmi jednoducho, pretože zpberieme posledný prvok v poli, a pomocou rovnice 3, ktorú si jemne upravíme mu nájdeme rodiča: <center><math> \text{posledný rodič} = \left \lfloor \frac{\text{posledný index } - 1}{2} \right \rfloor = \left \lfloor\frac{\text{dĺžka } - 2}{2} \right \rfloor = \left \lfloor \frac{\text{dĺžka}}{2}\right \rfloor - 1 </math></center>
Následne zavoláme Heapify na podhromadu s vrcholom posledného rodiča. Potom zmenšíme o 1 a opakujeme tento proces , až kým neprídeme na začiatok. Schematicky by sme to mohli napísať takto:
<center><math> \text{pre } i \text{ z intervalu } \left \langle \left \lfloor \frac {\text{dĺžka}}{2} \right \rfloor - 1 \quad ; \quad 0 \right \rangle :\ \text{heapify( pole[], dĺžka, i )}</math></center>

=====Zmazanie hromady=====
Pri mazaní hromady vykonáme dve operácie. Ako prvé vymeníme prvok na vrchu hromady s koncovým prvkom hromady. Prvok čo je na komci považujeme za zmazaný, preto veľkosť hromady znížime o 1. Následne musíme zabezpečiť zachovanie pravidiel pre hromadu, takže zavoláme funkciu Heapify na celú hromadu (index i bude vrch hromady, čiže 0-tý prvok v poli). Tento proces opakujeme, poikiaľ v hromade neostanú žiadne prvky.

Poznámka: v našom prípade nemusíme mazať celú hromadu, ale iba do chvíle, keď nám neostane 1 prvok.

Schematicky by sme to mohli zapísať takto:
<center><math>\text{pre } j \text{ z intervalu } \left \langle \text{dĺžka - 1} \quad ; \quad 0 \right \rangle : \ \ \text{vymeň(pole[0], pole[$j$])} \ \ a \ \ \text{heapify(pole[], dĺžka, 0)} </math></center>

====Pseudokód====
Nech funkcia Heap Sort má nasledovný prototyp: <code>HeapSort(pole[], dlzka)</code>

:1. Nech: <code>i = dlzka / 2 - 1</code>, kde "/" predstavuje celočíslené delenie.
:2. Je <code>i >= 0</code> ? Ak áno, pokračuj krokom 2.1., inak skoč na krok 3.
:::2.1. Zavolaj funkciu <code>Heapify(pole[], dlzka, i)</code>
:::2.2. Skoč na krok 2.
:3. Nech: <code>j = dlzka - 1</code>
:4 Je <code> j > 0</code> ? Ak áno, pokračuj krokom 4.1, inak skonči.
:::4.1. Vymeň: <code>pole[0]</code> a <code>pole[j]</code>
:::4.2. Zavolaj funkciu <code>Heapify(pole[], dlzka, i)</code>
:::4.3. Skoč na krok 4.

===Implementácia algoritmov Heapify a HeapSort v rôznych programovacích jazykoch===
<tabs>
<tab name="Iteračná C" block>
<syntaxhighlight lang="C">

#include <stdio.h>

void Vymen(int *a, int *b);
void Heapify(int pole[], int dlzka, int index);
void HeapSort(int pole[], int dlzka);

int main()
{
int pole[]= {10, 5, 2, 9, 8, 7, 1, 3, 4, 0, -1};
int dlzka = sizeof(pole) / sizeof(pole[0]);

HeapSort(pole, dlzka);

for (int i = 0; i < dlzka; ++i)
{
printf("%d ", pole[i]);
}
}

void Vymen(int *a, int *b)
{
int tmp = *a;
*a = *b;
*b = tmp;
}

void Heapify(int pole[], int dlzka, int index)
{
int pravy, lavy, max;

while(2 * index + 1 < dlzka)
{
lavy = 2 * index + 1;
pravy = 2 * index + 2;

// určenie potomka s maximálnou hodnotou
if(pravy < dlzka && pole[pravy] > pole[lavy])
{
max = pravy;
}
else
{
max = lavy;
}

// porovnanie maximálneho potomka s rodičom
if(pole[max] > pole[index])
{

Vymen(&pole[max], &pole[index]);
index = max;
}
else
{
return;
}
}
}

void HeapSort(int pole[], int dlzka)
{
// vytvor maximálnu hromadu (procedúra BuildMaxHeap)
for (int i = dlzka / 2 - 1 ; i >= 0; --i)
{
Heapify(pole, dlzka, i);
}

// zmaž všetky prvky z hromady
for (int j = dlzka - 1; j > 0; --j)
{
Vymen(&pole[0], &pole[j]);
Heapify(pole, j, 0);
}
}
</syntaxhighlight>
</tab>
<tab name="Rekurzívna C" block>
<syntaxhighlight lang="C">
#include <stdio.h>

void Vymen(int *a, int *b);
void Heapify(int pole[], int dlzka, int index);
void HeapSort(int pole[], int dlzka);

int main()
{
int pole[]= {10, 5, 2, 9, 8, 7, 1, 3, 4, 0, -1, -1};
int dlzka = sizeof(pole) / sizeof(pole[0]);

HeapSort(pole, dlzka);

for (int i = 0; i < dlzka; ++i)
{
printf("%d ", pole[i]);
}
}

void Vymen(int *a, int *b)
{
int tmp = *a;
*a = *b;
*b = tmp;
}

void Heapify(int pole[], int dlzka, int index)
{

int lavy = 2 * index + 1;
int pravy = 2 * index + 2;
int max = index;

// určenie potomka s maximálnou hodnotou
if(lavy < dlzka && pole[lavy] >= pole[pravy])
{
max = lavy;
}

if(pravy < dlzka && pole[pravy] > pole[lavy])
{
max = pravy;
}

// porovnanie maximálneho potomka s rodičom
if(pole[max] > pole[index])
{
Vymen(&pole[max], &pole[index]);
Heapify(pole, dlzka, max);
}
}

void HeapSort(int pole[], int dlzka)
{
// vytvor maximálnu hromadu (procedúra BuildMaxHeap)
for (int i = dlzka / 2 - 1 ; i >= 0; --i)
{
Heapify(pole, dlzka, i);
}

// zmaž všetky prvky z hromady
for (int j = dlzka - 1; j > 0; --j)
{
Vymen(&pole[0], &pole[j]);
Heapify(pole, j, 0);
}
}
</syntaxhighlight>
</tab>

<tab name="Iterácia Java" block>
<syntaxhighlight lang="Java">
class HeapSortIT {
void swap(int[] pole, int a, int b) {
int tmp = pole[a];
pole[a] = pole[b];
pole[b] = tmp;
}

void heapify(int[] pole, int n) {
for (int i = 1; i < n; i++) {

/* Ak je potomok väčší ako rodič */
if (pole[i] > pole[(i - 1) / 2]) {
int j = i;

/* Vymieňaj elementy (rodič, potomok), dokým je rodič menší ako potomok */
while (pole[j] > pole[(j - 1) / 2]) {
swap(pole, j, (j - 1) / 2);
j = (j - 1) / 2;
}
}
}
}

void sort(int[] pole) {
int n = pole.length;

heapify(pole, n);

for (int i = n - 1; i > 0; i--) {
int j = 0, index;

/* Vymeň prvý a posledný prvok */
swap(pole, 0, i);

do {
index = 2 * j + 1;

/* Ak je ľavý potomok menši ako pravý, presuň 'index' na pravého potomka */
if (index < i - 1 && pole[index] < pole[index + 1])
index++;

/* Ak je rodič menší ako potomok, tak ho vymeň s potomkom, ktorý má väčšiu hodnotu */
if (index < i && pole[j] < pole[index])
swap(pole, j, index);

j = index;
} while (index < i);
}
}
}

public class Main {

static void printArray(int[] pole) {
int n = pole.length;

for (int i : pole)
System.out.print(i + " ");

System.out.println();
}

public static void main(String[] args) {
int[] pole = {12, 11, 13, 5, 6, 7};
int n = pole.length;

System.out.println("Pole pred zoradenim: ");
printArray(pole);

HeapSortIT hs = new HeapSortIT();
hs.sort(pole);

System.out.println("Pole po zoradeni: ");
printArray(pole);
}
}
</syntaxhighlight>
</tab>

<tab name="Rekurzia Java" block>
<syntaxhighlight lang="Java">
class HeapSortRE {
void swap(int[] pole, int a, int b) {
int tmp = pole[a];
pole[a] = pole[b];
pole[b] = tmp;
}

void heapify(int[] pole, int n, int i) {
int max = i; // rodič
int l = 2 * i + 1; // ľavý potomok
int p = 2 * i + 2; // pravý potomok

/* Ak je ľavý potomok väčší ako rodič */
if (l < n && pole[l] > pole[max])
max = l;

/* Ak je pravý potomok väčší ako rodič */
if (p < n && pole[p] > pole[max])
max = p;

/* Ak sa rodič v priebehu funkcie zmenil */
if (max != i) {
swap(pole, i, max);

heapify(pole, n, max);
}
}

public void sort(int[] pole) {
int n = pole.length;

/* Vytvorenie hromadu */
for (int i = n / 2 - 1; i >= 0 ; i--)
heapify(pole, n, i);

/* Extrahovanie jednotlivých elemetov z hromady */
for (int i = n - 1; i > 0; i--) {
/* Presuň aktuálneho rodiča na koniec */
swap(pole, 0, i);

/* Zavolanie heapify na zredukovanú hromadu */
heapify(pole, i, 0);
}
}
}

public class Main {

static void printArray(int[] pole) {
int n = pole.length;

for (int i : pole)
System.out.print(i + " ");

System.out.println();
}

public static void main(String[] args) {
int[] pole = {12, 11, 13, 5, 6, 7};
int n = pole.length;

System.out.println("Pole pred zoradenim: ");
printArray(pole);

HeapSortRE hs = new HeapSortRE();
hs.sort(pole);

System.out.println("Pole po zoradeni: ");
printArray(pole);
}
}
</syntaxhighlight>
</tab>

<tab name="Iterácia Python3" block>
<syntaxhighlight lang="Python3">
def heapify(pole, n):
for i in range(n):

# Ak je potomok väčší ako rodič
if pole[i] > pole[int((i - 1) / 2)]:
j = i

# Vymieňaj elementy (rodič, potomok), dokým je rodič menší ako potomok
while pole[j] > pole[int((j - 1) / 2)]:
pole[j], pole[int((j - 1) / 2)] = pole[int((j - 1) / 2)], pole[j] # swap
j = int((j - 1) / 2)

def sort(pole, n):
heapify(pole, n)

for i in range(n - 1, 0, -1):

# Vymeň prvý a posledný prvok
pole[0], pole[i] = pole[i], pole[0] # swap

j, index = 0, 0

while True:
index = 2 * j + 1

# Ak je ľavý potomok menši ako pravý, presuň 'index' na pravého potomka
if index < (i - 1) and pole[index] < pole[index + 1]:
index += 1

# Ak je rodič menší ako potomok, tak ho vymeň s potomkom, ktorý má väčšiu hodnotu
if index = i:
break

def printArray(pole, n):
for i in range(n):
print(pole[i], end=" ")

if __name__ == '__main__':
pole = [12, 11, 13, 5, 6, 7]
n = len(pole)

print("Zadane pole:")
printArray(pole, n)

sort(pole, n)

print("\nZoradene pole:")
printArray(pole, n)

</syntaxhighlight>
</tab>

<tab name="Rekurzia Python3" block>
<syntaxhighlight lang="Python3">
def heapify(pole, n, i):
max = i # rodic
l = 2 * i + 1 # lavy potomok
p = 2 * i + 2 # pravy potomok

# Ak je ľavý potomok väčší ako rodič
if l < n and pole[max] < pole[l]:
max = l

# Ak je pravý potomok väčší ako rodič
if p < n and pole[max] < pole[p]:
max = p

# Ak sa rodič v priebehu funkcie zmenil
if max != i:
pole[i], pole[max] = pole[max], pole[i] # swap

heapify(pole, n, max)

def sort(pole):
n = len(pole)

# Vytvorenie hromady
for i in range(n // 2 - 1, -1, -1):
heapify(pole, n, i)

# Extrahovanie jednotlivých elementov z hromady
for i in range(n - 1, 0, -1):
pole[i], pole[0] = pole[0], pole[i] # swap
heapify(pole, i, 0)

def printArray(pole):
n = len(pole)

for i in range(n):
print(pole[i], end=" ")

if __name__ == '__main__':
pole = [12, 11, 13, 5, 6, 7]

print("Zadane pole:")
printArray(pole)

sort(pole)

print("\nZoradene pole:")
printArray(pole)
</syntaxhighlight>
</tab>
</tabs>

==Selection Sort==
Coming soon :)

==Odkazy==
Heap Sort:

https://www.tutorialspoint.com/design_and_analysis_of_algorithms/design_and_analysis_of_algorithms_heapify_method.htm

https://www.geeksforgeeks.org/heap-sort/

https://www.geeksforgeeks.org/iterative-heap-sort/

https://www.youtube.com/watch?v=H5kAcmGOn4Q

Triedenie výberom

2021-04-11T09:58:43Z

Filip Tomek: /* Odkazy */

[[Kategória:Algoritmy triedenia]]
{{Draft}}
{{Skripta programovanie}}
__TOC__
==Tento článok je v prvotnom štádiu konštrukcie, zatiaľ je to len hromada myšlienok :)==
odtiaľto sa odrazíme: https://en.wikipedia.org/wiki/Heapsort

==Heap Sort==

===Prehľad===
Heap Sort je triediaci algoritmus, ktorý podobne ako Selection sort rozeľuje pole na zotriedenú a nezotriedenú časť, pričom nezotriedená časť predstavuje dátovú štruktúru [[Hromada|binárna hromada]]. Celé triedenie spočíva v tom, že si zo vstupného poľa vytvoríme binárnu hromadu a následne postupným vyberaním a mazaním všetkých jej prvkov toto pole utriedime.

Hromada, ktorú využíva algoritmus Heap Sort, musí spĺňať nasledovné podmienky (ak indexujeme pole od 0):
:1. Vrchol hromady (koreň) je vždy prvý prvok v poli (v našom prípade prvok na 0-tej pozícii).
:2. Pre ľubovoľný prvok (uzol), uložený na indexe <math>i</math> z intervalu <math> \langle 0 \ ; \ \text{dĺžka} - 1 \rangle </math>, platia nasledovné rovnice:
:: <math>
\begin{align}
\text{ľavý potomok} &= 2i + 1 && (1) \\
\text{pravý potomok} &= 2i + 2 && (2) \\
\text{rodič} &= \left \lfloor \frac{i - 1}{2} \right \rfloor \quad (\text {okrem} \ i = 0) && (3)
\end{align}
</math>
:3. Každý prvok (uzol) v hromade musí mať väčšiu, alebo rovnakú hodnotu ako jeho potomkovia (MAX HEAP - ak triedime pole vzostupne, v opačnom prípade by sme použili MIN HEAP).

===Algoritmus Heapify===
[[Súbor:Heapify.png|vizualizácia|699px|náhľad|vpravo]]
Heapify je kľúčovým podprogramom triediaceho algoritmu Heap Sort, vďaka ktorému vieme efektíve zabezpečiť vytvorenie hromady z poľa a zmazanie hromady.

Princíp algoritmu Heapify spočíva v tom, že ak máme i-ty prvok v poli (v kompletnom binárnom strome), ktorého potomkovia tvoria dve samostatné podhromady, potom tieto dve podhromady zlúčime do jednej hromady, pričom i-ty prvok bude jej vrcholom.

====Vlastnosti algoritmu====
* dátová štruktúra: hromada (reprezentovaná ako: pole, strom)
* časová zložitosť: lineárna <math>O(n)</math>
* priestorová zložitosť: konštantná <math>O(1)</math> pri iteračnej verzii, <math>O(log(n))</math> pri rekurzívnej verzii

====Základné časti algoritmu====
# Určenie potomka s maximálnou hodnotou i-teho prvku.
# Porovnanie maximálneho potomka s rodičom (i-tym prvkom).
# Ak je potomok väčší ako rodič, tak výmena potomka a rodiča.
# Ak nastala výmena, skontrolovanie ovplyvneného potomka (podhromady).

====Slovný opis algoritmu====
Na vstupe prijmeme pole a index i, v ktorom chceme vytvoriť hromadu (Max Heap). Najskôr skontrolujeme, či prvok na indexe i má nejakých potomkov (využijeme rovnice (1) a (2) z časti "Prehľad"). Ak nemá žiadnych potomkov, funkcia skončí, pretože i predstavuje vrchol jednoprvkovej hromady. Ak má práve jedného potomka, tento potomok je zároveň jeho maximálnym potomkom. Ak má práve dvoch potomkov, tak porovnáme ich hodnoty a vyberieme z nich maximálneho potomka. Následne skontrolujeme veľkosť maximálneho potomka a jeho rodiča (prvok na indexe i). Ak je rodič väčší, funkcia skončí, pretože želaná hromada už je utvorená. Ak nie, vymeníme rodiča a maximálneho potomka. Ak nastala výmena, musíme skontrolovať ovplyvnenú podhromadu, tj. zopakovať tento sled krokov pre podhromadu, ktorej vrchol bude v maximálnom potomkovi i-teho prvku.

Z hľadiska implementácie môžeme vytvoriť iteračnú aj rekurzívnu verziu.

====Pseudokód====
<tabs>
<tab name="Iteračná verzia" block>
Nech funkcia Heapify má nasledovný prototyp: <code>Heapify(pole[], dlzka, i)</code>
:1. Je <code>2 * i + 1 < dlzka</code> ? Ak áno, pokračuj krokom 1.1., inak skonči.
:::1.1. Nech: <code>lavy = 2 * i + 1</code>
:::1.2. Nech: <code>pravy = 2 * i + 2</code>
:::1.3. Je <code>pravy < dlzka</code> a zároveň <code>pole[pravy] > pole[lavy]</code> ?
:::::Ak áno:
:::::::1.3.1. Nech: <code>max = pravy</code>
:::::Ak nie:
:::::::1.3.1. Nech: <code>max = lavy</code>
:::1.4. Je <code>pole[max] > pole[i]</code> ?
:::::Ak áno:
:::::::1.4.1. Vymeň: <code>pole[max]</code> a <code>pole[i]</code>
:::::::1.4.2. <code>i = max</code>
:::::Ak nie:
:::::::1.4.1 Skonči.
:::1.5. Skoč na krok 1.

</tab>

<tab name="Rekurzívna verzia" block>
Nech funkcia Heapify má nasledovný prototyp: <code>Heapify(pole[], dlzka, i)</code>
:1. Je <code>pole[2 * i + 1] >= pole[2 * i + 2]</code> ?
::: Ak áno:
:::::1.1. Nech: <code>max = pole[2 * i + 1]</code>
::: Ak nie:
:::::1.1. Nech: <code>max = pole[2 * i + 2]</code>
:2. Je <code>pole[max] > pole[i]</code> ?
::: Ak áno:
::::: 2.1. Vymeň: <code>pole[i] a pole[max]</code>
::::: 2.2. Rekurzívne zavolaj: <code>Heapify(pole[], dlzka, max)</code>
::: Ak nie:
::::: 2.1. Skonči volanie.
</tab>
</tabs>

===Algoritmus Heap Sort===
Heapsort pri triedení vykonáva dve základné úlohy: Vytvorenie maximálnej binárnej hromady zo vstupného poľa a mazanie jednotlivých prvkov z hromady. Pri oboch procedúrach využíva algoritmus Heapify

====Vlastnosti algoritmu====
* vhodný pre dátové štruktúry: pole
* časová náročnosť: vždy linearitmická <math> O(n\log(n)) </math>, vďaka ktorej dokáže efektívne triediť veľmi veľké polia

[[Súbor:HeapSort.png|500px|náhľad|vpravo]]

* priestorová náročnosť: konštantná <math>O(1)</math> pri iteračnej verzii, logaritmická <math>O(\log(n))</math> pri rekurzívnej verzii.
* druh triedenia: triedenie výberom (komparačný algoritmus)
* stabilita triedenia: nestabilný
* miesto triedenia: vnútorné triedenie

====Základné časti algoritmu====
# vytvorenie hromady
# zmazanie hromady

====Slovný opis====
=====Vytvorenie hromady=====
Pri vytváraní hromady využijeme algoritmus heapify, pričom hromadu vytvoríme spôsobom zospodu na vrch. Najskôr si určíme prvok ktorý je najspodnejší a najviac vpravo a zároveň má aspoň jedného potomka. Tento prvok určíme veľmi jednoducho, pretože zpberieme posledný prvok v poli, a pomocou rovnice 3, ktorú si jemne upravíme mu nájdeme rodiča: <center><math> \text{posledný rodič} = \left \lfloor \frac{\text{posledný index } - 1}{2} \right \rfloor = \left \lfloor\frac{\text{dĺžka } - 2}{2} \right \rfloor = \left \lfloor \frac{\text{dĺžka}}{2}\right \rfloor - 1 </math></center>
Následne zavoláme Heapify na podhromadu s vrcholom posledného rodiča. Potom zmenšíme o 1 a opakujeme tento proces , až kým neprídeme na začiatok. Schematicky by sme to mohli napísať takto:
<center><math> \text{pre } i \text{ z intervalu } \left \langle \left \lfloor \frac {\text{dĺžka}}{2} \right \rfloor - 1 \quad ; \quad 0 \right \rangle :\ \text{heapify( pole[], dĺžka, i )}</math></center>

=====Zmazanie hromady=====
Pri mazaní hromady vykonáme dve operácie. Ako prvé vymeníme prvok na vrchu hromady s koncovým prvkom hromady. Prvok čo je na komci považujeme za zmazaný, preto veľkosť hromady znížime o 1. Následne musíme zabezpečiť zachovanie pravidiel pre hromadu, takže zavoláme funkciu Heapify na celú hromadu (index i bude vrch hromady, čiže 0-tý prvok v poli). Tento proces opakujeme, poikiaľ v hromade neostanú žiadne prvky.

Poznámka: v našom prípade nemusíme mazať celú hromadu, ale iba do chvíle, keď nám neostane 1 prvok.

Schematicky by sme to mohli zapísať takto:
<center><math>\text{pre } j \text{ z intervalu } \left \langle \text{dĺžka - 1} \quad ; \quad 0 \right \rangle : \ \ \text{vymeň(pole[0], pole[$j$])} \ \ a \ \ \text{heapify(pole[], dĺžka, 0)} </math></center>

====Pseudokód====
Nech funkcia Heap Sort má nasledovný prototyp: <code>HeapSort(pole[], dlzka)</code>

:1. Nech: <code>i = dlzka / 2 - 1</code>, kde "/" predstavuje celočíslené delenie.
:2. Je <code>i >= 0</code> ? Ak áno, pokračuj krokom 2.1., inak skoč na krok 3.
:::2.1. Zavolaj funkciu <code>Heapify(pole[], dlzka, i)</code>
:::2.2. Skoč na krok 2.
:3. Nech: <code>j = dlzka - 1</code>
:4 Je <code> j > 0</code> ? Ak áno, pokračuj krokom 4.1, inak skonči.
:::4.1. Vymeň: <code>pole[0]</code> a <code>pole[j]</code>
:::4.2. Zavolaj funkciu <code>Heapify(pole[], dlzka, i)</code>
:::4.3. Skoč na krok 4.

===Implementácia algoritmov Heapify a HeapSort v rôznych programovacích jazykoch===
<tabs>
<tab name="Iteračná C" block>
<syntaxhighlight lang="C">

#include <stdio.h>

void Vymen(int *a, int *b);
void Heapify(int pole[], int dlzka, int index);
void HeapSort(int pole[], int dlzka);

int main()
{
int pole[]= {10, 5, 2, 9, 8, 7, 1, 3, 4, 0, -1};
int dlzka = sizeof(pole) / sizeof(pole[0]);

HeapSort(pole, dlzka);

for (int i = 0; i < dlzka; ++i)
{
printf("%d ", pole[i]);
}
}

void Vymen(int *a, int *b)
{
int tmp = *a;
*a = *b;
*b = tmp;
}

void Heapify(int pole[], int dlzka, int index)
{
int pravy, lavy, max;

while(2 * index + 1 < dlzka)
{
lavy = 2 * index + 1;
pravy = 2 * index + 2;

// určenie potomka s maximálnou hodnotou
if(pravy < dlzka && pole[pravy] > pole[lavy])
{
max = pravy;
}
else
{
max = lavy;
}

// porovnanie maximálneho potomka s rodičom
if(pole[max] > pole[index])
{

Vymen(&pole[max], &pole[index]);
index = max;
}
else
{
return;
}
}
}

void HeapSort(int pole[], int dlzka)
{
// vytvor maximálnu hromadu (procedúra BuildMaxHeap)
for (int i = dlzka / 2 - 1 ; i >= 0; --i)
{
Heapify(pole, dlzka, i);
}

// zmaž všetky prvky z hromady
for (int j = dlzka - 1; j > 0; --j)
{
Vymen(&pole[0], &pole[j]);
Heapify(pole, j, 0);
}
}
</syntaxhighlight>
</tab>
<tab name="Rekurzívna C" block>
<syntaxhighlight lang="C">
#include <stdio.h>

void Vymen(int *a, int *b);
void Heapify(int pole[], int dlzka, int index);
void HeapSort(int pole[], int dlzka);

int main()
{
int pole[]= {10, 5, 2, 9, 8, 7, 1, 3, 4, 0, -1, -1};
int dlzka = sizeof(pole) / sizeof(pole[0]);

HeapSort(pole, dlzka);

for (int i = 0; i < dlzka; ++i)
{
printf("%d ", pole[i]);
}
}

void Vymen(int *a, int *b)
{
int tmp = *a;
*a = *b;
*b = tmp;
}

void Heapify(int pole[], int dlzka, int index)
{

int lavy = 2 * index + 1;
int pravy = 2 * index + 2;
int max = index;

// určenie potomka s maximálnou hodnotou
if(lavy < dlzka && pole[lavy] >= pole[pravy])
{
max = lavy;
}

if(pravy < dlzka && pole[pravy] > pole[lavy])
{
max = pravy;
}

// porovnanie maximálneho potomka s rodičom
if(pole[max] > pole[index])
{
Vymen(&pole[max], &pole[index]);
Heapify(pole, dlzka, max);
}
}

void HeapSort(int pole[], int dlzka)
{
// vytvor maximálnu hromadu (procedúra BuildMaxHeap)
for (int i = dlzka / 2 - 1 ; i >= 0; --i)
{
Heapify(pole, dlzka, i);
}

// zmaž všetky prvky z hromady
for (int j = dlzka - 1; j > 0; --j)
{
Vymen(&pole[0], &pole[j]);
Heapify(pole, j, 0);
}
}
</syntaxhighlight>
</tab>

<tab name="Iterácia Java" block>
<syntaxhighlight lang="Java">
class HeapSortIT {
void swap(int[] pole, int a, int b) {
int tmp = pole[a];
pole[a] = pole[b];
pole[b] = tmp;
}

void heapify(int[] pole, int n) {
for (int i = 1; i < n; i++) {

/* Ak je potomok väčší ako rodič */
if (pole[i] > pole[(i - 1) / 2]) {
int j = i;

/* Vymieňaj elementy (rodič, potomok), dokým je rodič menší ako potomok */
while (pole[j] > pole[(j - 1) / 2]) {
swap(pole, j, (j - 1) / 2);
j = (j - 1) / 2;
}
}
}
}

void sort(int[] pole) {
int n = pole.length;

heapify(pole, n);

for (int i = n - 1; i > 0; i--) {
int j = 0, index;

/* Vymeň prvý a posledný prvok */
swap(pole, 0, i);

do {
index = 2 * j + 1;

/* Ak je ľavý potomok menši ako pravý, presuň 'index' na pravého potomka */
if (index < i - 1 && pole[index] < pole[index + 1])
index++;

/* Ak je rodič menší ako potomok, tak ho vymeň s potomkom, ktorý má väčšiu hodnotu */
if (index < i && pole[j] < pole[index])
swap(pole, j, index);

j = index;
} while (index < i);
}
}
}

public class Main {

static void printArray(int[] pole) {
int n = pole.length;

for (int i : pole)
System.out.print(i + " ");

System.out.println();
}

public static void main(String[] args) {
int[] pole = {12, 11, 13, 5, 6, 7};
int n = pole.length;

System.out.println("Pole pred zoradenim: ");
printArray(pole);

HeapSortIT hs = new HeapSortIT();
hs.sort(pole);

System.out.println("Pole po zoradeni: ");
printArray(pole);
}
}
</syntaxhighlight>
</tab>

<tab name="Rekurzia Java" block>
<syntaxhighlight lang="Java">
class HeapSortRE {
void swap(int[] pole, int a, int b) {
int tmp = pole[a];
pole[a] = pole[b];
pole[b] = tmp;
}

void heapify(int[] pole, int n, int i) {
int max = i; // rodič
int l = 2 * i + 1; // ľavý potomok
int p = 2 * i + 2; // pravý potomok

/* Ak je ľavý potomok väčší ako rodič */
if (l < n && pole[l] > pole[max])
max = l;

/* Ak je pravý potomok väčší ako rodič */
if (p < n && pole[p] > pole[max])
max = p;

/* Ak sa rodič v priebehu funkcie zmenil */
if (max != i) {
swap(pole, i, max);

heapify(pole, n, max);
}
}

public void sort(int[] pole) {
int n = pole.length;

/* Vytvorenie hromadu */
for (int i = n / 2 - 1; i >= 0 ; i--)
heapify(pole, n, i);

/* Extrahovanie jednotlivých elemetov z hromady */
for (int i = n - 1; i > 0; i--) {
/* Presuň aktuálneho rodiča na koniec */
swap(pole, 0, i);

/* Zavolanie heapify na zredukovanú hromadu */
heapify(pole, i, 0);
}
}
}

public class Main {

static void printArray(int[] pole) {
int n = pole.length;

for (int i : pole)
System.out.print(i + " ");

System.out.println();
}

public static void main(String[] args) {
int[] pole = {12, 11, 13, 5, 6, 7};
int n = pole.length;

System.out.println("Pole pred zoradenim: ");
printArray(pole);

HeapSortRE hs = new HeapSortRE();
hs.sort(pole);

System.out.println("Pole po zoradeni: ");
printArray(pole);
}
}
</syntaxhighlight>
</tab>

<tab name="Iterácia Python3" block>
<syntaxhighlight lang="Python3">
def heapify(pole, n):
for i in range(n):

# Ak je potomok väčší ako rodič
if pole[i] > pole[int((i - 1) / 2)]:
j = i

# Vymieňaj elementy (rodič, potomok), dokým je rodič menší ako potomok
while pole[j] > pole[int((j - 1) / 2)]:
pole[j], pole[int((j - 1) / 2)] = pole[int((j - 1) / 2)], pole[j] # swap
j = int((j - 1) / 2)

def sort(pole, n):
heapify(pole, n)

for i in range(n - 1, 0, -1):

# Vymeň prvý a posledný prvok
pole[0], pole[i] = pole[i], pole[0] # swap

j, index = 0, 0

while True:
index = 2 * j + 1

# Ak je ľavý potomok menši ako pravý, presuň 'index' na pravého potomka
if index < (i - 1) and pole[index] < pole[index + 1]:
index += 1

# Ak je rodič menší ako potomok, tak ho vymeň s potomkom, ktorý má väčšiu hodnotu
if index = i:
break

def printArray(pole, n):
for i in range(n):
print(pole[i], end=" ")

if __name__ == '__main__':
pole = [12, 11, 13, 5, 6, 7]
n = len(pole)

print("Zadane pole:")
printArray(pole, n)

sort(pole, n)

print("\nZoradene pole:")
printArray(pole, n)

</syntaxhighlight>
</tab>

<tab name="Rekurzia Python3" block>
<syntaxhighlight lang="Python3">
def heapify(pole, n, i):
max = i # rodic
l = 2 * i + 1 # lavy potomok
p = 2 * i + 2 # pravy potomok

# Ak je ľavý potomok väčší ako rodič
if l < n and pole[max] < pole[l]:
max = l

# Ak je pravý potomok väčší ako rodič
if p < n and pole[max] < pole[p]:
max = p

# Ak sa rodič v priebehu funkcie zmenil
if max != i:
pole[i], pole[max] = pole[max], pole[i] # swap

heapify(pole, n, max)

def sort(pole):
n = len(pole)

# Vytvorenie hromady
for i in range(n // 2 - 1, -1, -1):
heapify(pole, n, i)

# Extrahovanie jednotlivých elementov z hromady
for i in range(n - 1, 0, -1):
pole[i], pole[0] = pole[0], pole[i] # swap
heapify(pole, i, 0)

def printArray(pole):
n = len(pole)

for i in range(n):
print(pole[i], end=" ")

if __name__ == '__main__':
pole = [12, 11, 13, 5, 6, 7]

print("Zadane pole:")
printArray(pole)

sort(pole)

print("\nZoradene pole:")
printArray(pole)
</syntaxhighlight>
</tab>
</tabs>

==Selection Sort==
Coming soon :)

==Odkazy==
Heap Sort:

https://www.tutorialspoint.com/design_and_analysis_of_algorithms/design_and_analysis_of_algorithms_heapify_method.htm
https://www.geeksforgeeks.org/heap-sort/
https://www.geeksforgeeks.org/iterative-heap-sort/
https://www.youtube.com/watch?v=H5kAcmGOn4Q

Triedenie výberom

2021-04-11T09:56:43Z

Filip Tomek: /* Implementácia algoritmov Heapify a HeapSort v rôznych programovacích jazykoch */

[[Kategória:Algoritmy triedenia]]
{{Draft}}
{{Skripta programovanie}}
__TOC__
==Tento článok je v prvotnom štádiu konštrukcie, zatiaľ je to len hromada myšlienok :)==
odtiaľto sa odrazíme: https://en.wikipedia.org/wiki/Heapsort

==Heap Sort==

===Prehľad===
Heap Sort je triediaci algoritmus, ktorý podobne ako Selection sort rozeľuje pole na zotriedenú a nezotriedenú časť, pričom nezotriedená časť predstavuje dátovú štruktúru [[Hromada|binárna hromada]]. Celé triedenie spočíva v tom, že si zo vstupného poľa vytvoríme binárnu hromadu a následne postupným vyberaním a mazaním všetkých jej prvkov toto pole utriedime.

Hromada, ktorú využíva algoritmus Heap Sort, musí spĺňať nasledovné podmienky (ak indexujeme pole od 0):
:1. Vrchol hromady (koreň) je vždy prvý prvok v poli (v našom prípade prvok na 0-tej pozícii).
:2. Pre ľubovoľný prvok (uzol), uložený na indexe <math>i</math> z intervalu <math> \langle 0 \ ; \ \text{dĺžka} - 1 \rangle </math>, platia nasledovné rovnice:
:: <math>
\begin{align}
\text{ľavý potomok} &= 2i + 1 && (1) \\
\text{pravý potomok} &= 2i + 2 && (2) \\
\text{rodič} &= \left \lfloor \frac{i - 1}{2} \right \rfloor \quad (\text {okrem} \ i = 0) && (3)
\end{align}
</math>
:3. Každý prvok (uzol) v hromade musí mať väčšiu, alebo rovnakú hodnotu ako jeho potomkovia (MAX HEAP - ak triedime pole vzostupne, v opačnom prípade by sme použili MIN HEAP).

===Algoritmus Heapify===
[[Súbor:Heapify.png|vizualizácia|699px|náhľad|vpravo]]
Heapify je kľúčovým podprogramom triediaceho algoritmu Heap Sort, vďaka ktorému vieme efektíve zabezpečiť vytvorenie hromady z poľa a zmazanie hromady.

Princíp algoritmu Heapify spočíva v tom, že ak máme i-ty prvok v poli (v kompletnom binárnom strome), ktorého potomkovia tvoria dve samostatné podhromady, potom tieto dve podhromady zlúčime do jednej hromady, pričom i-ty prvok bude jej vrcholom.

====Vlastnosti algoritmu====
* dátová štruktúra: hromada (reprezentovaná ako: pole, strom)
* časová zložitosť: lineárna <math>O(n)</math>
* priestorová zložitosť: konštantná <math>O(1)</math> pri iteračnej verzii, <math>O(log(n))</math> pri rekurzívnej verzii

====Základné časti algoritmu====
# Určenie potomka s maximálnou hodnotou i-teho prvku.
# Porovnanie maximálneho potomka s rodičom (i-tym prvkom).
# Ak je potomok väčší ako rodič, tak výmena potomka a rodiča.
# Ak nastala výmena, skontrolovanie ovplyvneného potomka (podhromady).

====Slovný opis algoritmu====
Na vstupe prijmeme pole a index i, v ktorom chceme vytvoriť hromadu (Max Heap). Najskôr skontrolujeme, či prvok na indexe i má nejakých potomkov (využijeme rovnice (1) a (2) z časti "Prehľad"). Ak nemá žiadnych potomkov, funkcia skončí, pretože i predstavuje vrchol jednoprvkovej hromady. Ak má práve jedného potomka, tento potomok je zároveň jeho maximálnym potomkom. Ak má práve dvoch potomkov, tak porovnáme ich hodnoty a vyberieme z nich maximálneho potomka. Následne skontrolujeme veľkosť maximálneho potomka a jeho rodiča (prvok na indexe i). Ak je rodič väčší, funkcia skončí, pretože želaná hromada už je utvorená. Ak nie, vymeníme rodiča a maximálneho potomka. Ak nastala výmena, musíme skontrolovať ovplyvnenú podhromadu, tj. zopakovať tento sled krokov pre podhromadu, ktorej vrchol bude v maximálnom potomkovi i-teho prvku.

Z hľadiska implementácie môžeme vytvoriť iteračnú aj rekurzívnu verziu.

====Pseudokód====
<tabs>
<tab name="Iteračná verzia" block>
Nech funkcia Heapify má nasledovný prototyp: <code>Heapify(pole[], dlzka, i)</code>
:1. Je <code>2 * i + 1 < dlzka</code> ? Ak áno, pokračuj krokom 1.1., inak skonči.
:::1.1. Nech: <code>lavy = 2 * i + 1</code>
:::1.2. Nech: <code>pravy = 2 * i + 2</code>
:::1.3. Je <code>pravy < dlzka</code> a zároveň <code>pole[pravy] > pole[lavy]</code> ?
:::::Ak áno:
:::::::1.3.1. Nech: <code>max = pravy</code>
:::::Ak nie:
:::::::1.3.1. Nech: <code>max = lavy</code>
:::1.4. Je <code>pole[max] > pole[i]</code> ?
:::::Ak áno:
:::::::1.4.1. Vymeň: <code>pole[max]</code> a <code>pole[i]</code>
:::::::1.4.2. <code>i = max</code>
:::::Ak nie:
:::::::1.4.1 Skonči.
:::1.5. Skoč na krok 1.

</tab>

<tab name="Rekurzívna verzia" block>
Nech funkcia Heapify má nasledovný prototyp: <code>Heapify(pole[], dlzka, i)</code>
:1. Je <code>pole[2 * i + 1] >= pole[2 * i + 2]</code> ?
::: Ak áno:
:::::1.1. Nech: <code>max = pole[2 * i + 1]</code>
::: Ak nie:
:::::1.1. Nech: <code>max = pole[2 * i + 2]</code>
:2. Je <code>pole[max] > pole[i]</code> ?
::: Ak áno:
::::: 2.1. Vymeň: <code>pole[i] a pole[max]</code>
::::: 2.2. Rekurzívne zavolaj: <code>Heapify(pole[], dlzka, max)</code>
::: Ak nie:
::::: 2.1. Skonči volanie.
</tab>
</tabs>

===Algoritmus Heap Sort===
Heapsort pri triedení vykonáva dve základné úlohy: Vytvorenie maximálnej binárnej hromady zo vstupného poľa a mazanie jednotlivých prvkov z hromady. Pri oboch procedúrach využíva algoritmus Heapify

====Vlastnosti algoritmu====
* vhodný pre dátové štruktúry: pole
* časová náročnosť: vždy linearitmická <math> O(n\log(n)) </math>, vďaka ktorej dokáže efektívne triediť veľmi veľké polia

[[Súbor:HeapSort.png|500px|náhľad|vpravo]]

* priestorová náročnosť: konštantná <math>O(1)</math> pri iteračnej verzii, logaritmická <math>O(\log(n))</math> pri rekurzívnej verzii.
* druh triedenia: triedenie výberom (komparačný algoritmus)
* stabilita triedenia: nestabilný
* miesto triedenia: vnútorné triedenie

====Základné časti algoritmu====
# vytvorenie hromady
# zmazanie hromady

====Slovný opis====
=====Vytvorenie hromady=====
Pri vytváraní hromady využijeme algoritmus heapify, pričom hromadu vytvoríme spôsobom zospodu na vrch. Najskôr si určíme prvok ktorý je najspodnejší a najviac vpravo a zároveň má aspoň jedného potomka. Tento prvok určíme veľmi jednoducho, pretože zpberieme posledný prvok v poli, a pomocou rovnice 3, ktorú si jemne upravíme mu nájdeme rodiča: <center><math> \text{posledný rodič} = \left \lfloor \frac{\text{posledný index } - 1}{2} \right \rfloor = \left \lfloor\frac{\text{dĺžka } - 2}{2} \right \rfloor = \left \lfloor \frac{\text{dĺžka}}{2}\right \rfloor - 1 </math></center>
Následne zavoláme Heapify na podhromadu s vrcholom posledného rodiča. Potom zmenšíme o 1 a opakujeme tento proces , až kým neprídeme na začiatok. Schematicky by sme to mohli napísať takto:
<center><math> \text{pre } i \text{ z intervalu } \left \langle \left \lfloor \frac {\text{dĺžka}}{2} \right \rfloor - 1 \quad ; \quad 0 \right \rangle :\ \text{heapify( pole[], dĺžka, i )}</math></center>

=====Zmazanie hromady=====
Pri mazaní hromady vykonáme dve operácie. Ako prvé vymeníme prvok na vrchu hromady s koncovým prvkom hromady. Prvok čo je na komci považujeme za zmazaný, preto veľkosť hromady znížime o 1. Následne musíme zabezpečiť zachovanie pravidiel pre hromadu, takže zavoláme funkciu Heapify na celú hromadu (index i bude vrch hromady, čiže 0-tý prvok v poli). Tento proces opakujeme, poikiaľ v hromade neostanú žiadne prvky.

Poznámka: v našom prípade nemusíme mazať celú hromadu, ale iba do chvíle, keď nám neostane 1 prvok.

Schematicky by sme to mohli zapísať takto:
<center><math>\text{pre } j \text{ z intervalu } \left \langle \text{dĺžka - 1} \quad ; \quad 0 \right \rangle : \ \ \text{vymeň(pole[0], pole[$j$])} \ \ a \ \ \text{heapify(pole[], dĺžka, 0)} </math></center>

====Pseudokód====
Nech funkcia Heap Sort má nasledovný prototyp: <code>HeapSort(pole[], dlzka)</code>

:1. Nech: <code>i = dlzka / 2 - 1</code>, kde "/" predstavuje celočíslené delenie.
:2. Je <code>i >= 0</code> ? Ak áno, pokračuj krokom 2.1., inak skoč na krok 3.
:::2.1. Zavolaj funkciu <code>Heapify(pole[], dlzka, i)</code>
:::2.2. Skoč na krok 2.
:3. Nech: <code>j = dlzka - 1</code>
:4 Je <code> j > 0</code> ? Ak áno, pokračuj krokom 4.1, inak skonči.
:::4.1. Vymeň: <code>pole[0]</code> a <code>pole[j]</code>
:::4.2. Zavolaj funkciu <code>Heapify(pole[], dlzka, i)</code>
:::4.3. Skoč na krok 4.

===Implementácia algoritmov Heapify a HeapSort v rôznych programovacích jazykoch===
<tabs>
<tab name="Iteračná C" block>
<syntaxhighlight lang="C">

#include <stdio.h>

void Vymen(int *a, int *b);
void Heapify(int pole[], int dlzka, int index);
void HeapSort(int pole[], int dlzka);

int main()
{
int pole[]= {10, 5, 2, 9, 8, 7, 1, 3, 4, 0, -1};
int dlzka = sizeof(pole) / sizeof(pole[0]);

HeapSort(pole, dlzka);

for (int i = 0; i < dlzka; ++i)
{
printf("%d ", pole[i]);
}
}

void Vymen(int *a, int *b)
{
int tmp = *a;
*a = *b;
*b = tmp;
}

void Heapify(int pole[], int dlzka, int index)
{
int pravy, lavy, max;

while(2 * index + 1 < dlzka)
{
lavy = 2 * index + 1;
pravy = 2 * index + 2;

// určenie potomka s maximálnou hodnotou
if(pravy < dlzka && pole[pravy] > pole[lavy])
{
max = pravy;
}
else
{
max = lavy;
}

// porovnanie maximálneho potomka s rodičom
if(pole[max] > pole[index])
{

Vymen(&pole[max], &pole[index]);
index = max;
}
else
{
return;
}
}
}

void HeapSort(int pole[], int dlzka)
{
// vytvor maximálnu hromadu (procedúra BuildMaxHeap)
for (int i = dlzka / 2 - 1 ; i >= 0; --i)
{
Heapify(pole, dlzka, i);
}

// zmaž všetky prvky z hromady
for (int j = dlzka - 1; j > 0; --j)
{
Vymen(&pole[0], &pole[j]);
Heapify(pole, j, 0);
}
}
</syntaxhighlight>
</tab>
<tab name="Rekurzívna C" block>
<syntaxhighlight lang="C">
#include <stdio.h>

void Vymen(int *a, int *b);
void Heapify(int pole[], int dlzka, int index);
void HeapSort(int pole[], int dlzka);

int main()
{
int pole[]= {10, 5, 2, 9, 8, 7, 1, 3, 4, 0, -1, -1};
int dlzka = sizeof(pole) / sizeof(pole[0]);

HeapSort(pole, dlzka);

for (int i = 0; i < dlzka; ++i)
{
printf("%d ", pole[i]);
}
}

void Vymen(int *a, int *b)
{
int tmp = *a;
*a = *b;
*b = tmp;
}

void Heapify(int pole[], int dlzka, int index)
{

int lavy = 2 * index + 1;
int pravy = 2 * index + 2;
int max = index;

// určenie potomka s maximálnou hodnotou
if(lavy < dlzka && pole[lavy] >= pole[pravy])
{
max = lavy;
}

if(pravy < dlzka && pole[pravy] > pole[lavy])
{
max = pravy;
}

// porovnanie maximálneho potomka s rodičom
if(pole[max] > pole[index])
{
Vymen(&pole[max], &pole[index]);
Heapify(pole, dlzka, max);
}
}

void HeapSort(int pole[], int dlzka)
{
// vytvor maximálnu hromadu (procedúra BuildMaxHeap)
for (int i = dlzka / 2 - 1 ; i >= 0; --i)
{
Heapify(pole, dlzka, i);
}

// zmaž všetky prvky z hromady
for (int j = dlzka - 1; j > 0; --j)
{
Vymen(&pole[0], &pole[j]);
Heapify(pole, j, 0);
}
}
</syntaxhighlight>
</tab>

<tab name="Iterácia Java" block>
<syntaxhighlight lang="Java">
class HeapSortIT {
void swap(int[] pole, int a, int b) {
int tmp = pole[a];
pole[a] = pole[b];
pole[b] = tmp;
}

void heapify(int[] pole, int n) {
for (int i = 1; i < n; i++) {

/* Ak je potomok väčší ako rodič */
if (pole[i] > pole[(i - 1) / 2]) {
int j = i;

/* Vymieňaj elementy (rodič, potomok), dokým je rodič menší ako potomok */
while (pole[j] > pole[(j - 1) / 2]) {
swap(pole, j, (j - 1) / 2);
j = (j - 1) / 2;
}
}
}
}

void sort(int[] pole) {
int n = pole.length;

heapify(pole, n);

for (int i = n - 1; i > 0; i--) {
int j = 0, index;

/* Vymeň prvý a posledný prvok */
swap(pole, 0, i);

do {
index = 2 * j + 1;

/* Ak je ľavý potomok menši ako pravý, presuň 'index' na pravého potomka */
if (index < i - 1 && pole[index] < pole[index + 1])
index++;

/* Ak je rodič menší ako potomok, tak ho vymeň s potomkom, ktorý má väčšiu hodnotu */
if (index < i && pole[j] < pole[index])
swap(pole, j, index);

j = index;
} while (index < i);
}
}
}

public class Main {

static void printArray(int[] pole) {
int n = pole.length;

for (int i : pole)
System.out.print(i + " ");

System.out.println();
}

public static void main(String[] args) {
int[] pole = {12, 11, 13, 5, 6, 7};
int n = pole.length;

System.out.println("Pole pred zoradenim: ");
printArray(pole);

HeapSortIT hs = new HeapSortIT();
hs.sort(pole);

System.out.println("Pole po zoradeni: ");
printArray(pole);
}
}
</syntaxhighlight>
</tab>

<tab name="Rekurzia Java" block>
<syntaxhighlight lang="Java">
class HeapSortRE {
void swap(int[] pole, int a, int b) {
int tmp = pole[a];
pole[a] = pole[b];
pole[b] = tmp;
}

void heapify(int[] pole, int n, int i) {
int max = i; // rodič
int l = 2 * i + 1; // ľavý potomok
int p = 2 * i + 2; // pravý potomok

/* Ak je ľavý potomok väčší ako rodič */
if (l < n && pole[l] > pole[max])
max = l;

/* Ak je pravý potomok väčší ako rodič */
if (p < n && pole[p] > pole[max])
max = p;

/* Ak sa rodič v priebehu funkcie zmenil */
if (max != i) {
swap(pole, i, max);

heapify(pole, n, max);
}
}

public void sort(int[] pole) {
int n = pole.length;

/* Vytvorenie hromadu */
for (int i = n / 2 - 1; i >= 0 ; i--)
heapify(pole, n, i);

/* Extrahovanie jednotlivých elemetov z hromady */
for (int i = n - 1; i > 0; i--) {
/* Presuň aktuálneho rodiča na koniec */
swap(pole, 0, i);

/* Zavolanie heapify na zredukovanú hromadu */
heapify(pole, i, 0);
}
}
}

public class Main {

static void printArray(int[] pole) {
int n = pole.length;

for (int i : pole)
System.out.print(i + " ");

System.out.println();
}

public static void main(String[] args) {
int[] pole = {12, 11, 13, 5, 6, 7};
int n = pole.length;

System.out.println("Pole pred zoradenim: ");
printArray(pole);

HeapSortRE hs = new HeapSortRE();
hs.sort(pole);

System.out.println("Pole po zoradeni: ");
printArray(pole);
}
}
</syntaxhighlight>
</tab>

<tab name="Iterácia Python3" block>
<syntaxhighlight lang="Python3">
def heapify(pole, n):
for i in range(n):

# Ak je potomok väčší ako rodič
if pole[i] > pole[int((i - 1) / 2)]:
j = i

# Vymieňaj elementy (rodič, potomok), dokým je rodič menší ako potomok
while pole[j] > pole[int((j - 1) / 2)]:
pole[j], pole[int((j - 1) / 2)] = pole[int((j - 1) / 2)], pole[j] # swap
j = int((j - 1) / 2)

def sort(pole, n):
heapify(pole, n)

for i in range(n - 1, 0, -1):

# Vymeň prvý a posledný prvok
pole[0], pole[i] = pole[i], pole[0] # swap

j, index = 0, 0

while True:
index = 2 * j + 1

# Ak je ľavý potomok menši ako pravý, presuň 'index' na pravého potomka
if index < (i - 1) and pole[index] < pole[index + 1]:
index += 1

# Ak je rodič menší ako potomok, tak ho vymeň s potomkom, ktorý má väčšiu hodnotu
if index = i:
break

def printArray(pole, n):
for i in range(n):
print(pole[i], end=" ")

if __name__ == '__main__':
pole = [12, 11, 13, 5, 6, 7]
n = len(pole)

print("Zadane pole:")
printArray(pole, n)

sort(pole, n)

print("\nZoradene pole:")
printArray(pole, n)

</syntaxhighlight>
</tab>

<tab name="Rekurzia Python3" block>
<syntaxhighlight lang="Python3">
def heapify(pole, n, i):
max = i # rodic
l = 2 * i + 1 # lavy potomok
p = 2 * i + 2 # pravy potomok

# Ak je ľavý potomok väčší ako rodič
if l < n and pole[max] < pole[l]:
max = l

# Ak je pravý potomok väčší ako rodič
if p < n and pole[max] < pole[p]:
max = p

# Ak sa rodič v priebehu funkcie zmenil
if max != i:
pole[i], pole[max] = pole[max], pole[i] # swap

heapify(pole, n, max)

def sort(pole):
n = len(pole)

# Vytvorenie hromady
for i in range(n // 2 - 1, -1, -1):
heapify(pole, n, i)

# Extrahovanie jednotlivých elementov z hromady
for i in range(n - 1, 0, -1):
pole[i], pole[0] = pole[0], pole[i] # swap
heapify(pole, i, 0)

def printArray(pole):
n = len(pole)

for i in range(n):
print(pole[i], end=" ")

if __name__ == '__main__':
pole = [12, 11, 13, 5, 6, 7]

print("Zadane pole:")
printArray(pole)

sort(pole)

print("\nZoradene pole:")
printArray(pole)
</syntaxhighlight>
</tab>
</tabs>

==Selection Sort==
Coming soon :)

==Odkazy==
https://www.tutorialspoint.com/design_and_analysis_of_algorithms/design_and_analysis_of_algorithms_heapify_method.htm

Triedenie výberom

2021-04-11T09:35:50Z

Filip Tomek: /* Implementácia algoritmov Heapify a HeapSort v rôznych programovacích jazykoch */

[[Kategória:Algoritmy triedenia]]
{{Draft}}
{{Skripta programovanie}}
__TOC__
==Tento článok je v prvotnom štádiu konštrukcie, zatiaľ je to len hromada myšlienok :)==
odtiaľto sa odrazíme: https://en.wikipedia.org/wiki/Heapsort

==Heap Sort==

===Prehľad===
Heap Sort je triediaci algoritmus, ktorý podobne ako Selection sort rozeľuje pole na zotriedenú a nezotriedenú časť, pričom nezotriedená časť predstavuje dátovú štruktúru [[Hromada|binárna hromada]]. Celé triedenie spočíva v tom, že si zo vstupného poľa vytvoríme binárnu hromadu a následne postupným vyberaním a mazaním všetkých jej prvkov toto pole utriedime.

Hromada, ktorú využíva algoritmus Heap Sort, musí spĺňať nasledovné podmienky (ak indexujeme pole od 0):
:1. Vrchol hromady (koreň) je vždy prvý prvok v poli (v našom prípade prvok na 0-tej pozícii).
:2. Pre ľubovoľný prvok (uzol), uložený na indexe <math>i</math> z intervalu <math> \langle 0 \ ; \ \text{dĺžka} - 1 \rangle </math>, platia nasledovné rovnice:
:: <math>
\begin{align}
\text{ľavý potomok} &= 2i + 1 && (1) \\
\text{pravý potomok} &= 2i + 2 && (2) \\
\text{rodič} &= \left \lfloor \frac{i - 1}{2} \right \rfloor \quad (\text {okrem} \ i = 0) && (3)
\end{align}
</math>
:3. Každý prvok (uzol) v hromade musí mať väčšiu, alebo rovnakú hodnotu ako jeho potomkovia (MAX HEAP - ak triedime pole vzostupne, v opačnom prípade by sme použili MIN HEAP).

===Algoritmus Heapify===
[[Súbor:Heapify.png|vizualizácia|699px|náhľad|vpravo]]
Heapify je kľúčovým podprogramom triediaceho algoritmu Heap Sort, vďaka ktorému vieme efektíve zabezpečiť vytvorenie hromady z poľa a zmazanie hromady.

Princíp algoritmu Heapify spočíva v tom, že ak máme i-ty prvok v poli (v kompletnom binárnom strome), ktorého potomkovia tvoria dve samostatné podhromady, potom tieto dve podhromady zlúčime do jednej hromady, pričom i-ty prvok bude jej vrcholom.

====Vlastnosti algoritmu====
* dátová štruktúra: hromada (reprezentovaná ako: pole, strom)
* časová zložitosť: lineárna <math>O(n)</math>
* priestorová zložitosť: konštantná <math>O(1)</math> pri iteračnej verzii, <math>O(log(n))</math> pri rekurzívnej verzii

====Základné časti algoritmu====
# Určenie potomka s maximálnou hodnotou i-teho prvku.
# Porovnanie maximálneho potomka s rodičom (i-tym prvkom).
# Ak je potomok väčší ako rodič, tak výmena potomka a rodiča.
# Ak nastala výmena, skontrolovanie ovplyvneného potomka (podhromady).

====Slovný opis algoritmu====
Na vstupe prijmeme pole a index i, v ktorom chceme vytvoriť hromadu (Max Heap). Najskôr skontrolujeme, či prvok na indexe i má nejakých potomkov (využijeme rovnice (1) a (2) z časti "Prehľad"). Ak nemá žiadnych potomkov, funkcia skončí, pretože i predstavuje vrchol jednoprvkovej hromady. Ak má práve jedného potomka, tento potomok je zároveň jeho maximálnym potomkom. Ak má práve dvoch potomkov, tak porovnáme ich hodnoty a vyberieme z nich maximálneho potomka. Následne skontrolujeme veľkosť maximálneho potomka a jeho rodiča (prvok na indexe i). Ak je rodič väčší, funkcia skončí, pretože želaná hromada už je utvorená. Ak nie, vymeníme rodiča a maximálneho potomka. Ak nastala výmena, musíme skontrolovať ovplyvnenú podhromadu, tj. zopakovať tento sled krokov pre podhromadu, ktorej vrchol bude v maximálnom potomkovi i-teho prvku.

Z hľadiska implementácie môžeme vytvoriť iteračnú aj rekurzívnu verziu.

====Pseudokód====
<tabs>
<tab name="Iteračná verzia" block>
Nech funkcia Heapify má nasledovný prototyp: <code>Heapify(pole[], dlzka, i)</code>
:1. Je <code>2 * i + 1 < dlzka</code> ? Ak áno, pokračuj krokom 1.1., inak skonči.
:::1.1. Nech: <code>lavy = 2 * i + 1</code>
:::1.2. Nech: <code>pravy = 2 * i + 2</code>
:::1.3. Je <code>pravy < dlzka</code> a zároveň <code>pole[pravy] > pole[lavy]</code> ?
:::::Ak áno:
:::::::1.3.1. Nech: <code>max = pravy</code>
:::::Ak nie:
:::::::1.3.1. Nech: <code>max = lavy</code>
:::1.4. Je <code>pole[max] > pole[i]</code> ?
:::::Ak áno:
:::::::1.4.1. Vymeň: <code>pole[max]</code> a <code>pole[i]</code>
:::::::1.4.2. <code>i = max</code>
:::::Ak nie:
:::::::1.4.1 Skonči.
:::1.5. Skoč na krok 1.

</tab>

<tab name="Rekurzívna verzia" block>
Nech funkcia Heapify má nasledovný prototyp: <code>Heapify(pole[], dlzka, i)</code>
:1. Je <code>pole[2 * i + 1] >= pole[2 * i + 2]</code> ?
::: Ak áno:
:::::1.1. Nech: <code>max = pole[2 * i + 1]</code>
::: Ak nie:
:::::1.1. Nech: <code>max = pole[2 * i + 2]</code>
:2. Je <code>pole[max] > pole[i]</code> ?
::: Ak áno:
::::: 2.1. Vymeň: <code>pole[i] a pole[max]</code>
::::: 2.2. Rekurzívne zavolaj: <code>Heapify(pole[], dlzka, max)</code>
::: Ak nie:
::::: 2.1. Skonči volanie.
</tab>
</tabs>

===Algoritmus Heap Sort===
Heapsort pri triedení vykonáva dve základné úlohy: Vytvorenie maximálnej binárnej hromady zo vstupného poľa a mazanie jednotlivých prvkov z hromady. Pri oboch procedúrach využíva algoritmus Heapify

====Vlastnosti algoritmu====
* vhodný pre dátové štruktúry: pole
* časová náročnosť: vždy linearitmická <math> O(n\log(n)) </math>, vďaka ktorej dokáže efektívne triediť veľmi veľké polia

[[Súbor:HeapSort.png|500px|náhľad|vpravo]]

* priestorová náročnosť: konštantná <math>O(1)</math> pri iteračnej verzii, logaritmická <math>O(\log(n))</math> pri rekurzívnej verzii.
* druh triedenia: triedenie výberom (komparačný algoritmus)
* stabilita triedenia: nestabilný
* miesto triedenia: vnútorné triedenie

====Základné časti algoritmu====
# vytvorenie hromady
# zmazanie hromady

====Slovný opis====
=====Vytvorenie hromady=====
Pri vytváraní hromady využijeme algoritmus heapify, pričom hromadu vytvoríme spôsobom zospodu na vrch. Najskôr si určíme prvok ktorý je najspodnejší a najviac vpravo a zároveň má aspoň jedného potomka. Tento prvok určíme veľmi jednoducho, pretože zpberieme posledný prvok v poli, a pomocou rovnice 3, ktorú si jemne upravíme mu nájdeme rodiča: <center><math> \text{posledný rodič} = \left \lfloor \frac{\text{posledný index } - 1}{2} \right \rfloor = \left \lfloor\frac{\text{dĺžka } - 2}{2} \right \rfloor = \left \lfloor \frac{\text{dĺžka}}{2}\right \rfloor - 1 </math></center>
Následne zavoláme Heapify na podhromadu s vrcholom posledného rodiča. Potom zmenšíme o 1 a opakujeme tento proces , až kým neprídeme na začiatok. Schematicky by sme to mohli napísať takto:
<center><math> \text{pre } i \text{ z intervalu } \left \langle \left \lfloor \frac {\text{dĺžka}}{2} \right \rfloor - 1 \quad ; \quad 0 \right \rangle :\ \text{heapify( pole[], dĺžka, i )}</math></center>

=====Zmazanie hromady=====
Pri mazaní hromady vykonáme dve operácie. Ako prvé vymeníme prvok na vrchu hromady s koncovým prvkom hromady. Prvok čo je na komci považujeme za zmazaný, preto veľkosť hromady znížime o 1. Následne musíme zabezpečiť zachovanie pravidiel pre hromadu, takže zavoláme funkciu Heapify na celú hromadu (index i bude vrch hromady, čiže 0-tý prvok v poli). Tento proces opakujeme, poikiaľ v hromade neostanú žiadne prvky.

Poznámka: v našom prípade nemusíme mazať celú hromadu, ale iba do chvíle, keď nám neostane 1 prvok.

Schematicky by sme to mohli zapísať takto:
<center><math>\text{pre } j \text{ z intervalu } \left \langle \text{dĺžka - 1} \quad ; \quad 0 \right \rangle : \ \ \text{vymeň(pole[0], pole[$j$])} \ \ a \ \ \text{heapify(pole[], dĺžka, 0)} </math></center>

====Pseudokód====
Nech funkcia Heap Sort má nasledovný prototyp: <code>HeapSort(pole[], dlzka)</code>

:1. Nech: <code>i = dlzka / 2 - 1</code>, kde "/" predstavuje celočíslené delenie.
:2. Je <code>i >= 0</code> ? Ak áno, pokračuj krokom 2.1., inak skoč na krok 3.
:::2.1. Zavolaj funkciu <code>Heapify(pole[], dlzka, i)</code>
:::2.2. Skoč na krok 2.
:3. Nech: <code>j = dlzka - 1</code>
:4 Je <code> j > 0</code> ? Ak áno, pokračuj krokom 4.1, inak skonči.
:::4.1. Vymeň: <code>pole[0]</code> a <code>pole[j]</code>
:::4.2. Zavolaj funkciu <code>Heapify(pole[], dlzka, i)</code>
:::4.3. Skoč na krok 4.

===Implementácia algoritmov Heapify a HeapSort v rôznych programovacích jazykoch===
<tabs>
<tab name="Iteračná C" block>
<syntaxhighlight lang="C">

#include <stdio.h>

void Vymen(int *a, int *b);
void Heapify(int pole[], int dlzka, int index);
void HeapSort(int pole[], int dlzka);

int main()
{
int pole[]= {10, 5, 2, 9, 8, 7, 1, 3, 4, 0, -1};
int dlzka = sizeof(pole) / sizeof(pole[0]);

HeapSort(pole, dlzka);

for (int i = 0; i < dlzka; ++i)
{
printf("%d ", pole[i]);
}
}

void Vymen(int *a, int *b)
{
int tmp = *a;
*a = *b;
*b = tmp;
}

void Heapify(int pole[], int dlzka, int index)
{
int pravy, lavy, max;

while(2 * index + 1 < dlzka)
{
lavy = 2 * index + 1;
pravy = 2 * index + 2;

// určenie potomka s maximálnou hodnotou
if(pravy < dlzka && pole[pravy] > pole[lavy])
{
max = pravy;
}
else
{
max = lavy;
}

// porovnanie maximálneho potomka s rodičom
if(pole[max] > pole[index])
{

Vymen(&pole[max], &pole[index]);
index = max;
}
else
{
return;
}
}
}

void HeapSort(int pole[], int dlzka)
{
// vytvor maximálnu hromadu (procedúra BuildMaxHeap)
for (int i = dlzka / 2 - 1 ; i >= 0; --i)
{
Heapify(pole, dlzka, i);
}

// zmaž všetky prvky z hromady
for (int j = dlzka - 1; j > 0; --j)
{
Vymen(&pole[0], &pole[j]);
Heapify(pole, j, 0);
}
}
</syntaxhighlight>
</tab>
<tab name="Rekurzívna C" block>
<syntaxhighlight lang="C">
#include <stdio.h>

void Vymen(int *a, int *b);
void Heapify(int pole[], int dlzka, int index);
void HeapSort(int pole[], int dlzka);

int main()
{
int pole[]= {10, 5, 2, 9, 8, 7, 1, 3, 4, 0, -1, -1};
int dlzka = sizeof(pole) / sizeof(pole[0]);

HeapSort(pole, dlzka);

for (int i = 0; i < dlzka; ++i)
{
printf("%d ", pole[i]);
}
}

void Vymen(int *a, int *b)
{
int tmp = *a;
*a = *b;
*b = tmp;
}

void Heapify(int pole[], int dlzka, int index)
{

int lavy = 2 * index + 1;
int pravy = 2 * index + 2;
int max = index;

// určenie potomka s maximálnou hodnotou
if(lavy < dlzka && pole[lavy] >= pole[pravy])
{
max = lavy;
}

if(pravy < dlzka && pole[pravy] > pole[lavy])
{
max = pravy;
}

// porovnanie maximálneho potomka s rodičom
if(pole[max] > pole[index])
{
Vymen(&pole[max], &pole[index]);
Heapify(pole, dlzka, max);
}
}

void HeapSort(int pole[], int dlzka)
{
// vytvor maximálnu hromadu (procedúra BuildMaxHeap)
for (int i = dlzka / 2 - 1 ; i >= 0; --i)
{
Heapify(pole, dlzka, i);
}

// zmaž všetky prvky z hromady
for (int j = dlzka - 1; j > 0; --j)
{
Vymen(&pole[0], &pole[j]);
Heapify(pole, j, 0);
}
}
</syntaxhighlight>
</tab>

<tab name="Iterácia Java" block>
<syntaxhighlight lang="Java">
class HeapSortIT {
void swap(int[] pole, int a, int b) {
int tmp = pole[a];
pole[a] = pole[b];
pole[b] = tmp;
}

void heapify(int[] pole, int n) {
for (int i = 1; i < n; i++) {

/* Ak je potomok väčší ako rodič */
if (pole[i] > pole[(i - 1) / 2]) {
int j = i;

/* Vymieňaj elementy (rodič, potomok), dokým je rodič menší ako potomok */
while (pole[j] > pole[(j - 1) / 2]) {
swap(pole, j, (j - 1) / 2);
j = (j - 1) / 2;
}
}
}
}

void sort(int[] pole) {
int n = pole.length;

heapify(pole, n);

for (int i = n - 1; i > 0; i--) {
int j = 0, index;

/* Vymeň prvý a posledný prvok */
swap(pole, 0, i);

do {
index = 2 * j + 1;

/* Ak je ľavý potomok menši ako pravý, presuň 'index' na pravého potomka */
if (index < i - 1 && pole[index] < pole[index + 1])
index++;

/* Ak je rodič menší ako potomok, tak ho vymeň s potomkom, ktorý má väčšiu hodnotu */
if (index < i && pole[j] < pole[index])
swap(pole, j, index);

j = index;
} while (index < i);
}
}
}

public class Main {

static void printArray(int[] pole) {
int n = pole.length;

for (int i : pole)
System.out.print(i + " ");

System.out.println();
}

public static void main(String[] args) {
int[] pole = {12, 11, 13, 5, 6, 7};
int n = pole.length;

System.out.println("Pole pred zoradenim: ");
printArray(pole);

HeapSortIT hs = new HeapSortIT();
hs.sort(pole);

System.out.println("Pole po zoradeni: ");
printArray(pole);
}
}
</syntaxhighlight>
</tab>

<tab name="Rekurzia Java" block>
<syntaxhighlight lang="Java">
class HeapSortRE {
void swap(int[] pole, int a, int b) {
int tmp = pole[a];
pole[a] = pole[b];
pole[b] = tmp;
}

void heapify(int[] pole, int n, int i) {
int max = i; // rodič
int l = 2 * i + 1; // ľavý potomok
int p = 2 * i + 2; // pravý potomok

/* Ak je ľavý potomok väčší ako rodič */
if (l < n && pole[l] > pole[max])
max = l;

/* Ak je pravý potomok väčší ako rodič */
if (p < n && pole[p] > pole[max])
max = p;

/* Ak sa rodič v priebehu funkcie zmenil */
if (max != i) {
swap(pole, i, max);

heapify(pole, n, max);
}
}

public void sort(int[] pole) {
int n = pole.length;

/* Vytvorenie hromadu */
for (int i = n / 2 - 1; i >= 0 ; i--)
heapify(pole, n, i);

/* Extrahovanie jednotlivých elemetov z hromady */
for (int i = n - 1; i > 0; i--) {
/* Presuň aktuálneho rodiča na koniec */
swap(pole, 0, i);

/* Zavolanie heapify na zredukovanú hromadu */
heapify(pole, i, 0);
}
}
}

public class Main {

static void printArray(int[] pole) {
int n = pole.length;

for (int i : pole)
System.out.print(i + " ");

System.out.println();
}

public static void main(String[] args) {
int[] pole = {12, 11, 13, 5, 6, 7};
int n = pole.length;

System.out.println("Pole pred zoradenim: ");
printArray(pole);

HeapSortRE hs = new HeapSortRE();
hs.sort(pole);

System.out.println("Pole po zoradeni: ");
printArray(pole);
}
}
</syntaxhighlight>
</tab>

<tab name="Rekurzia Python3" block>
<syntaxhighlight lang="Python3">
def heapify(pole, n, i):
max = i # rodic
l = 2 * i + 1 # lavy potomok
p = 2 * i + 2 # pravy potomok

# Ak je ľavý potomok väčší ako rodič
if l < n and pole[max] < pole[l]:
max = l

# Ak je pravý potomok väčší ako rodič
if p < n and pole[max] < pole[p]:
max = p

# Ak sa rodič v priebehu funkcie zmenil
if max != i:
pole[i], pole[max] = pole[max], pole[i] # swap

heapify(pole, n, max)

def sort(pole):
n = len(pole)

# Vytvorenie hromady
for i in range(n // 2 - 1, -1, -1):
heapify(pole, n, i)

# Extrahovanie jednotlivých elementov z hromady
for i in range(n - 1, 0, -1):
pole[i], pole[0] = pole[0], pole[i] # swap
heapify(pole, i, 0)

def printArray(pole):
n = len(pole)

for i in range(n):
print(pole[i], end=" ")

if __name__ == '__main__':
pole = [12, 11, 13, 5, 6, 7]

print("Zadane pole:")
printArray(pole)

sort(pole)

print("\nZoradene pole:")
printArray(pole)
</syntaxhighlight>
</tab>
</tabs>

==Selection Sort==
Coming soon :)

==Odkazy==
https://www.tutorialspoint.com/design_and_analysis_of_algorithms/design_and_analysis_of_algorithms_heapify_method.htm

Triedenie výberom

2021-04-11T09:34:23Z

Filip Tomek: /* Implementácia algoritmov Heapify a HeapSort v rôznych programovacích jazykoch */

[[Kategória:Algoritmy triedenia]]
{{Draft}}
{{Skripta programovanie}}
__TOC__
==Tento článok je v prvotnom štádiu konštrukcie, zatiaľ je to len hromada myšlienok :)==
odtiaľto sa odrazíme: https://en.wikipedia.org/wiki/Heapsort

==Heap Sort==

===Prehľad===
Heap Sort je triediaci algoritmus, ktorý podobne ako Selection sort rozeľuje pole na zotriedenú a nezotriedenú časť, pričom nezotriedená časť predstavuje dátovú štruktúru [[Hromada|binárna hromada]]. Celé triedenie spočíva v tom, že si zo vstupného poľa vytvoríme binárnu hromadu a následne postupným vyberaním a mazaním všetkých jej prvkov toto pole utriedime.

Hromada, ktorú využíva algoritmus Heap Sort, musí spĺňať nasledovné podmienky (ak indexujeme pole od 0):
:1. Vrchol hromady (koreň) je vždy prvý prvok v poli (v našom prípade prvok na 0-tej pozícii).
:2. Pre ľubovoľný prvok (uzol), uložený na indexe <math>i</math> z intervalu <math> \langle 0 \ ; \ \text{dĺžka} - 1 \rangle </math>, platia nasledovné rovnice:
:: <math>
\begin{align}
\text{ľavý potomok} &= 2i + 1 && (1) \\
\text{pravý potomok} &= 2i + 2 && (2) \\
\text{rodič} &= \left \lfloor \frac{i - 1}{2} \right \rfloor \quad (\text {okrem} \ i = 0) && (3)
\end{align}
</math>
:3. Každý prvok (uzol) v hromade musí mať väčšiu, alebo rovnakú hodnotu ako jeho potomkovia (MAX HEAP - ak triedime pole vzostupne, v opačnom prípade by sme použili MIN HEAP).

===Algoritmus Heapify===
[[Súbor:Heapify.png|vizualizácia|699px|náhľad|vpravo]]
Heapify je kľúčovým podprogramom triediaceho algoritmu Heap Sort, vďaka ktorému vieme efektíve zabezpečiť vytvorenie hromady z poľa a zmazanie hromady.

Princíp algoritmu Heapify spočíva v tom, že ak máme i-ty prvok v poli (v kompletnom binárnom strome), ktorého potomkovia tvoria dve samostatné podhromady, potom tieto dve podhromady zlúčime do jednej hromady, pričom i-ty prvok bude jej vrcholom.

====Vlastnosti algoritmu====
* dátová štruktúra: hromada (reprezentovaná ako: pole, strom)
* časová zložitosť: lineárna <math>O(n)</math>
* priestorová zložitosť: konštantná <math>O(1)</math> pri iteračnej verzii, <math>O(log(n))</math> pri rekurzívnej verzii

====Základné časti algoritmu====
# Určenie potomka s maximálnou hodnotou i-teho prvku.
# Porovnanie maximálneho potomka s rodičom (i-tym prvkom).
# Ak je potomok väčší ako rodič, tak výmena potomka a rodiča.
# Ak nastala výmena, skontrolovanie ovplyvneného potomka (podhromady).

====Slovný opis algoritmu====
Na vstupe prijmeme pole a index i, v ktorom chceme vytvoriť hromadu (Max Heap). Najskôr skontrolujeme, či prvok na indexe i má nejakých potomkov (využijeme rovnice (1) a (2) z časti "Prehľad"). Ak nemá žiadnych potomkov, funkcia skončí, pretože i predstavuje vrchol jednoprvkovej hromady. Ak má práve jedného potomka, tento potomok je zároveň jeho maximálnym potomkom. Ak má práve dvoch potomkov, tak porovnáme ich hodnoty a vyberieme z nich maximálneho potomka. Následne skontrolujeme veľkosť maximálneho potomka a jeho rodiča (prvok na indexe i). Ak je rodič väčší, funkcia skončí, pretože želaná hromada už je utvorená. Ak nie, vymeníme rodiča a maximálneho potomka. Ak nastala výmena, musíme skontrolovať ovplyvnenú podhromadu, tj. zopakovať tento sled krokov pre podhromadu, ktorej vrchol bude v maximálnom potomkovi i-teho prvku.

Z hľadiska implementácie môžeme vytvoriť iteračnú aj rekurzívnu verziu.

====Pseudokód====
<tabs>
<tab name="Iteračná verzia" block>
Nech funkcia Heapify má nasledovný prototyp: <code>Heapify(pole[], dlzka, i)</code>
:1. Je <code>2 * i + 1 < dlzka</code> ? Ak áno, pokračuj krokom 1.1., inak skonči.
:::1.1. Nech: <code>lavy = 2 * i + 1</code>
:::1.2. Nech: <code>pravy = 2 * i + 2</code>
:::1.3. Je <code>pravy < dlzka</code> a zároveň <code>pole[pravy] > pole[lavy]</code> ?
:::::Ak áno:
:::::::1.3.1. Nech: <code>max = pravy</code>
:::::Ak nie:
:::::::1.3.1. Nech: <code>max = lavy</code>
:::1.4. Je <code>pole[max] > pole[i]</code> ?
:::::Ak áno:
:::::::1.4.1. Vymeň: <code>pole[max]</code> a <code>pole[i]</code>
:::::::1.4.2. <code>i = max</code>
:::::Ak nie:
:::::::1.4.1 Skonči.
:::1.5. Skoč na krok 1.

</tab>

<tab name="Rekurzívna verzia" block>
Nech funkcia Heapify má nasledovný prototyp: <code>Heapify(pole[], dlzka, i)</code>
:1. Je <code>pole[2 * i + 1] >= pole[2 * i + 2]</code> ?
::: Ak áno:
:::::1.1. Nech: <code>max = pole[2 * i + 1]</code>
::: Ak nie:
:::::1.1. Nech: <code>max = pole[2 * i + 2]</code>
:2. Je <code>pole[max] > pole[i]</code> ?
::: Ak áno:
::::: 2.1. Vymeň: <code>pole[i] a pole[max]</code>
::::: 2.2. Rekurzívne zavolaj: <code>Heapify(pole[], dlzka, max)</code>
::: Ak nie:
::::: 2.1. Skonči volanie.
</tab>
</tabs>

===Algoritmus Heap Sort===
Heapsort pri triedení vykonáva dve základné úlohy: Vytvorenie maximálnej binárnej hromady zo vstupného poľa a mazanie jednotlivých prvkov z hromady. Pri oboch procedúrach využíva algoritmus Heapify

====Vlastnosti algoritmu====
* vhodný pre dátové štruktúry: pole
* časová náročnosť: vždy linearitmická <math> O(n\log(n)) </math>, vďaka ktorej dokáže efektívne triediť veľmi veľké polia

[[Súbor:HeapSort.png|500px|náhľad|vpravo]]

* priestorová náročnosť: konštantná <math>O(1)</math> pri iteračnej verzii, logaritmická <math>O(\log(n))</math> pri rekurzívnej verzii.
* druh triedenia: triedenie výberom (komparačný algoritmus)
* stabilita triedenia: nestabilný
* miesto triedenia: vnútorné triedenie

====Základné časti algoritmu====
# vytvorenie hromady
# zmazanie hromady

====Slovný opis====
=====Vytvorenie hromady=====
Pri vytváraní hromady využijeme algoritmus heapify, pričom hromadu vytvoríme spôsobom zospodu na vrch. Najskôr si určíme prvok ktorý je najspodnejší a najviac vpravo a zároveň má aspoň jedného potomka. Tento prvok určíme veľmi jednoducho, pretože zpberieme posledný prvok v poli, a pomocou rovnice 3, ktorú si jemne upravíme mu nájdeme rodiča: <center><math> \text{posledný rodič} = \left \lfloor \frac{\text{posledný index } - 1}{2} \right \rfloor = \left \lfloor\frac{\text{dĺžka } - 2}{2} \right \rfloor = \left \lfloor \frac{\text{dĺžka}}{2}\right \rfloor - 1 </math></center>
Následne zavoláme Heapify na podhromadu s vrcholom posledného rodiča. Potom zmenšíme o 1 a opakujeme tento proces , až kým neprídeme na začiatok. Schematicky by sme to mohli napísať takto:
<center><math> \text{pre } i \text{ z intervalu } \left \langle \left \lfloor \frac {\text{dĺžka}}{2} \right \rfloor - 1 \quad ; \quad 0 \right \rangle :\ \text{heapify( pole[], dĺžka, i )}</math></center>

=====Zmazanie hromady=====
Pri mazaní hromady vykonáme dve operácie. Ako prvé vymeníme prvok na vrchu hromady s koncovým prvkom hromady. Prvok čo je na komci považujeme za zmazaný, preto veľkosť hromady znížime o 1. Následne musíme zabezpečiť zachovanie pravidiel pre hromadu, takže zavoláme funkciu Heapify na celú hromadu (index i bude vrch hromady, čiže 0-tý prvok v poli). Tento proces opakujeme, poikiaľ v hromade neostanú žiadne prvky.

Poznámka: v našom prípade nemusíme mazať celú hromadu, ale iba do chvíle, keď nám neostane 1 prvok.

Schematicky by sme to mohli zapísať takto:
<center><math>\text{pre } j \text{ z intervalu } \left \langle \text{dĺžka - 1} \quad ; \quad 0 \right \rangle : \ \ \text{vymeň(pole[0], pole[$j$])} \ \ a \ \ \text{heapify(pole[], dĺžka, 0)} </math></center>

====Pseudokód====
Nech funkcia Heap Sort má nasledovný prototyp: <code>HeapSort(pole[], dlzka)</code>

:1. Nech: <code>i = dlzka / 2 - 1</code>, kde "/" predstavuje celočíslené delenie.
:2. Je <code>i >= 0</code> ? Ak áno, pokračuj krokom 2.1., inak skoč na krok 3.
:::2.1. Zavolaj funkciu <code>Heapify(pole[], dlzka, i)</code>
:::2.2. Skoč na krok 2.
:3. Nech: <code>j = dlzka - 1</code>
:4 Je <code> j > 0</code> ? Ak áno, pokračuj krokom 4.1, inak skonči.
:::4.1. Vymeň: <code>pole[0]</code> a <code>pole[j]</code>
:::4.2. Zavolaj funkciu <code>Heapify(pole[], dlzka, i)</code>
:::4.3. Skoč na krok 4.

===Implementácia algoritmov Heapify a HeapSort v rôznych programovacích jazykoch===
<tabs>
<tab name="Iteračná C" block>
<syntaxhighlight lang="C">

#include <stdio.h>

void Vymen(int *a, int *b);
void Heapify(int pole[], int dlzka, int index);
void HeapSort(int pole[], int dlzka);

int main()
{
int pole[]= {10, 5, 2, 9, 8, 7, 1, 3, 4, 0, -1};
int dlzka = sizeof(pole) / sizeof(pole[0]);

HeapSort(pole, dlzka);

for (int i = 0; i < dlzka; ++i)
{
printf("%d ", pole[i]);
}
}

void Vymen(int *a, int *b)
{
int tmp = *a;
*a = *b;
*b = tmp;
}

void Heapify(int pole[], int dlzka, int index)
{
int pravy, lavy, max;

while(2 * index + 1 < dlzka)
{
lavy = 2 * index + 1;
pravy = 2 * index + 2;

// určenie potomka s maximálnou hodnotou
if(pravy < dlzka && pole[pravy] > pole[lavy])
{
max = pravy;
}
else
{
max = lavy;
}

// porovnanie maximálneho potomka s rodičom
if(pole[max] > pole[index])
{

Vymen(&pole[max], &pole[index]);
index = max;
}
else
{
return;
}
}
}

void HeapSort(int pole[], int dlzka)
{
// vytvor maximálnu hromadu (procedúra BuildMaxHeap)
for (int i = dlzka / 2 - 1 ; i >= 0; --i)
{
Heapify(pole, dlzka, i);
}

// zmaž všetky prvky z hromady
for (int j = dlzka - 1; j > 0; --j)
{
Vymen(&pole[0], &pole[j]);
Heapify(pole, j, 0);
}
}
</syntaxhighlight>
</tab>
<tab name="Rekurzívna C" block>
<syntaxhighlight lang="C">
#include <stdio.h>

void Vymen(int *a, int *b);
void Heapify(int pole[], int dlzka, int index);
void HeapSort(int pole[], int dlzka);

int main()
{
int pole[]= {10, 5, 2, 9, 8, 7, 1, 3, 4, 0, -1, -1};
int dlzka = sizeof(pole) / sizeof(pole[0]);

HeapSort(pole, dlzka);

for (int i = 0; i < dlzka; ++i)
{
printf("%d ", pole[i]);
}
}

void Vymen(int *a, int *b)
{
int tmp = *a;
*a = *b;
*b = tmp;
}

void Heapify(int pole[], int dlzka, int index)
{

int lavy = 2 * index + 1;
int pravy = 2 * index + 2;
int max = index;

// určenie potomka s maximálnou hodnotou
if(lavy < dlzka && pole[lavy] >= pole[pravy])
{
max = lavy;
}

if(pravy < dlzka && pole[pravy] > pole[lavy])
{
max = pravy;
}

// porovnanie maximálneho potomka s rodičom
if(pole[max] > pole[index])
{
Vymen(&pole[max], &pole[index]);
Heapify(pole, dlzka, max);
}
}

void HeapSort(int pole[], int dlzka)
{
// vytvor maximálnu hromadu (procedúra BuildMaxHeap)
for (int i = dlzka / 2 - 1 ; i >= 0; --i)
{
Heapify(pole, dlzka, i);
}

// zmaž všetky prvky z hromady
for (int j = dlzka - 1; j > 0; --j)
{
Vymen(&pole[0], &pole[j]);
Heapify(pole, j, 0);
}
}
</syntaxhighlight>
</tab>

<tab name="Iterácia Java" block>
<syntaxhighlight lang="Java">
class HeapSortIT {
void swap(int[] pole, int a, int b) {
int tmp = pole[a];
pole[a] = pole[b];
pole[b] = tmp;
}

void heapify(int[] pole, int n) {
for (int i = 1; i < n; i++) {

/* Ak je potomok väčší ako rodič */
if (pole[i] > pole[(i - 1) / 2]) {
int j = i;

/* Vymieňaj elementy (rodič, potomok), dokým je rodič menší ako potomok */
while (pole[j] > pole[(j - 1) / 2]) {
swap(pole, j, (j - 1) / 2);
j = (j - 1) / 2;
}
}
}
}

void sort(int[] pole) {
int n = pole.length;

heapify(pole, n);

for (int i = n - 1; i > 0; i--) {
int j = 0, index;

/* Vymeň prvý a posledný prvok */
swap(pole, 0, i);

do {
index = 2 * j + 1;

/* Ak je ľavý potomok menši ako pravý, presuň 'index' na pravého potomka */
if (index < i - 1 && pole[index] < pole[index + 1])
index++;

/* Ak je rodič menší ako potomok, tak ho vymeň s potomkom, ktorý má väčšiu hodnotu */
if (index < i && pole[j] < pole[index])
swap(pole, j, index);

j = index;
} while (index < i);
}
}
}

public class Main {

static void printArray(int[] pole) {
int n = pole.length;

for (int i : pole)
System.out.print(i + " ");

System.out.println();
}

public static void main(String[] args) {
int[] pole = {12, 11, 13, 5, 6, 7};
int n = pole.length;

System.out.println("Pole pred zoradenim: ");
printArray(pole);

HeapSortIT hs = new HeapSortIT();
hs.sort(pole);

System.out.println("Pole po zoradeni: ");
printArray(pole);
}
}
</syntaxhighlight>
</tab>

<tab name="Rekurzia Java" block>
<syntaxhighlight lang="Java">
class HeapSortRE {
void swap(int[] pole, int a, int b) {
int tmp = pole[a];
pole[a] = pole[b];
pole[b] = tmp;
}

void heapify(int[] pole, int n, int i) {
int max = i; // rodič
int l = 2 * i + 1; // ľavý potomok
int p = 2 * i + 2; // pravý potomok

/* Ak je ľavý potomok väčší ako rodič */
if (l < n && pole[l] > pole[max])
max = l;

/* Ak je pravý potomok väčší ako rodič */
if (p < n && pole[p] > pole[max])
max = p;

/* Ak sa rodič v priebehu funkcie zmenil */
if (max != i) {
swap(pole, i, max);

heapify(pole, n, max);
}
}

public void sort(int[] pole) {
int n = pole.length;

/* Vytvorenie hromadu */
for (int i = n / 2 - 1; i >= 0 ; i--)
heapify(pole, n, i);

/* Extrahovanie jednotlivých elemetov z hromady */
for (int i = n - 1; i > 0; i--) {
/* Presuň aktuálneho rodiča na koniec */
swap(pole, 0, i);

/* Zavolanie heapify na zredukovanú hromadu */
heapify(pole, i, 0);
}
}
}

public class Main {

static void printArray(int[] pole) {
int n = pole.length;

for (int i : pole)
System.out.print(i + " ");

System.out.println();
}

public static void main(String[] args) {
int[] pole = {12, 11, 13, 5, 6, 7};
int n = pole.length;

System.out.println("Pole pred zoradenim: ");
printArray(pole);

HeapSortRE hs = new HeapSortRE();
hs.sort(pole);

System.out.println("Pole po zoradeni: ");
printArray(pole);
}
}
</syntaxhighlight>
</tab>

<tab name="Rekurzia Python3" block>
<syntaxhighlight lang="Python3">
def heapify(pole, n, i):
max = i # rodic
l = 2 * i + 1 # lavy potomok
p = 2 * i + 2 # pravy potomok

# Ak je ľavý potomok väčší ako rodič
if l < n and pole[max] < pole[l]:
max = l

# Ak je pravý potomok väčší ako rodič
if p < n and pole[max] < pole[p]:
max = p

# Ak sa rodič v priebehu funkcie zmenil
if max != i:
pole[i], pole[max] = pole[max], pole[i] # swap

heapify(pole, n, max)

def sort(pole):
n = len(pole)

# Vytvorenie hromady
for i in range(n // 2 - 1, -1, -1):
heapify(pole, n, i)

# Extrahovanie jednotlivých elementov z hromady
for i in range(n - 1, 0, -1):
pole[i], pole[0] = pole[0], pole[i] # swap
heapify(pole, i, 0)

def printArray(pole):
n = len(pole)

for i in range(n):
print(pole[i])

if __name__ == '__main__':
pole = [12, 11, 13, 5, 6, 7]

print("Zadane pole:")
printArray(pole)

sort(pole)

print("\nZoradene pole:")
printArray(pole)
</syntaxhighlight>
</tab>
</tabs>

==Selection Sort==
Coming soon :)

==Odkazy==
https://www.tutorialspoint.com/design_and_analysis_of_algorithms/design_and_analysis_of_algorithms_heapify_method.htm

Triedenie výberom

2021-04-10T11:25:58Z

Filip Tomek: /* Algoritmus Heap Sort */

[[Kategória:Algoritmy triedenia]]
{{Draft}}
{{Skripta programovanie}}
__TOC__
==Tento článok je v prvotnom štádiu konštrukcie, zatiaľ je to len hromada myšlienok :)==
odtiaľto sa odrazíme: https://en.wikipedia.org/wiki/Heapsort

==Heap Sort==

===Prehľad===
Heap Sort je triediaci algoritmus, ktorý podobne ako Selection sort rozeľuje pole na zotriedenú a nezotriedenú časť, pričom nezotriedená časť predstavuje dátovú štruktúru [[Hromada|binárna hromada]]. Celé triedenie spočíva v tom, že si zo vstupného poľa vytvoríme binárnu hromadu a následne postupným vyberaním a mazaním všetkých jej prvkov toto pole utriedime.

Hromada, ktorú využíva algoritmus Heap Sort, musí spĺňať nasledovné podmienky (ak indexujeme pole od 0):
:1. Vrchol hromady (koreň) je vždy prvý prvok v poli (v našom prípade prvok na 0-tej pozícii).
:2. Pre ľubovoľný prvok (uzol), uložený na indexe <math>i</math> z intervalu <math> \langle 0 \ ; \ \text{dĺžka} - 1 \rangle </math>, platia nasledovné rovnice:
:: <math>
\begin{align}
\text{ľavý potomok} &= 2i + 1 && (1) \\
\text{pravý potomok} &= 2i + 2 && (2) \\
\text{rodič} &= \left \lfloor \frac{i - 1}{2} \right \rfloor \quad (\text {okrem} \ i = 0) && (3)
\end{align}
</math>
:3. Každý prvok (uzol) v hromade musí mať väčšiu, alebo rovnakú hodnotu ako jeho potomkovia (MAX HEAP - ak triedime pole vzostupne, v opačnom prípade by sme použili MIN HEAP).

===Algoritmus Heapify===
[[Súbor:Heapify.png|vizualizácia|699px|náhľad|vpravo]]
Heapify je kľúčovým podprogramom triediaceho algoritmu Heap Sort, vďaka ktorému vieme efektíve zabezpečiť vytvorenie hromady z poľa a zmazanie hromady.

Princíp algoritmu Heapify spočíva v tom, že ak máme i-ty prvok v poli (v kompletnom binárnom strome), ktorého potomkovia tvoria dve samostatné podhromady, potom tieto dve podhromady zlúčime do jednej hromady, pričom i-ty prvok bude jej vrcholom.

====Vlastnosti algoritmu====
* dátová štruktúra: hromada (reprezentovaná ako: pole, strom)
* časová zložitosť: lineárna <math>O(n)</math>
* priestorová zložitosť: konštantná <math>O(1)</math> pri iteračnej verzii, <math>O(log(n))</math> pri rekurzívnej verzii

====Základné časti algoritmu====
# Určenie potomka s maximálnou hodnotou i-teho prvku.
# Porovnanie maximálneho potomka s rodičom (i-tym prvkom).
# Ak je potomok väčší ako rodič, tak výmena potomka a rodiča.
# Ak nastala výmena, skontrolovanie ovplyvneného potomka (podhromady).

====Slovný opis algoritmu====
Na vstupe prijmeme pole a index i, v ktorom chceme vytvoriť hromadu (Max Heap). Najskôr skontrolujeme, či prvok na indexe i má nejakých potomkov (využijeme rovnice (1) a (2) z časti "Prehľad"). Ak nemá žiadnych potomkov, funkcia skončí, pretože i predstavuje vrchol jednoprvkovej hromady. Ak má práve jedného potomka, tento potomok je zároveň jeho maximálnym potomkom. Ak má práve dvoch potomkov, tak porovnáme ich hodnoty a vyberieme z nich maximálneho potomka. Následne skontrolujeme veľkosť maximálneho potomka a jeho rodiča (prvok na indexe i). Ak je rodič väčší, funkcia skončí, pretože želaná hromada už je utvorená. Ak nie, vymeníme rodiča a maximálneho potomka. Ak nastala výmena, musíme skontrolovať ovplyvnenú podhromadu, tj. zopakovať tento sled krokov pre podhromadu, ktorej vrchol bude v maximálnom potomkovi i-teho prvku.

Z hľadiska implementácie môžeme vytvoriť iteračnú aj rekurzívnu verziu.

====Pseudokód====
<tabs>
<tab name="Iteračná verzia" block>
Nech funkcia Heapify má nasledovný prototyp: <code>Heapify(pole[], dlzka, i)</code>
:1. Je <code>2 * i + 1 < dlzka</code> ? Ak áno, pokračuj krokom 1.1., inak skonči.
:::1.1. Nech: <code>lavy = 2 * i + 1</code>
:::1.2. Nech: <code>pravy = 2 * i + 2</code>
:::1.3. Je <code>pravy < dlzka</code> a zároveň <code>pole[pravy] > pole[lavy]</code> ?
:::::Ak áno:
:::::::1.3.1. Nech: <code>max = pravy</code>
:::::Ak nie:
:::::::1.3.1. Nech: <code>max = lavy</code>
:::1.4. Je <code>pole[max] > pole[i]</code> ?
:::::Ak áno:
:::::::1.4.1. Vymeň: <code>pole[max]</code> a <code>pole[i]</code>
:::::::1.4.2. <code>i = max</code>
:::::Ak nie:
:::::::1.4.1 Skonči.
:::1.5. Skoč na krok 1.

</tab>

<tab name="Rekurzívna verzia" block>
Nech funkcia Heapify má nasledovný prototyp: <code>Heapify(pole[], dlzka, i)</code>
:1. Je <code>pole[2 * i + 1] >= pole[2 * i + 2]</code> ?
::: Ak áno:
:::::1.1. Nech: <code>max = pole[2 * i + 1]</code>
::: Ak nie:
:::::1.1. Nech: <code>max = pole[2 * i + 2]</code>
:2. Je <code>pole[max] > pole[i]</code> ?
::: Ak áno:
::::: 2.1. Vymeň: <code>pole[i] a pole[max]</code>
::::: 2.2. Rekurzívne zavolaj: <code>Heapify(pole[], dlzka, max)</code>
::: Ak nie:
::::: 2.1. Skonči volanie.
</tab>
</tabs>

===Algoritmus Heap Sort===
Heapsort pri triedení vykonáva dve základné úlohy: Vytvorenie maximálnej binárnej hromady zo vstupného poľa a mazanie jednotlivých prvkov z hromady. Pri oboch procedúrach využíva algoritmus Heapify

====Vlastnosti algoritmu====
* vhodný pre dátové štruktúry: pole
* časová náročnosť: vždy linearitmická <math> O(n\log(n)) </math>, vďaka ktorej dokáže efektívne triediť veľmi veľké polia

[[Súbor:HeapSort.png|500px|náhľad|vpravo]]

* priestorová náročnosť: konštantná <math>O(1)</math> pri iteračnej verzii, logaritmická <math>O(\log(n))</math> pri rekurzívnej verzii.
* druh triedenia: triedenie výberom (komparačný algoritmus)
* stabilita triedenia: nestabilný
* miesto triedenia: vnútorné triedenie

====Základné časti algoritmu====
# vytvorenie hromady
# zmazanie hromady

====Slovný opis====
=====Vytvorenie hromady=====
Pri vytváraní hromady využijeme algoritmus heapify, pričom hromadu vytvoríme spôsobom zospodu na vrch. Najskôr si určíme prvok ktorý je najspodnejší a najviac vpravo a zároveň má aspoň jedného potomka. Tento prvok určíme veľmi jednoducho, pretože zpberieme posledný prvok v poli, a pomocou rovnice 3, ktorú si jemne upravíme mu nájdeme rodiča: <center><math> \text{posledný rodič} = \left \lfloor \frac{\text{posledný index } - 1}{2} \right \rfloor = \left \lfloor\frac{\text{dĺžka } - 2}{2} \right \rfloor = \left \lfloor \frac{\text{dĺžka}}{2}\right \rfloor - 1 </math></center>
Následne zavoláme Heapify na podhromadu s vrcholom posledného rodiča. Potom zmenšíme o 1 a opakujeme tento proces , až kým neprídeme na začiatok. Schematicky by sme to mohli napísať takto:
<center><math> \text{pre } i \text{ z intervalu } \left \langle \left \lfloor \frac {\text{dĺžka}}{2} \right \rfloor - 1 \quad ; \quad 0 \right \rangle :\ \text{heapify( pole[], dĺžka, i )}</math></center>

=====Zmazanie hromady=====
Pri mazaní hromady vykonáme dve operácie. Ako prvé vymeníme prvok na vrchu hromady s koncovým prvkom hromady. Prvok čo je na komci považujeme za zmazaný, preto veľkosť hromady znížime o 1. Následne musíme zabezpečiť zachovanie pravidiel pre hromadu, takže zavoláme funkciu Heapify na celú hromadu (index i bude vrch hromady, čiže 0-tý prvok v poli). Tento proces opakujeme, poikiaľ v hromade neostanú žiadne prvky.

Poznámka: v našom prípade nemusíme mazať celú hromadu, ale iba do chvíle, keď nám neostane 1 prvok.

Schematicky by sme to mohli zapísať takto:
<center><math>\text{pre } j \text{ z intervalu } \left \langle \text{dĺžka - 1} \quad ; \quad 0 \right \rangle : \ \ \text{vymeň(pole[0], pole[$j$])} \ \ a \ \ \text{heapify(pole[], dĺžka, 0)} </math></center>

====Pseudokód====
Nech funkcia Heap Sort má nasledovný prototyp: <code>HeapSort(pole[], dlzka)</code>

:1. Nech: <code>i = dlzka / 2 - 1</code>, kde "/" predstavuje celočíslené delenie.
:2. Je <code>i >= 0</code> ? Ak áno, pokračuj krokom 2.1., inak skoč na krok 3.
:::2.1. Zavolaj funkciu <code>Heapify(pole[], dlzka, i)</code>
:::2.2. Skoč na krok 2.
:3. Nech: <code>j = dlzka - 1</code>
:4 Je <code> j > 0</code> ? Ak áno, pokračuj krokom 4.1, inak skonči.
:::4.1. Vymeň: <code>pole[0]</code> a <code>pole[j]</code>
:::4.2. Zavolaj funkciu <code>Heapify(pole[], dlzka, i)</code>
:::4.3. Skoč na krok 4.

===Implementácia algoritmov Heapify a HeapSort v rôznych programovacích jazykoch===
<tabs>
<tab name="Iteračná C" block>
<syntaxhighlight lang="C">

#include <stdio.h>

void Vymen(int *a, int *b);
void Heapify(int pole[], int dlzka, int index);
void HeapSort(int pole[], int dlzka);

int main()
{
int pole[]= {10, 5, 2, 9, 8, 7, 1, 3, 4, 0, -1};
int dlzka = sizeof(pole) / sizeof(pole[0]);

HeapSort(pole, dlzka);

for (int i = 0; i < dlzka; ++i)
{
printf("%d ", pole[i]);
}
}

void Vymen(int *a, int *b)
{
int tmp = *a;
*a = *b;
*b = tmp;
}

void Heapify(int pole[], int dlzka, int index)
{
int pravy, lavy, max;

while(2 * index + 1 < dlzka)
{
lavy = 2 * index + 1;
pravy = 2 * index + 2;

// určenie potomka s maximálnou hodnotou
if(pravy < dlzka && pole[pravy] > pole[lavy])
{
max = pravy;
}
else
{
max = lavy;
}

// porovnanie maximálneho potomka s rodičom
if(pole[max] > pole[index])
{

Vymen(&pole[max], &pole[index]);
index = max;
}
else
{
return;
}
}
}

void HeapSort(int pole[], int dlzka)
{
// vytvor maximálnu hromadu (procedúra BuildMaxHeap)
for (int i = dlzka / 2 - 1 ; i >= 0; --i)
{
Heapify(pole, dlzka, i);
}

// zmaž všetky prvky z hromady
for (int j = dlzka - 1; j > 0; --j)
{
Vymen(&pole[0], &pole[j]);
Heapify(pole, j, 0);
}
}
</syntaxhighlight>
</tab>
<tab name="Rekurzívna C" block>
<syntaxhighlight lang="C">
#include <stdio.h>

void Vymen(int *a, int *b);
void Heapify(int pole[], int dlzka, int index);
void HeapSort(int pole[], int dlzka);

int main()
{
int pole[]= {10, 5, 2, 9, 8, 7, 1, 3, 4, 0, -1, -1};
int dlzka = sizeof(pole) / sizeof(pole[0]);

HeapSort(pole, dlzka);

for (int i = 0; i < dlzka; ++i)
{
printf("%d ", pole[i]);
}
}

void Vymen(int *a, int *b)
{
int tmp = *a;
*a = *b;
*b = tmp;
}

void Heapify(int pole[], int dlzka, int index)
{

int lavy = 2 * index + 1;
int pravy = 2 * index + 2;
int max = index;

// určenie potomka s maximálnou hodnotou
if(lavy < dlzka && pole[lavy] >= pole[pravy])
{
max = lavy;
}

if(pravy < dlzka && pole[pravy] > pole[lavy])
{
max = pravy;
}

// porovnanie maximálneho potomka s rodičom
if(pole[max] > pole[index])
{
Vymen(&pole[max], &pole[index]);
Heapify(pole, dlzka, max);
}
}

void HeapSort(int pole[], int dlzka)
{
// vytvor maximálnu hromadu (procedúra BuildMaxHeap)
for (int i = dlzka / 2 - 1 ; i >= 0; --i)
{
Heapify(pole, dlzka, i);
}

// zmaž všetky prvky z hromady
for (int j = dlzka - 1; j > 0; --j)
{
Vymen(&pole[0], &pole[j]);
Heapify(pole, j, 0);
}
}
</syntaxhighlight>
</tab>

<tab name="Iterácia Java" block>
<syntaxhighlight lang="Java">
class HeapSortIT {
void swap(int[] pole, int a, int b) {
int tmp = pole[a];
pole[a] = pole[b];
pole[b] = tmp;
}

void heapify(int[] pole, int n) {
for (int i = 1; i < n; i++) {

/* Ak je potomok väčší ako rodič */
if (pole[i] > pole[(i - 1) / 2]) {
int j = i;

/* Vymieňaj elementy (rodič, potomok), dokým je rodič menší ako potomok */
while (pole[j] > pole[(j - 1) / 2]) {
swap(pole, j, (j - 1) / 2);
j = (j - 1) / 2;
}
}
}
}

void sort(int[] pole) {
int n = pole.length;

heapify(pole, n);

for (int i = n - 1; i > 0; i--) {
int j = 0, index;

/* Vymeň prvý a posledný prvok */
swap(pole, 0, i);

do {
index = 2 * j + 1;

/* Ak je ľavý potomok menši ako pravý, presuň 'index' na pravého potomka */
if (index < i - 1 && pole[index] < pole[index + 1])
index++;

/* Ak je rodič menší ako potomok, tak ho vymeň s potomkom, ktorý má väčšiu hodnotu */
if (index < i && pole[j] < pole[index])
swap(pole, j, index);

j = index;
} while (index < i);
}
}
}

public class Main {

static void printArray(int[] pole) {
int n = pole.length;

for (int i : pole)
System.out.print(i + " ");

System.out.println();
}

public static void main(String[] args) {
int[] pole = {12, 11, 13, 5, 6, 7};
int n = pole.length;

System.out.println("Pole pred zoradenim: ");
printArray(pole);

HeapSortIT hs = new HeapSortIT();
hs.sort(pole);

System.out.println("Pole po zoradeni: ");
printArray(pole);
}
}
</syntaxhighlight>
</tab>

<tab name="Rekurzia Java" block>
<syntaxhighlight lang="Java">
class HeapSortRE {
void swap(int[] pole, int a, int b) {
int tmp = pole[a];
pole[a] = pole[b];
pole[b] = tmp;
}

void heapify(int[] pole, int n, int i) {
int max = i; // rodič
int l = 2 * i + 1; // ľavý potomok
int p = 2 * i + 2; // pravý potomok

/* Ak je ľavý potomok väčší ako rodič */
if (l < n && pole[l] > pole[max])
max = l;

/* Ak je pravý potomok väčší ako rodič */
if (p < n && pole[p] > pole[max])
max = p;

/* Ak sa rodič v priebehu funkcie zmenil */
if (max != i) {
swap(pole, i, max);

heapify(pole, n, max);
}
}

public void sort(int[] pole) {
int n = pole.length;

/* Vytvorenie hromadu */
for (int i = n / 2 - 1; i >= 0 ; i--)
heapify(pole, n, i);

/* Extrahovanie jednotlivých elemetov z hromady */
for (int i = n - 1; i > 0; i--) {
/* Presuň aktuálneho rodiča na koniec */
swap(pole, 0, i);

/* Zavolanie heapify na zredukovanú hromadu */
heapify(pole, i, 0);
}
}
}

public class Main {

static void printArray(int[] pole) {
int n = pole.length;

for (int i : pole)
System.out.print(i + " ");

System.out.println();
}

public static void main(String[] args) {
int[] pole = {12, 11, 13, 5, 6, 7};
int n = pole.length;

System.out.println("Pole pred zoradenim: ");
printArray(pole);

HeapSortRE hs = new HeapSortRE();
hs.sort(pole);

System.out.println("Pole po zoradeni: ");
printArray(pole);
}
}
</syntaxhighlight>
</tab>
</tabs>

==Selection Sort==
Coming soon :)

==Odkazy==
https://www.tutorialspoint.com/design_and_analysis_of_algorithms/design_and_analysis_of_algorithms_heapify_method.htm

Triedenie výberom

2021-04-10T11:20:51Z

Filip Tomek: /* Implementácia algoritmov Heapify a HeapSort v rôznych programovacích jazykoch */

[[Kategória:Algoritmy triedenia]]
{{Draft}}
{{Skripta programovanie}}
__TOC__
==Tento článok je v prvotnom štádiu konštrukcie, zatiaľ je to len hromada myšlienok :)==
odtiaľto sa odrazíme: https://en.wikipedia.org/wiki/Heapsort

==Heap Sort==

===Prehľad===
Heap Sort je triediaci algoritmus, ktorý podobne ako Selection sort rozeľuje pole na zotriedenú a nezotriedenú časť, pričom nezotriedená časť predstavuje dátovú štruktúru [[Hromada|binárna hromada]]. Celé triedenie spočíva v tom, že si zo vstupného poľa vytvoríme binárnu hromadu a následne postupným vyberaním a mazaním všetkých jej prvkov toto pole utriedime.

Hromada, ktorú využíva algoritmus Heap Sort, musí spĺňať nasledovné podmienky (ak indexujeme pole od 0):
:1. Vrchol hromady (koreň) je vždy prvý prvok v poli (v našom prípade prvok na 0-tej pozícii).
:2. Pre ľubovoľný prvok (uzol), uložený na indexe <math>i</math> z intervalu <math> \langle 0 \ ; \ \text{dĺžka} - 1 \rangle </math>, platia nasledovné rovnice:
:: <math>
\begin{align}
\text{ľavý potomok} &= 2i + 1 && (1) \\
\text{pravý potomok} &= 2i + 2 && (2) \\
\text{rodič} &= \left \lfloor \frac{i - 1}{2} \right \rfloor \quad (\text {okrem} \ i = 0) && (3)
\end{align}
</math>
:3. Každý prvok (uzol) v hromade musí mať väčšiu, alebo rovnakú hodnotu ako jeho potomkovia (MAX HEAP - ak triedime pole vzostupne, v opačnom prípade by sme použili MIN HEAP).

===Algoritmus Heapify===
[[Súbor:Heapify.png|vizualizácia|699px|náhľad|vpravo]]
Heapify je kľúčovým podprogramom triediaceho algoritmu Heap Sort, vďaka ktorému vieme efektíve zabezpečiť vytvorenie hromady z poľa a zmazanie hromady.

Princíp algoritmu Heapify spočíva v tom, že ak máme i-ty prvok v poli (v kompletnom binárnom strome), ktorého potomkovia tvoria dve samostatné podhromady, potom tieto dve podhromady zlúčime do jednej hromady, pričom i-ty prvok bude jej vrcholom.

====Vlastnosti algoritmu====
* dátová štruktúra: hromada (reprezentovaná ako: pole, strom)
* časová zložitosť: lineárna <math>O(n)</math>
* priestorová zložitosť: konštantná <math>O(1)</math> pri iteračnej verzii, <math>O(log(n))</math> pri rekurzívnej verzii

====Základné časti algoritmu====
# Určenie potomka s maximálnou hodnotou i-teho prvku.
# Porovnanie maximálneho potomka s rodičom (i-tym prvkom).
# Ak je potomok väčší ako rodič, tak výmena potomka a rodiča.
# Ak nastala výmena, skontrolovanie ovplyvneného potomka (podhromady).

====Slovný opis algoritmu====
Na vstupe prijmeme pole a index i, v ktorom chceme vytvoriť hromadu (Max Heap). Najskôr skontrolujeme, či prvok na indexe i má nejakých potomkov (využijeme rovnice (1) a (2) z časti "Prehľad"). Ak nemá žiadnych potomkov, funkcia skončí, pretože i predstavuje vrchol jednoprvkovej hromady. Ak má práve jedného potomka, tento potomok je zároveň jeho maximálnym potomkom. Ak má práve dvoch potomkov, tak porovnáme ich hodnoty a vyberieme z nich maximálneho potomka. Následne skontrolujeme veľkosť maximálneho potomka a jeho rodiča (prvok na indexe i). Ak je rodič väčší, funkcia skončí, pretože želaná hromada už je utvorená. Ak nie, vymeníme rodiča a maximálneho potomka. Ak nastala výmena, musíme skontrolovať ovplyvnenú podhromadu, tj. zopakovať tento sled krokov pre podhromadu, ktorej vrchol bude v maximálnom potomkovi i-teho prvku.

Z hľadiska implementácie môžeme vytvoriť iteračnú aj rekurzívnu verziu.

====Pseudokód====
<tabs>
<tab name="Iteračná verzia" block>
Nech funkcia Heapify má nasledovný prototyp: <code>Heapify(pole[], dlzka, i)</code>
:1. Je <code>2 * i + 1 < dlzka</code> ? Ak áno, pokračuj krokom 1.1., inak skonči.
:::1.1. Nech: <code>lavy = 2 * i + 1</code>
:::1.2. Nech: <code>pravy = 2 * i + 2</code>
:::1.3. Je <code>pravy < dlzka</code> a zároveň <code>pole[pravy] > pole[lavy]</code> ?
:::::Ak áno:
:::::::1.3.1. Nech: <code>max = pravy</code>
:::::Ak nie:
:::::::1.3.1. Nech: <code>max = lavy</code>
:::1.4. Je <code>pole[max] > pole[i]</code> ?
:::::Ak áno:
:::::::1.4.1. Vymeň: <code>pole[max]</code> a <code>pole[i]</code>
:::::::1.4.2. <code>i = max</code>
:::::Ak nie:
:::::::1.4.1 Skonči.
:::1.5. Skoč na krok 1.

</tab>

<tab name="Rekurzívna verzia" block>
Nech funkcia Heapify má nasledovný prototyp: <code>Heapify(pole[], dlzka, i)</code>
:1. Je <code>pole[2 * i + 1] >= pole[2 * i + 2]</code> ?
::: Ak áno:
:::::1.1. Nech: <code>max = pole[2 * i + 1]</code>
::: Ak nie:
:::::1.1. Nech: <code>max = pole[2 * i + 2]</code>
:2. Je <code>pole[max] > pole[i]</code> ?
::: Ak áno:
::::: 2.1. Vymeň: <code>pole[i] a pole[max]</code>
::::: 2.2. Rekurzívne zavolaj: <code>Heapify(pole[], dlzka, max)</code>
::: Ak nie:
::::: 2.1. Skonči volanie.
</tab>
</tabs>

===Algoritmus Heap Sort===
Heapsort pri triedení vykonáva dve základné úlohy: Vytvorenie maximálnej binárnej hromady zo vstupného poľa a mazanie jednotlivých prvkov z hromady. Pri oboch procedúrach využíva algoritmus Heapify

====Vlastnosti algoritmu====
* vhodný pre dátové štruktúry: pole
* časová náročnosť: vždy linearitmická <math> O(n\log(n)) </math>, vďaka ktorej dokáže efektívne triediť veľmi veľké polia
* priestorová náročnosť: konštantná <math>O(1)</math> pri iteračnej verzii, logaritmická <math>O(\log(n))</math> pri rekurzívnej verzii.
* druh triedenia: triedenie výberom (komparačný algoritmus)
* stabilita triedenia: nestabilný
* miesto triedenia: vnútorné triedenie
====Základné časti algoritmu====
# vytvorenie hromady
# zmazanie hromady

[[Súbor:HeapSort.png|500px|náhľad|vpravo]]

====Slovný opis====
=====Vytvorenie hromady=====
Pri vytváraní hromady využijeme algoritmus heapify, pričom hromadu vytvoríme spôsobom zospodu na vrch. Najskôr si určíme prvok ktorý je najspodnejší a najviac vpravo a zároveň má aspoň jedného potomka. Tento prvok určíme veľmi jednoducho, pretože zpberieme posledný prvok v poli, a pomocou rovnice 3, ktorú si jemne upravíme mu nájdeme rodiča: <center><math> \text{posledný rodič} = \left \lfloor \frac{\text{posledný index } - 1}{2} \right \rfloor = \left \lfloor\frac{\text{dĺžka } - 2}{2} \right \rfloor = \left \lfloor \frac{\text{dĺžka}}{2}\right \rfloor - 1 </math></center>
Následne zavoláme Heapify na podhromadu s vrcholom posledného rodiča. Potom zmenšíme o 1 a opakujeme tento proces , až kým neprídeme na začiatok. Schematicky by sme to mohli napísať takto:
<center><math> \text{pre } i \text{ z intervalu } \left \langle \left \lfloor \frac {\text{dĺžka}}{2} \right \rfloor - 1 \quad ; \quad 0 \right \rangle :\ \text{heapify( pole[], dĺžka, i )}</math></center>

=====Zmazanie hromady=====
Pri mazaní hromady vykonáme dve operácie. Ako prvé vymeníme prvok na vrchu hromady s koncovým prvkom hromady. Prvok čo je na komci považujeme za zmazaný, preto veľkosť hromady znížime o 1. Následne musíme zabezpečiť zachovanie pravidiel pre hromadu, takže zavoláme funkciu Heapify na celú hromadu (index i bude vrch hromady, čiže 0-tý prvok v poli). Tento proces opakujeme, poikiaľ v hromade neostanú žiadne prvky.

Poznámka: v našom prípade nemusíme mazať celú hromadu, ale iba do chvíle, keď nám neostane 1 prvok.

Schematicky by sme to mohli zapísať takto:
<center><math>\text{pre } j \text{ z intervalu } \left \langle \text{dĺžka - 1} \quad ; \quad 0 \right \rangle : \ \ \text{vymeň(pole[0], pole[$j$])} \ \ a \ \ \text{heapify(pole[], dĺžka, 0)} </math></center>

====Pseudokód====
Nech funkcia Heap Sort má nasledovný prototyp: <code>HeapSort(pole[], dlzka)</code>

:1. Nech: <code>i = dlzka / 2 - 1</code>, kde "/" predstavuje celočíslené delenie.
:2. Je <code>i >= 0</code> ? Ak áno, pokračuj krokom 2.1., inak skoč na krok 3.
:::2.1. Zavolaj funkciu <code>Heapify(pole[], dlzka, i)</code>
:::2.2. Skoč na krok 2.
:3. Nech: <code>j = dlzka - 1</code>
:4 Je <code> j > 0</code> ? Ak áno, pokračuj krokom 4.1, inak skonči.
:::4.1. Vymeň: <code>pole[0]</code> a <code>pole[j]</code>
:::4.2. Zavolaj funkciu <code>Heapify(pole[], dlzka, i)</code>
:::4.3. Skoč na krok 4.

===Implementácia algoritmov Heapify a HeapSort v rôznych programovacích jazykoch===
<tabs>
<tab name="Iteračná C" block>
<syntaxhighlight lang="C">

#include <stdio.h>

void Vymen(int *a, int *b);
void Heapify(int pole[], int dlzka, int index);
void HeapSort(int pole[], int dlzka);

int main()
{
int pole[]= {10, 5, 2, 9, 8, 7, 1, 3, 4, 0, -1};
int dlzka = sizeof(pole) / sizeof(pole[0]);

HeapSort(pole, dlzka);

for (int i = 0; i < dlzka; ++i)
{
printf("%d ", pole[i]);
}
}

void Vymen(int *a, int *b)
{
int tmp = *a;
*a = *b;
*b = tmp;
}

void Heapify(int pole[], int dlzka, int index)
{
int pravy, lavy, max;

while(2 * index + 1 < dlzka)
{
lavy = 2 * index + 1;
pravy = 2 * index + 2;

// určenie potomka s maximálnou hodnotou
if(pravy < dlzka && pole[pravy] > pole[lavy])
{
max = pravy;
}
else
{
max = lavy;
}

// porovnanie maximálneho potomka s rodičom
if(pole[max] > pole[index])
{

Vymen(&pole[max], &pole[index]);
index = max;
}
else
{
return;
}
}
}

void HeapSort(int pole[], int dlzka)
{
// vytvor maximálnu hromadu (procedúra BuildMaxHeap)
for (int i = dlzka / 2 - 1 ; i >= 0; --i)
{
Heapify(pole, dlzka, i);
}

// zmaž všetky prvky z hromady
for (int j = dlzka - 1; j > 0; --j)
{
Vymen(&pole[0], &pole[j]);
Heapify(pole, j, 0);
}
}
</syntaxhighlight>
</tab>
<tab name="Rekurzívna C" block>
<syntaxhighlight lang="C">
#include <stdio.h>

void Vymen(int *a, int *b);
void Heapify(int pole[], int dlzka, int index);
void HeapSort(int pole[], int dlzka);

int main()
{
int pole[]= {10, 5, 2, 9, 8, 7, 1, 3, 4, 0, -1, -1};
int dlzka = sizeof(pole) / sizeof(pole[0]);

HeapSort(pole, dlzka);

for (int i = 0; i < dlzka; ++i)
{
printf("%d ", pole[i]);
}
}

void Vymen(int *a, int *b)
{
int tmp = *a;
*a = *b;
*b = tmp;
}

void Heapify(int pole[], int dlzka, int index)
{

int lavy = 2 * index + 1;
int pravy = 2 * index + 2;
int max = index;

// určenie potomka s maximálnou hodnotou
if(lavy < dlzka && pole[lavy] >= pole[pravy])
{
max = lavy;
}

if(pravy < dlzka && pole[pravy] > pole[lavy])
{
max = pravy;
}

// porovnanie maximálneho potomka s rodičom
if(pole[max] > pole[index])
{
Vymen(&pole[max], &pole[index]);
Heapify(pole, dlzka, max);
}
}

void HeapSort(int pole[], int dlzka)
{
// vytvor maximálnu hromadu (procedúra BuildMaxHeap)
for (int i = dlzka / 2 - 1 ; i >= 0; --i)
{
Heapify(pole, dlzka, i);
}

// zmaž všetky prvky z hromady
for (int j = dlzka - 1; j > 0; --j)
{
Vymen(&pole[0], &pole[j]);
Heapify(pole, j, 0);
}
}
</syntaxhighlight>
</tab>

<tab name="Iterácia Java" block>
<syntaxhighlight lang="Java">
class HeapSortIT {
void swap(int[] pole, int a, int b) {
int tmp = pole[a];
pole[a] = pole[b];
pole[b] = tmp;
}

void heapify(int[] pole, int n) {
for (int i = 1; i < n; i++) {

/* Ak je potomok väčší ako rodič */
if (pole[i] > pole[(i - 1) / 2]) {
int j = i;

/* Vymieňaj elementy (rodič, potomok), dokým je rodič menší ako potomok */
while (pole[j] > pole[(j - 1) / 2]) {
swap(pole, j, (j - 1) / 2);
j = (j - 1) / 2;
}
}
}
}

void sort(int[] pole) {
int n = pole.length;

heapify(pole, n);

for (int i = n - 1; i > 0; i--) {
int j = 0, index;

/* Vymeň prvý a posledný prvok */
swap(pole, 0, i);

do {
index = 2 * j + 1;

/* Ak je ľavý potomok menši ako pravý, presuň 'index' na pravého potomka */
if (index < i - 1 && pole[index] < pole[index + 1])
index++;

/* Ak je rodič menší ako potomok, tak ho vymeň s potomkom, ktorý má väčšiu hodnotu */
if (index < i && pole[j] < pole[index])
swap(pole, j, index);

j = index;
} while (index < i);
}
}
}

public class Main {

static void printArray(int[] pole) {
int n = pole.length;

for (int i : pole)
System.out.print(i + " ");

System.out.println();
}

public static void main(String[] args) {
int[] pole = {12, 11, 13, 5, 6, 7};
int n = pole.length;

System.out.println("Pole pred zoradenim: ");
printArray(pole);

HeapSortIT hs = new HeapSortIT();
hs.sort(pole);

System.out.println("Pole po zoradeni: ");
printArray(pole);
}
}
</syntaxhighlight>
</tab>

<tab name="Rekurzia Java" block>
<syntaxhighlight lang="Java">
class HeapSortRE {
void swap(int[] pole, int a, int b) {
int tmp = pole[a];
pole[a] = pole[b];
pole[b] = tmp;
}

void heapify(int[] pole, int n, int i) {
int max = i; // rodič
int l = 2 * i + 1; // ľavý potomok
int p = 2 * i + 2; // pravý potomok

/* Ak je ľavý potomok väčší ako rodič */
if (l < n && pole[l] > pole[max])
max = l;

/* Ak je pravý potomok väčší ako rodič */
if (p < n && pole[p] > pole[max])
max = p;

/* Ak sa rodič v priebehu funkcie zmenil */
if (max != i) {
swap(pole, i, max);

heapify(pole, n, max);
}
}

public void sort(int[] pole) {
int n = pole.length;

/* Vytvorenie hromadu */
for (int i = n / 2 - 1; i >= 0 ; i--)
heapify(pole, n, i);

/* Extrahovanie jednotlivých elemetov z hromady */
for (int i = n - 1; i > 0; i--) {
/* Presuň aktuálneho rodiča na koniec */
swap(pole, 0, i);

/* Zavolanie heapify na zredukovanú hromadu */
heapify(pole, i, 0);
}
}
}

public class Main {

static void printArray(int[] pole) {
int n = pole.length;

for (int i : pole)
System.out.print(i + " ");

System.out.println();
}

public static void main(String[] args) {
int[] pole = {12, 11, 13, 5, 6, 7};
int n = pole.length;

System.out.println("Pole pred zoradenim: ");
printArray(pole);

HeapSortRE hs = new HeapSortRE();
hs.sort(pole);

System.out.println("Pole po zoradeni: ");
printArray(pole);
}
}
</syntaxhighlight>
</tab>
</tabs>

==Selection Sort==
Coming soon :)

==Odkazy==
https://www.tutorialspoint.com/design_and_analysis_of_algorithms/design_and_analysis_of_algorithms_heapify_method.htm

Triedenie výberom

2021-04-10T11:17:05Z

Filip Tomek: /* Implementácia algoritmov Heapify a HeapSort v rôznych programovacích jazykoch */

[[Kategória:Algoritmy triedenia]]
{{Draft}}
{{Skripta programovanie}}
__TOC__
==Tento článok je v prvotnom štádiu konštrukcie, zatiaľ je to len hromada myšlienok :)==
odtiaľto sa odrazíme: https://en.wikipedia.org/wiki/Heapsort

==Heap Sort==

===Prehľad===
Heap Sort je triediaci algoritmus, ktorý podobne ako Selection sort rozeľuje pole na zotriedenú a nezotriedenú časť, pričom nezotriedená časť predstavuje dátovú štruktúru [[Hromada|binárna hromada]]. Celé triedenie spočíva v tom, že si zo vstupného poľa vytvoríme binárnu hromadu a následne postupným vyberaním a mazaním všetkých jej prvkov toto pole utriedime.

Hromada, ktorú využíva algoritmus Heap Sort, musí spĺňať nasledovné podmienky (ak indexujeme pole od 0):
:1. Vrchol hromady (koreň) je vždy prvý prvok v poli (v našom prípade prvok na 0-tej pozícii).
:2. Pre ľubovoľný prvok (uzol), uložený na indexe <math>i</math> z intervalu <math> \langle 0 \ ; \ \text{dĺžka} - 1 \rangle </math>, platia nasledovné rovnice:
:: <math>
\begin{align}
\text{ľavý potomok} &= 2i + 1 && (1) \\
\text{pravý potomok} &= 2i + 2 && (2) \\
\text{rodič} &= \left \lfloor \frac{i - 1}{2} \right \rfloor \quad (\text {okrem} \ i = 0) && (3)
\end{align}
</math>
:3. Každý prvok (uzol) v hromade musí mať väčšiu, alebo rovnakú hodnotu ako jeho potomkovia (MAX HEAP - ak triedime pole vzostupne, v opačnom prípade by sme použili MIN HEAP).

===Algoritmus Heapify===
[[Súbor:Heapify.png|vizualizácia|699px|náhľad|vpravo]]
Heapify je kľúčovým podprogramom triediaceho algoritmu Heap Sort, vďaka ktorému vieme efektíve zabezpečiť vytvorenie hromady z poľa a zmazanie hromady.

Princíp algoritmu Heapify spočíva v tom, že ak máme i-ty prvok v poli (v kompletnom binárnom strome), ktorého potomkovia tvoria dve samostatné podhromady, potom tieto dve podhromady zlúčime do jednej hromady, pričom i-ty prvok bude jej vrcholom.

====Vlastnosti algoritmu====
* dátová štruktúra: hromada (reprezentovaná ako: pole, strom)
* časová zložitosť: lineárna <math>O(n)</math>
* priestorová zložitosť: konštantná <math>O(1)</math> pri iteračnej verzii, <math>O(log(n))</math> pri rekurzívnej verzii

====Základné časti algoritmu====
# Určenie potomka s maximálnou hodnotou i-teho prvku.
# Porovnanie maximálneho potomka s rodičom (i-tym prvkom).
# Ak je potomok väčší ako rodič, tak výmena potomka a rodiča.
# Ak nastala výmena, skontrolovanie ovplyvneného potomka (podhromady).

====Slovný opis algoritmu====
Na vstupe prijmeme pole a index i, v ktorom chceme vytvoriť hromadu (Max Heap). Najskôr skontrolujeme, či prvok na indexe i má nejakých potomkov (využijeme rovnice (1) a (2) z časti "Prehľad"). Ak nemá žiadnych potomkov, funkcia skončí, pretože i predstavuje vrchol jednoprvkovej hromady. Ak má práve jedného potomka, tento potomok je zároveň jeho maximálnym potomkom. Ak má práve dvoch potomkov, tak porovnáme ich hodnoty a vyberieme z nich maximálneho potomka. Následne skontrolujeme veľkosť maximálneho potomka a jeho rodiča (prvok na indexe i). Ak je rodič väčší, funkcia skončí, pretože želaná hromada už je utvorená. Ak nie, vymeníme rodiča a maximálneho potomka. Ak nastala výmena, musíme skontrolovať ovplyvnenú podhromadu, tj. zopakovať tento sled krokov pre podhromadu, ktorej vrchol bude v maximálnom potomkovi i-teho prvku.

Z hľadiska implementácie môžeme vytvoriť iteračnú aj rekurzívnu verziu.

====Pseudokód====
<tabs>
<tab name="Iteračná verzia" block>
Nech funkcia Heapify má nasledovný prototyp: <code>Heapify(pole[], dlzka, i)</code>
:1. Je <code>2 * i + 1 < dlzka</code> ? Ak áno, pokračuj krokom 1.1., inak skonči.
:::1.1. Nech: <code>lavy = 2 * i + 1</code>
:::1.2. Nech: <code>pravy = 2 * i + 2</code>
:::1.3. Je <code>pravy < dlzka</code> a zároveň <code>pole[pravy] > pole[lavy]</code> ?
:::::Ak áno:
:::::::1.3.1. Nech: <code>max = pravy</code>
:::::Ak nie:
:::::::1.3.1. Nech: <code>max = lavy</code>
:::1.4. Je <code>pole[max] > pole[i]</code> ?
:::::Ak áno:
:::::::1.4.1. Vymeň: <code>pole[max]</code> a <code>pole[i]</code>
:::::::1.4.2. <code>i = max</code>
:::::Ak nie:
:::::::1.4.1 Skonči.
:::1.5. Skoč na krok 1.

</tab>

<tab name="Rekurzívna verzia" block>
Nech funkcia Heapify má nasledovný prototyp: <code>Heapify(pole[], dlzka, i)</code>
:1. Je <code>pole[2 * i + 1] >= pole[2 * i + 2]</code> ?
::: Ak áno:
:::::1.1. Nech: <code>max = pole[2 * i + 1]</code>
::: Ak nie:
:::::1.1. Nech: <code>max = pole[2 * i + 2]</code>
:2. Je <code>pole[max] > pole[i]</code> ?
::: Ak áno:
::::: 2.1. Vymeň: <code>pole[i] a pole[max]</code>
::::: 2.2. Rekurzívne zavolaj: <code>Heapify(pole[], dlzka, max)</code>
::: Ak nie:
::::: 2.1. Skonči volanie.
</tab>
</tabs>

===Algoritmus Heap Sort===
Heapsort pri triedení vykonáva dve základné úlohy: Vytvorenie maximálnej binárnej hromady zo vstupného poľa a mazanie jednotlivých prvkov z hromady. Pri oboch procedúrach využíva algoritmus Heapify

====Vlastnosti algoritmu====
* vhodný pre dátové štruktúry: pole
* časová náročnosť: vždy linearitmická <math> O(n\log(n)) </math>, vďaka ktorej dokáže efektívne triediť veľmi veľké polia
* priestorová náročnosť: konštantná <math>O(1)</math> pri iteračnej verzii, logaritmická <math>O(\log(n))</math> pri rekurzívnej verzii.
* druh triedenia: triedenie výberom (komparačný algoritmus)
* stabilita triedenia: nestabilný
* miesto triedenia: vnútorné triedenie
====Základné časti algoritmu====
# vytvorenie hromady
# zmazanie hromady

[[Súbor:HeapSort.png|500px|náhľad|vpravo]]

====Slovný opis====
=====Vytvorenie hromady=====
Pri vytváraní hromady využijeme algoritmus heapify, pričom hromadu vytvoríme spôsobom zospodu na vrch. Najskôr si určíme prvok ktorý je najspodnejší a najviac vpravo a zároveň má aspoň jedného potomka. Tento prvok určíme veľmi jednoducho, pretože zpberieme posledný prvok v poli, a pomocou rovnice 3, ktorú si jemne upravíme mu nájdeme rodiča: <center><math> \text{posledný rodič} = \left \lfloor \frac{\text{posledný index } - 1}{2} \right \rfloor = \left \lfloor\frac{\text{dĺžka } - 2}{2} \right \rfloor = \left \lfloor \frac{\text{dĺžka}}{2}\right \rfloor - 1 </math></center>
Následne zavoláme Heapify na podhromadu s vrcholom posledného rodiča. Potom zmenšíme o 1 a opakujeme tento proces , až kým neprídeme na začiatok. Schematicky by sme to mohli napísať takto:
<center><math> \text{pre } i \text{ z intervalu } \left \langle \left \lfloor \frac {\text{dĺžka}}{2} \right \rfloor - 1 \quad ; \quad 0 \right \rangle :\ \text{heapify( pole[], dĺžka, i )}</math></center>

=====Zmazanie hromady=====
Pri mazaní hromady vykonáme dve operácie. Ako prvé vymeníme prvok na vrchu hromady s koncovým prvkom hromady. Prvok čo je na komci považujeme za zmazaný, preto veľkosť hromady znížime o 1. Následne musíme zabezpečiť zachovanie pravidiel pre hromadu, takže zavoláme funkciu Heapify na celú hromadu (index i bude vrch hromady, čiže 0-tý prvok v poli). Tento proces opakujeme, poikiaľ v hromade neostanú žiadne prvky.

Poznámka: v našom prípade nemusíme mazať celú hromadu, ale iba do chvíle, keď nám neostane 1 prvok.

Schematicky by sme to mohli zapísať takto:
<center><math>\text{pre } j \text{ z intervalu } \left \langle \text{dĺžka - 1} \quad ; \quad 0 \right \rangle : \ \ \text{vymeň(pole[0], pole[$j$])} \ \ a \ \ \text{heapify(pole[], dĺžka, 0)} </math></center>

====Pseudokód====
Nech funkcia Heap Sort má nasledovný prototyp: <code>HeapSort(pole[], dlzka)</code>

:1. Nech: <code>i = dlzka / 2 - 1</code>, kde "/" predstavuje celočíslené delenie.
:2. Je <code>i >= 0</code> ? Ak áno, pokračuj krokom 2.1., inak skoč na krok 3.
:::2.1. Zavolaj funkciu <code>Heapify(pole[], dlzka, i)</code>
:::2.2. Skoč na krok 2.
:3. Nech: <code>j = dlzka - 1</code>
:4 Je <code> j > 0</code> ? Ak áno, pokračuj krokom 4.1, inak skonči.
:::4.1. Vymeň: <code>pole[0]</code> a <code>pole[j]</code>
:::4.2. Zavolaj funkciu <code>Heapify(pole[], dlzka, i)</code>
:::4.3. Skoč na krok 4.

===Implementácia algoritmov Heapify a HeapSort v rôznych programovacích jazykoch===
<tabs>
<tab name="Iteračná C" block>
<syntaxhighlight lang="C">

#include <stdio.h>

void Vymen(int *a, int *b);
void Heapify(int pole[], int dlzka, int index);
void HeapSort(int pole[], int dlzka);

int main()
{
int pole[]= {10, 5, 2, 9, 8, 7, 1, 3, 4, 0, -1};
int dlzka = sizeof(pole) / sizeof(pole[0]);

HeapSort(pole, dlzka);

for (int i = 0; i < dlzka; ++i)
{
printf("%d ", pole[i]);
}
}

void Vymen(int *a, int *b)
{
int tmp = *a;
*a = *b;
*b = tmp;
}

void Heapify(int pole[], int dlzka, int index)
{
int pravy, lavy, max;

while(2 * index + 1 < dlzka)
{
lavy = 2 * index + 1;
pravy = 2 * index + 2;

// určenie potomka s maximálnou hodnotou
if(pravy < dlzka && pole[pravy] > pole[lavy])
{
max = pravy;
}
else
{
max = lavy;
}

// porovnanie maximálneho potomka s rodičom
if(pole[max] > pole[index])
{

Vymen(&pole[max], &pole[index]);
index = max;
}
else
{
return;
}
}
}

void HeapSort(int pole[], int dlzka)
{
// vytvor maximálnu hromadu (procedúra BuildMaxHeap)
for (int i = dlzka / 2 - 1 ; i >= 0; --i)
{
Heapify(pole, dlzka, i);
}

// zmaž všetky prvky z hromady
for (int j = dlzka - 1; j > 0; --j)
{
Vymen(&pole[0], &pole[j]);
Heapify(pole, j, 0);
}
}
</syntaxhighlight>
</tab>
<tab name="Rekurzívna C" block>
<syntaxhighlight lang="C">
#include <stdio.h>

void Vymen(int *a, int *b);
void Heapify(int pole[], int dlzka, int index);
void HeapSort(int pole[], int dlzka);

int main()
{
int pole[]= {10, 5, 2, 9, 8, 7, 1, 3, 4, 0, -1, -1};
int dlzka = sizeof(pole) / sizeof(pole[0]);

HeapSort(pole, dlzka);

for (int i = 0; i < dlzka; ++i)
{
printf("%d ", pole[i]);
}
}

void Vymen(int *a, int *b)
{
int tmp = *a;
*a = *b;
*b = tmp;
}

void Heapify(int pole[], int dlzka, int index)
{

int lavy = 2 * index + 1;
int pravy = 2 * index + 2;
int max = index;

// určenie potomka s maximálnou hodnotou
if(lavy < dlzka && pole[lavy] >= pole[pravy])
{
max = lavy;
}

if(pravy < dlzka && pole[pravy] > pole[lavy])
{
max = pravy;
}

// porovnanie maximálneho potomka s rodičom
if(pole[max] > pole[index])
{
Vymen(&pole[max], &pole[index]);
Heapify(pole, dlzka, max);
}
}

void HeapSort(int pole[], int dlzka)
{
// vytvor maximálnu hromadu (procedúra BuildMaxHeap)
for (int i = dlzka / 2 - 1 ; i >= 0; --i)
{
Heapify(pole, dlzka, i);
}

// zmaž všetky prvky z hromady
for (int j = dlzka - 1; j > 0; --j)
{
Vymen(&pole[0], &pole[j]);
Heapify(pole, j, 0);
}
}
</syntaxhighlight>
</tab>

<tab name="Java" block>
<syntaxhighlight lang="Java">
class HeapSort_Iteracia {
void swap(int[] pole, int a, int b) {
int tmp = pole[a];
pole[a] = pole[b];
pole[b] = tmp;
}

void heapify(int[] pole, int n) {
for (int i = 1; i < n; i++) {

/* Ak je potomok väčší ako rodič */
if (pole[i] > pole[(i - 1) / 2]) {
int j = i;

/* Vymieňaj elementy (rodič, potomok), dokým je rodič menší ako potomok */
while (pole[j] > pole[(j - 1) / 2]) {
swap(pole, j, (j - 1) / 2);
j = (j - 1) / 2;
}
}
}
}

void sort(int[] pole) {
int n = pole.length;

heapify(pole, n);

for (int i = n - 1; i > 0; i--) {
int j = 0, index;

/* Vymeň prvý a posledný prvok */
swap(pole, 0, i);

do {
index = 2 * j + 1;

/* Ak je ľavý potomok menši ako pravý, presuň 'index' na pravého potomka */
if (index < i - 1 && pole[index] < pole[index + 1])
index++;

/* Ak je rodič menší ako potomok, tak ho vymeň s potomkom, ktorý má väčšiu hodnotu */
if (index < i && pole[j] < pole[index])
swap(pole, j, index);

j = index;
} while (index < i);
}
}
}

public class Main {

static void printArray(int[] pole) {
int n = pole.length;

for (int i : pole)
System.out.print(i + " ");

System.out.println();
}

public static void main(String[] args) {
int[] pole = {12, 11, 13, 5, 6, 7};
int n = pole.length;

System.out.println("Pole pred zoradenim: ");
printArray(pole);

HeapSort_Iteracia hs = new HeapSort_Iteracia();
hs.sort(pole);

System.out.println("Pole po zoradeni: ");
printArray(pole);
}
}
</syntaxhighlight>
</tab>

<tab name="Java" block>
<syntaxhighlight lang="Java">
class HeapSort_Rekurzia {
void swap(int[] pole, int a, int b) {
int tmp = pole[a];
pole[a] = pole[b];
pole[b] = tmp;
}

void heapify(int[] pole, int n, int i) {
int max = i; // rodič
int l = 2 * i + 1; // ľavý potomok
int p = 2 * i + 2; // pravý potomok

/* Ak je ľavý potomok väčší ako rodič */
if (l < n && pole[l] > pole[max])
max = l;

/* Ak je pravý potomok väčší ako rodič */
if (p < n && pole[p] > pole[max])
max = p;

/* Ak sa rodič v priebehu funkcie zmenil */
if (max != i) {
swap(pole, i, max);

heapify(pole, n, max);
}
}

public void sort(int[] pole) {
int n = pole.length;

/* Vytvorenie hromadu */
for (int i = n / 2 - 1; i >= 0 ; i--)
heapify(pole, n, i);

/* Extrahovanie jednotlivých elemetov z hromady */
for (int i = n - 1; i > 0; i--) {
/* Presuň aktuálneho rodiča na koniec */
swap(pole, 0, i);

/* Zavolanie heapify na zredukovanú hromadu */
heapify(pole, i, 0);
}
}
}

public class Main {

static void printArray(int[] pole) {
int n = pole.length;

for (int i : pole)
System.out.print(i + " ");

System.out.println();
}

public static void main(String[] args) {
int[] pole = {12, 11, 13, 5, 6, 7};
int n = pole.length;

System.out.println("Pole pred zoradenim: ");
printArray(pole);

HeapSort_Rekurzia hs = new HeapSort_Rekurzia();
hs.sort(pole);

System.out.println("Pole po zoradeni: ");
printArray(pole);
}
}
</syntaxhighlight>
</tab>
</tabs>

==Selection Sort==
Coming soon :)

==Odkazy==
https://www.tutorialspoint.com/design_and_analysis_of_algorithms/design_and_analysis_of_algorithms_heapify_method.htm

Triedenie výberom

2021-04-10T10:41:30Z

Filip Tomek: /* Implementácia algoritmov Heapify a HeapSort v rôznych programovacích jazykoch */

[[Kategória:Algoritmy triedenia]]
{{Draft}}
{{Skripta programovanie}}
__TOC__
==Tento článok je v prvotnom štádiu konštrukcie, zatiaľ je to len hromada myšlienok :)==
odtiaľto sa odrazíme: https://en.wikipedia.org/wiki/Heapsort

==Heap Sort==

===Prehľad===
Heap Sort je triediaci algoritmus, ktorý podobne ako Selection sort rozeľuje pole na zotriedenú a nezotriedenú časť, pričom nezotriedená časť predstavuje dátovú štruktúru [[Hromada|binárna hromada]]. Celé triedenie spočíva v tom, že si zo vstupného poľa vytvoríme binárnu hromadu a následne postupným vyberaním a mazaním všetkých jej prvkov toto pole utriedime.

Hromada, ktorú využíva algoritmus Heap Sort, musí spĺňať nasledovné podmienky (ak indexujeme pole od 0):
:1. Vrchol hromady (koreň) je vždy prvý prvok v poli (v našom prípade prvok na 0-tej pozícii).
:2. Pre ľubovoľný prvok (uzol), uložený na indexe <math>i</math> z intervalu <math> \langle 0 \ ; \ \text{dĺžka} - 1 \rangle </math>, platia nasledovné rovnice:
:: <math>
\begin{align}
\text{ľavý potomok} &= 2i + 1 && (1) \\
\text{pravý potomok} &= 2i + 2 && (2) \\
\text{rodič} &= \left \lfloor \frac{i - 1}{2} \right \rfloor \quad (\text {okrem} \ i = 0) && (3)
\end{align}
</math>
:3. Každý prvok (uzol) v hromade musí mať väčšiu, alebo rovnakú hodnotu ako jeho potomkovia (MAX HEAP - ak triedime pole vzostupne, v opačnom prípade by sme použili MIN HEAP).

===Algoritmus Heapify===
[[Súbor:Heapify.png|vizualizácia|699px|náhľad|vpravo]]
Heapify je kľúčovým podprogramom triediaceho algoritmu Heap Sort, vďaka ktorému vieme efektíve zabezpečiť vytvorenie hromady z poľa a zmazanie hromady.

Princíp algoritmu Heapify spočíva v tom, že ak máme i-ty prvok v poli (v kompletnom binárnom strome), ktorého potomkovia tvoria dve samostatné podhromady, potom tieto dve podhromady zlúčime do jednej hromady, pričom i-ty prvok bude jej vrcholom.

====Vlastnosti algoritmu====
* dátová štruktúra: hromada (reprezentovaná ako: pole, strom)
* časová zložitosť: lineárna <math>O(n)</math>
* priestorová zložitosť: konštantná <math>O(1)</math> pri iteračnej verzii, <math>O(log(n))</math> pri rekurzívnej verzii

====Základné časti algoritmu====
# Určenie potomka s maximálnou hodnotou i-teho prvku.
# Porovnanie maximálneho potomka s rodičom (i-tym prvkom).
# Ak je potomok väčší ako rodič, tak výmena potomka a rodiča.
# Ak nastala výmena, skontrolovanie ovplyvneného potomka (podhromady).

====Slovný opis algoritmu====
Na vstupe prijmeme pole a index i, v ktorom chceme vytvoriť hromadu (Max Heap). Najskôr skontrolujeme, či prvok na indexe i má nejakých potomkov (využijeme rovnice (1) a (2) z časti "Prehľad"). Ak nemá žiadnych potomkov, funkcia skončí, pretože i predstavuje vrchol jednoprvkovej hromady. Ak má práve jedného potomka, tento potomok je zároveň jeho maximálnym potomkom. Ak má práve dvoch potomkov, tak porovnáme ich hodnoty a vyberieme z nich maximálneho potomka. Následne skontrolujeme veľkosť maximálneho potomka a jeho rodiča (prvok na indexe i). Ak je rodič väčší, funkcia skončí, pretože želaná hromada už je utvorená. Ak nie, vymeníme rodiča a maximálneho potomka. Ak nastala výmena, musíme skontrolovať ovplyvnenú podhromadu, tj. zopakovať tento sled krokov pre podhromadu, ktorej vrchol bude v maximálnom potomkovi i-teho prvku.

Z hľadiska implementácie môžeme vytvoriť iteračnú aj rekurzívnu verziu.

====Pseudokód====
<tabs>
<tab name="Iteračná verzia" block>
Nech funkcia Heapify má nasledovný prototyp: <code>Heapify(pole[], dlzka, i)</code>
:1. Je <code>2 * i + 1 < dlzka</code> ? Ak áno, pokračuj krokom 1.1., inak skonči.
:::1.1. Nech: <code>lavy = 2 * i + 1</code>
:::1.2. Nech: <code>pravy = 2 * i + 2</code>
:::1.3. Je <code>pravy < dlzka</code> a zároveň <code>pole[pravy] > pole[lavy]</code> ?
:::::Ak áno:
:::::::1.3.1. Nech: <code>max = pravy</code>
:::::Ak nie:
:::::::1.3.1. Nech: <code>max = lavy</code>
:::1.4. Je <code>pole[max] > pole[i]</code> ?
:::::Ak áno:
:::::::1.4.1. Vymeň: <code>pole[max]</code> a <code>pole[i]</code>
:::::::1.4.2. <code>i = max</code>
:::::Ak nie:
:::::::1.4.1 Skonči.
:::1.5. Skoč na krok 1.

</tab>

<tab name="Rekurzívna verzia" block>
Nech funkcia Heapify má nasledovný prototyp: <code>Heapify(pole[], dlzka, i)</code>
:1. Je <code>pole[2 * i + 1] >= pole[2 * i + 2]</code> ?
::: Ak áno:
:::::1.1. Nech: <code>max = pole[2 * i + 1]</code>
::: Ak nie:
:::::1.1. Nech: <code>max = pole[2 * i + 2]</code>
:2. Je <code>pole[max] > pole[i]</code> ?
::: Ak áno:
::::: 2.1. Vymeň: <code>pole[i] a pole[max]</code>
::::: 2.2. Rekurzívne zavolaj: <code>Heapify(pole[], dlzka, max)</code>
::: Ak nie:
::::: 2.1. Skonči volanie.
</tab>
</tabs>

===Algoritmus Heap Sort===
Heapsort pri triedení vykonáva dve základné úlohy: Vytvorenie maximálnej binárnej hromady zo vstupného poľa a mazanie jednotlivých prvkov z hromady. Pri oboch procedúrach využíva algoritmus Heapify

====Vlastnosti algoritmu====
* vhodný pre dátové štruktúry: pole
* časová náročnosť: vždy linearitmická <math> O(n\log(n)) </math>, vďaka ktorej dokáže efektívne triediť veľmi veľké polia
* priestorová náročnosť: konštantná <math>O(1)</math> pri iteračnej verzii, logaritmická <math>O(\log(n))</math> pri rekurzívnej verzii.
* druh triedenia: triedenie výberom (komparačný algoritmus)
* stabilita triedenia: nestabilný
* miesto triedenia: vnútorné triedenie
====Základné časti algoritmu====
# vytvorenie hromady
# zmazanie hromady

[[Súbor:HeapSort.png|500px|náhľad|vpravo]]

====Slovný opis====
=====Vytvorenie hromady=====
Pri vytváraní hromady využijeme algoritmus heapify, pričom hromadu vytvoríme spôsobom zospodu na vrch. Najskôr si určíme prvok ktorý je najspodnejší a najviac vpravo a zároveň má aspoň jedného potomka. Tento prvok určíme veľmi jednoducho, pretože zpberieme posledný prvok v poli, a pomocou rovnice 3, ktorú si jemne upravíme mu nájdeme rodiča: <center><math> \text{posledný rodič} = \left \lfloor \frac{\text{posledný index } - 1}{2} \right \rfloor = \left \lfloor\frac{\text{dĺžka } - 2}{2} \right \rfloor = \left \lfloor \frac{\text{dĺžka}}{2}\right \rfloor - 1 </math></center>
Následne zavoláme Heapify na podhromadu s vrcholom posledného rodiča. Potom zmenšíme o 1 a opakujeme tento proces , až kým neprídeme na začiatok. Schematicky by sme to mohli napísať takto:
<center><math> \text{pre } i \text{ z intervalu } \left \langle \left \lfloor \frac {\text{dĺžka}}{2} \right \rfloor - 1 \quad ; \quad 0 \right \rangle :\ \text{heapify( pole[], dĺžka, i )}</math></center>

=====Zmazanie hromady=====
Pri mazaní hromady vykonáme dve operácie. Ako prvé vymeníme prvok na vrchu hromady s koncovým prvkom hromady. Prvok čo je na komci považujeme za zmazaný, preto veľkosť hromady znížime o 1. Následne musíme zabezpečiť zachovanie pravidiel pre hromadu, takže zavoláme funkciu Heapify na celú hromadu (index i bude vrch hromady, čiže 0-tý prvok v poli). Tento proces opakujeme, poikiaľ v hromade neostanú žiadne prvky.

Poznámka: v našom prípade nemusíme mazať celú hromadu, ale iba do chvíle, keď nám neostane 1 prvok.

Schematicky by sme to mohli zapísať takto:
<center><math>\text{pre } j \text{ z intervalu } \left \langle \text{dĺžka - 1} \quad ; \quad 0 \right \rangle : \ \ \text{vymeň(pole[0], pole[$j$])} \ \ a \ \ \text{heapify(pole[], dĺžka, 0)} </math></center>

====Pseudokód====
Nech funkcia Heap Sort má nasledovný prototyp: <code>HeapSort(pole[], dlzka)</code>

:1. Nech: <code>i = dlzka / 2 - 1</code>, kde "/" predstavuje celočíslené delenie.
:2. Je <code>i >= 0</code> ? Ak áno, pokračuj krokom 2.1., inak skoč na krok 3.
:::2.1. Zavolaj funkciu <code>Heapify(pole[], dlzka, i)</code>
:::2.2. Skoč na krok 2.
:3. Nech: <code>j = dlzka - 1</code>
:4 Je <code> j > 0</code> ? Ak áno, pokračuj krokom 4.1, inak skonči.
:::4.1. Vymeň: <code>pole[0]</code> a <code>pole[j]</code>
:::4.2. Zavolaj funkciu <code>Heapify(pole[], dlzka, i)</code>
:::4.3. Skoč na krok 4.

===Implementácia algoritmov Heapify a HeapSort v rôznych programovacích jazykoch===
<tabs>
<tab name="Iteračná C" block>
<syntaxhighlight lang="C">

#include <stdio.h>

void Vymen(int *a, int *b);
void Heapify(int pole[], int dlzka, int index);
void HeapSort(int pole[], int dlzka);

int main()
{
int pole[]= {10, 5, 2, 9, 8, 7, 1, 3, 4, 0, -1};
int dlzka = sizeof(pole) / sizeof(pole[0]);

HeapSort(pole, dlzka);

for (int i = 0; i < dlzka; ++i)
{
printf("%d ", pole[i]);
}
}

void Vymen(int *a, int *b)
{
int tmp = *a;
*a = *b;
*b = tmp;
}

void Heapify(int pole[], int dlzka, int index)
{
int pravy, lavy, max;

while(2 * index + 1 < dlzka)
{
lavy = 2 * index + 1;
pravy = 2 * index + 2;

// určenie potomka s maximálnou hodnotou
if(pravy < dlzka && pole[pravy] > pole[lavy])
{
max = pravy;
}
else
{
max = lavy;
}

// porovnanie maximálneho potomka s rodičom
if(pole[max] > pole[index])
{

Vymen(&pole[max], &pole[index]);
index = max;
}
else
{
return;
}
}
}

void HeapSort(int pole[], int dlzka)
{
// vytvor maximálnu hromadu (procedúra BuildMaxHeap)
for (int i = dlzka / 2 - 1 ; i >= 0; --i)
{
Heapify(pole, dlzka, i);
}

// zmaž všetky prvky z hromady
for (int j = dlzka - 1; j > 0; --j)
{
Vymen(&pole[0], &pole[j]);
Heapify(pole, j, 0);
}
}
</syntaxhighlight>
</tab>
<tab name="Rekurzívna C" block>
<syntaxhighlight lang="C">
#include <stdio.h>

void Vymen(int *a, int *b);
void Heapify(int pole[], int dlzka, int index);
void HeapSort(int pole[], int dlzka);

int main()
{
int pole[]= {10, 5, 2, 9, 8, 7, 1, 3, 4, 0, -1, -1};
int dlzka = sizeof(pole) / sizeof(pole[0]);

HeapSort(pole, dlzka);

for (int i = 0; i < dlzka; ++i)
{
printf("%d ", pole[i]);
}
}

void Vymen(int *a, int *b)
{
int tmp = *a;
*a = *b;
*b = tmp;
}

void Heapify(int pole[], int dlzka, int index)
{

int lavy = 2 * index + 1;
int pravy = 2 * index + 2;
int max = index;

// určenie potomka s maximálnou hodnotou
if(lavy < dlzka && pole[lavy] >= pole[pravy])
{
max = lavy;
}

if(pravy < dlzka && pole[pravy] > pole[lavy])
{
max = pravy;
}

// porovnanie maximálneho potomka s rodičom
if(pole[max] > pole[index])
{
Vymen(&pole[max], &pole[index]);
Heapify(pole, dlzka, max);
}
}

void HeapSort(int pole[], int dlzka)
{
// vytvor maximálnu hromadu (procedúra BuildMaxHeap)
for (int i = dlzka / 2 - 1 ; i >= 0; --i)
{
Heapify(pole, dlzka, i);
}

// zmaž všetky prvky z hromady
for (int j = dlzka - 1; j > 0; --j)
{
Vymen(&pole[0], &pole[j]);
Heapify(pole, j, 0);
}
}
</syntaxhighlight>
</tab>

<tab name="Rekurzívna Java" block>
<syntaxhighlight lang="Java">
class HeapSortRE {
void swap(int[] pole, int a, int b) {
int tmp = pole[a];
pole[a] = pole[b];
pole[b] = tmp;
}

void heapify(int[] pole, int n, int i) {
int max = i; // rodič
int l = 2 * i + 1; // ľavý potomok
int p = 2 * i + 2; // pravý potomok

/* Ak je ľavý potomok väčší ako rodič */
if (l < n && pole[l] > pole[max])
max = l;

/* Ak je pravý potomok väčší ako rodič */
if (p < n && pole[p] > pole[max])
max = p;

/* Ak sa rodič v priebehu funkcie zmenil */
if (max != i) {
swap(pole, i, max);

heapify(pole, n, max);
}
}

public void sort(int[] pole) {
int n = pole.length;

/* Vytvorenie hromadu */
for (int i = n / 2 - 1; i >= 0 ; i--)
heapify(pole, n, i);

/* Extrahovanie jednotlivých elemetov z hromady */
for (int i = n - 1; i > 0; i--) {
/* Presuň aktuálneho rodiča na koniec */
swap(pole, 0, i);

/* Zavolanie heapify na zredukovanú hromadu */
heapify(pole, i, 0);
}
}
}

public class Main {

static void printArray(int[] pole) {
int n = pole.length;

for (int i : pole)
System.out.print(i + " ");

System.out.println();
}

public static void main(String[] args) {
int[] pole = {12, 11, 13, 5, 6, 7};
int n = pole.length;

System.out.println("Pole pred zoradenim: ");
printArray(pole);

HeapSortRE hs = new HeapSortRE();
hs.sort(pole);

System.out.println("Pole po zoradeni: ");
printArray(pole);
}
}
</syntaxhighlight>
</tab>
</tabs>

==Selection Sort==
Coming soon :)

==Odkazy==
https://www.tutorialspoint.com/design_and_analysis_of_algorithms/design_and_analysis_of_algorithms_heapify_method.htm

Triedenie výberom

2021-04-10T10:35:25Z

Filip Tomek: /* Implementácia algoritmov Heapify a HeapSort v rôznych programovacích jazykoch */

[[Kategória:Algoritmy triedenia]]
{{Draft}}
{{Skripta programovanie}}
__TOC__
==Tento článok je v prvotnom štádiu konštrukcie, zatiaľ je to len hromada myšlienok :)==
odtiaľto sa odrazíme: https://en.wikipedia.org/wiki/Heapsort

==Heap Sort==

===Prehľad===
Heap Sort je triediaci algoritmus, ktorý podobne ako Selection sort rozeľuje pole na zotriedenú a nezotriedenú časť, pričom nezotriedená časť predstavuje dátovú štruktúru [[Hromada|binárna hromada]]. Celé triedenie spočíva v tom, že si zo vstupného poľa vytvoríme binárnu hromadu a následne postupným vyberaním a mazaním všetkých jej prvkov toto pole utriedime.

Hromada, ktorú využíva algoritmus Heap Sort, musí spĺňať nasledovné podmienky (ak indexujeme pole od 0):
:1. Vrchol hromady (koreň) je vždy prvý prvok v poli (v našom prípade prvok na 0-tej pozícii).
:2. Pre ľubovoľný prvok (uzol), uložený na indexe <math>i</math> z intervalu <math> \langle 0 \ ; \ \text{dĺžka} - 1 \rangle </math>, platia nasledovné rovnice:
:: <math>
\begin{align}
\text{ľavý potomok} &= 2i + 1 && (1) \\
\text{pravý potomok} &= 2i + 2 && (2) \\
\text{rodič} &= \left \lfloor \frac{i - 1}{2} \right \rfloor \quad (\text {okrem} \ i = 0) && (3)
\end{align}
</math>
:3. Každý prvok (uzol) v hromade musí mať väčšiu, alebo rovnakú hodnotu ako jeho potomkovia (MAX HEAP - ak triedime pole vzostupne, v opačnom prípade by sme použili MIN HEAP).

===Algoritmus Heapify===
[[Súbor:Heapify.png|vizualizácia|699px|náhľad|vpravo]]
Heapify je kľúčovým podprogramom triediaceho algoritmu Heap Sort, vďaka ktorému vieme efektíve zabezpečiť vytvorenie hromady z poľa a zmazanie hromady.

Princíp algoritmu Heapify spočíva v tom, že ak máme i-ty prvok v poli (v kompletnom binárnom strome), ktorého potomkovia tvoria dve samostatné podhromady, potom tieto dve podhromady zlúčime do jednej hromady, pričom i-ty prvok bude jej vrcholom.

====Vlastnosti algoritmu====
* dátová štruktúra: hromada (reprezentovaná ako: pole, strom)
* časová zložitosť: lineárna <math>O(n)</math>
* priestorová zložitosť: konštantná <math>O(1)</math> pri iteračnej verzii, <math>O(log(n))</math> pri rekurzívnej verzii

====Základné časti algoritmu====
# Určenie potomka s maximálnou hodnotou i-teho prvku.
# Porovnanie maximálneho potomka s rodičom (i-tym prvkom).
# Ak je potomok väčší ako rodič, tak výmena potomka a rodiča.
# Ak nastala výmena, skontrolovanie ovplyvneného potomka (podhromady).

====Slovný opis algoritmu====
Na vstupe prijmeme pole a index i, v ktorom chceme vytvoriť hromadu (Max Heap). Najskôr skontrolujeme, či prvok na indexe i má nejakých potomkov (využijeme rovnice (1) a (2) z časti "Prehľad"). Ak nemá žiadnych potomkov, funkcia skončí, pretože i predstavuje vrchol jednoprvkovej hromady. Ak má práve jedného potomka, tento potomok je zároveň jeho maximálnym potomkom. Ak má práve dvoch potomkov, tak porovnáme ich hodnoty a vyberieme z nich maximálneho potomka. Následne skontrolujeme veľkosť maximálneho potomka a jeho rodiča (prvok na indexe i). Ak je rodič väčší, funkcia skončí, pretože želaná hromada už je utvorená. Ak nie, vymeníme rodiča a maximálneho potomka. Ak nastala výmena, musíme skontrolovať ovplyvnenú podhromadu, tj. zopakovať tento sled krokov pre podhromadu, ktorej vrchol bude v maximálnom potomkovi i-teho prvku.

Z hľadiska implementácie môžeme vytvoriť iteračnú aj rekurzívnu verziu.

====Pseudokód====
<tabs>
<tab name="Iteračná verzia" block>
Nech funkcia Heapify má nasledovný prototyp: <code>Heapify(pole[], dlzka, i)</code>
:1. Je <code>2 * i + 1 < dlzka</code> ? Ak áno, pokračuj krokom 1.1., inak skonči.
:::1.1. Nech: <code>lavy = 2 * i + 1</code>
:::1.2. Nech: <code>pravy = 2 * i + 2</code>
:::1.3. Je <code>pravy < dlzka</code> a zároveň <code>pole[pravy] > pole[lavy]</code> ?
:::::Ak áno:
:::::::1.3.1. Nech: <code>max = pravy</code>
:::::Ak nie:
:::::::1.3.1. Nech: <code>max = lavy</code>
:::1.4. Je <code>pole[max] > pole[i]</code> ?
:::::Ak áno:
:::::::1.4.1. Vymeň: <code>pole[max]</code> a <code>pole[i]</code>
:::::::1.4.2. <code>i = max</code>
:::::Ak nie:
:::::::1.4.1 Skonči.
:::1.5. Skoč na krok 1.

</tab>

<tab name="Rekurzívna verzia" block>
Nech funkcia Heapify má nasledovný prototyp: <code>Heapify(pole[], dlzka, i)</code>
:1. Je <code>pole[2 * i + 1] >= pole[2 * i + 2]</code> ?
::: Ak áno:
:::::1.1. Nech: <code>max = pole[2 * i + 1]</code>
::: Ak nie:
:::::1.1. Nech: <code>max = pole[2 * i + 2]</code>
:2. Je <code>pole[max] > pole[i]</code> ?
::: Ak áno:
::::: 2.1. Vymeň: <code>pole[i] a pole[max]</code>
::::: 2.2. Rekurzívne zavolaj: <code>Heapify(pole[], dlzka, max)</code>
::: Ak nie:
::::: 2.1. Skonči volanie.
</tab>
</tabs>

===Algoritmus Heap Sort===
Heapsort pri triedení vykonáva dve základné úlohy: Vytvorenie maximálnej binárnej hromady zo vstupného poľa a mazanie jednotlivých prvkov z hromady. Pri oboch procedúrach využíva algoritmus Heapify

====Vlastnosti algoritmu====
* vhodný pre dátové štruktúry: pole
* časová náročnosť: vždy linearitmická <math> O(n\log(n)) </math>, vďaka ktorej dokáže efektívne triediť veľmi veľké polia
* priestorová náročnosť: konštantná <math>O(1)</math> pri iteračnej verzii, logaritmická <math>O(\log(n))</math> pri rekurzívnej verzii.
* druh triedenia: triedenie výberom (komparačný algoritmus)
* stabilita triedenia: nestabilný
* miesto triedenia: vnútorné triedenie
====Základné časti algoritmu====
# vytvorenie hromady
# zmazanie hromady

[[Súbor:HeapSort.png|500px|náhľad|vpravo]]

====Slovný opis====
=====Vytvorenie hromady=====
Pri vytváraní hromady využijeme algoritmus heapify, pričom hromadu vytvoríme spôsobom zospodu na vrch. Najskôr si určíme prvok ktorý je najspodnejší a najviac vpravo a zároveň má aspoň jedného potomka. Tento prvok určíme veľmi jednoducho, pretože zpberieme posledný prvok v poli, a pomocou rovnice 3, ktorú si jemne upravíme mu nájdeme rodiča: <center><math> \text{posledný rodič} = \left \lfloor \frac{\text{posledný index } - 1}{2} \right \rfloor = \left \lfloor\frac{\text{dĺžka } - 2}{2} \right \rfloor = \left \lfloor \frac{\text{dĺžka}}{2}\right \rfloor - 1 </math></center>
Následne zavoláme Heapify na podhromadu s vrcholom posledného rodiča. Potom zmenšíme o 1 a opakujeme tento proces , až kým neprídeme na začiatok. Schematicky by sme to mohli napísať takto:
<center><math> \text{pre } i \text{ z intervalu } \left \langle \left \lfloor \frac {\text{dĺžka}}{2} \right \rfloor - 1 \quad ; \quad 0 \right \rangle :\ \text{heapify( pole[], dĺžka, i )}</math></center>

=====Zmazanie hromady=====
Pri mazaní hromady vykonáme dve operácie. Ako prvé vymeníme prvok na vrchu hromady s koncovým prvkom hromady. Prvok čo je na komci považujeme za zmazaný, preto veľkosť hromady znížime o 1. Následne musíme zabezpečiť zachovanie pravidiel pre hromadu, takže zavoláme funkciu Heapify na celú hromadu (index i bude vrch hromady, čiže 0-tý prvok v poli). Tento proces opakujeme, poikiaľ v hromade neostanú žiadne prvky.

Poznámka: v našom prípade nemusíme mazať celú hromadu, ale iba do chvíle, keď nám neostane 1 prvok.

Schematicky by sme to mohli zapísať takto:
<center><math>\text{pre } j \text{ z intervalu } \left \langle \text{dĺžka - 1} \quad ; \quad 0 \right \rangle : \ \ \text{vymeň(pole[0], pole[$j$])} \ \ a \ \ \text{heapify(pole[], dĺžka, 0)} </math></center>

====Pseudokód====
Nech funkcia Heap Sort má nasledovný prototyp: <code>HeapSort(pole[], dlzka)</code>

:1. Nech: <code>i = dlzka / 2 - 1</code>, kde "/" predstavuje celočíslené delenie.
:2. Je <code>i >= 0</code> ? Ak áno, pokračuj krokom 2.1., inak skoč na krok 3.
:::2.1. Zavolaj funkciu <code>Heapify(pole[], dlzka, i)</code>
:::2.2. Skoč na krok 2.
:3. Nech: <code>j = dlzka - 1</code>
:4 Je <code> j > 0</code> ? Ak áno, pokračuj krokom 4.1, inak skonči.
:::4.1. Vymeň: <code>pole[0]</code> a <code>pole[j]</code>
:::4.2. Zavolaj funkciu <code>Heapify(pole[], dlzka, i)</code>
:::4.3. Skoč na krok 4.

===Implementácia algoritmov Heapify a HeapSort v rôznych programovacích jazykoch===
<tabs>
<tab name="Iteračná C" block>
<syntaxhighlight lang="C">

#include <stdio.h>

void Vymen(int *a, int *b);
void Heapify(int pole[], int dlzka, int index);
void HeapSort(int pole[], int dlzka);

int main()
{
int pole[]= {10, 5, 2, 9, 8, 7, 1, 3, 4, 0, -1};
int dlzka = sizeof(pole) / sizeof(pole[0]);

HeapSort(pole, dlzka);

for (int i = 0; i < dlzka; ++i)
{
printf("%d ", pole[i]);
}
}

void Vymen(int *a, int *b)
{
int tmp = *a;
*a = *b;
*b = tmp;
}

void Heapify(int pole[], int dlzka, int index)
{
int pravy, lavy, max;

while(2 * index + 1 < dlzka)
{
lavy = 2 * index + 1;
pravy = 2 * index + 2;

// určenie potomka s maximálnou hodnotou
if(pravy < dlzka && pole[pravy] > pole[lavy])
{
max = pravy;
}
else
{
max = lavy;
}

// porovnanie maximálneho potomka s rodičom
if(pole[max] > pole[index])
{

Vymen(&pole[max], &pole[index]);
index = max;
}
else
{
return;
}
}
}

void HeapSort(int pole[], int dlzka)
{
// vytvor maximálnu hromadu (procedúra BuildMaxHeap)
for (int i = dlzka / 2 - 1 ; i >= 0; --i)
{
Heapify(pole, dlzka, i);
}

// zmaž všetky prvky z hromady
for (int j = dlzka - 1; j > 0; --j)
{
Vymen(&pole[0], &pole[j]);
Heapify(pole, j, 0);
}
}
</syntaxhighlight>
</tab>
<tab name="Rekurzívna C" block>
<syntaxhighlight lang="C">
#include <stdio.h>

void Vymen(int *a, int *b);
void Heapify(int pole[], int dlzka, int index);
void HeapSort(int pole[], int dlzka);

int main()
{
int pole[]= {10, 5, 2, 9, 8, 7, 1, 3, 4, 0, -1, -1};
int dlzka = sizeof(pole) / sizeof(pole[0]);

HeapSort(pole, dlzka);

for (int i = 0; i < dlzka; ++i)
{
printf("%d ", pole[i]);
}
}

void Vymen(int *a, int *b)
{
int tmp = *a;
*a = *b;
*b = tmp;
}

void Heapify(int pole[], int dlzka, int index)
{

int lavy = 2 * index + 1;
int pravy = 2 * index + 2;
int max = index;

// určenie potomka s maximálnou hodnotou
if(lavy < dlzka && pole[lavy] >= pole[pravy])
{
max = lavy;
}

if(pravy < dlzka && pole[pravy] > pole[lavy])
{
max = pravy;
}

// porovnanie maximálneho potomka s rodičom
if(pole[max] > pole[index])
{
Vymen(&pole[max], &pole[index]);
Heapify(pole, dlzka, max);
}
}

void HeapSort(int pole[], int dlzka)
{
// vytvor maximálnu hromadu (procedúra BuildMaxHeap)
for (int i = dlzka / 2 - 1 ; i >= 0; --i)
{
Heapify(pole, dlzka, i);
}

// zmaž všetky prvky z hromady
for (int j = dlzka - 1; j > 0; --j)
{
Vymen(&pole[0], &pole[j]);
Heapify(pole, j, 0);
}
}
</syntaxhighlight>
</tab>

<tab name="Rekurzívna Java" block>
<syntaxhighlight lang="Java">
class HeapSortRE {
void heapify(int[] pole, int n, int i) {
int max = i; // rodič
int l = 2 * i + 1; // ľavý potomok
int p = 2 * i + 2; // pravý potomok

/* Ak je ľavý potomok väčší ako rodič */
if (l < n && pole[l] > pole[max])
max = l;

/* Ak je pravý potomok väčší ako rodič */
if (p < n && pole[p] > pole[max])
max = p;

/* Ak sa rodič v priebehu funkcie zmenil */
if (max != i) {
int swap = pole[i];
pole[i] = pole[max];
pole[max] = swap;

heapify(pole, n, max);
}
}

public void sort(int[] pole) {
int n = pole.length;

/* Vytvorenie hromadu */
for (int i = n / 2 - 1; i >= 0 ; i--)
heapify(pole, n, i);

/* Extrahovanie jednotlivých elemetov z hromady */
for (int i = n - 1; i > 0; i--) {
/* Presuň aktuálneho rodiča na koniec */
int swap = pole[0];
pole[0] = pole[i];
pole[i] = swap;

/* Zavolanie heapify na zredukovanú hromadu */
heapify(pole, i, 0);
}
}
}

public class Main {

static void printArray(int[] pole) {
int n = pole.length;

for (int i : pole)
System.out.print(i + " ");

System.out.println();
}

public static void main(String[] args) {
int[] pole = {12, 11, 13, 5, 6, 7};
int n = pole.length;

System.out.println("Pole pred zoradenim: ");
printArray(pole);

HeapSortRE hs = new HeapSortRE();
hs.sort(pole);

System.out.println("Pole po zoradeni: ");
printArray(pole);
}
}

</syntaxhighlight>
</tab>
</tabs>

==Selection Sort==
Coming soon :)

==Odkazy==
https://www.tutorialspoint.com/design_and_analysis_of_algorithms/design_and_analysis_of_algorithms_heapify_method.htm

Triedenie výberom

2021-04-08T13:34:06Z

Filip Tomek: /* Heap Sort */

Triedenie výberom

2021-04-08T13:19:54Z

Filip Tomek: /* Heap Sort */

Triedenie výberom

2021-04-08T13:18:23Z

Filip Tomek: /* Algoritmus Heap Sort */

Triedenie výberom

2021-04-08T13:14:22Z

Filip Tomek: /* Heap Sort */

Triedenie zlučovaním

2021-03-30T17:11:52Z

Filip Tomek: /* Zlučovací algoritmus Merge */

[[Kategória:Algoritmy triedenia]]
{{Draft}}
{{Skripta programovanie}}
__TOC__
==Zlučovací algoritmus Merge==
[[Súbor:Funkcia merge.png|500px|náhľad|vpravo|Vizualizácia funkcie ''Merge'': Máme pole prvkov ''p = [1, 3, 5, 2, 4, 6]'', ktoré je už čiastočne utriedené. Použijeme algoritmus ''Merge'', ktorý si vytvorí pomocné polia ''L = [1, 3, 5]'' a ''P = [2, 4, 6]''. Všetky polia indexujeme od ''0'', pričom pre pole ''p'' používame index ''k'', pre ''L'' index ''i'' a pre ''P'' index ''j''. Postupnosť krokov je označená číslicami 1 až 6.
]]

Princíp zlučovania tkvie v tom, že máme dva alebo viac utriedených zoznamov, ktoré skombinujeme do jedného utriedeného zoznamu (výsledný zoznam musí obsahovať všetky prvky z pôvodných zoznamov). Zoznam môže byť reprezentovaný ako dátová štruktúra pole alebo aj ako lineárny zoznam. V tomto článku sa zameriame na algoritmus pre dátovú štruktúru pole.

Algoritmus ''Merge'' tvorí kľúčovú časť triediaceho algoritmu ''Merge Sort''.

===Vlastnosti algoritmu===
* vhodný pre dátové štruktúry: pole, lineárny zoznam
* časová náročnosť: vždy lineárna <math>O(n)</math>
* priestorová náročnosť: lineárna <math>O(n)</math> pre pole (alokovanie pomocných polí), <math>O(1)</math> pre lineárny zoznam (pri lineárnom zozname netreba alokovať dočasné polia, stačí iba presmerovať smerníky)
* využitie: kľúčový podprogram pre triediaci algoritmus ''Merge Sort''

===Základné časti algoritmu===
# Vytvorenie pomocných polí.
# Prechádzanie pomocných polí a vyberanie minima z 2 prvkov.
# Vkladanie minima na začiatok výsledného poľa.
# Kopírovanie prvkov, ktoré ešte neboli porovnané, z pomocného poľa do výsledného poľa.

===Slovný opis algoritmu===
Nech máme vstupné pole, ktoré sa skladá z dvoch už utriedených polovíc. Vytvoríme si dve pomocné polia ''L'' a ''P'' a do každého z nich skopírujeme obsah jednej polovice (''L'' - ľavá polovica, ''P'' - pravá polovica). Potom súčasne prechádzame polia ''L'' a ''P'' od začiatku po koniec, pričom v každej iterácii porovnáme prvok poľa ''L'' s prvkom v poli ''P''. Z tejto dvojice následne vyberieme minimum, (keď triedime od najmenšieho po najväčší) ktoré vložíme na prvú voľnú pozíciu pôvodného poľa (na začiatku je to prvá pozícia poľa). Nakoniec zvýšime index pri vstupnom poli a pri pomocnom poli, z ktorého vyberáme daný prvok. Túto postupnosť krokov opakujeme, pokiaľ neprídeme na koniec jedného z polí ''P'' a ''L''. Ak nastane situácia, že prídeme na koniec jedného z pomocných polí (a v druhom nám ostali ešte nejaké prvky), potom už iba naspäť skopírujeme zbytok druhého pomocného poľa na koniec pôvodného poľa.

===Pseudokód===
Nech funkcia ''Merge'' má nasledovný prototyp: <code>Merge(pole[], lavy, stred, pravy)</code>
:1. Je <code>lavy >= pravy ? Ak áno, skonči, inak pokračuj krokom 2.</code>
:2. Nech: <code>i = 0, j = 0, k = lavy </code>
:3. Nech: <code>dlzka_L = stred - lavy + 1, dlzka_P = pravy - stred</code>
:4. Nech: <code> L = pole[lavy ... stred], P = pole[stred + 1 ... pravy] </code>
:5. Je <code>i < dlzka_L</code> a zároveň <code>j < dlzka_P</code> ? Ak áno, pokračuj krokom 5.1., inak skoč na krok 6.
:::5.1. Je <code>L[i] <= P[j]</code>?
:::: Ak áno:
:::::5.1.1. <code>pole[k] = L[i]</code>
:::::5.1.2. <code>k += 1</code>
:::::5.1.3. <code>i += 1</code>
:::::5.1.4. Skoč na krok 5.
:::: Ak nie:
:::::5.1.1. <code>pole[k] = P[j]</code>
:::::5.1.2. <code>k += 1</code>
:::::5.1.3. <code>j += 1</code>
:::::5.1.4. Skoč na krok 5.
:6. Je <code>i < dlzka_L</code> ? Ak áno, pokračuj krokom 6.1., inak skoč na krok 7.
:::6.1. <code>pole[k] = L[i]</code>
:::6.2. <code>k += 1</code>
:::6.3. <code>i += 1</code>
:::6.4. Skoč na krok 6.
:7. Je <code>j < dlzka_P</code> ? Ak áno, pokračuj krokom 7.1., inak skonči.
:::7.1. <code>pole[k] = P[j]</code>
:::7.2. <code>k += 1</code>
:::7.3. <code>j += 1</code>
:::7.4. Skoč na krok 7.

==Merge Sort==
''Merge Sort'' je triediaci algoritmus, ktorý využíva stratégiu '''"rozdeľuj a panuj"''', čo znamená, že vstupný zoznam najskôr rozdelí na menšie časti, tie zoradí a potom ich zlúči naspäť dokopy. Radí sa medzi najpoužívanejšie a najviac rešpektované triediace algoritmy.

===Vlastnosti algoritmu Merge Sort===
* vhodný pre dátové štruktúry: pole, lineárny zoznam
* časová náročnosť: vždy linearitmická <math> O(n.log(n)) </math>, vďaka ktorej dokáže efektívne triediť veľmi veľké zoznamy
* priestorová náročnosť: lineárna <math>O(n)</math> pre pole (alokovanie dočasných polí), konštantná <math>O(1)</math> pre lineárny zoznam (pri lineárnom zozname stačí iba presmerovať smerníky)
* druh triedenia: triedenie zlučovaním (komparačný algoritmus)
* stabilita triedenia: stabilný
* miesto triedenia: externé triedenie (vhodný na triedenie veľkých objemov dát uložených na disku)

Z hľadiska implementácie môžeme vytvoriť dve základné verzie algoritmu, a to ''rekurzívnu'' a ''iteračnú''.

===Opis rekurzívnej a iteračnej verzie algoritmu Merge Sort===

<tabs>
<tab name="Rekurzívna verzia" block>
[[Súbor:Merge sort.png|400px|náhľad|vpravo|Vizualizácia rekurzívnej verzie algoritmu Merge Sort: chronologický priebeh algoritmu je znázornený číslicami 1 až 19.]]

===Základné časti algoritmu===
# Delenie poľa na dve polovice.
# Triedenie ľavej polovice poľa.
# Triedenie pravej polovice poľa.
# Zlúčenie oboch polovíc pomocou funkcie ''Merge''.

===Slovný opis===
Našou úlohou je vzostupne (min -> max) utriediť vstupné pole. Určíme si stred poľa (pri párnom počte prvkov je to ten menší z prostredných indexov). Následne vykonávame sériu rekurzívnych delení pre ľavú a pravú časť poľa (''začiatok ... stred ; stred + 1 ... koniec'') až do momentu, keď nám ostanú len jednoprvkové podpolia (tie sú už utriedené). Následne v každom volaní obe tieto podpolia zlúčime pomocou algoritmu ''Merge'' do väčších podpolí (max: 2, 4, 8, ...), až nakoniec dostaneme jedno výsledné utriedené pole.

===Pseudokód===
Nech má funkcia ''MergeSort'' nasledovný prototyp: <code>MergeSort(pole[], lavy, pravy) </code>
:1. Je <code>lavy >= pravy</code> ? Ak áno, skonči volanie, inak pokračuj krokom 2.
:2. Nech: <code>stred = lavy + (pravy - lavy) / 2</code>, pričom znak ''/'' vyjadruje celočíselné delenie.
:3. Rekurzívne zavolaj funkciu <code>MergeSort(pole[], lavy , stred)</code>
:3. Rekurzívne zavolaj funkciu <code>MergeSort(pole[], stred + 1 , pravy)</code>
:4. Zavolaj funkciu <code>Merge(pole[], lavy, stred, pravy)</code>
:5. Skonči volanie.

</tab>
<tab name="Iteračná verzia" block>
[[Súbor:MergeSort IT.png|400px|náhľad|Vizualizácia iteračnej verzie algoritmu Merge Sort: chronologický priebeh algoritmu je znázornený číslicami 1 až 7.|vpravo]]

===Základné časti algoritmu===
# Určenie maximálnej veľkosti podpoľa na zlučovanie.
# Prechádzanie jednotlivých podpolí v poli.
# Zlučovanie jednotlivých podpolí pomocou funkcie ''Merge''.

===Slovný opis===
Vstupné pole, ktoré má ''N'' prvkov, môžeme chápať, ako ''N'' rôznych jednoprvkových (utriedených) podpolí, ktoré máme zlúčiť do jedného výsledného ''N'' - prvkového utriedeného poľa. Keďže by bolo veľmi nepraktické zlučovať ''N'' podpolí naraz, zvolíme nasledovnú stratégiu: Budeme prechádzať dané pole od začiatku po koniec a v prvej iterácii zlúčime každé dva prvky, čím dostaneme <math>\frac{N}{2}</math> dvojprvkových utriedených podpolí. Potom v druhej iterácii zlúčime každé 4 prvky do jedného podpoľa, v treťom cykle každých 8, ..., až do momentu, keď dostaneme jedno výsledné utriedené pole.
Aby sme mohli túto stratégiu implementovať, potrebujeme dva cykly: vonkajší, ktorý nastaví maximálnu veľkosť podpoľa, ktoré ideme zlučovať (1,2,4,8 ... ''dlzka - 1'') a vnútorný, ktorý prechádza jednotlivé podpolia. Následne už iba voláme funkciu ''Merge'', ktorá dané podpolia zlučuje.

Poznámka, ak máme ''pole'', ktoré má nepárny počet prvkov, tak ten posledný prvok nezlúčime hneď v prvej iterácii, ale až v tých ďalších. Takisto, ak ''N'' nie je mocnina čísla 2, tak musíme samozrejme ošetriť situáciu, kedy by sme sa dostali mimo rozsah poľa (Ak máme napríklad ''pole'', čo má 7 prvkov, tak po prvej iterácii budú prvky utiredené podľa vzoru 2 + 2 + 2 + 1, po druhej 4 + 3, a po tretej 7 + 0)

===Pseudokód===
Nech nech má funkcia ''MergeSort'' nasledovný prototyp: <code>MergeSort(pole[], lavy, pravy) </code>
:1. Je <code>lavy >= pravy</code> ? Ak áno, skonči, inak pokračuj krokom 2.
:2. Nech: <code>dlzka_podpola = 1 </code>
:3. Nech: <code>zaciatok = lavy</code>
:4. Je <code>dlzka_podpola <= pravy</code> ? Ak áno pokračuj krokom 4.1, inak skonči.
:::4.1. Je <code>zaciatok < pravy</code> Ak áno pokračuj krokom 4.1.1, inak skoč na krok 4.2.
:::::4.1.1. Je <code>zaciatok + 2 * dlzka_zoznamu - 1 <= pravy</code> ?
:::::::Ak áno:
:::::::::4.1.1.1. Nech: <code>koniec = zaciatok + 2 * dlzka_podpola - 1</code>
:::::::Ak nie:
:::::::::4.1.1.1. Nech: <code>koniec = pravy</code>
:::::4.1.2. Je <code>zaciatok + dlzka_podpola - 1 <= pravy</code> ?
:::::::Ak áno:
:::::::::4.1.2.1. Nech <code>stred = zaciatok + dlzka_podpola - 1</code>
:::::::Ak nie:
:::::::::4.1.2.1. Nech <code>stred = pravy</code>
:::::4.1.3. <code>Merge(pole[], zaciatok, stred, koniec)</code>
:::::4.1.4. <code>zaciatok += 2 * dlzka_podpola</code>
:::::4.1.5. Skoč na krok 4.1.
:::4.2. <code>dlzka_podpole *= 2</code>
:::4.3 Skoč na krok 4.

</tab>
</tabs>

==Implementácia algoritmov Merge a MergeSort v rôznych programovacích jazykoch==
<tabs>
<tab name="Rekurzívna: C " block>
<syntaxhighlight lang="C">
#include <stdio.h>
#include <stdlib.h>

void Merge(int pole[], int lavy, int stred, int pravy);
void MergeSort(int pole[], int lavy, int pravy);

/* hlavný program */

int main()
{
int pole[] = {12, 11, 13, 5, 6, 7};
int dlzka_pola = sizeof(pole) / sizeof(pole[0]);

printf("Pôvodné pole: \n");

for (int i = 0; i < dlzka_pola; ++i)
{
printf("%d ", pole[i]);
}

MergeSort(pole, 0, dlzka_pola - 1);

printf("\nUtriedené pole: \n");

for (int i = 0; i < dlzka_pola; ++i)
{
printf("%d ", pole[i]);
}

return 0;
}

void Merge(int pole[], int lavy, int stred, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči */

if (lavy >= pravy)
{
return;
}

/* vyrátaj dĺžky oboch polovíc poľa */

int L_dlzka = stred - lavy + 1;
int P_dlzka = pravy - stred;

/* alokuj dočasné polia, kam uložíš prvky z oboch polovíc poľa */

int *L = (int*)malloc(L_dlzka * sizeof(int));
int *P = (int*)malloc(P_dlzka * sizeof(int));

/* indexy, ktorými iterujeme všetky polia: i pre L, j pre P, k pre pole */

int i, j, k;

/* skopíruj obsah oboch polovíc poľa do dočasných polí L a P */

for (i = 0; i < L_dlzka; ++i)
{
L[i] = pole[lavy + i];
}

for (j = 0; j < P_dlzka; ++j)
{
P[j] = pole[stred + 1 + j];
}

/* nastav indexy na začiatok daných polí */

i = 0; j = 0; k = lavy;

/* zlučuj dočasné polia L a P do finálneho poľa pole */

while(i < L_dlzka && j < P_dlzka)
{
if(L[i] <= P[j])
{
pole[k++] = L[i++];
}
else
{
pole[k++] = P[j++];
}
}

/* ak ostali nejaké prvky v dočasnom poli L, skopíruj ich do finálneho poľa */

while(i < L_dlzka)
{
pole[k++] = L[i++];
}

/* ak ostali nejaké prvky v dočasnom poli P, skopíruj ich do finálneho poľa */

while(j < P_dlzka)
{
pole[k++] = P[j++];
}

/* uvoľni použitú pamäť */

free(L);
free(P);
}

void MergeSort(int pole[], int lavy, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči volanie */

if(lavy >= pravy)
{
return;
}
/* urči si prostredný index */

int stred = lavy + (pravy - lavy) / 2;

/* utrieď ľavú polovicu poľa */

MergeSort(pole, lavy, stred);

/* utrieď pravú polovicu poľa */

MergeSort(pole, stred+1, pravy);

/* zlúč obe polovice dokopy */

Merge(pole, lavy, stred, pravy);
}
</syntaxhighlight>
</tab>

<tab name="Iteračná: C" block>
<syntaxhighlight lang="C">
#include <stdio.h>
#include <stdlib.h>

void Merge(int pole[], int lavy, int stred, int pravy);
void MergeSortIt(int *pole, int lavy, int pravy);

/* hlavný program */

int main()
{
int pole[] = {12, 11, 13, 5, 6, 7, 19};
int dlzka_pola = sizeof(pole) / sizeof(pole[0]);

printf("Pôvodné pole %d: \n", dlzka_pola);

for (int i = 0; i < dlzka_pola; ++i)
{
printf("%d ", pole[i]);
}

MergeSortIt(pole, 0, dlzka_pola - 1);

printf("\nUtriedené pole: \n");

for (int i = 0; i < dlzka_pola; ++i)
{
printf("%d ", pole[i]);
}

return 0;
}

void Merge(int pole[], int lavy, int stred, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči */

if (lavy >= pravy)
{
return;
}

/* vyrátaj dĺžky oboch polovíc poľa */

int L_dlzka = stred - lavy + 1;
int P_dlzka = pravy - stred;

/* alokuj dočasné polia, kam uložíš prvky z oboch polovíc poľa */

int *L = (int*)malloc(L_dlzka * sizeof(int));
int *P = (int*)malloc(P_dlzka * sizeof(int));

/* indexy, ktorými iterujeme všetky polia: i pre L, j pre P, k pre pole */

int i, j, k;

/* skopíruj obsah oboch polovíc poľa do dočasných polí L a P */

for (i = 0; i < L_dlzka; ++i)
{
L[i] = pole[lavy + i];
}

for (j = 0; j < P_dlzka; ++j)
{
P[j] = pole[stred + 1 + j];
}

/* nastav indexy na začiatok daných polí */

i = 0; j = 0; k = lavy;

/* zlučuj dočasné polia L a P do finálneho poľa pole */

while(i < L_dlzka && j < P_dlzka)
{
if(L[i] <= P[j])
{
pole[k++] = L[i++];
}
else
{
pole[k++] = P[j++];
}
}

/* ak ostali nejaké prvky v dočasnom poli L, skopíruj ich do finálneho poľa */

while(i < L_dlzka)
{
pole[k++] = L[i++];
}

/* ak ostali nejaké prvky v dočasnom poli P, skopíruj ich do finálneho poľa */

while(j < P_dlzka)
{
pole[k++] = P[j++];
}

/* uvoľni použitú pamäť */

free(L);
free(P);
}

void MergeSortIt(int *pole, int lavy, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči volanie */

if(lavy >= pravy)
{
return;
}

int stred, koniec;

for (int dlzka_podpola = 1; dlzka_podpola <= pravy; dlzka_podpola *= 2)
{
for (int zaciatok = lavy; zaciatok < pravy; zaciatok += 2 * dlzka_podpola)
{
koniec = (zaciatok + 2 * dlzka_podpola - 1 <= pravy) ? zaciatok + 2 * dlzka_podpola - 1 : pravy;

stred = (zaciatok + dlzka_podpola - 1 <= pravy) ? zaciatok + dlzka_podpola - 1 : pravy;

Merge(pole, zaciatok, stred, koniec);

}
}
}
</syntaxhighlight>
</tab>

<tab name="Rekurzívna: C++" block>
<syntaxhighlight lang="C++">
#include <iostream>

using std::cout;
using std::endl;

void Merge(int pole[], int lavy, int stred, int pravy);
void MergeSort(int pole[], int lavy, int pravy);

/* hlavný program */

int main()
{
int pole[] = {12, 11, 13, 5, 6, 7};
int dlzka_pola = sizeof(pole) / sizeof(pole[0]);

printf("Pôvodné pole: \n");

for (auto i: pole)
{
cout<<i<<" ";
}

MergeSort(pole, 0, dlzka_pola - 1);

cout<<endl<<"Utriedené pole:"<<endl;

for (auto i: pole)
{
cout<<i<<" ";
}

return 0;
}

void Merge(int pole[], int lavy, int stred, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči */

if (lavy >= pravy)
{
return;
}

/* vyrátaj dĺžky oboch polovíc poľa */

int L_dlzka = stred - lavy + 1;
int P_dlzka = pravy - stred;

/* alokuj dočasné polia, kam uložíš prvky z oboch polovíc poľa */

int *L = new int[L_dlzka];
int *P = new int[P_dlzka];

/* indexy, ktorými iterujeme všetky polia: i pre L, j pre P, k pre pole */

int i, j, k;

/* skopíruj obsah oboch polovíc poľa do dočasných polí L a P */

for (i = 0; i < L_dlzka; ++i)
{
L[i] = pole[lavy + i];
}

for (j = 0; j < P_dlzka; ++j)
{
P[j] = pole[stred + 1 + j];
}

/* nastav indexy na začiatok daných polí */

i = 0; j = 0; k = lavy;

/* zlučuj dočasné polia L a P do finálneho poľa pole */

while(i < L_dlzka && j < P_dlzka)
{
if(L[i] <= P[j])
{
pole[k++] = L[i++];
}
else
{
pole[k++] = P[j++];
}
}

/* ak ostali nejaké prvky v dočasnom poli L, skopíruj ich do finálneho poľa */

while(i < L_dlzka)
{
pole[k++] = L[i++];
}

/* ak ostali nejaké prvky v dočasnom poli P, skopíruj ich do finálneho poľa */

while(j < P_dlzka)
{
pole[k++] = P[j++];
}

/* uvoľni použitú pamäť */

delete []L;
delete []P;
}

void MergeSort(int pole[], int lavy, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči volanie */

if(lavy >= pravy)
{
return;
}
/* urči si prostredný index */

int stred = lavy + (pravy - lavy) / 2;

/* utrieď ľavú polovicu poľa */

MergeSort(pole, lavy, stred);

/* utrieď pravú polovicu poľa */

MergeSort(pole, stred+1, pravy);

/* zlúč obe polovice dokopy */

Merge(pole, lavy, stred, pravy);
}

</syntaxhighlight>
</tab>

<tab name="Iteračná: C++" block>
<syntaxhighlight lang="C++">
#include <iostream>

using std::cout;
using std::endl;

void Merge(int pole[], int lavy, int stred, int pravy);
void MergeSortIt(int *pole, int lavy, int pravy);

/* hlavný program */

int main()
{
int pole[] = {12, 11, 13, 5, 6, 7};
int dlzka_pola = sizeof(pole) / sizeof(pole[0]);

printf("Pôvodné pole: \n");

for (auto i: pole)
{
cout<<i<<" ";
}

MergeSortIt(pole, 0, dlzka_pola - 1);

cout<<endl<<"Utriedené pole:"<<endl;

for (auto i: pole)
{
cout<<i<<" ";
}

return 0;
}

void Merge(int pole[], int lavy, int stred, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči */

if (lavy >= pravy)
{
return;
}

/* vyrátaj dĺžky oboch polovíc poľa */

int L_dlzka = stred - lavy + 1;
int P_dlzka = pravy - stred;

/* alokuj dočasné polia, kam uložíš prvky z oboch polovíc poľa */

int *L = new int[L_dlzka];
int *P = new int[P_dlzka];

/* indexy, ktorými iterujeme všetky polia: i pre L, j pre P, k pre pole */

int i, j, k;

/* skopíruj obsah oboch polovíc poľa do dočasných polí L a P */

for (i = 0; i < L_dlzka; ++i)
{
L[i] = pole[lavy + i];
}

for (j = 0; j < P_dlzka; ++j)
{
P[j] = pole[stred + 1 + j];
}

/* nastav indexy na začiatok daných polí */

i = 0; j = 0; k = lavy;

/* zlučuj dočasné polia L a P do finálneho poľa pole */

while(i < L_dlzka && j < P_dlzka)
{
if(L[i] <= P[j])
{
pole[k++] = L[i++];
}
else
{
pole[k++] = P[j++];
}
}

/* ak ostali nejaké prvky v dočasnom poli L, skopíruj ich do finálneho poľa */

while(i < L_dlzka)
{
pole[k++] = L[i++];
}

/* ak ostali nejaké prvky v dočasnom poli P, skopíruj ich do finálneho poľa */

while(j < P_dlzka)
{
pole[k++] = P[j++];
}

/* uvoľni použitú pamäť */

delete []L;
delete []P;
}

void MergeSortIt(int *pole, int lavy, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči volanie */

if(lavy >= pravy)
{
return;
}

int stred, koniec;

for (int dlzka_podpola = 1; dlzka_podpola <= pravy; dlzka_podpola *= 2)
{
for (int zaciatok = lavy; zaciatok < pravy; zaciatok += 2 * dlzka_podpola)
{
koniec = (zaciatok + 2 * dlzka_podpola - 1 <= pravy) ? zaciatok + 2 * dlzka_podpola - 1 : pravy;

stred = (zaciatok + dlzka_podpola - 1 <= pravy) ? zaciatok + dlzka_podpola - 1 : pravy;

Merge(pole, zaciatok, stred, koniec);
}
}
}
</syntaxhighlight>
</tab>

<tab name="Rekurzívna: Java" block>
<syntaxhighlight lang="Java">
class MergeSort
{

/* Funkcia zlúči 2 podpolia, ktoré sme vytvorili z pôvodného poľa.
* Každé podpole má polovičnú dĺžku pôvodného poľa.
* podpole1 [ľavý ... stred]
* podpole2 [stred + 1 ... pravý]
*/

void merge(int[] pole, int lavy, int stred, int pravy)
{

// Výpočet dĺžky 2 podpolí

int n1 = stred - lavy + 1;
int n2 = pravy - stred;

// Vytvorenie pomocných polí

int[] L = new int[n1];
int[] P = new int[n2];

// Načítanie dát do pomocných polí

for (int i = 0; i < n1; i++)
L[i] = pole[lavy + i];

for (int j = 0; j < n2; j++)
P[j] = pole[stred + 1 + j];

// Počiatočné indexy prvého a druhého podpoľa

int i = 0, j = 0;

// Počiatočný index zlúčeného podpoľa

int k = lavy;

// Zlúčenie dvoch podpolí

while (i < n1 && j < n2)
{
if (L[i] <= P[j])
{
pole[k] = L[i];
i++;
}
else
{
pole[k] = P[j];
j++;
}
k++;
}

/* V prípade, že sa v jednom zo podpolí nachádzajú ešte nejaké prvky, ktoré neboli zlúčené do poľa,
* tak sa do poľa jednoducho skopírujú
*/

while (i < n1)
{
pole[k] = L[i];
i++;
k++;
}

while (j < n2)
{
pole[k] = P[j];
k++;
j++;
}

}

/* Funkcia, ktorá zoradí pole použitím funkcie merge() */

void sort (int[] pole, int lavy, int pravy)
{
if (lavy < pravy)
{
// Musíme nájsť stred poľa

int stred = lavy + (pravy - lavy) / 2;

// Zoradíme prvú a druhú polovicu poľa samostatne

sort(pole, lavy, stred);
sort(pole, stred + 1, pravy);

// Zlúčime zoradené polovice do jedného poľa

merge(pole, lavy, stred, pravy);
}
}
}

public class Main
{
/* Funkcia na výpis poľa dĺžky n */

static void vypis_pole(int[] pole)
{

for (int j : pole)
{
System.out.print(j + " ");
}

System.out.println();
}

/* Hlavný program */

public static void main(String[] args)
{
int[] pole = {12, 11, 13, 5, 6, 7};

System.out.println("Zadané pole:");
vypis_pole(pole);

MergeSort ms = new MergeSort();
ms.sort(pole, 0, pole.length - 1);

System.out.println("\nZoradené pole:");
vypis_pole(pole);
}
}
</syntaxhighlight>
</tab>

<tab name="Iteračná: Java" block>
<syntaxhighlight lang="Java">
class MergeSort_iteracia
{
/* Zlúči 2 podpolia, ktoré sa vytvorili z pôvodného poľa.
* Každé podpole má polovičnú dĺžku pôvodného poľa.
* podpole1 [ľavý..stred]
* podpole2 [stred+1..pravý]
*/

void merge(int[] pole, int lavy, int stred, int pravy)
{
// Výpočet dĺžky 2 podpolí

int n1 = stred - lavy + 1;
int n2 = pravy - stred;

// Vytvorenie pomocných polí

int[] L = new int[n1];
int[] P = new int[n2];

// Načítanie dát do pomocných polí

for (int i = 0; i < n1; i++)
L[i] = pole[lavy + i];

for (int j = 0; j < n2; j++)
P[j] = pole[stred + 1 + j];

// Počiatočné indexy prvého a druhého podpoľa

int i = 0, j = 0;

// Počiatočný index zlúčeného podpoľa

int k = lavy;

// Zlúčenie dvoch podpolí

while (i < n1 && j < n2)
{
if (L[i] <= P[j])
{
pole[k] = L[i];
i++;
}
else
{
pole[k] = P[j];
j++;
}
k++;
}

/* V prípade, že v jednom z podpolí sa nachádzajú prvky, ktoré neboli zlúčené do poľa,
* tak sa do poľa jednoducho skopírujú
*/

while (i < n1)
{
pole[k] = L[i];
i++;
k++;
}

while (j < n2)
{
pole[k] = P[j];
k++;
j++;
}
}

/* Funkcia, ktorá zoradí pole použitím funkcie merge() */

void sort (int[] pole, int n)
{
/* Dĺžka podpolí, ktoré majú byť zlúčené, hodnoty premennej sa pohybujú v intervale <1;n-1> */

int aktual_dlzka;

/* Začiatočný index ľavého podpoľa, ktoré má byť zlúčené */

int zaciatok_vlavo;

/* Vzostupné usporiadanie prvkov. Najskôr sa zlúčia podpolia veľkosti 1 do podpolí veľkosti 2,
* potom podpolia veľkosti 2 do podpolí veľkosti 4 a tak ďalej
*/

for (aktual_dlzka = 1; aktual_dlzka <= n - 1; aktual_dlzka *= 2)
{
/* Určenie začiatočného prvku rôznych podpolí aktuálnej dĺžky podpoľa */

for (zaciatok_vlavo = 0; zaciatok_vlavo < n - 1; zaciatok_vlavo += 2 * aktual_dlzka)
{
/* Nájdenie konečného prvku ľavého podpoľa, stred+1 je začiatočný prvok pravého podpoľa */

int stred = Math.min(zaciatok_vlavo + aktual_dlzka - 1, n - 1);
int koniec_vpravo = Math.min(zaciatok_vlavo + 2 * aktual_dlzka - 1, n - 1);

/* Zlúči podpolia L[zaciatok_vlavo .. stred] & P[stred+1 .. koniec_vpravo] */

merge(pole, zaciatok_vlavo, stred, koniec_vpravo);
}
}
}
}

public class Main {

/* Funkcia na výpis poľa dĺžky n */

static void vypis_pole(int[] pole)
{
int n = pole.length;

for (int j : pole)
{
System.out.print(j + " ");
}
System.out.println();
}

/* Hlavný program */

public static void main(String[] args) {

/* Inicializácia poľa */

int[] pole = {12, 11, 13, 5, 6, 7};

System.out.println("Zadané pole:");
vypis_pole(pole);

MergeSort_iteracia ms_it = new MergeSort_iteracia();
ms_it.sort(pole, pole.length);

System.out.println("Zoradené pole:");
vypis_pole(pole);
}
}
</syntaxhighlight>
</tab>

<tab name="Rekurzívna: Python3" block>
<syntaxhighlight lang="Python3">
def MergeSort(pole):
if len(pole) > 1:

# Nájdenie stredu poľa
# zápis len(pole)//2 znamená, že dĺžka poľa sa vydelí 2 a výsledok je celé číslo

stred = len(pole) // 2

# Rozdelenie poľa na dve časti

L = pole[:stred]
P = pole[stred:]

# Zoradenie najskôr prvej časti poľa, potom druhej

MergeSort(L)
MergeSort(P)

i = j = k = 0

# Zlúčenie a zoradenie údajov z pomocných polí do jedného poľa

while i < len(L) and j < len(P):
if L[i] < P[j]:
pole[k] = L[i]
i += 1
else:
pole[k] = P[j]
j += 1
k += 1

# Kontrola či všetky prvky boli zlúčené dokopy,
# ak nie, tak sa do zlúčeného poľa jednoducho skopírujú

while i < len(L):
pole[k] = L[i]
i += 1
k += 1

while j < len(P):
pole[k] = P[j]
j += 1
k += 1

# Hlavný program

if __name__ == '__main__':

pole = [12, 11, 13, 5, 6, 7]

print("Zadané pole:", end="\n")
print(pole, end="\n")

MergeSort(pole)

print("Zoradené pole:", end="\n")
print(pole, end="\n")

</syntaxhighlight>
</tab>

<tab name="Iteračná: Python3" block>
<syntaxhighlight lang="Python3">
def MergeSort_iteracia(pole):

# Dĺžka podpolí, ktoré majú byť zlúčené, hodnoty premennej sa pohybujú v intervale <1;n-1>

aktual_dlzka = 1

# Vonkajší cyklus, ktorý určuje podpolia aktuálnej dĺžky

while aktual_dlzka < len(pole) - 1:

lavy = 0

# Vnútorný cyklus, ktorý slúži na zlúčenie a zoradenie podpolí do jedného podpoľa

while lavy < len(pole) - 1:

# Index stredného prvku sa určí, keď k indexu ľavého prvku podpoľa pripočítame aktuálnu
# dĺžku podpolí a odčítame 1

stred = min((lavy + aktual_dlzka - 1), len(pole) - 1)

# Ak platí podmienka 2 * aktuálna dĺžka < dĺžka poľa - 1, tak pravý index = aktuálnej dĺžke subpolí,
# inak pravý index = dĺžka poľa - 1

pravy = ((2 * aktual_dlzka + lavy - 1, len(pole) - 1)[2 * aktual_dlzka + lavy - 1 > len(pole) - 1])

# Volanie funkcie merge

merge(pole, lavy, stred, pravy)

lavy = lavy + 2 * aktual_dlzka

# Aktuálna dĺžka sa sa zmení na dvojnásobok jej predošlej hodnoty

aktual_dlzka = 2 * aktual_dlzka

def merge(pole, lavy, stred, pravy):

n1 = stred - lavy + 1
n2 = pravy - stred

# Inicializácia pomocných polí

L = [0] * n1
P = [0] * n2

# Načítanie dát do pomocných polí

for i in range(0, n1):
L[i] = pole[lavy + i]
for i in range(0, n2):
P[i] = pole[stred + i + 1]

i, j, k = 0, 0, lavy

# Zlúčenie a zoradenie údajov z pomocných polí do jedného poľa

while i < n1 and j < n2:
if L[i] > P[j]:
pole[k] = P[j]
j += 1
else:
pole[k] = L[i]
i += 1
k += 1

# Kontrola či všetky prvky boli zlúčené dokopy,
# ak nie, tak sa do zlúčeného pola jednoducho skopírujú

while i < n1:
pole[k] = L[i]
i += 1
k += 1

while j < n2:
pole[k] = P[j]
j += 1
k += 1

# Hlavný program

if __name__ == '__main__':

pole = [12, 11, 13, 5, 6, 7]

print("Zadané pole:", end="\n")
print(pole, end="\n")

MergeSort_iteracia(pole)

print("Zoradené pole:", end="\n")
print(pole, end="\n")

</syntaxhighlight>
</tab>

</tabs>

==Odkazy==
# https://www.geeksforgeeks.org/merge-sort/
# https://www.geeksforgeeks.org/iterative-merge-sort/
# https://medium.com/@paulsoham/merge-sort-63d75df76388
# https://www.khanacademy.org/computing/computer-science/algorithms/merge-sort/a/overview-of-merge-sort
# https://www.tutorialspoint.com/data_structures_algorithms/merge_sort_algorithm.htm
# https://www.youtube.com/watch?v=6pV2IF0fgKY
# https://www.youtube.com/watch?v=mB5HXBb_HY8
# https://www.youtube.com/watch?v=ak-pz7tS5DE

Triedenie zlučovaním

2021-03-29T18:03:38Z

Filip Tomek: /* Opis rekurzívnej a iteračnej verzie algoritmu Merge Sort */

[[Kategória:Algoritmy triedenia]]
{{Draft}}
{{Skripta programovanie}}
__TOC__
==Zlučovací algoritmus Merge==
[[Súbor:Funkcia merge.png|500px|náhľad|vpravo|Vizualizácia funkcie ''Merge'': Máme pole prvkov ''p = [1, 3, 5, 2, 4, 6]'', ktoré je už čiastočne utriedené. Použijeme algoritmus ''Merge'', ktorý si vytvorí pomocné polia ''L = [1, 3, 5]'' a ''P = [2, 4, 6]''. Všetky polia indexujeme od ''0'', pričom pre pole ''p'' používame index ''k'', pre ''L'' index ''i'' a pre ''P'' index ''j''. Postupnosť krokov je označená číslicami 1 až 6.
]]

Princíp zlučovania tkvie v tom, že máme dva alebo viac utriedených zoznamov, ktoré skombinujeme do jedného utriedeného zoznamu (výsledný zoznam musí obsahovať všetky prvky z pôvodných zoznamov). Zoznam môže byť reprezentovaný ako dátová štruktúra pole alebo aj ako lineárny zoznam. V tomto článku sa zameriame na algoritmus pre dátovú štruktúru pole.

Algoritmus ''Merge'' tvorí kľúčovú časť triediaceho algoritmu ''Merge Sort''.

===Základné časti algoritmu===
# Vytvorenie pomocných polí.
# Prechádzanie pomocných polí a vyberanie minima z 2 prvkov.
# Vkladanie minima na začiatok výsledného poľa.
# Kopírovanie prvkov, ktoré ešte neboli porovnané, z pomocného poľa do výsledného poľa.

===Slovný opis algoritmu===
Nech máme vstupné pole, ktoré sa skladá z dvoch už utriedených polovíc. Vytvoríme si dve pomocné polia ''L'' a ''P'' a do každého z nich skopírujeme obsah jednej polovice (''L'' - ľavá polovica, ''P'' - pravá polovica). Potom súčasne prechádzame polia ''L'' a ''P'' od začiatku po koniec, pričom v každej iterácii porovnáme prvok poľa ''L'' s prvkom v poli ''P''. Z tejto dvojice následne vyberieme minimum, (keď triedime od najmenšieho po najväčší) ktoré vložíme na prvú voľnú pozíciu pôvodného poľa (na začiatku je to prvá pozícia poľa). Nakoniec zvýšime index pri vstupnom poli a pri pomocnom poli, z ktorého vyberáme daný prvok. Túto postupnosť krokov opakujeme, pokiaľ neprídeme na koniec jedného z polí ''P'' a ''L''. Ak nastane situácia, že prídeme na koniec jedného z pomocných polí (a v druhom nám ostali ešte nejaké prvky), potom už iba naspäť skopírujeme zbytok druhého pomocného poľa na koniec pôvodného poľa.

===Vlastnosti algoritmu===
* vhodný pre dátové štruktúry: pole, lineárny zoznam
* časová náročnosť: vždy lineárna <math>O(n)</math>
* priestorová náročnosť: lineárna <math>O(n)</math> pre pole (alokovanie pomocných polí), <math>O(1)</math> pre lineárny zoznam (pri lineárnom zozname netreba alokovať dočasné polia, stačí iba presmerovať smerníky)
* využitie: kľúčový podprogram pre triediaci algoritmus ''Merge Sort''

===Pseudokód===
Nech funkcia ''Merge'' má nasledovný prototyp: <code>Merge(pole[], lavy, stred, pravy)</code>
:1. Je <code>lavy >= pravy ? Ak áno, skonči, inak pokračuj krokom 2.</code>
:2. Nech: <code>i = 0, j = 0, k = lavy </code>
:3. Nech: <code>dlzka_L = stred - lavy + 1, dlzka_P = pravy - stred</code>
:4. Nech: <code> L = pole[lavy ... stred], P = pole[stred + 1 ... pravy] </code>
:5. Je <code>i < dlzka_L</code> a zároveň <code>j < dlzka_P</code> ? Ak áno, pokračuj krokom 5.1., inak skoč na krok 6.
:::5.1. Je <code>L[i] <= P[j]</code>?
:::: Ak áno:
:::::5.1.1. <code>pole[k] = L[i]</code>
:::::5.1.2. <code>k += 1</code>
:::::5.1.3. <code>i += 1</code>
:::::5.1.4. Skoč na krok 5.
:::: Ak nie:
:::::5.1.1. <code>pole[k] = P[j]</code>
:::::5.1.2. <code>k += 1</code>
:::::5.1.3. <code>j += 1</code>
:::::5.1.4. Skoč na krok 5.
:6. Je <code>i < dlzka_L</code> ? Ak áno, pokračuj krokom 6.1., inak skoč na krok 7.
:::6.1. <code>pole[k] = L[i]</code>
:::6.2. <code>k += 1</code>
:::6.3. <code>i += 1</code>
:::6.4. Skoč na krok 6.
:7. Je <code>j < dlzka_P</code> ? Ak áno, pokračuj krokom 7.1., inak skonči.
:::7.1. <code>pole[k] = P[j]</code>
:::7.2. <code>k += 1</code>
:::7.3. <code>j += 1</code>
:::7.4. Skoč na krok 7.

==Merge Sort==
''Merge Sort'' je triediaci algoritmus, ktorý využíva stratégiu '''"rozdeľuj a panuj"''', čo znamená, že vstupný zoznam najskôr rozdelí na menšie časti, tie zoradí a potom ich zlúči naspäť dokopy. Radí sa medzi najpoužívanejšie a najviac rešpektované triediace algoritmy.

===Vlastnosti algoritmu Merge Sort===
* vhodný pre dátové štruktúry: pole, lineárny zoznam
* časová náročnosť: vždy linearitmická <math> O(n.log(n)) </math>, vďaka ktorej dokáže efektívne triediť veľmi veľké zoznamy
* priestorová náročnosť: lineárna <math>O(n)</math> pre pole (alokovanie dočasných polí), konštantná <math>O(1)</math> pre lineárny zoznam (pri lineárnom zozname stačí iba presmerovať smerníky)
* druh triedenia: triedenie zlučovaním (komparačný algoritmus)
* stabilita triedenia: stabilný
* miesto triedenia: externé triedenie (vhodný na triedenie veľkých objemov dát uložených na disku)

Z hľadiska implementácie môžeme vytvoriť dve základné verzie algoritmu, a to ''rekurzívnu'' a ''iteračnú''.

===Opis rekurzívnej a iteračnej verzie algoritmu Merge Sort===

<tabs>
<tab name="Rekurzívna verzia" block>
[[Súbor:Merge sort.png|400px|náhľad|vpravo|Vizualizácia rekurzívnej verzie algoritmu Merge Sort: chronologický priebeh algoritmu je znázornený číslicami 1 až 19.]]

===Základné časti algoritmu===
# Delenie poľa na dve polovice.
# Triedenie ľavej polovice poľa.
# Triedenie pravej polovice poľa.
# Zlúčenie oboch polovíc pomocou funkcie ''Merge''.

===Slovný opis===
Našou úlohou je vzostupne (min -> max) utriediť vstupné pole. Určíme si stred poľa (pri párnom počte prvkov je to ten menší z prostredných indexov). Následne vykonávame sériu rekurzívnych delení pre ľavú a pravú časť poľa (''začiatok ... stred ; stred + 1 ... koniec'') až do momentu, keď nám ostanú len jednoprvkové podpolia (tie sú už utriedené). Následne v každom volaní obe tieto podpolia zlúčime pomocou algoritmu ''Merge'' do väčších podpolí (max: 2, 4, 8, ...), až nakoniec dostaneme jedno výsledné utriedené pole.

===Pseudokód===
Nech má funkcia ''MergeSort'' nasledovný prototyp: <code>MergeSort(pole[], lavy, pravy) </code>
:1. Je <code>lavy >= pravy</code> ? Ak áno, skonči volanie, inak pokračuj krokom 2.
:2. Nech: <code>stred = lavy + (pravy - lavy) / 2</code>, pričom znak ''/'' vyjadruje celočíselné delenie.
:3. Rekurzívne zavolaj funkciu <code>MergeSort(pole[], lavy , stred)</code>
:3. Rekurzívne zavolaj funkciu <code>MergeSort(pole[], stred + 1 , pravy)</code>
:4. Zavolaj funkciu <code>Merge(pole[], lavy, stred, pravy)</code>
:5. Skonči volanie.

</tab>
<tab name="Iteračná verzia" block>
[[Súbor:MergeSort IT.png|400px|náhľad|Vizualizácia iteračnej verzie algoritmu Merge Sort: chronologický priebeh algoritmu je znázornený číslicami 1 až 7.|vpravo]]

===Základné časti algoritmu===
# Určenie maximálnej veľkosti podpoľa na zlučovanie.
# Prechádzanie jednotlivých podpolí v poli.
# Zlučovanie jednotlivých podpolí pomocou funkcie ''Merge''.

===Slovný opis===
Vstupné pole, ktoré má ''N'' prvkov, môžeme chápať, ako ''N'' rôznych jednoprvkových (utriedených) podpolí, ktoré máme zlúčiť do jedného výsledného ''N'' - prvkového utriedeného poľa. Keďže by bolo veľmi nepraktické zlučovať ''N'' podpolí naraz, zvolíme nasledovnú stratégiu: Budeme prechádzať dané pole od začiatku po koniec a v prvej iterácii zlúčime každé dva prvky, čím dostaneme <math>\frac{N}{2}</math> dvojprvkových utriedených podpolí. Potom v druhej iterácii zlúčime každé 4 prvky do jedného podpoľa, v treťom cykle každých 8, ..., až do momentu, keď dostaneme jedno výsledné utriedené pole.
Aby sme mohli túto stratégiu implementovať, potrebujeme dva cykly: vonkajší, ktorý nastaví maximálnu veľkosť podpoľa, ktoré ideme zlučovať (1,2,4,8 ... ''dlzka - 1'') a vnútorný, ktorý prechádza jednotlivé podpolia. Následne už iba voláme funkciu ''Merge'', ktorá dané podpolia zlučuje.

Poznámka, ak máme ''pole'', ktoré má nepárny počet prvkov, tak ten posledný prvok nezlúčime hneď v prvej iterácii, ale až v tých ďalších. Takisto, ak ''N'' nie je mocnina čísla 2, tak musíme samozrejme ošetriť situáciu, kedy by sme sa dostali mimo rozsah poľa (Ak máme napríklad ''pole'', čo má 7 prvkov, tak po prvej iterácii budú prvky utiredené podľa vzoru 2 + 2 + 2 + 1, po druhej 4 + 3, a po tretej 7 + 0)

===Pseudokód===
Nech nech má funkcia ''MergeSort'' nasledovný prototyp: <code>MergeSort(pole[], lavy, pravy) </code>
:1. Je <code>lavy >= pravy</code> ? Ak áno, skonči, inak pokračuj krokom 2.
:2. Nech: <code>dlzka_podpola = 1 </code>
:3. Nech: <code>zaciatok = lavy</code>
:4. Je <code>dlzka_podpola <= pravy</code> ? Ak áno pokračuj krokom 4.1, inak skonči.
:::4.1. Je <code>zaciatok < pravy</code> Ak áno pokračuj krokom 4.1.1, inak skoč na krok 4.2.
:::::4.1.1. Je <code>zaciatok + 2 * dlzka_zoznamu - 1 <= pravy</code> ?
:::::::Ak áno:
:::::::::4.1.1.1. Nech: <code>koniec = zaciatok + 2 * dlzka_podpola - 1</code>
:::::::Ak nie:
:::::::::4.1.1.1. Nech: <code>koniec = pravy</code>
:::::4.1.2. Je <code>zaciatok + dlzka_podpola - 1 <= pravy</code> ?
:::::::Ak áno:
:::::::::4.1.2.1. Nech <code>stred = zaciatok + dlzka_podpola - 1</code>
:::::::Ak nie:
:::::::::4.1.2.1. Nech <code>stred = pravy</code>
:::::4.1.3. <code>Merge(pole[], zaciatok, stred, koniec)</code>
:::::4.1.4. <code>zaciatok += 2 * dlzka_podpola</code>
:::::4.1.5. Skoč na krok 4.1.
:::4.2. <code>dlzka_podpole *= 2</code>
:::4.3 Skoč na krok 4.

</tab>
</tabs>

==Implementácia algoritmov Merge a MergeSort v rôznych programovacích jazykoch==
<tabs>
<tab name="Rekurzívna: C " block>
<syntaxhighlight lang="C">
#include <stdio.h>
#include <stdlib.h>

void Merge(int pole[], int lavy, int stred, int pravy);
void MergeSort(int pole[], int lavy, int pravy);

/* hlavný program */

int main()
{
int pole[] = {12, 11, 13, 5, 6, 7};
int dlzka_pola = sizeof(pole) / sizeof(pole[0]);

printf("Pôvodné pole: \n");

for (int i = 0; i < dlzka_pola; ++i)
{
printf("%d ", pole[i]);
}

MergeSort(pole, 0, dlzka_pola - 1);

printf("\nUtriedené pole: \n");

for (int i = 0; i < dlzka_pola; ++i)
{
printf("%d ", pole[i]);
}

return 0;
}

void Merge(int pole[], int lavy, int stred, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči */

if (lavy >= pravy)
{
return;
}

/* vyrátaj dĺžky oboch polovíc poľa */

int L_dlzka = stred - lavy + 1;
int P_dlzka = pravy - stred;

/* alokuj dočasné polia, kam uložíš prvky z oboch polovíc poľa */

int *L = (int*)malloc(L_dlzka * sizeof(int));
int *P = (int*)malloc(P_dlzka * sizeof(int));

/* indexy, ktorými iterujeme všetky polia: i pre L, j pre P, k pre pole */

int i, j, k;

/* skopíruj obsah oboch polovíc poľa do dočasných polí L a P */

for (i = 0; i < L_dlzka; ++i)
{
L[i] = pole[lavy + i];
}

for (j = 0; j < P_dlzka; ++j)
{
P[j] = pole[stred + 1 + j];
}

/* nastav indexy na začiatok daných polí */

i = 0; j = 0; k = lavy;

/* zlučuj dočasné polia L a P do finálneho poľa pole */

while(i < L_dlzka && j < P_dlzka)
{
if(L[i] <= P[j])
{
pole[k++] = L[i++];
}
else
{
pole[k++] = P[j++];
}
}

/* ak ostali nejaké prvky v dočasnom poli L, skopíruj ich do finálneho poľa */

while(i < L_dlzka)
{
pole[k++] = L[i++];
}

/* ak ostali nejaké prvky v dočasnom poli P, skopíruj ich do finálneho poľa */

while(j < P_dlzka)
{
pole[k++] = P[j++];
}

/* uvoľni použitú pamäť */

free(L);
free(P);
}

void MergeSort(int pole[], int lavy, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči volanie */

if(lavy >= pravy)
{
return;
}
/* urči si prostredný index */

int stred = lavy + (pravy - lavy) / 2;

/* utrieď ľavú polovicu poľa */

MergeSort(pole, lavy, stred);

/* utrieď pravú polovicu poľa */

MergeSort(pole, stred+1, pravy);

/* zlúč obe polovice dokopy */

Merge(pole, lavy, stred, pravy);
}
</syntaxhighlight>
</tab>

<tab name="Iteračná: C" block>
<syntaxhighlight lang="C">
#include <stdio.h>
#include <stdlib.h>

void Merge(int pole[], int lavy, int stred, int pravy);
void MergeSortIt(int *pole, int lavy, int pravy);

/* hlavný program */

int main()
{
int pole[] = {12, 11, 13, 5, 6, 7, 19};
int dlzka_pola = sizeof(pole) / sizeof(pole[0]);

printf("Pôvodné pole %d: \n", dlzka_pola);

for (int i = 0; i < dlzka_pola; ++i)
{
printf("%d ", pole[i]);
}

MergeSortIt(pole, 0, dlzka_pola - 1);

printf("\nUtriedené pole: \n");

for (int i = 0; i < dlzka_pola; ++i)
{
printf("%d ", pole[i]);
}

return 0;
}

void Merge(int pole[], int lavy, int stred, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči */

if (lavy >= pravy)
{
return;
}

/* vyrátaj dĺžky oboch polovíc poľa */

int L_dlzka = stred - lavy + 1;
int P_dlzka = pravy - stred;

/* alokuj dočasné polia, kam uložíš prvky z oboch polovíc poľa */

int *L = (int*)malloc(L_dlzka * sizeof(int));
int *P = (int*)malloc(P_dlzka * sizeof(int));

/* indexy, ktorými iterujeme všetky polia: i pre L, j pre P, k pre pole */

int i, j, k;

/* skopíruj obsah oboch polovíc poľa do dočasných polí L a P */

for (i = 0; i < L_dlzka; ++i)
{
L[i] = pole[lavy + i];
}

for (j = 0; j < P_dlzka; ++j)
{
P[j] = pole[stred + 1 + j];
}

/* nastav indexy na začiatok daných polí */

i = 0; j = 0; k = lavy;

/* zlučuj dočasné polia L a P do finálneho poľa pole */

while(i < L_dlzka && j < P_dlzka)
{
if(L[i] <= P[j])
{
pole[k++] = L[i++];
}
else
{
pole[k++] = P[j++];
}
}

/* ak ostali nejaké prvky v dočasnom poli L, skopíruj ich do finálneho poľa */

while(i < L_dlzka)
{
pole[k++] = L[i++];
}

/* ak ostali nejaké prvky v dočasnom poli P, skopíruj ich do finálneho poľa */

while(j < P_dlzka)
{
pole[k++] = P[j++];
}

/* uvoľni použitú pamäť */

free(L);
free(P);
}

void MergeSortIt(int *pole, int lavy, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči volanie */

if(lavy >= pravy)
{
return;
}

int stred, koniec;

for (int dlzka_podpola = 1; dlzka_podpola <= pravy; dlzka_podpola *= 2)
{
for (int zaciatok = lavy; zaciatok < pravy; zaciatok += 2 * dlzka_podpola)
{
koniec = (zaciatok + 2 * dlzka_podpola - 1 <= pravy) ? zaciatok + 2 * dlzka_podpola - 1 : pravy;

stred = (zaciatok + dlzka_podpola - 1 <= pravy) ? zaciatok + dlzka_podpola - 1 : pravy;

Merge(pole, zaciatok, stred, koniec);

}
}
}
</syntaxhighlight>
</tab>

<tab name="Rekurzívna: C++" block>
<syntaxhighlight lang="C++">
#include <iostream>

using std::cout;
using std::endl;

void Merge(int pole[], int lavy, int stred, int pravy);
void MergeSort(int pole[], int lavy, int pravy);

/* hlavný program */

int main()
{
int pole[] = {12, 11, 13, 5, 6, 7};
int dlzka_pola = sizeof(pole) / sizeof(pole[0]);

printf("Pôvodné pole: \n");

for (auto i: pole)
{
cout<<i<<" ";
}

MergeSort(pole, 0, dlzka_pola - 1);

cout<<endl<<"Utriedené pole:"<<endl;

for (auto i: pole)
{
cout<<i<<" ";
}

return 0;
}

void Merge(int pole[], int lavy, int stred, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči */

if (lavy >= pravy)
{
return;
}

/* vyrátaj dĺžky oboch polovíc poľa */

int L_dlzka = stred - lavy + 1;
int P_dlzka = pravy - stred;

/* alokuj dočasné polia, kam uložíš prvky z oboch polovíc poľa */

int *L = new int[L_dlzka];
int *P = new int[P_dlzka];

/* indexy, ktorými iterujeme všetky polia: i pre L, j pre P, k pre pole */

int i, j, k;

/* skopíruj obsah oboch polovíc poľa do dočasných polí L a P */

for (i = 0; i < L_dlzka; ++i)
{
L[i] = pole[lavy + i];
}

for (j = 0; j < P_dlzka; ++j)
{
P[j] = pole[stred + 1 + j];
}

/* nastav indexy na začiatok daných polí */

i = 0; j = 0; k = lavy;

/* zlučuj dočasné polia L a P do finálneho poľa pole */

while(i < L_dlzka && j < P_dlzka)
{
if(L[i] <= P[j])
{
pole[k++] = L[i++];
}
else
{
pole[k++] = P[j++];
}
}

/* ak ostali nejaké prvky v dočasnom poli L, skopíruj ich do finálneho poľa */

while(i < L_dlzka)
{
pole[k++] = L[i++];
}

/* ak ostali nejaké prvky v dočasnom poli P, skopíruj ich do finálneho poľa */

while(j < P_dlzka)
{
pole[k++] = P[j++];
}

/* uvoľni použitú pamäť */

delete []L;
delete []P;
}

void MergeSort(int pole[], int lavy, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči volanie */

if(lavy >= pravy)
{
return;
}
/* urči si prostredný index */

int stred = lavy + (pravy - lavy) / 2;

/* utrieď ľavú polovicu poľa */

MergeSort(pole, lavy, stred);

/* utrieď pravú polovicu poľa */

MergeSort(pole, stred+1, pravy);

/* zlúč obe polovice dokopy */

Merge(pole, lavy, stred, pravy);
}

</syntaxhighlight>
</tab>

<tab name="Iteračná: C++" block>
<syntaxhighlight lang="C++">
#include <iostream>

using std::cout;
using std::endl;

void Merge(int pole[], int lavy, int stred, int pravy);
void MergeSortIt(int *pole, int lavy, int pravy);

/* hlavný program */

int main()
{
int pole[] = {12, 11, 13, 5, 6, 7};
int dlzka_pola = sizeof(pole) / sizeof(pole[0]);

printf("Pôvodné pole: \n");

for (auto i: pole)
{
cout<<i<<" ";
}

MergeSortIt(pole, 0, dlzka_pola - 1);

cout<<endl<<"Utriedené pole:"<<endl;

for (auto i: pole)
{
cout<<i<<" ";
}

return 0;
}

void Merge(int pole[], int lavy, int stred, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči */

if (lavy >= pravy)
{
return;
}

/* vyrátaj dĺžky oboch polovíc poľa */

int L_dlzka = stred - lavy + 1;
int P_dlzka = pravy - stred;

/* alokuj dočasné polia, kam uložíš prvky z oboch polovíc poľa */

int *L = new int[L_dlzka];
int *P = new int[P_dlzka];

/* indexy, ktorými iterujeme všetky polia: i pre L, j pre P, k pre pole */

int i, j, k;

/* skopíruj obsah oboch polovíc poľa do dočasných polí L a P */

for (i = 0; i < L_dlzka; ++i)
{
L[i] = pole[lavy + i];
}

for (j = 0; j < P_dlzka; ++j)
{
P[j] = pole[stred + 1 + j];
}

/* nastav indexy na začiatok daných polí */

i = 0; j = 0; k = lavy;

/* zlučuj dočasné polia L a P do finálneho poľa pole */

while(i < L_dlzka && j < P_dlzka)
{
if(L[i] <= P[j])
{
pole[k++] = L[i++];
}
else
{
pole[k++] = P[j++];
}
}

/* ak ostali nejaké prvky v dočasnom poli L, skopíruj ich do finálneho poľa */

while(i < L_dlzka)
{
pole[k++] = L[i++];
}

/* ak ostali nejaké prvky v dočasnom poli P, skopíruj ich do finálneho poľa */

while(j < P_dlzka)
{
pole[k++] = P[j++];
}

/* uvoľni použitú pamäť */

delete []L;
delete []P;
}

void MergeSortIt(int *pole, int lavy, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči volanie */

if(lavy >= pravy)
{
return;
}

int stred, koniec;

for (int dlzka_podpola = 1; dlzka_podpola <= pravy; dlzka_podpola *= 2)
{
for (int zaciatok = lavy; zaciatok < pravy; zaciatok += 2 * dlzka_podpola)
{
koniec = (zaciatok + 2 * dlzka_podpola - 1 <= pravy) ? zaciatok + 2 * dlzka_podpola - 1 : pravy;

stred = (zaciatok + dlzka_podpola - 1 <= pravy) ? zaciatok + dlzka_podpola - 1 : pravy;

Merge(pole, zaciatok, stred, koniec);
}
}
}
</syntaxhighlight>
</tab>

<tab name="Rekurzívna: Java" block>
<syntaxhighlight lang="Java">
class MergeSort
{

/* Funkcia zlúči 2 podpolia, ktoré sme vytvorili z pôvodného poľa.
* Každé podpole má polovičnú dĺžku pôvodného poľa.
* podpole1 [ľavý ... stred]
* podpole2 [stred + 1 ... pravý]
*/

void merge(int[] pole, int lavy, int stred, int pravy)
{

// Výpočet dĺžky 2 podpolí

int n1 = stred - lavy + 1;
int n2 = pravy - stred;

// Vytvorenie pomocných polí

int[] L = new int[n1];
int[] P = new int[n2];

// Načítanie dát do pomocných polí

for (int i = 0; i < n1; i++)
L[i] = pole[lavy + i];

for (int j = 0; j < n2; j++)
P[j] = pole[stred + 1 + j];

// Počiatočné indexy prvého a druhého podpoľa

int i = 0, j = 0;

// Počiatočný index zlúčeného podpoľa

int k = lavy;

// Zlúčenie dvoch podpolí

while (i < n1 && j < n2)
{
if (L[i] <= P[j])
{
pole[k] = L[i];
i++;
}
else
{
pole[k] = P[j];
j++;
}
k++;
}

/* V prípade, že sa v jednom zo podpolí nachádzajú ešte nejaké prvky, ktoré neboli zlúčené do poľa,
* tak sa do poľa jednoducho skopírujú
*/

while (i < n1)
{
pole[k] = L[i];
i++;
k++;
}

while (j < n2)
{
pole[k] = P[j];
k++;
j++;
}

}

/* Funkcia, ktorá zoradí pole použitím funkcie merge() */

void sort (int[] pole, int lavy, int pravy)
{
if (lavy < pravy)
{
// Musíme nájsť stred poľa

int stred = lavy + (pravy - lavy) / 2;

// Zoradíme prvú a druhú polovicu poľa samostatne

sort(pole, lavy, stred);
sort(pole, stred + 1, pravy);

// Zlúčime zoradené polovice do jedného poľa

merge(pole, lavy, stred, pravy);
}
}
}

public class Main
{
/* Funkcia na výpis poľa dĺžky n */

static void vypis_pole(int[] pole)
{

for (int j : pole)
{
System.out.print(j + " ");
}

System.out.println();
}

/* Hlavný program */

public static void main(String[] args)
{
int[] pole = {12, 11, 13, 5, 6, 7};

System.out.println("Zadané pole:");
vypis_pole(pole);

MergeSort ms = new MergeSort();
ms.sort(pole, 0, pole.length - 1);

System.out.println("\nZoradené pole:");
vypis_pole(pole);
}
}
</syntaxhighlight>
</tab>

<tab name="Iteračná: Java" block>
<syntaxhighlight lang="Java">
class MergeSort_iteracia
{
/* Zlúči 2 podpolia, ktoré sa vytvorili z pôvodného poľa.
* Každé podpole má polovičnú dĺžku pôvodného poľa.
* podpole1 [ľavý..stred]
* podpole2 [stred+1..pravý]
*/

void merge(int[] pole, int lavy, int stred, int pravy)
{
// Výpočet dĺžky 2 podpolí

int n1 = stred - lavy + 1;
int n2 = pravy - stred;

// Vytvorenie pomocných polí

int[] L = new int[n1];
int[] P = new int[n2];

// Načítanie dát do pomocných polí

for (int i = 0; i < n1; i++)
L[i] = pole[lavy + i];

for (int j = 0; j < n2; j++)
P[j] = pole[stred + 1 + j];

// Počiatočné indexy prvého a druhého podpoľa

int i = 0, j = 0;

// Počiatočný index zlúčeného podpoľa

int k = lavy;

// Zlúčenie dvoch podpolí

while (i < n1 && j < n2)
{
if (L[i] <= P[j])
{
pole[k] = L[i];
i++;
}
else
{
pole[k] = P[j];
j++;
}
k++;
}

/* V prípade, že v jednom z podpolí sa nachádzajú prvky, ktoré neboli zlúčené do poľa,
* tak sa do poľa jednoducho skopírujú
*/

while (i < n1)
{
pole[k] = L[i];
i++;
k++;
}

while (j < n2)
{
pole[k] = P[j];
k++;
j++;
}
}

/* Funkcia, ktorá zoradí pole použitím funkcie merge() */

void sort (int[] pole, int n)
{
/* Dĺžka podpolí, ktoré majú byť zlúčené, hodnoty premennej sa pohybujú v intervale <1;n-1> */

int aktual_dlzka;

/* Začiatočný index ľavého podpoľa, ktoré má byť zlúčené */

int zaciatok_vlavo;

/* Vzostupné usporiadanie prvkov. Najskôr sa zlúčia podpolia veľkosti 1 do podpolí veľkosti 2,
* potom podpolia veľkosti 2 do podpolí veľkosti 4 a tak ďalej
*/

for (aktual_dlzka = 1; aktual_dlzka <= n - 1; aktual_dlzka *= 2)
{
/* Určenie začiatočného prvku rôznych podpolí aktuálnej dĺžky podpoľa */

for (zaciatok_vlavo = 0; zaciatok_vlavo < n - 1; zaciatok_vlavo += 2 * aktual_dlzka)
{
/* Nájdenie konečného prvku ľavého podpoľa, stred+1 je začiatočný prvok pravého podpoľa */

int stred = Math.min(zaciatok_vlavo + aktual_dlzka - 1, n - 1);
int koniec_vpravo = Math.min(zaciatok_vlavo + 2 * aktual_dlzka - 1, n - 1);

/* Zlúči podpolia L[zaciatok_vlavo .. stred] & P[stred+1 .. koniec_vpravo] */

merge(pole, zaciatok_vlavo, stred, koniec_vpravo);
}
}
}
}

public class Main {

/* Funkcia na výpis poľa dĺžky n */

static void vypis_pole(int[] pole)
{
int n = pole.length;

for (int j : pole)
{
System.out.print(j + " ");
}
System.out.println();
}

/* Hlavný program */

public static void main(String[] args) {

/* Inicializácia poľa */

int[] pole = {12, 11, 13, 5, 6, 7};

System.out.println("Zadané pole:");
vypis_pole(pole);

MergeSort_iteracia ms_it = new MergeSort_iteracia();
ms_it.sort(pole, pole.length);

System.out.println("Zoradené pole:");
vypis_pole(pole);
}
}
</syntaxhighlight>
</tab>

<tab name="Rekurzívna: Python3" block>
<syntaxhighlight lang="Python3">
def MergeSort(pole):
if len(pole) > 1:

# Nájdenie stredu poľa
# zápis len(pole)//2 znamená, že dĺžka poľa sa vydelí 2 a výsledok je celé číslo

stred = len(pole) // 2

# Rozdelenie poľa na dve časti

L = pole[:stred]
P = pole[stred:]

# Zoradenie najskôr prvej časti poľa, potom druhej

MergeSort(L)
MergeSort(P)

i = j = k = 0

# Zlúčenie a zoradenie údajov z pomocných polí do jedného poľa

while i < len(L) and j < len(P):
if L[i] < P[j]:
pole[k] = L[i]
i += 1
else:
pole[k] = P[j]
j += 1
k += 1

# Kontrola či všetky prvky boli zlúčené dokopy,
# ak nie, tak sa do zlúčeného poľa jednoducho skopírujú

while i < len(L):
pole[k] = L[i]
i += 1
k += 1

while j < len(P):
pole[k] = P[j]
j += 1
k += 1

# Hlavný program

if __name__ == '__main__':

pole = [12, 11, 13, 5, 6, 7]

print("Zadané pole:", end="\n")
print(pole, end="\n")

MergeSort(pole)

print("Zoradené pole:", end="\n")
print(pole, end="\n")

</syntaxhighlight>
</tab>

<tab name="Iteračná: Python3" block>
<syntaxhighlight lang="Python3">
def MergeSort_iteracia(pole):

# Dĺžka podpolí, ktoré majú byť zlúčené, hodnoty premennej sa pohybujú v intervale <1;n-1>

aktual_dlzka = 1

# Vonkajší cyklus, ktorý určuje podpolia aktuálnej dĺžky

while aktual_dlzka < len(pole) - 1:

lavy = 0

# Vnútorný cyklus, ktorý slúži na zlúčenie a zoradenie podpolí do jedného podpoľa

while lavy < len(pole) - 1:

# Index stredného prvku sa určí, keď k indexu ľavého prvku podpoľa pripočítame aktuálnu
# dĺžku podpolí a odčítame 1

stred = min((lavy + aktual_dlzka - 1), len(pole) - 1)

# Ak platí podmienka 2 * aktuálna dĺžka < dĺžka poľa - 1, tak pravý index = aktuálnej dĺžke subpolí,
# inak pravý index = dĺžka poľa - 1

pravy = ((2 * aktual_dlzka + lavy - 1, len(pole) - 1)[2 * aktual_dlzka + lavy - 1 > len(pole) - 1])

# Volanie funkcie merge

merge(pole, lavy, stred, pravy)

lavy = lavy + 2 * aktual_dlzka

# Aktuálna dĺžka sa sa zmení na dvojnásobok jej predošlej hodnoty

aktual_dlzka = 2 * aktual_dlzka

def merge(pole, lavy, stred, pravy):

n1 = stred - lavy + 1
n2 = pravy - stred

# Inicializácia pomocných polí

L = [0] * n1
P = [0] * n2

# Načítanie dát do pomocných polí

for i in range(0, n1):
L[i] = pole[lavy + i]
for i in range(0, n2):
P[i] = pole[stred + i + 1]

i, j, k = 0, 0, lavy

# Zlúčenie a zoradenie údajov z pomocných polí do jedného poľa

while i < n1 and j < n2:
if L[i] > P[j]:
pole[k] = P[j]
j += 1
else:
pole[k] = L[i]
i += 1
k += 1

# Kontrola či všetky prvky boli zlúčené dokopy,
# ak nie, tak sa do zlúčeného pola jednoducho skopírujú

while i < n1:
pole[k] = L[i]
i += 1
k += 1

while j < n2:
pole[k] = P[j]
j += 1
k += 1

# Hlavný program

if __name__ == '__main__':

pole = [12, 11, 13, 5, 6, 7]

print("Zadané pole:", end="\n")
print(pole, end="\n")

MergeSort_iteracia(pole)

print("Zoradené pole:", end="\n")
print(pole, end="\n")

</syntaxhighlight>
</tab>

</tabs>

==Odkazy==
# https://www.geeksforgeeks.org/merge-sort/
# https://www.geeksforgeeks.org/iterative-merge-sort/
# https://medium.com/@paulsoham/merge-sort-63d75df76388
# https://www.khanacademy.org/computing/computer-science/algorithms/merge-sort/a/overview-of-merge-sort
# https://www.tutorialspoint.com/data_structures_algorithms/merge_sort_algorithm.htm
# https://www.youtube.com/watch?v=6pV2IF0fgKY
# https://www.youtube.com/watch?v=mB5HXBb_HY8
# https://www.youtube.com/watch?v=ak-pz7tS5DE

Triedenie zlučovaním

2021-03-29T17:09:55Z

Filip Tomek: /* Zlučovací algoritmus Merge */

[[Kategória:Algoritmy triedenia]]
{{Draft}}
{{Skripta programovanie}}
__TOC__
==Zlučovací algoritmus Merge==
[[Súbor:Funkcia merge.png|500px|náhľad|vpravo|Vizualizácia funkcie ''Merge'': Máme pole prvkov ''p = [1, 3, 5, 2, 4, 6]'', ktoré je už čiastočne utriedené. Použijeme algoritmus ''Merge'', ktorý si vytvorí pomocné polia ''L = [1, 3, 5]'' a ''P = [2, 4, 6]''. Všetky polia indexujeme od ''0'', pričom pre pole ''p'' používame index ''k'', pre ''L'' index ''i'' a pre ''P'' index ''j''. Postupnosť krokov je označená číslicami 1 až 6.
]]

Princíp zlučovania tkvie v tom, že máme dva alebo viac utriedených zoznamov, ktoré skombinujeme do jedného utriedeného zoznamu (výsledný zoznam musí obsahovať všetky prvky z pôvodných zoznamov). Zoznam môže byť reprezentovaný ako dátová štruktúra pole alebo aj ako lineárny zoznam. V tomto článku sa zameriame na algoritmus pre dátovú štruktúru pole.

Algoritmus ''Merge'' tvorí kľúčovú časť triediaceho algoritmu ''MergeSort''.

===Základné časti algoritmu===
# Vytvorenie pomocných polí.
# Prechádzanie pomocných polí a vyberanie minima z 2 prvkov.
# Vkladanie minima na začiatok výsledného poľa.
# Kopírovanie prvkov, ktoré ešte neboli porovnané, z pomocného poľa do výsledného poľa.

===Slovný opis algoritmu===
Nech máme vstupné pole, ktoré sa skladá z dvoch už utriedených polovíc. Vytvoríme si dve pomocné polia ''L'' a ''P'' a do každého z nich skopírujeme obsah jednej polovice (''L'' - ľavá polovica, ''P'' - pravá polovica). Potom súčasne prechádzame polia ''L'' a ''P'' od začiatku po koniec, pričom v každej iterácii porovnáme prvok poľa ''L'' s prvkom v poli ''P''. Z tejto dvojice následne vyberieme minimum, (keď triedime od najmenšieho po najväčší) ktoré vložíme na prvú voľnú pozíciu pôvodného poľa (na začiatku je to prvá pozícia poľa). Nakoniec zvýšime index pri vstupnom poli a pri pomocnom poli, z ktorého vyberáme daný prvok. Túto postupnosť krokov opakujeme, pokiaľ neprídeme na koniec jedného z polí ''P'' a ''L''. Ak nastane situácia, že prídeme na koniec jedného z pomocných polí (a v druhom nám ostali ešte nejaké prvky), potom už iba naspäť skopírujeme zbytok druhého pomocného poľa na koniec pôvodného poľa.

===Vlastnosti algoritmu===
* vhodný pre dátové štruktúry: pole, lineárny zoznam
* časová náročnosť: vždy lineárna <math>O(n)</math>
* priestorová náročnosť: lineárna <math>O(n)</math> pre pole (alokovanie pomocných polí), <math>O(1)</math> pre lineárny zoznam (pri lineárnom zozname netreba alokovať dočasné polia, stačí iba presmerovať smerníky)
* využitie: kľúčový podprogram pre triediaci algoritmus ''Merge Sort''

===Pseudokód===
Nech funkcia ''Merge'' má nasledovný prototyp: <code>Merge(pole[], lavy, stred, pravy)</code>
:1. Je <code>lavy >= pravy ? Ak áno, skonči, inak pokračuj krokom 2.</code>
:2. Nech: <code>i = 0, j = 0, k = lavy </code>
:3. Nech: <code>dlzka_L = stred - lavy + 1, dlzka_P = pravy - stred</code>
:4. Nech: <code> L = pole[lavy ... stred], P = pole[stred + 1 ... pravy] </code>
:5. Je <code>i < dlzka_L</code> a zároveň <code>j < dlzka_P</code> ? Ak áno, pokračuj krokom 5.1., inak skoč na krok 6.
:::5.1. Je <code>L[i] <= P[j]</code>?
:::: Ak áno:
:::::5.1.1. <code>pole[k] = L[i]</code>
:::::5.1.2. <code>k += 1</code>
:::::5.1.3. <code>i += 1</code>
:::::5.1.4. Skoč na krok 5.
:::: Ak nie:
:::::5.1.1. <code>pole[k] = P[j]</code>
:::::5.1.2. <code>k += 1</code>
:::::5.1.3. <code>j += 1</code>
:::::5.1.4. Skoč na krok 5.
:6. Je <code>i < dlzka_L</code> ? Ak áno, pokračuj krokom 6.1., inak skoč na krok 7.
:::6.1. <code>pole[k] = L[i]</code>
:::6.2. <code>k += 1</code>
:::6.3. <code>i += 1</code>
:::6.4. Skoč na krok 6.
:7. Je <code>j < dlzka_P</code> ? Ak áno, pokračuj krokom 7.1., inak skonči.
:::7.1. <code>pole[k] = P[j]</code>
:::7.2. <code>k += 1</code>
:::7.3. <code>j += 1</code>
:::7.4. Skoč na krok 7.

==MergeSort==
''MergeSort'' je triediaci algoritmus, ktorý využíva stratégiu '''"rozdeľuj a panuj"''', čo znamená, že vstupný zoznam najskôr rozdelí na menšie časti, tie zoradí a potom ich zlúči naspäť dokopy. Radí sa medzi najpoužívanejšie a najviac rešpektované triediace algoritmy.

===Vlastnosti algoritmu Merge Sort===
* vhodný pre dátové štruktúry: pole, lineárny zoznam
* časová náročnosť: vždy linearitmická <math> O(n.log(n)) </math>, vďaka ktorej dokáže efektívne triediť veľmi veľké zoznamy
* priestorová náročnosť: lineárna <math>O(n)</math> pre pole (alokovanie dočasných polí), konštantná <math>O(1)</math> pre lineárny zoznam (pri lineárnom zozname stačí iba presmerovať smerníky)
* druh triedenia: triedenie zlučovaním (komparačný algoritmus)
* stabilita triedenia: stabilný
* miesto triedenia: externé triedenie (vhodný na triedenie veľkých objemov dát uložených na disku)

Z hľadiska implementácie môžeme vytvoriť dve základné verzie algoritmu, a to ''rekurzívnu'' a ''iteračnú''.

===Opis rekurzívnej a iteračnej verzie algoritmu Merge Sort===

<tabs>
<tab name="Rekurzívna verzia" block>
[[Súbor:Merge sort.png|400px|náhľad|vpravo|Vizualizácia rekurzívnej verzie algoritmu MergeSort]]

===Základné časti algoritmu===
# Delenie poľa na dve polovice.
# Triedenie ľavej polovice poľa.
# Triedenie pravej polovice poľa.
# Zlúčenie oboch polovíc pomocou funkcie ''Merge''.

===Slovný opis===
Našou úlohou je vzostupne (min -> max) utriediť vstupné pole. Určíme si stred poľa (pri párnom počte prvkov je to ten menší z prostredných indexov). Následne vykonávame sériu rekurzívnych delení pre ľavú a pravú časť poľa (''začiatok ... stred ; stred + 1 ... koniec'') až do momentu, keď nám ostanú len jednoprvkové podpolia (tie sú už utriedené). Následne v každom volaní obe tieto podpolia zlúčime pomocou algoritmu ''Merge'' do väčších podpolí (max: 2, 4, 8, ...), až nakoniec dostaneme jedno výsledné utriedené pole.

===Pseudokód===
Nech má funkcia ''MergeSort'' nasledovný prototyp: <code>MergeSort(pole[], lavy, pravy) </code>
:1. Je <code>lavy >= pravy</code> ? Ak áno, skonči volanie, inak pokračuj krokom 2.
:2. Nech: <code>stred = lavy + (pravy - lavy) / 2</code>, pričom znak ''/'' vyjadruje celočíselné delenie.
:3. Rekurzívne zavolaj funkciu <code>MergeSort(pole[], lavy , stred)</code>
:3. Rekurzívne zavolaj funkciu <code>MergeSort(pole[], stred + 1 , pravy)</code>
:4. Zavolaj funkciu <code>Merge(pole[], lavy, stred, pravy)</code>
:5. Skonči volanie.

</tab>
<tab name="Iteračná verzia" block>
[[Súbor:MergeSort IT.png|400px|náhľad|vpravo]]

===Základné časti algoritmu===
# Vonkajší cyklus: určenie veľkosti zoznamu na zlučovanie.
# Vnútorný cyklus: prechádzanie jednotlivých zoznamov v poli.
# Zlučovanie jednotlivých zoznamov pomocou funkcie ''Merge''.

===Slovný opis===
Vstupné pole, ktoré má ''N'' prvkov, môžeme chápať, ako ''N'' rôznych jednoprvkových (utriedených) podpolí, ktoré máme zlúčiť do jedného výsledného ''N''-prvkového utriedeného poľa. Keďže by bolo veľmi nepraktické zlučovať ''N'' podpolí naraz, zvolíme nasledovnú stratégiu: Budeme prechádzať dané pole od začiatku po koniec a v prvom cykle zlúčime každé dva prvky, takže budeme mať <math>\frac{n}{2}</math> dvojprvkových utriedených podpolí. Potom v druhom cykle zlúčime každé 4 prvky do jedného podpoľa, v treťom cykle každých 8, až do momentu, keď dostaneme jedno utriedené pole.
Aby sme to docielili, potrebujeme dva cykly, vonkajší, ktorý nastaví maximálnu veľkosť podpoľa, ktoré ideme zlučovať (1,2,4,8 ... ''dlzka - 1'') a vnútorný, ktorý prechádza jednotlivé podpolia. Následne už iba voláme funkciu ''Merge'', ktorá dané podpolia zlučuje.

Poznámka, ak máme ''pole'', ktoré má nepárny počet prvkov, tak ten posledný prvok nezlúčime hneď v prvom cykle, ale až v tých ďalších. Takisto, ak ''N'' nie je mocnina čísla 2, tak musíme samozrejme ošetriť situáciu, kedy by sme sa dostali mimo rozsah poľa (Ak máme napríklad ''pole'', čo má 7 prvkov, tak po prvej iterácii budú prvky utiredené podľa vzoru 2 + 2 + 2 + 1, po druhej 4 + 3, a po tretej 7)

===Pseudokód===
Nech nech má funkcia ''MergeSort'' nasledovný prototyp: <code>MergeSort(pole[], lavy, pravy) </code>
:1. Je <code>lavy >= pravy</code> ? Ak áno, skonči, inak pokračuj krokom 2.
:2. Nech: <code>dlzka_podpola = 1 </code>
:3. Nech: <code>zaciatok = lavy</code>
:4. Je<code>dlzka_podpola <= pravy</code> ? Ak áno pokračuj krokom 4.1, inak skonči.
:::4.1. Je<code>zaciatok < pravy</code> Ak áno pokračuj krokom 4.1.1, inak skoč na krok 4.2.
:::::4.1.1. Je <code>zaciatok + 2 * dlzka_zoznamu - 1 <= pravy</code> ?
:::::::Ak áno:
:::::::::4.1.1.1. Nech <code>koniec = zaciatok + 2 * dlzka_podpola - 1</code>
:::::::Ak nie:
:::::::::4.1.1.1. Nech <code>koniec = pravy</code>
:::::4.1.2. Je <code>zaciatok + dlzka_podpola - 1 <= pravy</code> ?
:::::::Ak áno:
:::::::::4.1.2.1. Nech <code>stred = zaciatok + dlzka_podpola - 1</code>
:::::::Ak nie:
:::::::::4.1.2.1. Nech <code>stred = pravy</code>
:::::4.1.3. <code>Merge(pole[], zaciatok, stred, koniec)</code>
:::::4.1.4. <code>zaciatok += 2 * dlzka_podpola</code>
:::::4.1.5. Skoč na krok 4.1.
:::4.2. <code>dlzka_podpole *= 2</code>
:::4.3 Skoč na krok 4.

</tab>
</tabs>

==Implementácia algoritmov Merge a MergeSort v rôznych programovacích jazykoch==
<tabs>
<tab name="Rekurzívna: C " block>
<syntaxhighlight lang="C">
#include <stdio.h>
#include <stdlib.h>

void Merge(int pole[], int lavy, int stred, int pravy);
void MergeSort(int pole[], int lavy, int pravy);

/* hlavný program */

int main()
{
int pole[] = {12, 11, 13, 5, 6, 7};
int dlzka_pola = sizeof(pole) / sizeof(pole[0]);

printf("Pôvodné pole: \n");

for (int i = 0; i < dlzka_pola; ++i)
{
printf("%d ", pole[i]);
}

MergeSort(pole, 0, dlzka_pola - 1);

printf("\nUtriedené pole: \n");

for (int i = 0; i < dlzka_pola; ++i)
{
printf("%d ", pole[i]);
}

return 0;
}

void Merge(int pole[], int lavy, int stred, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči */

if (lavy >= pravy)
{
return;
}

/* vyrátaj dĺžky oboch polovíc poľa */

int L_dlzka = stred - lavy + 1;
int P_dlzka = pravy - stred;

/* alokuj dočasné polia, kam uložíš prvky z oboch polovíc poľa */

int *L = (int*)malloc(L_dlzka * sizeof(int));
int *P = (int*)malloc(P_dlzka * sizeof(int));

/* indexy, ktorými iterujeme všetky polia: i pre L, j pre P, k pre pole */

int i, j, k;

/* skopíruj obsah oboch polovíc poľa do dočasných polí L a P */

for (i = 0; i < L_dlzka; ++i)
{
L[i] = pole[lavy + i];
}

for (j = 0; j < P_dlzka; ++j)
{
P[j] = pole[stred + 1 + j];
}

/* nastav indexy na začiatok daných polí */

i = 0; j = 0; k = lavy;

/* zlučuj dočasné polia L a P do finálneho poľa pole */

while(i < L_dlzka && j < P_dlzka)
{
if(L[i] <= P[j])
{
pole[k++] = L[i++];
}
else
{
pole[k++] = P[j++];
}
}

/* ak ostali nejaké prvky v dočasnom poli L, skopíruj ich do finálneho poľa */

while(i < L_dlzka)
{
pole[k++] = L[i++];
}

/* ak ostali nejaké prvky v dočasnom poli P, skopíruj ich do finálneho poľa */

while(j < P_dlzka)
{
pole[k++] = P[j++];
}

/* uvoľni použitú pamäť */

free(L);
free(P);
}

void MergeSort(int pole[], int lavy, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči volanie */

if(lavy >= pravy)
{
return;
}
/* urči si prostredný index */

int stred = lavy + (pravy - lavy) / 2;

/* utrieď ľavú polovicu poľa */

MergeSort(pole, lavy, stred);

/* utrieď pravú polovicu poľa */

MergeSort(pole, stred+1, pravy);

/* zlúč obe polovice dokopy */

Merge(pole, lavy, stred, pravy);
}
</syntaxhighlight>
</tab>

<tab name="Iteračná: C" block>
<syntaxhighlight lang="C">
#include <stdio.h>
#include <stdlib.h>

void Merge(int pole[], int lavy, int stred, int pravy);
void MergeSortIt(int *pole, int lavy, int pravy);

/* hlavný program */

int main()
{
int pole[] = {12, 11, 13, 5, 6, 7, 19};
int dlzka_pola = sizeof(pole) / sizeof(pole[0]);

printf("Pôvodné pole %d: \n", dlzka_pola);

for (int i = 0; i < dlzka_pola; ++i)
{
printf("%d ", pole[i]);
}

MergeSortIt(pole, 0, dlzka_pola - 1);

printf("\nUtriedené pole: \n");

for (int i = 0; i < dlzka_pola; ++i)
{
printf("%d ", pole[i]);
}

return 0;
}

void Merge(int pole[], int lavy, int stred, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči */

if (lavy >= pravy)
{
return;
}

/* vyrátaj dĺžky oboch polovíc poľa */

int L_dlzka = stred - lavy + 1;
int P_dlzka = pravy - stred;

/* alokuj dočasné polia, kam uložíš prvky z oboch polovíc poľa */

int *L = (int*)malloc(L_dlzka * sizeof(int));
int *P = (int*)malloc(P_dlzka * sizeof(int));

/* indexy, ktorými iterujeme všetky polia: i pre L, j pre P, k pre pole */

int i, j, k;

/* skopíruj obsah oboch polovíc poľa do dočasných polí L a P */

for (i = 0; i < L_dlzka; ++i)
{
L[i] = pole[lavy + i];
}

for (j = 0; j < P_dlzka; ++j)
{
P[j] = pole[stred + 1 + j];
}

/* nastav indexy na začiatok daných polí */

i = 0; j = 0; k = lavy;

/* zlučuj dočasné polia L a P do finálneho poľa pole */

while(i < L_dlzka && j < P_dlzka)
{
if(L[i] <= P[j])
{
pole[k++] = L[i++];
}
else
{
pole[k++] = P[j++];
}
}

/* ak ostali nejaké prvky v dočasnom poli L, skopíruj ich do finálneho poľa */

while(i < L_dlzka)
{
pole[k++] = L[i++];
}

/* ak ostali nejaké prvky v dočasnom poli P, skopíruj ich do finálneho poľa */

while(j < P_dlzka)
{
pole[k++] = P[j++];
}

/* uvoľni použitú pamäť */

free(L);
free(P);
}

void MergeSortIt(int *pole, int lavy, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči volanie */

if(lavy >= pravy)
{
return;
}

int stred, koniec;

for (int dlzka_zoznamu = 1; dlzka_zoznamu <= pravy ; dlzka_zoznamu *= 2)
{
for (int zaciatok = lavy; zaciatok < pravy ; zaciatok += 2 * dlzka_zoznamu)
{
koniec = (zaciatok + 2 * dlzka_zoznamu - 1 <= pravy) ? zaciatok + 2 * dlzka_zoznamu - 1 : pravy;

stred = (zaciatok + dlzka_zoznamu - 1 <= pravy) ? zaciatok + dlzka_zoznamu - 1 : pravy;

Merge(pole, zaciatok, stred, koniec);

}
}
}

</syntaxhighlight>
</tab>

<tab name="Rekurzívna: C++" block>
<syntaxhighlight lang="C++">
#include <iostream>

using std::cout;
using std::endl;

void Merge(int pole[], int lavy, int stred, int pravy);
void MergeSort(int pole[], int lavy, int pravy);

/* hlavný program */

int main()
{
int pole[] = {12, 11, 13, 5, 6, 7};
int dlzka_pola = sizeof(pole) / sizeof(pole[0]);

printf("Pôvodné pole: \n");

for (auto i: pole)
{
cout<<i<<" ";
}

MergeSort(pole, 0, dlzka_pola - 1);

cout<<endl<<"Utriedené pole:"<<endl;

for (auto i: pole)
{
cout<<i<<" ";
}

return 0;
}

void Merge(int pole[], int lavy, int stred, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči */

if (lavy >= pravy)
{
return;
}

/* vyrátaj dĺžky oboch polovíc poľa */

int L_dlzka = stred - lavy + 1;
int P_dlzka = pravy - stred;

/* alokuj dočasné polia, kam uložíš prvky z oboch polovíc poľa */

int *L = new int[L_dlzka];
int *P = new int[P_dlzka];

/* indexy, ktorými iterujeme všetky polia: i pre L, j pre P, k pre pole */

int i, j, k;

/* skopíruj obsah oboch polovíc poľa do dočasných polí L a P */

for (i = 0; i < L_dlzka; ++i)
{
L[i] = pole[lavy + i];
}

for (j = 0; j < P_dlzka; ++j)
{
P[j] = pole[stred + 1 + j];
}

/* nastav indexy na začiatok daných polí */

i = 0; j = 0; k = lavy;

/* zlučuj dočasné polia L a P do finálneho poľa pole */

while(i < L_dlzka && j < P_dlzka)
{
if(L[i] <= P[j])
{
pole[k++] = L[i++];
}
else
{
pole[k++] = P[j++];
}
}

/* ak ostali nejaké prvky v dočasnom poli L, skopíruj ich do finálneho poľa */

while(i < L_dlzka)
{
pole[k++] = L[i++];
}

/* ak ostali nejaké prvky v dočasnom poli P, skopíruj ich do finálneho poľa */

while(j < P_dlzka)
{
pole[k++] = P[j++];
}

/* uvoľni použitú pamäť */

delete []L;
delete []P;
}

void MergeSort(int pole[], int lavy, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči volanie */

if(lavy >= pravy)
{
return;
}
/* urči si prostredný index */

int stred = lavy + (pravy - lavy) / 2;

/* utrieď ľavú polovicu poľa */

MergeSort(pole, lavy, stred);

/* utrieď pravú polovicu poľa */

MergeSort(pole, stred+1, pravy);

/* zlúč obe polovice dokopy */

Merge(pole, lavy, stred, pravy);
}

</syntaxhighlight>
</tab>

<tab name="Iteračná: C++" block>
<syntaxhighlight lang="C++">
#include <iostream>

using std::cout;
using std::endl;

void Merge(int pole[], int lavy, int stred, int pravy);
void MergeSort(int pole[], int lavy, int pravy);

/* hlavný program */

int main()
{
int pole[] = {12, 11, 13, 5, 6, 7};
int dlzka_pola = sizeof(pole) / sizeof(pole[0]);

printf("Pôvodné pole: \n");

for (auto i: pole)
{
cout<<i<<" ";
}

MergeSort(pole, 0, dlzka_pola - 1);

cout<<endl<<"Utriedené pole:"<<endl;

for (auto i: pole)
{
cout<<i<<" ";
}

return 0;
}

void Merge(int pole[], int lavy, int stred, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči */

if (lavy >= pravy)
{
return;
}

/* vyrátaj dĺžky oboch polovíc poľa */

int L_dlzka = stred - lavy + 1;
int P_dlzka = pravy - stred;

/* alokuj dočasné polia, kam uložíš prvky z oboch polovíc poľa */

int *L = new int[L_dlzka];
int *P = new int[P_dlzka];

/* indexy, ktorými iterujeme všetky polia: i pre L, j pre P, k pre pole */

int i, j, k;

/* skopíruj obsah oboch polovíc poľa do dočasných polí L a P */

for (i = 0; i < L_dlzka; ++i)
{
L[i] = pole[lavy + i];
}

for (j = 0; j < P_dlzka; ++j)
{
P[j] = pole[stred + 1 + j];
}

/* nastav indexy na začiatok daných polí */

i = 0; j = 0; k = lavy;

/* zlučuj dočasné polia L a P do finálneho poľa pole */

while(i < L_dlzka && j < P_dlzka)
{
if(L[i] <= P[j])
{
pole[k++] = L[i++];
}
else
{
pole[k++] = P[j++];
}
}

/* ak ostali nejaké prvky v dočasnom poli L, skopíruj ich do finálneho poľa */

while(i < L_dlzka)
{
pole[k++] = L[i++];
}

/* ak ostali nejaké prvky v dočasnom poli P, skopíruj ich do finálneho poľa */

while(j < P_dlzka)
{
pole[k++] = P[j++];
}

/* uvoľni použitú pamäť */

delete []L;
delete []P;
}

void MergeSort(int *pole, int lavy, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči volanie */

if(lavy >= pravy)
{
return;
}

int stred, koniec;

for (int dlzka_zoznamu = 1; dlzka_zoznamu <= pravy; dlzka_zoznamu *= 2)
{
for (int zaciatok = lavy; zaciatok < pravy; zaciatok += 2 * dlzka_zoznamu)
{
koniec = (zaciatok + 2 * dlzka_zoznamu - 1 <= pravy) ? zaciatok + 2 * dlzka_zoznamu - 1 : pravy;

stred = (zaciatok + dlzka_zoznamu - 1 <= pravy) ? zaciatok + dlzka_zoznamu - 1 : pravy;

Merge(pole, zaciatok, stred, koniec);
}
}
}
</syntaxhighlight>
</tab>

<tab name="Rekurzívna: Java" block>
<syntaxhighlight lang="Java">
class MergeSort
{

/* Funkcia zlúči 2 podpolia, ktoré sme vytvorili z pôvodného poľa.
* Každé podpole má polovičnú dĺžku pôvodného poľa.
* podpole1 [ľavý ... stred]
* podpole2 [stred + 1 ... pravý]
*/

void merge(int[] pole, int lavy, int stred, int pravy)
{

// Výpočet dĺžky 2 podpolí

int n1 = stred - lavy + 1;
int n2 = pravy - stred;

// Vytvorenie pomocných polí

int[] L = new int[n1];
int[] P = new int[n2];

// Načítanie dát do pomocných polí

for (int i = 0; i < n1; i++)
L[i] = pole[lavy + i];

for (int j = 0; j < n2; j++)
P[j] = pole[stred + 1 + j];

// Počiatočné indexy prvého a druhého podpoľa

int i = 0, j = 0;

// Počiatočný index zlúčeného podpoľa

int k = lavy;

// Zlúčenie dvoch podpolí

while (i < n1 && j < n2)
{
if (L[i] <= P[j])
{
pole[k] = L[i];
i++;
}
else
{
pole[k] = P[j];
j++;
}
k++;
}

/* V prípade, že sa v jednom zo podpolí nachádzajú ešte nejaké prvky, ktoré neboli zlúčené do poľa,
* tak sa do poľa jednoducho skopírujú
*/

while (i < n1)
{
pole[k] = L[i];
i++;
k++;
}

while (j < n2)
{
pole[k] = P[j];
k++;
j++;
}

}

/* Funkcia, ktorá zoradí pole použitím funkcie merge() */

void sort (int[] pole, int lavy, int pravy)
{
if (lavy < pravy)
{
// Musíme nájsť stred poľa

int stred = lavy + (pravy - lavy) / 2;

// Zoradíme prvú a druhú polovicu poľa samostatne

sort(pole, lavy, stred);
sort(pole, stred + 1, pravy);

// Zlúčime zoradené polovice do jedného poľa

merge(pole, lavy, stred, pravy);
}
}
}

public class Main
{
/* Funkcia na výpis poľa dĺžky n */

static void vypis_pole(int[] pole)
{

for (int j : pole)
{
System.out.print(j + " ");
}

System.out.println();
}

/* Hlavný program */

public static void main(String[] args)
{
int[] pole = {12, 11, 13, 5, 6, 7};

System.out.println("Zadané pole:");
vypis_pole(pole);

MergeSort ms = new MergeSort();
ms.sort(pole, 0, pole.length - 1);

System.out.println("\nZoradené pole:");
vypis_pole(pole);
}
}
</syntaxhighlight>
</tab>

<tab name="Iteračná: Java" block>
<syntaxhighlight lang="Java">
class MergeSort_iteracia
{
/* Zlúči 2 podpolia, ktoré sa vytvorili z pôvodného poľa.
* Každé podpole má polovičnú dĺžku pôvodného poľa.
* podpole1 [ľavý..stred]
* podpole2 [stred+1..pravý]
*/

void merge(int[] pole, int lavy, int stred, int pravy)
{
// Výpočet dĺžky 2 podpolí

int n1 = stred - lavy + 1;
int n2 = pravy - stred;

// Vytvorenie pomocných polí

int[] L = new int[n1];
int[] P = new int[n2];

// Načítanie dát do pomocných polí

for (int i = 0; i < n1; i++)
L[i] = pole[lavy + i];

for (int j = 0; j < n2; j++)
P[j] = pole[stred + 1 + j];

// Počiatočné indexy prvého a druhého podpoľa

int i = 0, j = 0;

// Počiatočný index zlúčeného podpoľa

int k = lavy;

// Zlúčenie dvoch podpolí

while (i < n1 && j < n2)
{
if (L[i] <= P[j])
{
pole[k] = L[i];
i++;
}
else
{
pole[k] = P[j];
j++;
}
k++;
}

/* V prípade, že v jednom z podpolí sa nachádzajú prvky, ktoré neboli zlúčené do poľa,
* tak sa do poľa jednoducho skopírujú
*/

while (i < n1)
{
pole[k] = L[i];
i++;
k++;
}

while (j < n2)
{
pole[k] = P[j];
k++;
j++;
}
}

/* Funkcia, ktorá zoradí pole použitím funkcie merge() */

void sort (int[] pole, int n)
{
/* Dĺžka podpolí, ktoré majú byť zlúčené, hodnoty premennej sa pohybujú v intervale <1;n-1> */

int aktual_dlzka;

/* Začiatočný index ľavého podpoľa, ktoré má byť zlúčené */

int zaciatok_vlavo;

/* Vzostupné usporiadanie prvkov. Najskôr sa zlúčia podpolia veľkosti 1 do podpolí veľkosti 2,
* potom podpolia veľkosti 2 do podpolí veľkosti 4 a tak ďalej
*/

for (aktual_dlzka = 1; aktual_dlzka <= n - 1; aktual_dlzka *= 2)
{
/* Určenie začiatočného prvku rôznych podpolí aktuálnej dĺžky podpoľa */

for (zaciatok_vlavo = 0; zaciatok_vlavo < n - 1; zaciatok_vlavo += 2 * aktual_dlzka)
{
/* Nájdenie konečného prvku ľavého podpoľa, stred+1 je začiatočný prvok pravého podpoľa */

int stred = Math.min(zaciatok_vlavo + aktual_dlzka - 1, n - 1);
int koniec_vpravo = Math.min(zaciatok_vlavo + 2 * aktual_dlzka - 1, n - 1);

/* Zlúči podpolia L[zaciatok_vlavo .. stred] & P[stred+1 .. koniec_vpravo] */

merge(pole, zaciatok_vlavo, stred, koniec_vpravo);
}
}
}
}

public class Main {

/* Funkcia na výpis poľa dĺžky n */

static void vypis_pole(int[] pole)
{
int n = pole.length;

for (int j : pole)
{
System.out.print(j + " ");
}
System.out.println();
}

/* Hlavný program */

public static void main(String[] args) {

/* Inicializácia poľa */

int[] pole = {12, 11, 13, 5, 6, 7};

System.out.println("Zadané pole:");
vypis_pole(pole);

MergeSort_iteracia ms_it = new MergeSort_iteracia();
ms_it.sort(pole, pole.length);

System.out.println("Zoradené pole:");
vypis_pole(pole);
}
}
</syntaxhighlight>
</tab>

<tab name="Rekurzívna: Python3" block>
<syntaxhighlight lang="Python3">
def MergeSort(pole):
if len(pole) > 1:

# Nájdenie stredu poľa
# zápis len(pole)//2 znamená, že dĺžka poľa sa vydelí 2 a výsledok je celé číslo

stred = len(pole) // 2

# Rozdelenie poľa na dve časti

L = pole[:stred]
P = pole[stred:]

# Zoradenie najskôr prvej časti poľa, potom druhej

MergeSort(L)
MergeSort(P)

i = j = k = 0

# Zlúčenie a zoradenie údajov z pomocných polí do jedného poľa

while i < len(L) and j < len(P):
if L[i] < P[j]:
pole[k] = L[i]
i += 1
else:
pole[k] = P[j]
j += 1
k += 1

# Kontrola či všetky prvky boli zlúčené dokopy,
# ak nie, tak sa do zlúčeného poľa jednoducho skopírujú

while i < len(L):
pole[k] = L[i]
i += 1
k += 1

while j < len(P):
pole[k] = P[j]
j += 1
k += 1

# Hlavný program

if __name__ == '__main__':

pole = [12, 11, 13, 5, 6, 7]

print("Zadané pole:", end="\n")
print(pole, end="\n")

MergeSort(pole)

print("Zoradené pole:", end="\n")
print(pole, end="\n")

</syntaxhighlight>
</tab>

<tab name="Iteračná: Python3" block>
<syntaxhighlight lang="Python3">
def MergeSort_iteracia(pole):

# Dĺžka podpolí, ktoré majú byť zlúčené, hodnoty premennej sa pohybujú v intervale <1;n-1>

aktual_dlzka = 1

# Vonkajší cyklus, ktorý určuje podpolia aktuálnej dĺžky

while aktual_dlzka < len(pole) - 1:

lavy = 0

# Vnútorný cyklus, ktorý slúži na zlúčenie a zoradenie podpolí do jedného podpoľa

while lavy < len(pole) - 1:

# Index stredného prvku sa určí, keď k indexu ľavého prvku podpoľa pripočítame aktuálnu
# dĺžku podpolí a odčítame 1

stred = min((lavy + aktual_dlzka - 1), len(pole) - 1)

# Ak platí podmienka 2 * aktuálna dĺžka < dĺžka poľa - 1, tak pravý index = aktuálnej dĺžke subpolí,
# inak pravý index = dĺžka poľa - 1

pravy = ((2 * aktual_dlzka + lavy - 1, len(pole) - 1)[2 * aktual_dlzka + lavy - 1 > len(pole) - 1])

# Volanie funkcie merge

merge(pole, lavy, stred, pravy)

lavy = lavy + 2 * aktual_dlzka

# Aktuálna dĺžka sa sa zmení na dvojnásobok jej predošlej hodnoty

aktual_dlzka = 2 * aktual_dlzka

def merge(pole, lavy, stred, pravy):

n1 = stred - lavy + 1
n2 = pravy - stred

# Inicializácia pomocných polí

L = [0] * n1
P = [0] * n2

# Načítanie dát do pomocných polí

for i in range(0, n1):
L[i] = pole[lavy + i]
for i in range(0, n2):
P[i] = pole[stred + i + 1]

i, j, k = 0, 0, lavy

# Zlúčenie a zoradenie údajov z pomocných polí do jedného poľa

while i < n1 and j < n2:
if L[i] > P[j]:
pole[k] = P[j]
j += 1
else:
pole[k] = L[i]
i += 1
k += 1

# Kontrola či všetky prvky boli zlúčené dokopy,
# ak nie, tak sa do zlúčeného pola jednoducho skopírujú

while i < n1:
pole[k] = L[i]
i += 1
k += 1

while j < n2:
pole[k] = P[j]
j += 1
k += 1

# Hlavný program

if __name__ == '__main__':

pole = [12, 11, 13, 5, 6, 7]

print("Zadané pole:", end="\n")
print(pole, end="\n")

MergeSort_iteracia(pole)

print("Zoradené pole:", end="\n")
print(pole, end="\n")

</syntaxhighlight>
</tab>

</tabs>

==Odkazy==
# https://www.geeksforgeeks.org/merge-sort/
# https://www.geeksforgeeks.org/iterative-merge-sort/
# https://medium.com/@paulsoham/merge-sort-63d75df76388
# https://www.khanacademy.org/computing/computer-science/algorithms/merge-sort/a/overview-of-merge-sort
# https://www.tutorialspoint.com/data_structures_algorithms/merge_sort_algorithm.htm
# https://www.youtube.com/watch?v=6pV2IF0fgKY
# https://www.youtube.com/watch?v=mB5HXBb_HY8
# https://www.youtube.com/watch?v=ak-pz7tS5DE

Triedenie zlučovaním

2021-03-29T16:22:35Z

Filip Tomek: /* Implementácia algoritmov Merge a MergeSort v rôznych programovacích jazykoch */

[[Kategória:Algoritmy triedenia]]
{{Draft}}
{{Skripta programovanie}}
__TOC__
==Zlučovací algoritmus Merge==
[[Súbor:Funkcia merge.png|500px|náhľad|vpravo|Vizualizácia funkcie Merge: Máme pole prvkov ''p = [1, 3, 5, 2, 4, 6]'', ktoré je už čiastočne utriedené. Použijeme algoritmus Merge, ktorý si vytvorí pomocné polia ''L = [1, 3, 5]'' a ''P = [2, 4, 6]''. Všetky polia indexujeme od ''0'', pričom pre pole ''p'' používame index ''k'', pre ''L'' index ''i'' a pre ''P'' index ''j''. Postupnosť krokov je označená číslicami 1 až 6.
]]

Princíp zlučovania tkvie v tom, že máme dva alebo viac utriedených zoznamov, ktoré skombinuje do jedného utriedeného zoznamu (výsledný zoznam musí obsahovať všetky prvky z pôvodných zoznamov). Zoznam môže byť reprezentovaný ako dátová štruktúra pole alebo aj ako lineárny zoznam. V tomto článku sa zameriame na algoritmus pre dátovú štruktúru pole.

Algoritmus ''Merge'' tvorí kľúčovú časť triediaceho algoritmu ''MergeSort''.

===Slovný opis algoritmu===
Nech máme pole, ktoré sa skladá z dvoch už utriedených polovíc. Vytvoríme si dve pomocné polia ''L'' a ''P'' a do každého z nich skopírujeme obsah jednej polovice (''L'' - ľavá polovica, ''P'' - pravá polovica). Potom súčasne prechádzame polia ''L'' a ''P'' od začiatku po koniec, pričom v každom cykle porovnáme prvok poľa ''L'' s prvkom v poli ''P''. Z tejto dvojice následne vyberieme minimum, (keď triedime od najmenšieho po najväčší) ktoré vložíme na prvú voľnú pozíciu pôvodného poľa (na začiatku je to prvá pozícia poľa). Nakoniec zvýšime index pri vstupnom poli a pri pomocnom poli, z ktorého vyberáme daný prvok. Túto postupnosť krokov opakujeme, pokiaľ neprídeme na koniec jedného z polí ''P'' a ''L''. Ak nastane situácia, že prídeme na koniec jedného z pomocných polí (a v druhom nám ostali ešte nejaké prvky), potom už iba naspäť skopírujeme zbytok druhého pomocného poľa na koniec pôvodného poľa.

===Vlastnosti algoritmu===
* vhodný pre dátové štruktúry: pole, lineárny zoznam
* časová náročnosť: vždy lineárna <math>O(n)</math>
* priestorová náročnosť: lineárna <math>O(n)</math> pre pole (alokovanie pomocných polí), <math>O(1)</math> pre lineárny zoznam (pri lineárnom zozname netreba alokovať dočasné polia, stačí iba presmerovať smerníky)
* využitie: kľúčový podprogram pre triediaci algoritmus MergeSort

===Pseudokód===
Nech funkcia ''Merge'' má nasledovný prototyp: <code>Merge(pole[], lavy, stred, pravy)</code>
:1. Je <code>lavy >= pravy ? Ak áno, skonči, inak pokračuj krokom 2.</code>
:2. Nech: <code>i = 0, j = 0, k = lavy </code>
:3. Nech: <code>dlzka_L = stred - lavy + 1, dlzka_P = pravy - stred</code>
:4. Nech: <code> L = pole[lavy ... stred], P = pole[stred + 1 ... pravy] </code>
:5. Je <code>i < dlzka_L</code> a zároveň <code>j < dlzka_P</code> ? Ak áno, pokračuj krokom 5.1., inak skoč na krok 6.
:::5.1. Je <code>L[i] <= P[j]</code>?
:::: Ak áno:
:::::5.1.1. <code>pole[k] = L[i]</code>
:::::5.1.2. <code>k += 1</code>
:::::5.1.3. <code>i += 1</code>
:::::5.1.4. Skoč na krok 5.
:::: Ak nie:
:::::5.1.1. <code>pole[k] = P[j]</code>
:::::5.1.2. <code>k += 1</code>
:::::5.1.3. <code>j += 1</code>
:::::5.1.4. Skoč na krok 5.
:6. Je <code>i < dlzka_L</code> ? Ak áno, pokračuj krokom 6.1., inak skoč na krok 7.
:::6.1. <code>pole[k] = L[i]</code>
:::6.2. <code>k += 1</code>
:::6.3. <code>i += 1</code>
:::6.4. Skoč na krok 6.
:7. Je <code>j < dlzka_P</code> ? Ak áno, pokračuj krokom 7.1., inak skonči.
:::7.1. <code>pole[k] = P[j]</code>
:::7.2. <code>k += 1</code>
:::7.3. <code>j += 1</code>
:::7.4. Skoč na krok 7.

==MergeSort==
''MergeSort'' je triediaci algoritmus, ktorý využíva stratégiu '''"rozdeľuj a panuj"''', čo znamená, že vstupný zoznam najskôr rozdelí menšie časti, tie zoradí a potom ich zlúči naspäť dokopy. Radí sa medzi najpoužívanejšie a najviac rešpektované triediace algoritmy.

===Vlastnosti algoritmu Merge Sort===
* vhodný pre dátové štruktúry: pole, lineárny zoznam
* časová náročnosť: vždy linearitmická <math> O(n.log(n)) </math>, vďaka ktorej dokáže efektívne triediť veľmi veľké zoznamy
* priestorová náročnosť: lineárna <math>O(n)</math> pre pole (alokovanie dočasných polí), konštantná <math>O(1)</math> pre lineárny zoznam (pri lineárnom zozname stačí iba presmerovať smerníky)
* druh triedenia: triedenie zlučovaním (komparačný algoritmus)
* stabilita triedenia: stabilný
* miesto triedenia: externé triedenie (vhodný na triedenie veľkých objemov dát uložených na disku)

Z hľadiska implementácie môžeme vytvoriť dve základné verzie algoritmu, a to ''rekurzívnu'' a ''iteračnú''.

===Opis rekurzívnej a iteračnej verzie algoritmu Merge Sort===

<tabs>
<tab name="Rekurzívna verzia" block>
[[Súbor:Merge sort.png|400px|náhľad|vpravo|Vizualizácia rekurzívnej verzie algoritmu MergeSort]]

===Princíp algoritmu===
Algoritmus ''MergeSort'' vykonáva 4 základné úlohy:
# Delenie poľa na dve polovice.
# Triedenie ľavej polovice poľa.
# Triedenie pravej polovice poľa.
# Zlúčenie oboch polovíc pomocou funkcie ''Merge''.

===Slovný opis===
Našou úlohou je vzostupne (min -> max) utriediť vstupné pole. Určíme si ''stred'' poľa (pri párnom počte prvkov je to ten menší z prostredných indexov). Následne vykonávame sériu rekurzívnych delení pre ľavú a pravú časť poľa (''začiatok ... stred ; stred + 1 ... koniec'') až do momentu, keď nám ostanú len jednoprvkové podpolia (tie sú už utriedené). Následne v každom volaní obe tieto podpolia zlúčime pomocou algoritmu ''Merge'' do väčších podpolí (2, 4, 8, ...), až nakoniec dostaneme jedno výsledné utriedené pole.

===Pseudokód===
Nech nech má funkcia ''MergeSort'' nasledovný prototyp: <code>MergeSort(pole[], lavy, pravy) </code>
:1. Je <code>lavy >= pravy</code> ? Ak áno, skonči volanie, inak pokračuj krokom 2.
:2. Nech: <code>stred = lavy + (pravy - lavy) / 2</code>, pričom znak ''/'' vyjadruje celočíselné delenie.
:3. Rekurzívne zavolaj funkciu <code>MergeSort(pole[], lavy , stred)</code>
:3. Rekurzívne zavolaj funkciu <code>MergeSort(pole[], stred + 1 , pravy)</code>
:4. Zavolaj funkciu <code>Merge(pole[], lavy, stred, pravy)</code>
:5. Skonči volanie.

</tab>
<tab name="Iteračná verzia" block>
[[Súbor:MergeSort IT.png|400px|náhľad|vpravo]]

===Princíp algoritmu===
Algoritmus ''MergeSort'' vykonáva 3 základné úlohy:
# Vonkajší cyklus: určenie veľkosti zoznamu na zlučovanie.
# Vnútorný cyklus: prechádzanie jednotlivých zoznamov v poli.
# Zlučovanie jednotlivých zoznamov pomocou funkcie ''Merge''.

===Slovný opis===
Vstupné pole, ktoré má ''N'' prvkov, môžeme chápať, ako ''N'' rôznych jednoprvkových (utriedených) podpolí, ktoré máme zlúčiť do jedného výsledného ''N''-prvkového utriedeného poľa. Keďže by bolo veľmi nepraktické zlučovať ''N'' podpolí naraz, zvolíme nasledovnú stratégiu: Budeme prechádzať dané pole od začiatku po koniec a v prvom cykle zlúčime každé dva prvky, takže budeme mať <math>\frac{n}{2}</math> dvojprvkových utriedených podpolí. Potom v druhom cykle zlúčime každé 4 prvky do jedného podpoľa, v treťom cykle každých 8, až do momentu, keď dostaneme jedno utriedené pole.
Aby sme to docielili, potrebujeme dva cykly, vonkajší, ktorý nastaví maximálnu veľkosť podpoľa, ktoré ideme zlučovať (1,2,4,8 ... ''dlzka - 1'') a vnútorný, ktorý prechádza jednotlivé podpolia. Následne už iba voláme funkciu ''Merge'', ktorá dané podpolia zlučuje.

Poznámka, ak máme ''pole'', ktoré má nepárny počet prvkov, tak ten posledný prvok nezlúčime hneď v prvom cykle, ale až v tých ďalších. Takisto, ak ''N'' nie je mocnina čísla 2, tak musíme samozrejme ošetriť situáciu, kedy by sme sa dostali mimo rozsah poľa (Ak máme napríklad ''pole'', čo má 7 prvkov, tak po prvej iterácii budú prvky utiredené podľa vzoru 2 + 2 + 2 + 1, po druhej 4 + 3, a po tretej 7)

===Pseudokód===
Nech nech má funkcia ''MergeSort'' nasledovný prototyp: <code>MergeSort(pole[], lavy, pravy) </code>
:1. Je <code>lavy >= pravy</code> ? Ak áno, skonči, inak pokračuj krokom 2.
:2. Nech: <code>dlzka_podpola = 1 </code>
:3. Nech: <code>zaciatok = lavy</code>
:4. Je<code>dlzka_podpola <= pravy</code> ? Ak áno pokračuj krokom 4.1, inak skonči.
:::4.1. Je<code>zaciatok < pravy</code> Ak áno pokračuj krokom 4.1.1, inak skoč na krok 4.2.
:::::4.1.1. Je <code>zaciatok + 2 * dlzka_zoznamu - 1 <= pravy</code> ?
:::::::Ak áno:
:::::::::4.1.1.1. Nech <code>koniec = zaciatok + 2 * dlzka_podpola - 1</code>
:::::::Ak nie:
:::::::::4.1.1.1. Nech <code>koniec = pravy</code>
:::::4.1.2. Je <code>zaciatok + dlzka_podpola - 1 <= pravy</code> ?
:::::::Ak áno:
:::::::::4.1.2.1. Nech <code>stred = zaciatok + dlzka_podpola - 1</code>
:::::::Ak nie:
:::::::::4.1.2.1. Nech <code>stred = pravy</code>
:::::4.1.3. <code>Merge(pole[], zaciatok, stred, koniec)</code>
:::::4.1.4. <code>zaciatok += 2 * dlzka_podpola</code>
:::::4.1.5. Skoč na krok 4.1.
:::4.2. <code>dlzka_podpole *= 2</code>
:::4.3 Skoč na krok 4.

</tab>
</tabs>

==Implementácia algoritmov Merge a MergeSort v rôznych programovacích jazykoch==
<tabs>
<tab name="Rekurzívna: C " block>
<syntaxhighlight lang="C">
#include <stdio.h>
#include <stdlib.h>

void Merge(int pole[], int lavy, int stred, int pravy);
void MergeSort(int pole[], int lavy, int pravy);

/* hlavný program */

int main()
{
int pole[] = {12, 11, 13, 5, 6, 7};
int dlzka_pola = sizeof(pole) / sizeof(pole[0]);

printf("Pôvodné pole: \n");

for (int i = 0; i < dlzka_pola; ++i)
{
printf("%d ", pole[i]);
}

MergeSort(pole, 0, dlzka_pola - 1);

printf("\nUtriedené pole: \n");

for (int i = 0; i < dlzka_pola; ++i)
{
printf("%d ", pole[i]);
}

return 0;
}

void Merge(int pole[], int lavy, int stred, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči */

if (lavy >= pravy)
{
return;
}

/* vyrátaj dĺžky oboch polovíc poľa */

int L_dlzka = stred - lavy + 1;
int P_dlzka = pravy - stred;

/* alokuj dočasné polia, kam uložíš prvky z oboch polovíc poľa */

int *L = (int*)malloc(L_dlzka * sizeof(int));
int *P = (int*)malloc(P_dlzka * sizeof(int));

/* indexy, ktorými iterujeme všetky polia: i pre L, j pre P, k pre pole */

int i, j, k;

/* skopíruj obsah oboch polovíc poľa do dočasných polí L a P */

for (i = 0; i < L_dlzka; ++i)
{
L[i] = pole[lavy + i];
}

for (j = 0; j < P_dlzka; ++j)
{
P[j] = pole[stred + 1 + j];
}

/* nastav indexy na začiatok daných polí */

i = 0; j = 0; k = lavy;

/* zlučuj dočasné polia L a P do finálneho poľa pole */

while(i < L_dlzka && j < P_dlzka)
{
if(L[i] <= P[j])
{
pole[k++] = L[i++];
}
else
{
pole[k++] = P[j++];
}
}

/* ak ostali nejaké prvky v dočasnom poli L, skopíruj ich do finálneho poľa */

while(i < L_dlzka)
{
pole[k++] = L[i++];
}

/* ak ostali nejaké prvky v dočasnom poli P, skopíruj ich do finálneho poľa */

while(j < P_dlzka)
{
pole[k++] = P[j++];
}

/* uvoľni použitú pamäť */

free(L);
free(P);
}

void MergeSort(int pole[], int lavy, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči volanie */

if(lavy >= pravy)
{
return;
}
/* urči si prostredný index */

int stred = lavy + (pravy - lavy) / 2;

/* utrieď ľavú polovicu poľa */

MergeSort(pole, lavy, stred);

/* utrieď pravú polovicu poľa */

MergeSort(pole, stred+1, pravy);

/* zlúč obe polovice dokopy */

Merge(pole, lavy, stred, pravy);
}
</syntaxhighlight>
</tab>

<tab name="Iteračná: C" block>
<syntaxhighlight lang="C">
#include <stdio.h>
#include <stdlib.h>

void Merge(int pole[], int lavy, int stred, int pravy);
void MergeSortIt(int *pole, int lavy, int pravy);

/* hlavný program */

int main()
{
int pole[] = {12, 11, 13, 5, 6, 7, 19};
int dlzka_pola = sizeof(pole) / sizeof(pole[0]);

printf("Pôvodné pole %d: \n", dlzka_pola);

for (int i = 0; i < dlzka_pola; ++i)
{
printf("%d ", pole[i]);
}

MergeSortIt(pole, 0, dlzka_pola - 1);

printf("\nUtriedené pole: \n");

for (int i = 0; i < dlzka_pola; ++i)
{
printf("%d ", pole[i]);
}

return 0;
}

void Merge(int pole[], int lavy, int stred, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči */

if (lavy >= pravy)
{
return;
}

/* vyrátaj dĺžky oboch polovíc poľa */

int L_dlzka = stred - lavy + 1;
int P_dlzka = pravy - stred;

/* alokuj dočasné polia, kam uložíš prvky z oboch polovíc poľa */

int *L = (int*)malloc(L_dlzka * sizeof(int));
int *P = (int*)malloc(P_dlzka * sizeof(int));

/* indexy, ktorými iterujeme všetky polia: i pre L, j pre P, k pre pole */

int i, j, k;

/* skopíruj obsah oboch polovíc poľa do dočasných polí L a P */

for (i = 0; i < L_dlzka; ++i)
{
L[i] = pole[lavy + i];
}

for (j = 0; j < P_dlzka; ++j)
{
P[j] = pole[stred + 1 + j];
}

/* nastav indexy na začiatok daných polí */

i = 0; j = 0; k = lavy;

/* zlučuj dočasné polia L a P do finálneho poľa pole */

while(i < L_dlzka && j < P_dlzka)
{
if(L[i] <= P[j])
{
pole[k++] = L[i++];
}
else
{
pole[k++] = P[j++];
}
}

/* ak ostali nejaké prvky v dočasnom poli L, skopíruj ich do finálneho poľa */

while(i < L_dlzka)
{
pole[k++] = L[i++];
}

/* ak ostali nejaké prvky v dočasnom poli P, skopíruj ich do finálneho poľa */

while(j < P_dlzka)
{
pole[k++] = P[j++];
}

/* uvoľni použitú pamäť */

free(L);
free(P);
}

void MergeSortIt(int *pole, int lavy, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči volanie */

if(lavy >= pravy)
{
return;
}

int stred, koniec;

for (int dlzka_zoznamu = 1; dlzka_zoznamu <= pravy ; dlzka_zoznamu *= 2)
{
for (int zaciatok = lavy; zaciatok < pravy ; zaciatok += 2 * dlzka_zoznamu)
{
koniec = (zaciatok + 2 * dlzka_zoznamu - 1 <= pravy) ? zaciatok + 2 * dlzka_zoznamu - 1 : pravy;

stred = (zaciatok + dlzka_zoznamu - 1 <= pravy) ? zaciatok + dlzka_zoznamu - 1 : pravy;

Merge(pole, zaciatok, stred, koniec);

}
}
}

</syntaxhighlight>
</tab>

<tab name="Rekurzívna: C++" block>
<syntaxhighlight lang="C++">
#include <iostream>

using std::cout;
using std::endl;

void Merge(int pole[], int lavy, int stred, int pravy);
void MergeSort(int pole[], int lavy, int pravy);

/* hlavný program */

int main()
{
int pole[] = {12, 11, 13, 5, 6, 7};
int dlzka_pola = sizeof(pole) / sizeof(pole[0]);

printf("Pôvodné pole: \n");

for (auto i: pole)
{
cout<<i<<" ";
}

MergeSort(pole, 0, dlzka_pola - 1);

cout<<endl<<"Utriedené pole:"<<endl;

for (auto i: pole)
{
cout<<i<<" ";
}

return 0;
}

void Merge(int pole[], int lavy, int stred, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči */

if (lavy >= pravy)
{
return;
}

/* vyrátaj dĺžky oboch polovíc poľa */

int L_dlzka = stred - lavy + 1;
int P_dlzka = pravy - stred;

/* alokuj dočasné polia, kam uložíš prvky z oboch polovíc poľa */

int *L = new int[L_dlzka];
int *P = new int[P_dlzka];

/* indexy, ktorými iterujeme všetky polia: i pre L, j pre P, k pre pole */

int i, j, k;

/* skopíruj obsah oboch polovíc poľa do dočasných polí L a P */

for (i = 0; i < L_dlzka; ++i)
{
L[i] = pole[lavy + i];
}

for (j = 0; j < P_dlzka; ++j)
{
P[j] = pole[stred + 1 + j];
}

/* nastav indexy na začiatok daných polí */

i = 0; j = 0; k = lavy;

/* zlučuj dočasné polia L a P do finálneho poľa pole */

while(i < L_dlzka && j < P_dlzka)
{
if(L[i] <= P[j])
{
pole[k++] = L[i++];
}
else
{
pole[k++] = P[j++];
}
}

/* ak ostali nejaké prvky v dočasnom poli L, skopíruj ich do finálneho poľa */

while(i < L_dlzka)
{
pole[k++] = L[i++];
}

/* ak ostali nejaké prvky v dočasnom poli P, skopíruj ich do finálneho poľa */

while(j < P_dlzka)
{
pole[k++] = P[j++];
}

/* uvoľni použitú pamäť */

delete []L;
delete []P;
}

void MergeSort(int pole[], int lavy, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči volanie */

if(lavy >= pravy)
{
return;
}
/* urči si prostredný index */

int stred = lavy + (pravy - lavy) / 2;

/* utrieď ľavú polovicu poľa */

MergeSort(pole, lavy, stred);

/* utrieď pravú polovicu poľa */

MergeSort(pole, stred+1, pravy);

/* zlúč obe polovice dokopy */

Merge(pole, lavy, stred, pravy);
}

</syntaxhighlight>
</tab>

<tab name="Iteračná: C++" block>
<syntaxhighlight lang="C++">
#include <iostream>

using std::cout;
using std::endl;

void Merge(int pole[], int lavy, int stred, int pravy);
void MergeSort(int pole[], int lavy, int pravy);

/* hlavný program */

int main()
{
int pole[] = {12, 11, 13, 5, 6, 7};
int dlzka_pola = sizeof(pole) / sizeof(pole[0]);

printf("Pôvodné pole: \n");

for (auto i: pole)
{
cout<<i<<" ";
}

MergeSort(pole, 0, dlzka_pola - 1);

cout<<endl<<"Utriedené pole:"<<endl;

for (auto i: pole)
{
cout<<i<<" ";
}

return 0;
}

void Merge(int pole[], int lavy, int stred, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči */

if (lavy >= pravy)
{
return;
}

/* vyrátaj dĺžky oboch polovíc poľa */

int L_dlzka = stred - lavy + 1;
int P_dlzka = pravy - stred;

/* alokuj dočasné polia, kam uložíš prvky z oboch polovíc poľa */

int *L = new int[L_dlzka];
int *P = new int[P_dlzka];

/* indexy, ktorými iterujeme všetky polia: i pre L, j pre P, k pre pole */

int i, j, k;

/* skopíruj obsah oboch polovíc poľa do dočasných polí L a P */

for (i = 0; i < L_dlzka; ++i)
{
L[i] = pole[lavy + i];
}

for (j = 0; j < P_dlzka; ++j)
{
P[j] = pole[stred + 1 + j];
}

/* nastav indexy na začiatok daných polí */

i = 0; j = 0; k = lavy;

/* zlučuj dočasné polia L a P do finálneho poľa pole */

while(i < L_dlzka && j < P_dlzka)
{
if(L[i] <= P[j])
{
pole[k++] = L[i++];
}
else
{
pole[k++] = P[j++];
}
}

/* ak ostali nejaké prvky v dočasnom poli L, skopíruj ich do finálneho poľa */

while(i < L_dlzka)
{
pole[k++] = L[i++];
}

/* ak ostali nejaké prvky v dočasnom poli P, skopíruj ich do finálneho poľa */

while(j < P_dlzka)
{
pole[k++] = P[j++];
}

/* uvoľni použitú pamäť */

delete []L;
delete []P;
}

void MergeSort(int *pole, int lavy, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči volanie */

if(lavy >= pravy)
{
return;
}

int stred, koniec;

for (int dlzka_zoznamu = 1; dlzka_zoznamu <= pravy; dlzka_zoznamu *= 2)
{
for (int zaciatok = lavy; zaciatok < pravy; zaciatok += 2 * dlzka_zoznamu)
{
koniec = (zaciatok + 2 * dlzka_zoznamu - 1 <= pravy) ? zaciatok + 2 * dlzka_zoznamu - 1 : pravy;

stred = (zaciatok + dlzka_zoznamu - 1 <= pravy) ? zaciatok + dlzka_zoznamu - 1 : pravy;

Merge(pole, zaciatok, stred, koniec);
}
}
}
</syntaxhighlight>
</tab>

<tab name="Rekurzívna: Java" block>
<syntaxhighlight lang="Java">
class MergeSort
{

/* Funkcia zlúči 2 podpolia, ktoré sme vytvorili z pôvodného poľa.
* Každé podpole má polovičnú dĺžku pôvodného poľa.
* podpole1 [ľavý ... stred]
* podpole2 [stred + 1 ... pravý]
*/

void merge(int[] pole, int lavy, int stred, int pravy)
{

// Výpočet dĺžky 2 podpolí

int n1 = stred - lavy + 1;
int n2 = pravy - stred;

// Vytvorenie pomocných polí

int[] L = new int[n1];
int[] P = new int[n2];

// Načítanie dát do pomocných polí

for (int i = 0; i < n1; i++)
L[i] = pole[lavy + i];

for (int j = 0; j < n2; j++)
P[j] = pole[stred + 1 + j];

// Počiatočné indexy prvého a druhého podpoľa

int i = 0, j = 0;

// Počiatočný index zlúčeného podpoľa

int k = lavy;

// Zlúčenie dvoch podpolí

while (i < n1 && j < n2)
{
if (L[i] <= P[j])
{
pole[k] = L[i];
i++;
}
else
{
pole[k] = P[j];
j++;
}
k++;
}

/* V prípade, že sa v jednom zo podpolí nachádzajú ešte nejaké prvky, ktoré neboli zlúčené do poľa,
* tak sa do poľa jednoducho skopírujú
*/

while (i < n1)
{
pole[k] = L[i];
i++;
k++;
}

while (j < n2)
{
pole[k] = P[j];
k++;
j++;
}

}

/* Funkcia, ktorá zoradí pole použitím funkcie merge() */

void sort (int[] pole, int lavy, int pravy)
{
if (lavy < pravy)
{
// Musíme nájsť stred poľa

int stred = lavy + (pravy - lavy) / 2;

// Zoradíme prvú a druhú polovicu poľa samostatne

sort(pole, lavy, stred);
sort(pole, stred + 1, pravy);

// Zlúčime zoradené polovice do jedného poľa

merge(pole, lavy, stred, pravy);
}
}
}

public class Main
{
/* Funkcia na výpis poľa dĺžky n */

static void vypis_pole(int[] pole)
{

for (int j : pole)
{
System.out.print(j + " ");
}

System.out.println();
}

/* Hlavný program */

public static void main(String[] args)
{
int[] pole = {12, 11, 13, 5, 6, 7};

System.out.println("Zadané pole:");
vypis_pole(pole);

MergeSort ms = new MergeSort();
ms.sort(pole, 0, pole.length - 1);

System.out.println("\nZoradené pole:");
vypis_pole(pole);
}
}
</syntaxhighlight>
</tab>

<tab name="Iteračná: Java" block>
<syntaxhighlight lang="Java">
class MergeSort_iteracia
{
/* Zlúči 2 podpolia, ktoré sa vytvorili z pôvodného poľa.
* Každé podpole má polovičnú dĺžku pôvodného poľa.
* podpole1 [ľavý..stred]
* podpole2 [stred+1..pravý]
*/

void merge(int[] pole, int lavy, int stred, int pravy)
{
// Výpočet dĺžky 2 podpolí

int n1 = stred - lavy + 1;
int n2 = pravy - stred;

// Vytvorenie pomocných polí

int[] L = new int[n1];
int[] P = new int[n2];

// Načítanie dát do pomocných polí

for (int i = 0; i < n1; i++)
L[i] = pole[lavy + i];

for (int j = 0; j < n2; j++)
P[j] = pole[stred + 1 + j];

// Počiatočné indexy prvého a druhého podpoľa

int i = 0, j = 0;

// Počiatočný index zlúčeného podpoľa

int k = lavy;

// Zlúčenie dvoch podpolí

while (i < n1 && j < n2)
{
if (L[i] <= P[j])
{
pole[k] = L[i];
i++;
}
else
{
pole[k] = P[j];
j++;
}
k++;
}

/* V prípade, že v jednom z podpolí sa nachádzajú prvky, ktoré neboli zlúčené do poľa,
* tak sa do poľa jednoducho skopírujú
*/

while (i < n1)
{
pole[k] = L[i];
i++;
k++;
}

while (j < n2)
{
pole[k] = P[j];
k++;
j++;
}
}

/* Funkcia, ktorá zoradí pole použitím funkcie merge() */

void sort (int[] pole, int n)
{
/* Dĺžka podpolí, ktoré majú byť zlúčené, hodnoty premennej sa pohybujú v intervale <1;n-1> */

int aktual_dlzka;

/* Začiatočný index ľavého podpoľa, ktoré má byť zlúčené */

int zaciatok_vlavo;

/* Vzostupné usporiadanie prvkov. Najskôr sa zlúčia podpolia veľkosti 1 do podpolí veľkosti 2,
* potom podpolia veľkosti 2 do podpolí veľkosti 4 a tak ďalej
*/

for (aktual_dlzka = 1; aktual_dlzka <= n - 1; aktual_dlzka *= 2)
{
/* Určenie začiatočného prvku rôznych podpolí aktuálnej dĺžky podpoľa */

for (zaciatok_vlavo = 0; zaciatok_vlavo < n - 1; zaciatok_vlavo += 2 * aktual_dlzka)
{
/* Nájdenie konečného prvku ľavého podpoľa, stred+1 je začiatočný prvok pravého podpoľa */

int stred = Math.min(zaciatok_vlavo + aktual_dlzka - 1, n - 1);
int koniec_vpravo = Math.min(zaciatok_vlavo + 2 * aktual_dlzka - 1, n - 1);

/* Zlúči podpolia L[zaciatok_vlavo .. stred] & P[stred+1 .. koniec_vpravo] */

merge(pole, zaciatok_vlavo, stred, koniec_vpravo);
}
}
}
}

public class Main {

/* Funkcia na výpis poľa dĺžky n */

static void vypis_pole(int[] pole)
{
int n = pole.length;

for (int j : pole)
{
System.out.print(j + " ");
}
System.out.println();
}

/* Hlavný program */

public static void main(String[] args) {

/* Inicializácia poľa */

int[] pole = {12, 11, 13, 5, 6, 7};

System.out.println("Zadané pole:");
vypis_pole(pole);

MergeSort_iteracia ms_it = new MergeSort_iteracia();
ms_it.sort(pole, pole.length);

System.out.println("Zoradené pole:");
vypis_pole(pole);
}
}
</syntaxhighlight>
</tab>

<tab name="Rekurzívna: Python3" block>
<syntaxhighlight lang="Python3">
def MergeSort(pole):
if len(pole) > 1:

# Nájdenie stredu poľa
# zápis len(pole)//2 znamená, že dĺžka poľa sa vydelí 2 a výsledok je celé číslo

stred = len(pole) // 2

# Rozdelenie poľa na dve časti

L = pole[:stred]
P = pole[stred:]

# Zoradenie najskôr prvej časti poľa, potom druhej

MergeSort(L)
MergeSort(P)

i = j = k = 0

# Zlúčenie a zoradenie údajov z pomocných polí do jedného poľa

while i < len(L) and j < len(P):
if L[i] < P[j]:
pole[k] = L[i]
i += 1
else:
pole[k] = P[j]
j += 1
k += 1

# Kontrola či všetky prvky boli zlúčené dokopy,
# ak nie, tak sa do zlúčeného poľa jednoducho skopírujú

while i < len(L):
pole[k] = L[i]
i += 1
k += 1

while j < len(P):
pole[k] = P[j]
j += 1
k += 1

# Hlavný program

if __name__ == '__main__':

pole = [12, 11, 13, 5, 6, 7]

print("Zadané pole:", end="\n")
print(pole, end="\n")

MergeSort(pole)

print("Zoradené pole:", end="\n")
print(pole, end="\n")

</syntaxhighlight>
</tab>

<tab name="Iteračná: Python3" block>
<syntaxhighlight lang="Python3">
def MergeSort_iteracia(pole):

# Dĺžka podpolí, ktoré majú byť zlúčené, hodnoty premennej sa pohybujú v intervale <1;n-1>

aktual_dlzka = 1

# Vonkajší cyklus, ktorý určuje podpolia aktuálnej dĺžky

while aktual_dlzka < len(pole) - 1:

lavy = 0

# Vnútorný cyklus, ktorý slúži na zlúčenie a zoradenie podpolí do jedného podpoľa

while lavy < len(pole) - 1:

# Index stredného prvku sa určí, keď k indexu ľavého prvku podpoľa pripočítame aktuálnu
# dĺžku podpolí a odčítame 1

stred = min((lavy + aktual_dlzka - 1), len(pole) - 1)

# Ak platí podmienka 2 * aktuálna dĺžka < dĺžka poľa - 1, tak pravý index = aktuálnej dĺžke subpolí,
# inak pravý index = dĺžka poľa - 1

pravy = ((2 * aktual_dlzka + lavy - 1, len(pole) - 1)[2 * aktual_dlzka + lavy - 1 > len(pole) - 1])

# Volanie funkcie merge

merge(pole, lavy, stred, pravy)

lavy = lavy + 2 * aktual_dlzka

# Aktuálna dĺžka sa sa zmení na dvojnásobok jej predošlej hodnoty

aktual_dlzka = 2 * aktual_dlzka

def merge(pole, lavy, stred, pravy):

n1 = stred - lavy + 1
n2 = pravy - stred

# Inicializácia pomocných polí

L = [0] * n1
P = [0] * n2

# Načítanie dát do pomocných polí

for i in range(0, n1):
L[i] = pole[lavy + i]
for i in range(0, n2):
P[i] = pole[stred + i + 1]

i, j, k = 0, 0, lavy

# Zlúčenie a zoradenie údajov z pomocných polí do jedného poľa

while i < n1 and j < n2:
if L[i] > P[j]:
pole[k] = P[j]
j += 1
else:
pole[k] = L[i]
i += 1
k += 1

# Kontrola či všetky prvky boli zlúčené dokopy,
# ak nie, tak sa do zlúčeného pola jednoducho skopírujú

while i < n1:
pole[k] = L[i]
i += 1
k += 1

while j < n2:
pole[k] = P[j]
j += 1
k += 1

# Hlavný program

if __name__ == '__main__':

pole = [12, 11, 13, 5, 6, 7]

print("Zadané pole:", end="\n")
print(pole, end="\n")

MergeSort_iteracia(pole)

print("Zoradené pole:", end="\n")
print(pole, end="\n")

</syntaxhighlight>
</tab>

</tabs>

==Odkazy==
# https://www.geeksforgeeks.org/merge-sort/
# https://www.geeksforgeeks.org/iterative-merge-sort/
# https://medium.com/@paulsoham/merge-sort-63d75df76388
# https://www.khanacademy.org/computing/computer-science/algorithms/merge-sort/a/overview-of-merge-sort
# https://www.tutorialspoint.com/data_structures_algorithms/merge_sort_algorithm.htm
# https://www.youtube.com/watch?v=6pV2IF0fgKY
# https://www.youtube.com/watch?v=mB5HXBb_HY8
# https://www.youtube.com/watch?v=ak-pz7tS5DE

Triedenie zlučovaním

2021-03-29T15:42:42Z

Filip Tomek: /* Implementácia algoritmov Merge a MergeSort v rôznych programovacích jazykoch */

[[Kategória:Algoritmy triedenia]]
{{Draft}}
{{Skripta programovanie}}
__TOC__
==Zlučovací algoritmus Merge==
[[Súbor:Funkcia merge.png|500px|náhľad|vpravo|Vizualizácia funkcie Merge: Máme pole prvkov ''p = [1, 3, 5, 2, 4, 6]'', ktoré je už čiastočne utriedené. Použijeme algoritmus Merge, ktorý si vytvorí pomocné polia ''L = [1, 3, 5]'' a ''P = [2, 4, 6]''. Všetky polia indexujeme od ''0'', pričom pre pole ''p'' používame index ''k'', pre ''L'' index ''i'' a pre ''P'' index ''j''. Postupnosť krokov je označená číslicami 1 až 6.
]]

Princíp zlučovania tkvie v tom, že máme dva alebo viac utriedených zoznamov, ktoré skombinuje do jedného utriedeného zoznamu (výsledný zoznam musí obsahovať všetky prvky z pôvodných zoznamov). Zoznam môže byť reprezentovaný ako dátová štruktúra pole alebo aj ako lineárny zoznam. V tomto článku sa zameriame na algoritmus pre dátovú štruktúru pole.

Algoritmus ''Merge'' tvorí kľúčovú časť triediaceho algoritmu ''MergeSort''.

===Slovný opis algoritmu===
Nech máme pole, ktoré sa skladá z dvoch už utriedených polovíc. Vytvoríme si dve pomocné polia ''L'' a ''P'' a do každého z nich skopírujeme obsah jednej polovice (''L'' - ľavá polovica, ''P'' - pravá polovica). Potom súčasne prechádzame polia ''L'' a ''P'' od začiatku po koniec, pričom v každom cykle porovnáme prvok poľa ''L'' s prvkom v poli ''P''. Z tejto dvojice následne vyberieme minimum, (keď triedime od najmenšieho po najväčší) ktoré vložíme na prvú voľnú pozíciu pôvodného poľa (na začiatku je to prvá pozícia poľa). Nakoniec zvýšime index pri vstupnom poli a pri pomocnom poli, z ktorého vyberáme daný prvok. Túto postupnosť krokov opakujeme, pokiaľ neprídeme na koniec jedného z polí ''P'' a ''L''. Ak nastane situácia, že prídeme na koniec jedného z pomocných polí (a v druhom nám ostali ešte nejaké prvky), potom už iba naspäť skopírujeme zbytok druhého pomocného poľa na koniec pôvodného poľa.

===Vlastnosti algoritmu===
* vhodný pre dátové štruktúry: pole, lineárny zoznam
* časová náročnosť: vždy lineárna <math>O(n)</math>
* priestorová náročnosť: lineárna <math>O(n)</math> pre pole (alokovanie pomocných polí), <math>O(1)</math> pre lineárny zoznam (pri lineárnom zozname netreba alokovať dočasné polia, stačí iba presmerovať smerníky)
* využitie: kľúčový podprogram pre triediaci algoritmus MergeSort

===Pseudokód===
Nech funkcia ''Merge'' má nasledovný prototyp: <code>Merge(pole[], lavy, stred, pravy)</code>
:1. Je <code>lavy >= pravy ? Ak áno, skonči, inak pokračuj krokom 2.</code>
:2. Nech: <code>i = 0, j = 0, k = lavy </code>
:3. Nech: <code>dlzka_L = stred - lavy + 1, dlzka_P = pravy - stred</code>
:4. Nech: <code> L = pole[lavy ... stred], P = pole[stred + 1 ... pravy] </code>
:5. Je <code>i < dlzka_L</code> a zároveň <code>j < dlzka_P</code> ? Ak áno, pokračuj krokom 5.1., inak skoč na krok 6.
:::5.1. Je <code>L[i] <= P[j]</code>?
:::: Ak áno:
:::::5.1.1. <code>pole[k] = L[i]</code>
:::::5.1.2. <code>k += 1</code>
:::::5.1.3. <code>i += 1</code>
:::::5.1.4. Skoč na krok 5.
:::: Ak nie:
:::::5.1.1. <code>pole[k] = P[j]</code>
:::::5.1.2. <code>k += 1</code>
:::::5.1.3. <code>j += 1</code>
:::::5.1.4. Skoč na krok 5.
:6. Je <code>i < dlzka_L</code> ? Ak áno, pokračuj krokom 6.1., inak skoč na krok 7.
:::6.1. <code>pole[k] = L[i]</code>
:::6.2. <code>k += 1</code>
:::6.3. <code>i += 1</code>
:::6.4. Skoč na krok 6.
:7. Je <code>j < dlzka_P</code> ? Ak áno, pokračuj krokom 7.1., inak skonči.
:::7.1. <code>pole[k] = P[j]</code>
:::7.2. <code>k += 1</code>
:::7.3. <code>j += 1</code>
:::7.4. Skoč na krok 7.

==MergeSort==
''MergeSort'' je triediaci algoritmus, ktorý využíva stratégiu '''"rozdeľuj a panuj"''', čo znamená, že vstupný zoznam najskôr rozdelí menšie časti, tie zoradí a potom ich zlúči naspäť dokopy. Radí sa medzi najpoužívanejšie a najviac rešpektované triediace algoritmy.

===Vlastnosti algoritmu Merge Sort===
* vhodný pre dátové štruktúry: pole, lineárny zoznam
* časová náročnosť: vždy linearitmická <math> O(n.log(n)) </math>, vďaka ktorej dokáže efektívne triediť veľmi veľké zoznamy
* priestorová náročnosť: lineárna <math>O(n)</math> pre pole (alokovanie dočasných polí), konštantná <math>O(1)</math> pre lineárny zoznam (pri lineárnom zozname stačí iba presmerovať smerníky)
* druh triedenia: triedenie zlučovaním (komparačný algoritmus)
* stabilita triedenia: stabilný
* miesto triedenia: externé triedenie (vhodný na triedenie veľkých objemov dát uložených na disku)

Z hľadiska implementácie môžeme vytvoriť dve základné verzie algoritmu, a to ''rekurzívnu'' a ''iteračnú''.

===Opis rekurzívnej a iteračnej verzie algoritmu Merge Sort===

<tabs>
<tab name="Rekurzívna verzia" block>
[[Súbor:Merge sort.png|400px|náhľad|vpravo|Vizualizácia rekurzívnej verzie algoritmu MergeSort]]

===Princíp algoritmu===
Algoritmus ''MergeSort'' vykonáva 4 základné úlohy:
# Delenie poľa na dve polovice.
# Triedenie ľavej polovice poľa.
# Triedenie pravej polovice poľa.
# Zlúčenie oboch polovíc pomocou funkcie ''Merge''.

===Slovný opis===
Našou úlohou je vzostupne (min -> max) utriediť vstupné pole. Určíme si ''stred'' poľa (pri párnom počte prvkov je to ten menší z prostredných indexov). Následne vykonávame sériu rekurzívnych delení pre ľavú a pravú časť poľa (''začiatok ... stred ; stred + 1 ... koniec'') až do momentu, keď nám ostanú len jednoprvkové podpolia (tie sú už utriedené). Následne v každom volaní obe tieto podpolia zlúčime pomocou algoritmu ''Merge'' do väčších podpolí (2, 4, 8, ...), až nakoniec dostaneme jedno výsledné utriedené pole.

===Pseudokód===
Nech nech má funkcia ''MergeSort'' nasledovný prototyp: <code>MergeSort(pole[], lavy, pravy) </code>
:1. Je <code>lavy >= pravy</code> ? Ak áno, skonči volanie, inak pokračuj krokom 2.
:2. Nech: <code>stred = lavy + (pravy - lavy) / 2</code>, pričom znak ''/'' vyjadruje celočíselné delenie.
:3. Rekurzívne zavolaj funkciu <code>MergeSort(pole[], lavy , stred)</code>
:3. Rekurzívne zavolaj funkciu <code>MergeSort(pole[], stred + 1 , pravy)</code>
:4. Zavolaj funkciu <code>Merge(pole[], lavy, stred, pravy)</code>
:5. Skonči volanie.

</tab>
<tab name="Iteračná verzia" block>
[[Súbor:MergeSort IT.png|400px|náhľad|vpravo]]

===Princíp algoritmu===
Algoritmus ''MergeSort'' vykonáva 3 základné úlohy:
# Vonkajší cyklus: určenie veľkosti zoznamu na zlučovanie.
# Vnútorný cyklus: prechádzanie jednotlivých zoznamov v poli.
# Zlučovanie jednotlivých zoznamov pomocou funkcie ''Merge''.

===Slovný opis===
Vstupné pole, ktoré má ''N'' prvkov, môžeme chápať, ako ''N'' rôznych jednoprvkových (utriedených) podpolí, ktoré máme zlúčiť do jedného výsledného ''N''-prvkového utriedeného poľa. Keďže by bolo veľmi nepraktické zlučovať ''N'' podpolí naraz, zvolíme nasledovnú stratégiu: Budeme prechádzať dané pole od začiatku po koniec a v prvom cykle zlúčime každé dva prvky, takže budeme mať <math>\frac{n}{2}</math> dvojprvkových utriedených podpolí. Potom v druhom cykle zlúčime každé 4 prvky do jedného podpoľa, v treťom cykle každých 8, až do momentu, keď dostaneme jedno utriedené pole.
Aby sme to docielili, potrebujeme dva cykly, vonkajší, ktorý nastaví maximálnu veľkosť podpoľa, ktoré ideme zlučovať (1,2,4,8 ... ''dlzka - 1'') a vnútorný, ktorý prechádza jednotlivé podpolia. Následne už iba voláme funkciu ''Merge'', ktorá dané podpolia zlučuje.

Poznámka, ak máme ''pole'', ktoré má nepárny počet prvkov, tak ten posledný prvok nezlúčime hneď v prvom cykle, ale až v tých ďalších. Takisto, ak ''N'' nie je mocnina čísla 2, tak musíme samozrejme ošetriť situáciu, kedy by sme sa dostali mimo rozsah poľa (Ak máme napríklad ''pole'', čo má 7 prvkov, tak po prvej iterácii budú prvky utiredené podľa vzoru 2 + 2 + 2 + 1, po druhej 4 + 3, a po tretej 7)

===Pseudokód===
Nech nech má funkcia ''MergeSort'' nasledovný prototyp: <code>MergeSort(pole[], lavy, pravy) </code>
:1. Je <code>lavy >= pravy</code> ? Ak áno, skonči, inak pokračuj krokom 2.
:2. Nech: <code>dlzka_podpola = 1 </code>
:3. Nech: <code>zaciatok = lavy</code>
:4. Je<code>dlzka_podpola <= pravy</code> ? Ak áno pokračuj krokom 4.1, inak skonči.
:::4.1. Je<code>zaciatok < pravy</code> Ak áno pokračuj krokom 4.1.1, inak skoč na krok 4.2.
:::::4.1.1. Je <code>zaciatok + 2 * dlzka_zoznamu - 1 <= pravy</code> ?
:::::::Ak áno:
:::::::::4.1.1.1. Nech <code>koniec = zaciatok + 2 * dlzka_podpola - 1</code>
:::::::Ak nie:
:::::::::4.1.1.1. Nech <code>koniec = pravy</code>
:::::4.1.2. Je <code>zaciatok + dlzka_podpola - 1 <= pravy</code> ?
:::::::Ak áno:
:::::::::4.1.2.1. Nech <code>stred = zaciatok + dlzka_podpola - 1</code>
:::::::Ak nie:
:::::::::4.1.2.1. Nech <code>stred = pravy</code>
:::::4.1.3. <code>Merge(pole[], zaciatok, stred, koniec)</code>
:::::4.1.4. <code>zaciatok += 2 * dlzka_podpola</code>
:::::4.1.5. Skoč na krok 4.1.
:::4.2. <code>dlzka_podpole *= 2</code>
:::4.3 Skoč na krok 4.

</tab>
</tabs>

==Implementácia algoritmov Merge a MergeSort v rôznych programovacích jazykoch==
<tabs>
<tab name="Rekurzívna: C " block>
<syntaxhighlight lang="C">
#include <stdio.h>
#include <stdlib.h>

void Merge(int pole[], int lavy, int stred, int pravy);
void MergeSort(int pole[], int lavy, int pravy);

/* hlavný program */

int main()
{
int pole[] = {12, 11, 13, 5, 6, 7};
int dlzka_pola = sizeof(pole) / sizeof(pole[0]);

printf("Pôvodné pole: \n");

for (int i = 0; i < dlzka_pola; ++i)
{
printf("%d ", pole[i]);
}

MergeSort(pole, 0, dlzka_pola - 1);

printf("\nUtriedené pole: \n");

for (int i = 0; i < dlzka_pola; ++i)
{
printf("%d ", pole[i]);
}

return 0;
}

void Merge(int pole[], int lavy, int stred, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči */

if (lavy >= pravy)
{
return;
}

/* vyrátaj dĺžky oboch polovíc poľa */

int L_dlzka = stred - lavy + 1;
int P_dlzka = pravy - stred;

/* alokuj dočasné polia, kam uložíš prvky z oboch polovíc poľa */

int *L = (int*)malloc(L_dlzka * sizeof(int));
int *P = (int*)malloc(P_dlzka * sizeof(int));

/* indexy, ktorými iterujeme všetky polia: i pre L, j pre P, k pre pole */

int i, j, k;

/* skopíruj obsah oboch polovíc poľa do dočasných polí L a P */

for (i = 0; i < L_dlzka; ++i)
{
L[i] = pole[lavy + i];
}

for (j = 0; j < P_dlzka; ++j)
{
P[j] = pole[stred + 1 + j];
}

/* nastav indexy na začiatok daných polí */

i = 0; j = 0; k = lavy;

/* zlučuj dočasné polia L a P do finálneho poľa pole */

while(i < L_dlzka && j < P_dlzka)
{
if(L[i] <= P[j])
{
pole[k++] = L[i++];
}
else
{
pole[k++] = P[j++];
}
}

/* ak ostali nejaké prvky v dočasnom poli L, skopíruj ich do finálneho poľa */

while(i < L_dlzka)
{
pole[k++] = L[i++];
}

/* ak ostali nejaké prvky v dočasnom poli P, skopíruj ich do finálneho poľa */

while(j < P_dlzka)
{
pole[k++] = P[j++];
}

/* uvoľni použitú pamäť */

free(L);
free(P);
}

void MergeSort(int pole[], int lavy, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči volanie */

if(lavy >= pravy)
{
return;
}
/* urči si prostredný index */

int stred = lavy + (pravy - lavy) / 2;

/* utrieď ľavú polovicu poľa */

MergeSort(pole, lavy, stred);

/* utrieď pravú polovicu poľa */

MergeSort(pole, stred+1, pravy);

/* zlúč obe polovice dokopy */

Merge(pole, lavy, stred, pravy);
}
</syntaxhighlight>
</tab>

<tab name="Iteračná: C" block>
<syntaxhighlight lang="C">
#include <stdio.h>
#include <stdlib.h>

void Merge(int pole[], int lavy, int stred, int pravy);
void MergeSortIt(int *pole, int lavy, int pravy);

/* hlavný program */

int main()
{
int pole[] = {12, 11, 13, 5, 6, 7, 19};
int dlzka_pola = sizeof(pole) / sizeof(pole[0]);

printf("Pôvodné pole %d: \n", dlzka_pola);

for (int i = 0; i < dlzka_pola; ++i)
{
printf("%d ", pole[i]);
}

MergeSortIt(pole, 0, dlzka_pola - 1);

printf("\nUtriedené pole: \n");

for (int i = 0; i < dlzka_pola; ++i)
{
printf("%d ", pole[i]);
}

return 0;
}

void Merge(int pole[], int lavy, int stred, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči */

if (lavy >= pravy)
{
return;
}

/* vyrátaj dĺžky oboch polovíc poľa */

int L_dlzka = stred - lavy + 1;
int P_dlzka = pravy - stred;

/* alokuj dočasné polia, kam uložíš prvky z oboch polovíc poľa */

int *L = (int*)malloc(L_dlzka * sizeof(int));
int *P = (int*)malloc(P_dlzka * sizeof(int));

/* indexy, ktorými iterujeme všetky polia: i pre L, j pre P, k pre pole */

int i, j, k;

/* skopíruj obsah oboch polovíc poľa do dočasných polí L a P */

for (i = 0; i < L_dlzka; ++i)
{
L[i] = pole[lavy + i];
}

for (j = 0; j < P_dlzka; ++j)
{
P[j] = pole[stred + 1 + j];
}

/* nastav indexy na začiatok daných polí */

i = 0; j = 0; k = lavy;

/* zlučuj dočasné polia L a P do finálneho poľa pole */

while(i < L_dlzka && j < P_dlzka)
{
if(L[i] <= P[j])
{
pole[k++] = L[i++];
}
else
{
pole[k++] = P[j++];
}
}

/* ak ostali nejaké prvky v dočasnom poli L, skopíruj ich do finálneho poľa */

while(i < L_dlzka)
{
pole[k++] = L[i++];
}

/* ak ostali nejaké prvky v dočasnom poli P, skopíruj ich do finálneho poľa */

while(j < P_dlzka)
{
pole[k++] = P[j++];
}

/* uvoľni použitú pamäť */

free(L);
free(P);
}

void MergeSortIt(int *pole, int lavy, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči volanie */

if(lavy >= pravy)
{
return;
}

int stred, koniec;

for (int dlzka_zoznamu = 1; dlzka_zoznamu <= pravy ; dlzka_zoznamu *= 2)
{
for (int zaciatok = lavy; zaciatok < pravy ; zaciatok += 2 * dlzka_zoznamu)
{
koniec = (zaciatok + 2 * dlzka_zoznamu - 1 <= pravy) ? zaciatok + 2 * dlzka_zoznamu - 1 : pravy;

stred = (zaciatok + dlzka_zoznamu - 1 <= pravy) ? zaciatok + dlzka_zoznamu - 1 : pravy;

Merge(pole, zaciatok, stred, koniec);

}
}
}

</syntaxhighlight>
</tab>

<tab name="Rekurzívna: C++" block>
<syntaxhighlight lang="C++">
#include <iostream>

using std::cout;
using std::endl;

void Merge(int pole[], int lavy, int stred, int pravy);
void MergeSort(int pole[], int lavy, int pravy);

/* hlavný program */

int main()
{
int pole[] = {12, 11, 13, 5, 6, 7};
int dlzka_pola = sizeof(pole) / sizeof(pole[0]);

printf("Pôvodné pole: \n");

for (auto i: pole)
{
cout<<i<<" ";
}

MergeSort(pole, 0, dlzka_pola - 1);

cout<<endl<<"Utriedené pole:"<<endl;

for (auto i: pole)
{
cout<<i<<" ";
}

return 0;
}

void Merge(int pole[], int lavy, int stred, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči */

if (lavy >= pravy)
{
return;
}

/* vyrátaj dĺžky oboch polovíc poľa */

int L_dlzka = stred - lavy + 1;
int P_dlzka = pravy - stred;

/* alokuj dočasné polia, kam uložíš prvky z oboch polovíc poľa */

int *L = new int[L_dlzka];
int *P = new int[P_dlzka];

/* indexy, ktorými iterujeme všetky polia: i pre L, j pre P, k pre pole */

int i, j, k;

/* skopíruj obsah oboch polovíc poľa do dočasných polí L a P */

for (i = 0; i < L_dlzka; ++i)
{
L[i] = pole[lavy + i];
}

for (j = 0; j < P_dlzka; ++j)
{
P[j] = pole[stred + 1 + j];
}

/* nastav indexy na začiatok daných polí */

i = 0; j = 0; k = lavy;

/* zlučuj dočasné polia L a P do finálneho poľa pole */

while(i < L_dlzka && j < P_dlzka)
{
if(L[i] <= P[j])
{
pole[k++] = L[i++];
}
else
{
pole[k++] = P[j++];
}
}

/* ak ostali nejaké prvky v dočasnom poli L, skopíruj ich do finálneho poľa */

while(i < L_dlzka)
{
pole[k++] = L[i++];
}

/* ak ostali nejaké prvky v dočasnom poli P, skopíruj ich do finálneho poľa */

while(j < P_dlzka)
{
pole[k++] = P[j++];
}

/* uvoľni použitú pamäť */

delete []L;
delete []P;
}

void MergeSort(int pole[], int lavy, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči volanie */

if(lavy >= pravy)
{
return;
}
/* urči si prostredný index */

int stred = lavy + (pravy - lavy) / 2;

/* utrieď ľavú polovicu poľa */

MergeSort(pole, lavy, stred);

/* utrieď pravú polovicu poľa */

MergeSort(pole, stred+1, pravy);

/* zlúč obe polovice dokopy */

Merge(pole, lavy, stred, pravy);
}

</syntaxhighlight>
</tab>

<tab name="Iteračná: C++" block>
<syntaxhighlight lang="C++">
#include <iostream>

using std::cout;
using std::endl;

void Merge(int pole[], int lavy, int stred, int pravy);
void MergeSort(int pole[], int lavy, int pravy);

/* hlavný program */

int main()
{
int pole[] = {12, 11, 13, 5, 6, 7};
int dlzka_pola = sizeof(pole) / sizeof(pole[0]);

printf("Pôvodné pole: \n");

for (auto i: pole)
{
cout<<i<<" ";
}

MergeSort(pole, 0, dlzka_pola - 1);

cout<<endl<<"Utriedené pole:"<<endl;

for (auto i: pole)
{
cout<<i<<" ";
}

return 0;
}

void Merge(int pole[], int lavy, int stred, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči */

if (lavy >= pravy)
{
return;
}

/* vyrátaj dĺžky oboch polovíc poľa */

int L_dlzka = stred - lavy + 1;
int P_dlzka = pravy - stred;

/* alokuj dočasné polia, kam uložíš prvky z oboch polovíc poľa */

int *L = new int[L_dlzka];
int *P = new int[P_dlzka];

/* indexy, ktorými iterujeme všetky polia: i pre L, j pre P, k pre pole */

int i, j, k;

/* skopíruj obsah oboch polovíc poľa do dočasných polí L a P */

for (i = 0; i < L_dlzka; ++i)
{
L[i] = pole[lavy + i];
}

for (j = 0; j < P_dlzka; ++j)
{
P[j] = pole[stred + 1 + j];
}

/* nastav indexy na začiatok daných polí */

i = 0; j = 0; k = lavy;

/* zlučuj dočasné polia L a P do finálneho poľa pole */

while(i < L_dlzka && j < P_dlzka)
{
if(L[i] <= P[j])
{
pole[k++] = L[i++];
}
else
{
pole[k++] = P[j++];
}
}

/* ak ostali nejaké prvky v dočasnom poli L, skopíruj ich do finálneho poľa */

while(i < L_dlzka)
{
pole[k++] = L[i++];
}

/* ak ostali nejaké prvky v dočasnom poli P, skopíruj ich do finálneho poľa */

while(j < P_dlzka)
{
pole[k++] = P[j++];
}

/* uvoľni použitú pamäť */

delete []L;
delete []P;
}

void MergeSort(int *pole, int lavy, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči volanie */

if(lavy >= pravy)
{
return;
}

int stred, koniec;

for (int dlzka_zoznamu = 1; dlzka_zoznamu <= pravy; dlzka_zoznamu *= 2)
{
for (int zaciatok = lavy; zaciatok < pravy; zaciatok += 2 * dlzka_zoznamu)
{
koniec = (zaciatok + 2 * dlzka_zoznamu - 1 <= pravy) ? zaciatok + 2 * dlzka_zoznamu - 1 : pravy;

stred = (zaciatok + dlzka_zoznamu - 1 <= pravy) ? zaciatok + dlzka_zoznamu - 1 : pravy;

Merge(pole, zaciatok, stred, koniec);
}
}
}
</syntaxhighlight>
</tab>

<tab name="Rekurzívna: Java" block>
<syntaxhighlight lang="Java">
class MergeSort
{

/* Funkcia zlúči 2 podpolia, ktoré sme vytvorili z pôvodného poľa.
* Každé podpole má polovičnú dĺžku pôvodného poľa.
* podpole1 [ľavý ... stred]
* podpole2 [stred + 1 ... pravý]
*/

void merge(int[] pole, int lavy, int stred, int pravy)
{

// Výpočet dĺžky 2 podpolí

int n1 = stred - lavy + 1;
int n2 = pravy - stred;

// Vytvorenie pomocných polí

int[] L = new int[n1];
int[] P = new int[n2];

// Načítanie dát do pomocných polí

for (int i = 0; i < n1; i++)
L[i] = pole[lavy + i];

for (int j = 0; j < n2; j++)
P[j] = pole[stred + 1 + j];

// Počiatočné indexy prvého a druhého podpoľa

int i = 0, j = 0;

// Počiatočný index zlúčeného podpoľa

int k = lavy;

// Zlúčenie dvoch podpolí

while (i < n1 && j < n2)
{
if (L[i] <= P[j])
{
pole[k] = L[i];
i++;
}
else
{
pole[k] = P[j];
j++;
}
k++;
}

/* V prípade, že sa v jednom zo podpolí nachádzajú ešte nejaké prvky, ktoré neboli zlúčené do poľa,
* tak sa do poľa jednoducho skopírujú
*/

while (i < n1)
{
pole[k] = L[i];
i++;
k++;
}

while (j < n2)
{
pole[k] = P[j];
k++;
j++;
}

}

/* Funkcia, ktorá zoradí pole použitím funkcie merge() */

void sort (int[] pole, int lavy, int pravy)
{
if (lavy < pravy)
{
// Musíme nájsť stred poľa

int stred = lavy + (pravy - lavy) / 2;

// Zoradíme prvú a druhú polovicu poľa samostatne

sort(pole, lavy, stred);
sort(pole, stred + 1, pravy);

// Zlúčime zoradené polovice do jedného poľa

merge(pole, lavy, stred, pravy);
}
}
}

public class Main
{
/* Funkcia na výpis poľa dĺžky n */

static void vypis_pole(int[] pole)
{

for (int j : pole)
{
System.out.print(j + " ");
}

System.out.println();
}

/* Hlavný program */

public static void main(String[] args)
{
int[] pole = {12, 11, 13, 5, 6, 7};

System.out.println("Zadané pole:");
vypis_pole(pole);

MergeSort ms = new MergeSort();
ms.sort(pole, 0, pole.length - 1);

System.out.println("\nZoradené pole:");
vypis_pole(pole);
}
}
</syntaxhighlight>
</tab>

<tab name="Iteračná: Java" block>
<syntaxhighlight lang="Java">
class MergeSort_iteracia
{
/* Zlúči 2 podpolia, ktoré sa vytvorili z pôvodného poľa.
* Každé podpole má polovičnú dĺžku pôvodného poľa.
* podpole1 [ľavý..stred]
* podpole2 [stred+1..pravý]
*/

void merge(int[] pole, int lavy, int stred, int pravy)
{
// Výpočet dĺžky 2 podpolí

int n1 = stred - lavy + 1;
int n2 = pravy - stred;

// Vytvorenie pomocných polí

int[] L = new int[n1];
int[] P = new int[n2];

// Načítanie dát do pomocných polí

for (int i = 0; i < n1; i++)
L[i] = pole[lavy + i];

for (int j = 0; j < n2; j++)
P[j] = pole[stred + 1 + j];

// Počiatočné indexy prvého a druhého podpoľa

int i = 0, j = 0;

// Počiatočný index zlúčeného podpoľa

int k = lavy;

// Zlúčenie dvoch podpolí

while (i < n1 && j < n2)
{
if (L[i] <= P[j])
{
pole[k] = L[i];
i++;
}
else
{
pole[k] = P[j];
j++;
}
k++;
}

/* V prípade, že v jednom z podpolí sa nachádzajú prvky, ktoré neboli zlúčené do poľa,
* tak sa do poľa jednoducho skopírujú
*/

while (i < n1)
{
pole[k] = L[i];
i++;
k++;
}

while (j < n2)
{
pole[k] = P[j];
k++;
j++;
}
}

/* Funkcia, ktorá zoradí pole použitím funkcie merge() */

void sort (int[] pole, int n)
{
/* Dĺžka podpolí, ktoré majú byť zlúčené, hodnoty premennej sa pohybujú v intervale <1;n-1> */

int aktual_dlzka;

/* Začiatočný index ľavého podpoľa, ktoré má byť zlúčené */

int zaciatok_vlavo;

/* Vzostupné usporiadanie prvkov. Najskôr sa zlúčia podpolia veľkosti 1 do podpolí veľkosti 2,
* potom podpolia veľkosti 2 do podpolí veľkosti 4 a tak ďalej
*/

for (aktual_dlzka = 1; aktual_dlzka <= n - 1; aktual_dlzka *= 2)
{
/* Určenie začiatočného prvku rôznych podpolí aktuálnej dĺžky podpoľa */

for (zaciatok_vlavo = 0; zaciatok_vlavo < n - 1; zaciatok_vlavo += 2 * aktual_dlzka)
{
/* Nájdenie konečného prvku ľavého podpoľa, stred+1 je začiatočný prvok pravého podpoľa */

int stred = Math.min(zaciatok_vlavo + aktual_dlzka - 1, n - 1);
int koniec_vpravo = Math.min(zaciatok_vlavo + 2 * aktual_dlzka - 1, n - 1);

/* Zlúči podpolia L[zaciatok_vlavo .. stred] & P[stred+1 .. koniec_vpravo] */

merge(pole, zaciatok_vlavo, stred, koniec_vpravo);
}
}
}
}

public class Main {

/* Funkcia na výpis poľa dĺžky n */

static void vypis_pole(int[] pole)
{
int n = pole.length;

for (int j : pole)
{
System.out.print(j + " ");
}
System.out.println();
}

/* Hlavný program */

public static void main(String[] args) {

/* Inicializácia poľa */

int[] pole = {12, 11, 13, 5, 6, 7};

System.out.println("Zadané pole:");
vypis_pole(pole);

MergeSort_iteracia ms_it = new MergeSort_iteracia();
ms_it.sort(pole, pole.length);

System.out.println("Zoradené pole:");
vypis_pole(pole);
}
}
</syntaxhighlight>
</tab>

<tab name="Rekurzívna: Python3" block>
<syntaxhighlight lang="Python3">
def MergeSort(pole):
if len(pole) > 1:

# Nájdenie stredu poľa
# zápis len(pole)//2 znamená, že dĺžka poľa sa vydelí 2 a výsledok je celé číslo

stred = len(pole) // 2

# Rozdelenie poľa na dve časti

L = pole[:stred]
P = pole[stred:]

# Zoradenie najskôr prvej časti poľa, potom druhej

MergeSort(L)
MergeSort(P)

i = j = k = 0

# Zlúčenie a zoradenie údajov z pomocných polí do jedného poľa

while i < len(L) and j < len(P):
if L[i] < P[j]:
pole[k] = L[i]
i += 1
else:
pole[k] = P[j]
j += 1
k += 1

# Kontrola či všetky prvky boli zlúčené dokopy,
# ak nie, tak sa do zlúčeného poľa jednoducho skopírujú

while i < len(L):
pole[k] = L[i]
i += 1
k += 1

while j < len(P):
pole[k] = P[j]
j += 1
k += 1

# Hlavný program

if __name__ == '__main__':

pole = [12, 11, 13, 5, 6, 7]

print("Zadané pole:", end="\n")
print(pole, end="\n")

MergeSort(pole)

print("Zoradené pole:", end="\n")
print(pole, end="\n")

</syntaxhighlight>
</tab>

<tab name="Iteračná: Python3" block>
<syntaxhighlight lang="Python3">
def MergeSort_iteracia(pole):

# Dĺžka podpolí, ktoré majú byť zlúčené, hodnoty premennej sa pohybujú v intervale <1;n-1>

aktual_dlzka = 1

# Vonkajší cyklus, ktorý určuje podpolia aktuálnej dĺžky

while aktual_dlzka < len(pole) - 1:

lavy = 0

# Vnútorný cyklus, ktorý slúži na zlúčenie a zoradenie podpolí do jedného podpoľa

while lavy < len(pole) - 1:

# Index stredného prvku sa určí, keď k indexu ľavého prvku podpoľa pripočítame aktuálnu
# dĺžku podpolí a odčítame 1

stred = min((lavy + aktual_dlzka - 1), len(pole) - 1)

# Ak platí podmienka 2 * aktuálna dĺžka < dĺžka poľa - 1, tak pravý index = aktuálnej dĺžke subpolí,
# inak pravý index = dĺžka poľa - 1

pravy = ((2 * aktual_dlzka + lavy - 1, len(pole) - 1)[2 * aktual_dlzka + lavy - 1 > len(pole) - 1])

# Volanie funkcie merge

merge(pole, lavy, stred, pravy)

lavy = lavy + 2 * aktual_dlzka

# Aktuálna dĺžka sa sa zmení na dvojnásobok jej predošlej hodnoty

aktual_dlzka = 2 * aktual_dlzka

def merge(pole, lavy, stred, pravy):

n1 = stred - lavy + 1
n2 = pravy - stred

# Inicializácia pomocných polí

L = [0] * n1
P = [0] * n2

# Načítanie dát do pomocných polí

for i in range(0, n1):
L[i] = pole[lavy + i]
for i in range(0, n2):
P[i] = pole[stred + i + 1]

i, j, k = 0, 0, lavy

# Zlúčenie a zoradenie údajov z pomocných polí do jedného poľa

while i < n1 and j < n2:
if L[i] > P[j]:
pole[k] = P[j]
j += 1
else:
pole[k] = L[i]
i += 1
k += 1

# Kontrola či všetky prvky boli zlúčené dokopy,
# ak nie, tak sa do zlúčeného pola jednoducho skopírujú

while i < n1:
pole[k] = L[i]
i += 1
k += 1

while j < n2:
pole[k] = P[j]
j += 1
k += 1

# Hlavný program

if __name__ == '__main__':

pole = [12, 11, 13, 5, 6, 7]

print("Zadané pole:", end="\n")
print(pole, end="\n")

MergeSort_iteracia(pole)

print("Zoradené pole:", end="\n")
print(pole, end="\n")

</syntaxhighlight>
</tab>

</tabs>

==Odkazy==
# https://www.geeksforgeeks.org/merge-sort/
# https://www.geeksforgeeks.org/iterative-merge-sort/
# https://medium.com/@paulsoham/merge-sort-63d75df76388
# https://www.khanacademy.org/computing/computer-science/algorithms/merge-sort/a/overview-of-merge-sort
# https://www.tutorialspoint.com/data_structures_algorithms/merge_sort_algorithm.htm
# https://www.youtube.com/watch?v=6pV2IF0fgKY
# https://www.youtube.com/watch?v=mB5HXBb_HY8
# https://www.youtube.com/watch?v=ak-pz7tS5DE

Triedenie zlučovaním

2021-03-29T15:21:28Z

Filip Tomek: /* Opis rekurzívnej a iteračnej verzie algoritmu Merge Sort */

[[Kategória:Algoritmy triedenia]]
{{Draft}}
{{Skripta programovanie}}
__TOC__
==Zlučovací algoritmus Merge==
[[Súbor:Funkcia merge.png|500px|náhľad|vpravo|Vizualizácia funkcie Merge: Máme pole prvkov ''p = [1, 3, 5, 2, 4, 6]'', ktoré je už čiastočne utriedené. Použijeme algoritmus Merge, ktorý si vytvorí pomocné polia ''L = [1, 3, 5]'' a ''P = [2, 4, 6]''. Všetky polia indexujeme od ''0'', pričom pre pole ''p'' používame index ''k'', pre ''L'' index ''i'' a pre ''P'' index ''j''. Postupnosť krokov je označená číslicami 1 až 6.
]]

Princíp zlučovania tkvie v tom, že máme dva alebo viac utriedených zoznamov, ktoré skombinuje do jedného utriedeného zoznamu (výsledný zoznam musí obsahovať všetky prvky z pôvodných zoznamov). Zoznam môže byť reprezentovaný ako dátová štruktúra pole alebo aj ako lineárny zoznam. V tomto článku sa zameriame na algoritmus pre dátovú štruktúru pole.

Algoritmus ''Merge'' tvorí kľúčovú časť triediaceho algoritmu ''MergeSort''.

===Slovný opis algoritmu===
Nech máme pole, ktoré sa skladá z dvoch už utriedených polovíc. Vytvoríme si dve pomocné polia ''L'' a ''P'' a do každého z nich skopírujeme obsah jednej polovice (''L'' - ľavá polovica, ''P'' - pravá polovica). Potom súčasne prechádzame polia ''L'' a ''P'' od začiatku po koniec, pričom v každom cykle porovnáme prvok poľa ''L'' s prvkom v poli ''P''. Z tejto dvojice následne vyberieme minimum, (keď triedime od najmenšieho po najväčší) ktoré vložíme na prvú voľnú pozíciu pôvodného poľa (na začiatku je to prvá pozícia poľa). Nakoniec zvýšime index pri vstupnom poli a pri pomocnom poli, z ktorého vyberáme daný prvok. Túto postupnosť krokov opakujeme, pokiaľ neprídeme na koniec jedného z polí ''P'' a ''L''. Ak nastane situácia, že prídeme na koniec jedného z pomocných polí (a v druhom nám ostali ešte nejaké prvky), potom už iba naspäť skopírujeme zbytok druhého pomocného poľa na koniec pôvodného poľa.

===Vlastnosti algoritmu===
* vhodný pre dátové štruktúry: pole, lineárny zoznam
* časová náročnosť: vždy lineárna <math>O(n)</math>
* priestorová náročnosť: lineárna <math>O(n)</math> pre pole (alokovanie pomocných polí), <math>O(1)</math> pre lineárny zoznam (pri lineárnom zozname netreba alokovať dočasné polia, stačí iba presmerovať smerníky)
* využitie: kľúčový podprogram pre triediaci algoritmus MergeSort

===Pseudokód===
Nech funkcia ''Merge'' má nasledovný prototyp: <code>Merge(pole[], lavy, stred, pravy)</code>
:1. Je <code>lavy >= pravy ? Ak áno, skonči, inak pokračuj krokom 2.</code>
:2. Nech: <code>i = 0, j = 0, k = lavy </code>
:3. Nech: <code>dlzka_L = stred - lavy + 1, dlzka_P = pravy - stred</code>
:4. Nech: <code> L = pole[lavy ... stred], P = pole[stred + 1 ... pravy] </code>
:5. Je <code>i < dlzka_L</code> a zároveň <code>j < dlzka_P</code> ? Ak áno, pokračuj krokom 5.1., inak skoč na krok 6.
:::5.1. Je <code>L[i] <= P[j]</code>?
:::: Ak áno:
:::::5.1.1. <code>pole[k] = L[i]</code>
:::::5.1.2. <code>k += 1</code>
:::::5.1.3. <code>i += 1</code>
:::::5.1.4. Skoč na krok 5.
:::: Ak nie:
:::::5.1.1. <code>pole[k] = P[j]</code>
:::::5.1.2. <code>k += 1</code>
:::::5.1.3. <code>j += 1</code>
:::::5.1.4. Skoč na krok 5.
:6. Je <code>i < dlzka_L</code> ? Ak áno, pokračuj krokom 6.1., inak skoč na krok 7.
:::6.1. <code>pole[k] = L[i]</code>
:::6.2. <code>k += 1</code>
:::6.3. <code>i += 1</code>
:::6.4. Skoč na krok 6.
:7. Je <code>j < dlzka_P</code> ? Ak áno, pokračuj krokom 7.1., inak skonči.
:::7.1. <code>pole[k] = P[j]</code>
:::7.2. <code>k += 1</code>
:::7.3. <code>j += 1</code>
:::7.4. Skoč na krok 7.

==MergeSort==
''MergeSort'' je triediaci algoritmus, ktorý využíva stratégiu '''"rozdeľuj a panuj"''', čo znamená, že vstupný zoznam najskôr rozdelí menšie časti, tie zoradí a potom ich zlúči naspäť dokopy. Radí sa medzi najpoužívanejšie a najviac rešpektované triediace algoritmy.

===Vlastnosti algoritmu Merge Sort===
* vhodný pre dátové štruktúry: pole, lineárny zoznam
* časová náročnosť: vždy linearitmická <math> O(n.log(n)) </math>, vďaka ktorej dokáže efektívne triediť veľmi veľké zoznamy
* priestorová náročnosť: lineárna <math>O(n)</math> pre pole (alokovanie dočasných polí), konštantná <math>O(1)</math> pre lineárny zoznam (pri lineárnom zozname stačí iba presmerovať smerníky)
* druh triedenia: triedenie zlučovaním (komparačný algoritmus)
* stabilita triedenia: stabilný
* miesto triedenia: externé triedenie (vhodný na triedenie veľkých objemov dát uložených na disku)

Z hľadiska implementácie môžeme vytvoriť dve základné verzie algoritmu, a to ''rekurzívnu'' a ''iteračnú''.

===Opis rekurzívnej a iteračnej verzie algoritmu Merge Sort===

<tabs>
<tab name="Rekurzívna verzia" block>
[[Súbor:Merge sort.png|400px|náhľad|vpravo|Vizualizácia rekurzívnej verzie algoritmu MergeSort]]

===Princíp algoritmu===
Algoritmus ''MergeSort'' vykonáva 4 základné úlohy:
# Delenie poľa na dve polovice.
# Triedenie ľavej polovice poľa.
# Triedenie pravej polovice poľa.
# Zlúčenie oboch polovíc pomocou funkcie ''Merge''.

===Slovný opis===
Našou úlohou je vzostupne (min -> max) utriediť vstupné pole. Určíme si ''stred'' poľa (pri párnom počte prvkov je to ten menší z prostredných indexov). Následne vykonávame sériu rekurzívnych delení pre ľavú a pravú časť poľa (''začiatok ... stred ; stred + 1 ... koniec'') až do momentu, keď nám ostanú len jednoprvkové podpolia (tie sú už utriedené). Následne v každom volaní obe tieto podpolia zlúčime pomocou algoritmu ''Merge'' do väčších podpolí (2, 4, 8, ...), až nakoniec dostaneme jedno výsledné utriedené pole.

===Pseudokód===
Nech nech má funkcia ''MergeSort'' nasledovný prototyp: <code>MergeSort(pole[], lavy, pravy) </code>
:1. Je <code>lavy >= pravy</code> ? Ak áno, skonči volanie, inak pokračuj krokom 2.
:2. Nech: <code>stred = lavy + (pravy - lavy) / 2</code>, pričom znak ''/'' vyjadruje celočíselné delenie.
:3. Rekurzívne zavolaj funkciu <code>MergeSort(pole[], lavy , stred)</code>
:3. Rekurzívne zavolaj funkciu <code>MergeSort(pole[], stred + 1 , pravy)</code>
:4. Zavolaj funkciu <code>Merge(pole[], lavy, stred, pravy)</code>
:5. Skonči volanie.

</tab>
<tab name="Iteračná verzia" block>
[[Súbor:MergeSort IT.png|400px|náhľad|vpravo]]

===Princíp algoritmu===
Algoritmus ''MergeSort'' vykonáva 3 základné úlohy:
# Vonkajší cyklus: určenie veľkosti zoznamu na zlučovanie.
# Vnútorný cyklus: prechádzanie jednotlivých zoznamov v poli.
# Zlučovanie jednotlivých zoznamov pomocou funkcie ''Merge''.

===Slovný opis===
Vstupné pole, ktoré má ''N'' prvkov, môžeme chápať, ako ''N'' rôznych jednoprvkových (utriedených) podpolí, ktoré máme zlúčiť do jedného výsledného ''N''-prvkového utriedeného poľa. Keďže by bolo veľmi nepraktické zlučovať ''N'' podpolí naraz, zvolíme nasledovnú stratégiu: Budeme prechádzať dané pole od začiatku po koniec a v prvom cykle zlúčime každé dva prvky, takže budeme mať <math>\frac{n}{2}</math> dvojprvkových utriedených podpolí. Potom v druhom cykle zlúčime každé 4 prvky do jedného podpoľa, v treťom cykle každých 8, až do momentu, keď dostaneme jedno utriedené pole.
Aby sme to docielili, potrebujeme dva cykly, vonkajší, ktorý nastaví maximálnu veľkosť podpoľa, ktoré ideme zlučovať (1,2,4,8 ... ''dlzka - 1'') a vnútorný, ktorý prechádza jednotlivé podpolia. Následne už iba voláme funkciu ''Merge'', ktorá dané podpolia zlučuje.

Poznámka, ak máme ''pole'', ktoré má nepárny počet prvkov, tak ten posledný prvok nezlúčime hneď v prvom cykle, ale až v tých ďalších. Takisto, ak ''N'' nie je mocnina čísla 2, tak musíme samozrejme ošetriť situáciu, kedy by sme sa dostali mimo rozsah poľa (Ak máme napríklad ''pole'', čo má 7 prvkov, tak po prvej iterácii budú prvky utiredené podľa vzoru 2 + 2 + 2 + 1, po druhej 4 + 3, a po tretej 7)

===Pseudokód===
Nech nech má funkcia ''MergeSort'' nasledovný prototyp: <code>MergeSort(pole[], lavy, pravy) </code>
:1. Je <code>lavy >= pravy</code> ? Ak áno, skonči, inak pokračuj krokom 2.
:2. Nech: <code>dlzka_podpola = 1 </code>
:3. Nech: <code>zaciatok = lavy</code>
:4. Je<code>dlzka_podpola <= pravy</code> ? Ak áno pokračuj krokom 4.1, inak skonči.
:::4.1. Je<code>zaciatok < pravy</code> Ak áno pokračuj krokom 4.1.1, inak skoč na krok 4.2.
:::::4.1.1. Je <code>zaciatok + 2 * dlzka_zoznamu - 1 <= pravy</code> ?
:::::::Ak áno:
:::::::::4.1.1.1. Nech <code>koniec = zaciatok + 2 * dlzka_podpola - 1</code>
:::::::Ak nie:
:::::::::4.1.1.1. Nech <code>koniec = pravy</code>
:::::4.1.2. Je <code>zaciatok + dlzka_podpola - 1 <= pravy</code> ?
:::::::Ak áno:
:::::::::4.1.2.1. Nech <code>stred = zaciatok + dlzka_podpola - 1</code>
:::::::Ak nie:
:::::::::4.1.2.1. Nech <code>stred = pravy</code>
:::::4.1.3. <code>Merge(pole[], zaciatok, stred, koniec)</code>
:::::4.1.4. <code>zaciatok += 2 * dlzka_podpola</code>
:::::4.1.5. Skoč na krok 4.1.
:::4.2. <code>dlzka_podpole *= 2</code>
:::4.3 Skoč na krok 4.

</tab>
</tabs>

==Implementácia algoritmov Merge a MergeSort v rôznych programovacích jazykoch==
<tabs>
<tab name="Rekurzívna: C " block>
<syntaxhighlight lang="C">
#include <stdio.h>
#include <stdlib.h>

void Merge(int pole[], int lavy, int stred, int pravy);
void MergeSort(int pole[], int lavy, int pravy);

/* hlavný program */

int main()
{
int pole[] = {12, 11, 13, 5, 6, 7};
int dlzka_pola = sizeof(pole) / sizeof(pole[0]);

printf("Pôvodné pole: \n");

for (int i = 0; i < dlzka_pola; ++i)
{
printf("%d ", pole[i]);
}

MergeSort(pole, 0, dlzka_pola - 1);

printf("\nUtriedené pole: \n");

for (int i = 0; i < dlzka_pola; ++i)
{
printf("%d ", pole[i]);
}

return 0;
}

void Merge(int pole[], int lavy, int stred, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči */

if (lavy >= pravy)
{
return;
}

/* vyrátaj dĺžky oboch polovíc poľa */

int L_dlzka = stred - lavy + 1;
int P_dlzka = pravy - stred;

/* alokuj dočasné polia, kam uložíš prvky z oboch polovíc poľa */

int *L = (int*)malloc(L_dlzka * sizeof(int));
int *P = (int*)malloc(P_dlzka * sizeof(int));

/* indexy, ktorými iterujeme všetky polia: i pre L, j pre P, k pre pole */

int i, j, k;

/* skopíruj obsah oboch polovíc poľa do dočasných polí L a P */

for (i = 0; i < L_dlzka; ++i)
{
L[i] = pole[lavy + i];
}

for (j = 0; j < P_dlzka; ++j)
{
P[j] = pole[stred + 1 + j];
}

/* nastav indexy na začiatok daných polí */

i = 0; j = 0; k = lavy;

/* zlučuj dočasné polia L a P do finálneho poľa pole */

while(i < L_dlzka && j < P_dlzka)
{
if(L[i] <= P[j])
{
pole[k++] = L[i++];
}
else
{
pole[k++] = P[j++];
}
}

/* ak ostali nejaké prvky v dočasnom poli L, skopíruj ich do finálneho poľa */

while(i < L_dlzka)
{
pole[k++] = L[i++];
}

/* ak ostali nejaké prvky v dočasnom poli P, skopíruj ich do finálneho poľa */

while(j < P_dlzka)
{
pole[k++] = P[j++];
}

/* uvoľni použitú pamäť */

free(L);
free(P);
}

void MergeSort(int pole[], int lavy, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči volanie */

if(lavy >= pravy)
{
return;
}
/* urči si prostredný index */

int stred = lavy + (pravy - lavy) / 2;

/* utrieď ľavú polovicu poľa */

MergeSort(pole, lavy, stred);

/* utrieď pravú polovicu poľa */

MergeSort(pole, stred+1, pravy);

/* zlúč obe polovice dokopy */

Merge(pole, lavy, stred, pravy);
}
</syntaxhighlight>
</tab>

<tab name="Iteračná: C" block>
<syntaxhighlight lang="C">
#include <stdio.h>
#include <stdlib.h>

void Merge(int pole[], int lavy, int stred, int pravy);
void MergeSortIt(int *pole, int lavy, int pravy);

/* hlavný program */

int main()
{
int pole[] = {12, 11, 13, 5, 6, 7, 19};
int dlzka_pola = sizeof(pole) / sizeof(pole[0]);

printf("Pôvodné pole %d: \n", dlzka_pola);

for (int i = 0; i < dlzka_pola; ++i)
{
printf("%d ", pole[i]);
}

MergeSortIt(pole, 0, dlzka_pola - 1);

printf("\nUtriedené pole: \n");

for (int i = 0; i < dlzka_pola; ++i)
{
printf("%d ", pole[i]);
}

return 0;
}

void Merge(int pole[], int lavy, int stred, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči */

if (lavy >= pravy)
{
return;
}

/* vyrátaj dĺžky oboch polovíc poľa */

int L_dlzka = stred - lavy + 1;
int P_dlzka = pravy - stred;

/* alokuj dočasné polia, kam uložíš prvky z oboch polovíc poľa */

int *L = (int*)malloc(L_dlzka * sizeof(int));
int *P = (int*)malloc(P_dlzka * sizeof(int));

/* indexy, ktorými iterujeme všetky polia: i pre L, j pre P, k pre pole */

int i, j, k;

/* skopíruj obsah oboch polovíc poľa do dočasných polí L a P */

for (i = 0; i < L_dlzka; ++i)
{
L[i] = pole[lavy + i];
}

for (j = 0; j < P_dlzka; ++j)
{
P[j] = pole[stred + 1 + j];
}

/* nastav indexy na začiatok daných polí */

i = 0; j = 0; k = lavy;

/* zlučuj dočasné polia L a P do finálneho poľa pole */

while(i < L_dlzka && j < P_dlzka)
{
if(L[i] <= P[j])
{
pole[k++] = L[i++];
}
else
{
pole[k++] = P[j++];
}
}

/* ak ostali nejaké prvky v dočasnom poli L, skopíruj ich do finálneho poľa */

while(i < L_dlzka)
{
pole[k++] = L[i++];
}

/* ak ostali nejaké prvky v dočasnom poli P, skopíruj ich do finálneho poľa */

while(j < P_dlzka)
{
pole[k++] = P[j++];
}

/* uvoľni použitú pamäť */

free(L);
free(P);
}

void MergeSortIt(int *pole, int lavy, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči volanie */

if(lavy >= pravy)
{
return;
}

int stred, koniec;

for (int dlzka_zoznamu = 1; dlzka_zoznamu <= pravy ; dlzka_zoznamu *= 2)
{
for (int zaciatok = lavy; zaciatok < pravy ; zaciatok += 2 * dlzka_zoznamu)
{
koniec = (zaciatok + 2 * dlzka_zoznamu - 1 <= pravy) ? zaciatok + 2 * dlzka_zoznamu - 1 : pravy;

stred = (zaciatok + dlzka_zoznamu - 1 <= pravy) ? zaciatok + dlzka_zoznamu - 1 : pravy;

Merge(pole, zaciatok, stred, koniec);

}
}
}

</syntaxhighlight>
</tab>

<tab name="Rekurzívna: C++" block>
<syntaxhighlight lang="C++">
#include <iostream>

using std::cout;
using std::endl;

void Merge(int pole[], int lavy, int stred, int pravy);
void MergeSort(int pole[], int lavy, int pravy);

/* hlavný program */

int main()
{
int pole[] = {12, 11, 13, 5, 6, 7};
int dlzka_pola = sizeof(pole) / sizeof(pole[0]);

printf("Pôvodné pole: \n");

for (auto i: pole)
{
cout<<i<<" ";
}

MergeSort(pole, 0, dlzka_pola - 1);

cout<<endl<<"Utriedené pole:"<<endl;

for (auto i: pole)
{
cout<<i<<" ";
}

return 0;
}

void Merge(int pole[], int lavy, int stred, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči */

if (lavy >= pravy)
{
return;
}

/* vyrátaj dĺžky oboch polovíc poľa */

int L_dlzka = stred - lavy + 1;
int P_dlzka = pravy - stred;

/* alokuj dočasné polia, kam uložíš prvky z oboch polovíc poľa */

int *L = new int[L_dlzka];
int *P = new int[P_dlzka];

/* indexy, ktorými iterujeme všetky polia: i pre L, j pre P, k pre pole */

int i, j, k;

/* skopíruj obsah oboch polovíc poľa do dočasných polí L a P */

for (i = 0; i < L_dlzka; ++i)
{
L[i] = pole[lavy + i];
}

for (j = 0; j < P_dlzka; ++j)
{
P[j] = pole[stred + 1 + j];
}

/* nastav indexy na začiatok daných polí */

i = 0; j = 0; k = lavy;

/* zlučuj dočasné polia L a P do finálneho poľa pole */

while(i < L_dlzka && j < P_dlzka)
{
if(L[i] <= P[j])
{
pole[k++] = L[i++];
}
else
{
pole[k++] = P[j++];
}
}

/* ak ostali nejaké prvky v dočasnom poli L, skopíruj ich do finálneho poľa */

while(i < L_dlzka)
{
pole[k++] = L[i++];
}

/* ak ostali nejaké prvky v dočasnom poli P, skopíruj ich do finálneho poľa */

while(j < P_dlzka)
{
pole[k++] = P[j++];
}

/* uvoľni použitú pamäť */

delete []L;
delete []P;
}

void MergeSort(int pole[], int lavy, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči volanie */

if(lavy >= pravy)
{
return;
}
/* urči si prostredný index */

int stred = lavy + (pravy - lavy) / 2;

/* utrieď ľavú polovicu poľa */

MergeSort(pole, lavy, stred);

/* utrieď pravú polovicu poľa */

MergeSort(pole, stred+1, pravy);

/* zlúč obe polovice dokopy */

Merge(pole, lavy, stred, pravy);
}

</syntaxhighlight>
</tab>

<tab name="Iteračná: C++" block>
<syntaxhighlight lang="C++">
#include <iostream>

using std::cout;
using std::endl;

void Merge(int pole[], int lavy, int stred, int pravy);
void MergeSort(int pole[], int lavy, int pravy);

/* hlavný program */

int main()
{
int pole[] = {12, 11, 13, 5, 6, 7};
int dlzka_pola = sizeof(pole) / sizeof(pole[0]);

printf("Pôvodné pole: \n");

for (auto i: pole)
{
cout<<i<<" ";
}

MergeSort(pole, 0, dlzka_pola - 1);

cout<<endl<<"Utriedené pole:"<<endl;

for (auto i: pole)
{
cout<<i<<" ";
}

return 0;
}

void Merge(int pole[], int lavy, int stred, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči */

if (lavy >= pravy)
{
return;
}

/* vyrátaj dĺžky oboch polovíc poľa */

int L_dlzka = stred - lavy + 1;
int P_dlzka = pravy - stred;

/* alokuj dočasné polia, kam uložíš prvky z oboch polovíc poľa */

int *L = new int[L_dlzka];
int *P = new int[P_dlzka];

/* indexy, ktorými iterujeme všetky polia: i pre L, j pre P, k pre pole */

int i, j, k;

/* skopíruj obsah oboch polovíc poľa do dočasných polí L a P */

for (i = 0; i < L_dlzka; ++i)
{
L[i] = pole[lavy + i];
}

for (j = 0; j < P_dlzka; ++j)
{
P[j] = pole[stred + 1 + j];
}

/* nastav indexy na začiatok daných polí */

i = 0; j = 0; k = lavy;

/* zlučuj dočasné polia L a P do finálneho poľa pole */

while(i < L_dlzka && j < P_dlzka)
{
if(L[i] <= P[j])
{
pole[k++] = L[i++];
}
else
{
pole[k++] = P[j++];
}
}

/* ak ostali nejaké prvky v dočasnom poli L, skopíruj ich do finálneho poľa */

while(i < L_dlzka)
{
pole[k++] = L[i++];
}

/* ak ostali nejaké prvky v dočasnom poli P, skopíruj ich do finálneho poľa */

while(j < P_dlzka)
{
pole[k++] = P[j++];
}

/* uvoľni použitú pamäť */

delete []L;
delete []P;
}

void MergeSort(int *pole, int lavy, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči volanie */

if(lavy >= pravy)
{
return;
}

int stred, koniec;

for (int dlzka_zoznamu = 1; dlzka_zoznamu <= pravy; dlzka_zoznamu *= 2)
{
for (int zaciatok = lavy; zaciatok < pravy; zaciatok += 2 * dlzka_zoznamu)
{
koniec = (zaciatok + 2 * dlzka_zoznamu - 1 <= pravy) ? zaciatok + 2 * dlzka_zoznamu - 1 : pravy;

stred = (zaciatok + dlzka_zoznamu - 1 <= pravy) ? zaciatok + dlzka_zoznamu - 1 : pravy;

Merge(pole, zaciatok, stred, koniec);
}
}
}
</syntaxhighlight>
</tab>

<tab name="Rekurzívna: Java" block>
<syntaxhighlight lang="Java">
class MergeSort
{

/* Funkcia zlúči 2 podpolia, ktoré sme vytvorili z pôvodného poľa.
* Každé podpole má polovičnú dĺžku pôvodného poľa.
* subpole1 [ľavý ... stred]
* subpole2 [stred + 1 ... pravý]
*/

void merge(int[] pole, int lavy, int stred, int pravy)
{

// Výpočet dĺžky 2 podpolí

int n1 = stred - lavy + 1;
int n2 = pravy - stred;

// Vytvorenie pomocných polí

int[] L = new int[n1];
int[] P = new int[n2];

// Načítanie dát do pomocných polí

for (int i = 0; i < n1; i++)
L[i] = pole[lavy + i];

for (int j = 0; j < n2; j++)
P[j] = pole[stred + 1 + j];

// Počiatočné indexy prvého a druhého podpoľa

int i = 0, j = 0;

// Počiatočný index zlúčeného podpoľa

int k = lavy;

// Zlúčenie dvoch podpolí

while (i < n1 && j < n2)
{
if (L[i] <= P[j])
{
pole[k] = L[i];
i++;
}
else
{
pole[k] = P[j];
j++;
}
k++;
}

/* V prípade, že sa v jednom zo podpoli nachádzajú ešte nejaké prvky, ktoré neboli zlúčené do pola,
* tak sa do pola jednoducho skopírujú
*/

while (i < n1)
{
pole[k] = L[i];
i++;
k++;
}

while (j < n2)
{
pole[k] = P[j];
k++;
j++;
}

}

/* Funkcia, ktorá zoradí pole použitím funkcie merge() */

void sort (int[] pole, int lavy, int pravy)
{
if (lavy < pravy)
{
// Musíme nájsť stred pola

int stred = lavy + (pravy - lavy) / 2;

// Zoradíme prvú a druhú polovicu pola samostatne

sort(pole, lavy, stred);
sort(pole, stred + 1, pravy);

// Zlúčime zoradené polovice do jedného pola

merge(pole, lavy, stred, pravy);
}
}
}

public class Main
{
/* Funkcia na výpis pola dĺžky n */

static void vypis_pole(int[] pole)
{

for (int j : pole)
{
System.out.print(j + " ");
}

System.out.println();
}

/* Hlavný program */

public static void main(String[] args)
{
int[] pole = {12, 11, 13, 5, 6, 7};

System.out.println("Zadané pole:");
vypis_pole(pole);

MergeSort ms = new MergeSort();
ms.sort(pole, 0, pole.length - 1);

System.out.println("\nZoradené pole:");
vypis_pole(pole);
}
}
</syntaxhighlight>
</tab>

<tab name="Iteračná: Java" block>
<syntaxhighlight lang="Java">
class MergeSort_iteracia
{
/* Zlúči 2 subpolia, ktoré sa vytvorili z pôvodného pola.
* Každé subpole má polovičnú dĺžku pôvodného pola.
* subpole1 [ľavý..stred]
* subpole2 [stred+1..pravý]
*/

void merge(int[] pole, int lavy, int stred, int pravy)
{
// Výpočet dĺžky 2 subpolí

int n1 = stred - lavy + 1;
int n2 = pravy - stred;

// Vytvorenie pomocných polí

int[] L = new int[n1];
int[] P = new int[n2];

// Načítanie dát do pomocných polí

for (int i = 0; i < n1; i++)
L[i] = pole[lavy + i];

for (int j = 0; j < n2; j++)
P[j] = pole[stred + 1 + j];

// Počiatočné indexy prvého a druhého subpola

int i = 0, j = 0;

// Počiatočný index zlúčeného subpola

int k = lavy;

// Zlúčenie dvoch podpolí

while (i < n1 && j < n2)
{
if (L[i] <= P[j])
{
pole[k] = L[i];
i++;
}
else
{
pole[k] = P[j];
j++;
}
k++;
}

/* V prípade, že v jednom zo subpolí sa nachádzajú prvky, ktoré neboli zlúčené do pola,
* tak sa do pola jednoducho skopírujú
*/

while (i < n1)
{
pole[k] = L[i];
i++;
k++;
}

while (j < n2)
{
pole[k] = P[j];
k++;
j++;
}
}

/* Funkcia, ktorá zoradí pole použitím funkcie merge() */

void sort (int[] pole, int n)
{
/* Dĺžka subpolí, ktoré majú byť zlúčené, hodnoty premennej sa pohybujú v intervale <1;n-1> */

int aktual_dlzka;

/* Začiatočný index ľavého subpola, ktoré má byť zlúčené */

int zaciatok_vlavo;

/* Vzostupné usporiadanie prvkov. Najskôr sa zlúčia subpolia veľkosti 1 do subpolí veľkosti 2,
* potom subpolia veľkosti 2 do subpolí veľkosti 4 a tak ďalej
*/

for (aktual_dlzka = 1; aktual_dlzka <= n - 1; aktual_dlzka *= 2)
{
/* Určenie začiatočného prvku rôznych subpolí aktuálnej dĺžky subpola */

for (zaciatok_vlavo = 0; zaciatok_vlavo < n - 1; zaciatok_vlavo += 2 * aktual_dlzka)
{
/* Nájdenie konečného prvku ľavého subpola, stred+1 je začiatočný prvok pravého subpola */

int stred = Math.min(zaciatok_vlavo + aktual_dlzka - 1, n - 1);
int koniec_vpravo = Math.min(zaciatok_vlavo + 2 * aktual_dlzka - 1, n - 1);

/* Zlúči subpolia L[zaciatok_vlavo .. stred] & P[stred+1 .. koniec_vpravo] */

merge(pole, zaciatok_vlavo, stred, koniec_vpravo);
}
}
}
}

public class Main {

/* Funkcia na výpis pola dĺžky n */

static void vypis_pole(int[] pole)
{
int n = pole.length;

for (int j : pole)
{
System.out.print(j + " ");
}
System.out.println();
}

/* Hlavný program */

public static void main(String[] args) {

/* Inicializácia pola */

int[] pole = {12, 11, 13, 5, 6, 7};

System.out.println("Zadané pole:");
vypis_pole(pole);

MergeSort_iteracia ms_it = new MergeSort_iteracia();
ms_it.sort(pole, pole.length);

System.out.println("Zoradené pole:");
vypis_pole(pole);
}
}
</syntaxhighlight>
</tab>

<tab name="Rekurzívna: Python3" block>
<syntaxhighlight lang="Python3">
def MergeSort(pole):
if len(pole) > 1:

# Nájdenie stredu pola
# zápis len(pole)//2 znamená, že dĺžka pola sa vydelí 2 a výsledok je celé číslo

stred = len(pole) // 2

# Rozdelenie pola na dve časti

L = pole[:stred]
P = pole[stred:]

# Zoradenie najskôr prvej časti pola, potom druhej

MergeSort(L)
MergeSort(P)

i = j = k = 0

# Zlúčenie a zoradenie údajov z pomocných polí do jedného pola

while i < len(L) and j < len(P):
if L[i] < P[j]:
pole[k] = L[i]
i += 1
else:
pole[k] = P[j]
j += 1
k += 1

# Kontrola či všetky prvky boli zlúčené dokopy,
# ak nie, tak sa do zlúčeného pola jednoducho skopírujú

while i < len(L):
pole[k] = L[i]
i += 1
k += 1

while j < len(P):
pole[k] = P[j]
j += 1
k += 1

# Hlavný program

if __name__ == '__main__':

pole = [12, 11, 13, 5, 6, 7]

print("Zadané pole:", end="\n")
print(pole, end="\n")

MergeSort(pole)

print("Zoradené pole:", end="\n")
print(pole, end="\n")

</syntaxhighlight>
</tab>

<tab name="Iteračná: Python3" block>
<syntaxhighlight lang="Python3">
def MergeSort_iteracia(pole):

# Dĺžka subpolí, ktoré majú byť zlúčené, hodnoty premennej sa pohybujú v intervale <1;n-1>

aktual_dlzka = 1

# Vonkajší cyklus, ktorý určuje subpolia aktuálnej dĺžky

while aktual_dlzka < len(pole) - 1:

lavy = 0

# Vnútorný cyklus, ktorý slúži na zlúčenie a zoradenie subpoli do jedného subpola

while lavy < len(pole) - 1:

# Index stredného prvku sa určí, keď k indexu ľavého prvku subpola pripočítame aktuálnu
# dĺžku subpolí a odčítame 1

stred = min((lavy + aktual_dlzka - 1), len(pole) - 1)

# Ak platí podmienka 2 * aktuálna dĺžka < dĺžka pola - 1, tak pravý index = aktuálnej dĺžke subpolí,
# inak pravý index = dĺžke pola - 1

pravy = ((2 * aktual_dlzka + lavy - 1, len(pole) - 1)[2 * aktual_dlzka + lavy - 1 > len(pole) - 1])

# Volanie funkcie merge

merge(pole, lavy, stred, pravy)

lavy = lavy + 2 * aktual_dlzka

# Aktuálna dĺžka sa sa zmení na dvojnásobok jej predošlej hodnoty

aktual_dlzka = 2 * aktual_dlzka

def merge(pole, lavy, stred, pravy):

n1 = stred - lavy + 1
n2 = pravy - stred

# Inicializácia pomocných polí

L = [0] * n1
P = [0] * n2

# Načítanie dát do pomocných polí

for i in range(0, n1):
L[i] = pole[lavy + i]
for i in range(0, n2):
P[i] = pole[stred + i + 1]

i, j, k = 0, 0, lavy

# Zlúčenie a zoradenie údajov z pomocných polí do jedného pola

while i < n1 and j < n2:
if L[i] > P[j]:
pole[k] = P[j]
j += 1
else:
pole[k] = L[i]
i += 1
k += 1

# Kontrola či všetky prvky boli zlúčené dokopy,
# ak nie, tak sa do zlúčeného pola jednoducho skopírujú

while i < n1:
pole[k] = L[i]
i += 1
k += 1

while j < n2:
pole[k] = P[j]
j += 1
k += 1

# Hlavný program

if __name__ == '__main__':

pole = [12, 11, 13, 5, 6, 7]

print("Zadané pole:", end="\n")
print(pole, end="\n")

MergeSort_iteracia(pole)

print("Zoradené pole:", end="\n")
print(pole, end="\n")

</syntaxhighlight>
</tab>

</tabs>

==Odkazy==
# https://www.geeksforgeeks.org/merge-sort/
# https://www.geeksforgeeks.org/iterative-merge-sort/
# https://medium.com/@paulsoham/merge-sort-63d75df76388
# https://www.khanacademy.org/computing/computer-science/algorithms/merge-sort/a/overview-of-merge-sort
# https://www.tutorialspoint.com/data_structures_algorithms/merge_sort_algorithm.htm
# https://www.youtube.com/watch?v=6pV2IF0fgKY
# https://www.youtube.com/watch?v=mB5HXBb_HY8
# https://www.youtube.com/watch?v=ak-pz7tS5DE

Triedenie zlučovaním

2021-03-29T15:05:47Z

Filip Tomek: /* Implementácia algoritmov Merge a MergeSort v rôznych programovacích jazykoch */

[[Kategória:Algoritmy triedenia]]
{{Draft}}
{{Skripta programovanie}}
__TOC__
==Zlučovací algoritmus Merge==
[[Súbor:Funkcia merge.png|500px|náhľad|vpravo|Vizualizácia funkcie Merge: Máme pole prvkov ''p = [1, 3, 5, 2, 4, 6]'', ktoré je už čiastočne utriedené. Použijeme algoritmus Merge, ktorý si vytvorí pomocné polia ''L = [1, 3, 5]'' a ''P = [2, 4, 6]''. Všetky polia indexujeme od ''0'', pričom pre pole ''p'' používame index ''k'', pre ''L'' index ''i'' a pre ''P'' index ''j''. Postupnosť krokov je označená číslicami 1 až 6.
]]

Princíp zlučovania tkvie v tom, že máme dva alebo viac utriedených zoznamov, ktoré skombinuje do jedného utriedeného zoznamu (výsledný zoznam musí obsahovať všetky prvky z pôvodných zoznamov). Zoznam môže byť reprezentovaný ako dátová štruktúra pole alebo aj ako lineárny zoznam. V tomto článku sa zameriame na algoritmus pre dátovú štruktúru pole.

Algoritmus ''Merge'' tvorí kľúčovú časť triediaceho algoritmu ''MergeSort''.

===Slovný opis algoritmu===
Nech máme pole, ktoré sa skladá z dvoch už utriedených polovíc. Vytvoríme si dve pomocné polia ''L'' a ''P'' a do každého z nich skopírujeme obsah jednej polovice (''L'' - ľavá polovica, ''P'' - pravá polovica). Potom súčasne prechádzame polia ''L'' a ''P'' od začiatku po koniec, pričom v každom cykle porovnáme prvok poľa ''L'' s prvkom v poli ''P''. Z tejto dvojice následne vyberieme minimum, (keď triedime od najmenšieho po najväčší) ktoré vložíme na prvú voľnú pozíciu pôvodného poľa (na začiatku je to prvá pozícia poľa). Nakoniec zvýšime index pri vstupnom poli a pri pomocnom poli, z ktorého vyberáme daný prvok. Túto postupnosť krokov opakujeme, pokiaľ neprídeme na koniec jedného z polí ''P'' a ''L''. Ak nastane situácia, že prídeme na koniec jedného z pomocných polí (a v druhom nám ostali ešte nejaké prvky), potom už iba naspäť skopírujeme zbytok druhého pomocného poľa na koniec pôvodného poľa.

===Vlastnosti algoritmu===
* vhodný pre dátové štruktúry: pole, lineárny zoznam
* časová náročnosť: vždy lineárna <math>O(n)</math>
* priestorová náročnosť: lineárna <math>O(n)</math> pre pole (alokovanie pomocných polí), <math>O(1)</math> pre lineárny zoznam (pri lineárnom zozname netreba alokovať dočasné polia, stačí iba presmerovať smerníky)
* využitie: kľúčový podprogram pre triediaci algoritmus MergeSort

===Pseudokód===
Nech funkcia ''Merge'' má nasledovný prototyp: <code>Merge(pole[], lavy, stred, pravy)</code>
:1. Je <code>lavy >= pravy ? Ak áno, skonči, inak pokračuj krokom 2.</code>
:2. Nech: <code>i = 0, j = 0, k = lavy </code>
:3. Nech: <code>dlzka_L = stred - lavy + 1, dlzka_P = pravy - stred</code>
:4. Nech: <code> L = pole[lavy ... stred], P = pole[stred + 1 ... pravy] </code>
:5. Je <code>i < dlzka_L</code> a zároveň <code>j < dlzka_P</code> ? Ak áno, pokračuj krokom 5.1., inak skoč na krok 6.
:::5.1. Je <code>L[i] <= P[j]</code>?
:::: Ak áno:
:::::5.1.1. <code>pole[k] = L[i]</code>
:::::5.1.2. <code>k += 1</code>
:::::5.1.3. <code>i += 1</code>
:::::5.1.4. Skoč na krok 5.
:::: Ak nie:
:::::5.1.1. <code>pole[k] = P[j]</code>
:::::5.1.2. <code>k += 1</code>
:::::5.1.3. <code>j += 1</code>
:::::5.1.4. Skoč na krok 5.
:6. Je <code>i < dlzka_L</code> ? Ak áno, pokračuj krokom 6.1., inak skoč na krok 7.
:::6.1. <code>pole[k] = L[i]</code>
:::6.2. <code>k += 1</code>
:::6.3. <code>i += 1</code>
:::6.4. Skoč na krok 6.
:7. Je <code>j < dlzka_P</code> ? Ak áno, pokračuj krokom 7.1., inak skonči.
:::7.1. <code>pole[k] = P[j]</code>
:::7.2. <code>k += 1</code>
:::7.3. <code>j += 1</code>
:::7.4. Skoč na krok 7.

==MergeSort==
''MergeSort'' je triediaci algoritmus, ktorý využíva stratégiu '''"rozdeľuj a panuj"''', čo znamená, že vstupný zoznam najskôr rozdelí na dve polovice, tie zoradí a potom ich zlúči naspäť dokopy. Radí sa medzi najpoužívanejšie a najviac rešpektované triediace algoritmy.

===Vlastnosti algoritmu Merge Sort===
* vhodný pre dátové štruktúry: pole, lineárny zoznam
* časová náročnosť: vždy linearitmická <math> O(n.log(n)) </math>, vďaka ktorej dokáže efektívne triediť veľmi veľké zoznamy
* priestorová náročnosť: lineárna <math>O(n)</math> pre pole (alokovanie dočasných polí), konštantná <math>O(1)</math> pre lineárny zoznam (pri lineárnom zozname stačí iba presmerovať smerníky)
* druh triedenia: triedenie zlučovaním (komparačný algoritmus)
* stabilita triedenia: stabilný
* miesto triedenia: externé triedenie (vhodný na triedenie veľkých objemov dát uložených na disku)

Z hľadiska implementácie môžeme vytvoriť dve základné verzie algoritmu, a to ''rekurzívnu'' a ''iteračnú''.

===Opis rekurzívnej a iteračnej verzie algoritmu Merge Sort===

<tabs>
<tab name="Rekurzívna verzia" block>
[[Súbor:Merge sort.png|400px|náhľad|vpravo|Vizualizácia rekurzívnej verzie algoritmu MergeSort]]

===Princíp algoritmu===
Algoritmus ''MergeSort'' vykonáva 4 základné úlohy:
# Delenie poľa na dve polovice.
# Triedenie ľavej polovice poľa.
# Triedenie pravej polovice poľa.
# Zlúčenie oboch polovíc pomocou funkcie ''Merge''.

===Slovný opis===
Našou úlohou je vzostupne (min -> max) utriediť vstupné pole. Určíme si ''stred'' poľa (pri párnom počte prvkov je to ten menší z prostredných indexov). Následne vykonávame sériu rekurzívnych delení pre ľavú a pravú časť poľa (''začiatok ... stred ; stred + 1 ... koniec'') až do momentu, keď nám ostanú len jednoprvkové podpolia (tie sú už utriedené). Následne v každom volaní obe tieto podpolia zlúčime pomocou algoritmu ''Merge'' do väčších podpolí (2, 4, 8, ...), až nakoniec dostaneme jedno výsledné utriedené pole.

===Pseudokód===
Nech nech má funkcia ''MergeSort'' nasledovný prototyp: <code>MergeSort(pole[], lavy, pravy) </code>
:1. Je <code>lavy >= pravy</code> ? Ak áno, skonči volanie, inak pokračuj krokom 2.
:2. Nech: <code>stred = lavy + (pravy - lavy) / 2</code>, pričom znak ''/'' vyjadruje celočíselné delenie.
:3. Rekurzívne zavolaj funkciu <code>MergeSort(pole[], lavy , stred)</code>
:3. Rekurzívne zavolaj funkciu <code>MergeSort(pole[], stred + 1 , pravy)</code>
:4. Zavolaj funkciu <code>Merge(pole[], lavy, stred, pravy)</code>
:5. Skonči volanie.

</tab>
<tab name="Iteračná verzia" block>
[[Súbor:MergeSort IT.png|400px|náhľad|vpravo]]

===Princíp algoritmu===
Algoritmus ''MergeSort'' vykonáva 3 základné úlohy:
# Vonkajší cyklus: určenie veľkosti zoznamu na zlučovanie.
# Vnútorný cyklus: prechádzanie jednotlivých zoznamov v poli.
# Zlučovanie jednotlivých zoznamov pomocou funkcie ''Merge''.

===Slovný opis===
Vstupné pole, ktoré má ''N'' prvkov, môžeme chápať, ako ''N'' rôznych jednoprvkových (utriedených) podpolí, ktoré máme zlúčiť do jedného výsledného ''N''-prvkového utriedeného poľa. Keďže by bolo veľmi nepraktické zlučovať ''N'' podpolí naraz, zvolíme nasledovnú stratégiu: Budeme prechádzať dané pole od začiatku po koniec a v prvom cykle zlúčime každé dva prvky, takže budeme mať <math>\frac{n}{2}</math> dvojprvkových utriedených podpolí. Potom v druhom cykle zlúčime každé 4 prvky do jedného podpoľa, v treťom cykle každých 8, až do momentu, keď dostaneme jedno utriedené pole.
Aby sme to docielili, potrebujeme dva cykly, vonkajší, ktorý nastaví maximálnu veľkosť podpoľa, ktoré ideme zlučovať (1,2,4,8 ... ''dlzka - 1'') a vnútorný, ktorý prechádza jednotlivé podpolia. Následne už iba voláme funkciu ''Merge'', ktorá dané podpolia zlučuje.

Poznámka, ak máme ''pole'', ktoré má nepárny počet prvkov, tak ten posledný prvok nezlúčime hneď v prvom cykle, ale až v tých ďalších. Takisto, ak ''N'' nie je mocnina čísla 2, tak musíme samozrejme ošetriť situáciu, kedy by sme sa dostali mimo rozsah poľa (Ak máme napríklad ''pole'', čo má 7 prvkov, tak po prvej iterácii budú prvky utiredené podľa vzoru 2 + 2 + 2 + 1, po druhej 4 + 3, a po tretej 7)

===Pseudokód===
Nech nech má funkcia ''MergeSort'' nasledovný prototyp: <code>MergeSort(pole[], lavy, pravy) </code>
:1. Je <code>lavy >= pravy</code> ? Ak áno, skonči, inak pokračuj krokom 2.
:2. Nech: <code>dlzka_subzoznamu = 1 </code>
:3. Nech: <code>zaciatok = lavy</code>
:4. Je<code>dlzka_subzoznamu <= pravy</code> ? Ak áno pokračuj krokom 4.1, inak skonči.
:::4.1. Je<code>zaciatok < pravy</code> Ak áno pokračuj krokom 4.1.1, inak skoč na krok 4.2.
:::::4.1.1. Je <code>zaciatok + 2 * dlzka_zoznamu - 1 <= pravy</code> ?
:::::::Ak áno:
:::::::::4.1.1.1. Nech <code>koniec = zaciatok + 2 * dlzka_zoznamu - 1</code>
:::::::Ak nie:
:::::::::4.1.1.1. Nech <code>koniec = pravy</code>
:::::4.1.2. Je <code>zaciatok + dlzka_zoznamu - 1 <= pravy</code> ?
:::::::Ak áno:
:::::::::4.1.2.1. Nech <code>stred = zaciatok + dlzka_zoznamu - 1</code>
:::::::Ak nie:
:::::::::4.1.2.1. Nech <code>stred = pravy</code>
:::::4.1.3. <code>Merge(pole[], zaciatok, stred, koniec)</code>
:::::4.1.4. <code>zaciatok += 2 * dlzka_subzoznamu</code>
:::::4.1.5. Skoč na krok 4.1.
:::4.2. <code>dlzka_subzoznamu *= 2</code>
:::4.3 Skoč na krok 4.

</tab>
</tabs>

==Implementácia algoritmov Merge a MergeSort v rôznych programovacích jazykoch==
<tabs>
<tab name="Rekurzívna: C " block>
<syntaxhighlight lang="C">
#include <stdio.h>
#include <stdlib.h>

void Merge(int pole[], int lavy, int stred, int pravy);
void MergeSort(int pole[], int lavy, int pravy);

/* hlavný program */

int main()
{
int pole[] = {12, 11, 13, 5, 6, 7};
int dlzka_pola = sizeof(pole) / sizeof(pole[0]);

printf("Pôvodné pole: \n");

for (int i = 0; i < dlzka_pola; ++i)
{
printf("%d ", pole[i]);
}

MergeSort(pole, 0, dlzka_pola - 1);

printf("\nUtriedené pole: \n");

for (int i = 0; i < dlzka_pola; ++i)
{
printf("%d ", pole[i]);
}

return 0;
}

void Merge(int pole[], int lavy, int stred, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči */

if (lavy >= pravy)
{
return;
}

/* vyrátaj dĺžky oboch polovíc poľa */

int L_dlzka = stred - lavy + 1;
int P_dlzka = pravy - stred;

/* alokuj dočasné polia, kam uložíš prvky z oboch polovíc poľa */

int *L = (int*)malloc(L_dlzka * sizeof(int));
int *P = (int*)malloc(P_dlzka * sizeof(int));

/* indexy, ktorými iterujeme všetky polia: i pre L, j pre P, k pre pole */

int i, j, k;

/* skopíruj obsah oboch polovíc poľa do dočasných polí L a P */

for (i = 0; i < L_dlzka; ++i)
{
L[i] = pole[lavy + i];
}

for (j = 0; j < P_dlzka; ++j)
{
P[j] = pole[stred + 1 + j];
}

/* nastav indexy na začiatok daných polí */

i = 0; j = 0; k = lavy;

/* zlučuj dočasné polia L a P do finálneho poľa pole */

while(i < L_dlzka && j < P_dlzka)
{
if(L[i] <= P[j])
{
pole[k++] = L[i++];
}
else
{
pole[k++] = P[j++];
}
}

/* ak ostali nejaké prvky v dočasnom poli L, skopíruj ich do finálneho poľa */

while(i < L_dlzka)
{
pole[k++] = L[i++];
}

/* ak ostali nejaké prvky v dočasnom poli P, skopíruj ich do finálneho poľa */

while(j < P_dlzka)
{
pole[k++] = P[j++];
}

/* uvoľni použitú pamäť */

free(L);
free(P);
}

void MergeSort(int pole[], int lavy, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči volanie */

if(lavy >= pravy)
{
return;
}
/* urči si prostredný index */

int stred = lavy + (pravy - lavy) / 2;

/* utrieď ľavú polovicu poľa */

MergeSort(pole, lavy, stred);

/* utrieď pravú polovicu poľa */

MergeSort(pole, stred+1, pravy);

/* zlúč obe polovice dokopy */

Merge(pole, lavy, stred, pravy);
}
</syntaxhighlight>
</tab>

<tab name="Iteračná: C" block>
<syntaxhighlight lang="C">
#include <stdio.h>
#include <stdlib.h>

void Merge(int pole[], int lavy, int stred, int pravy);
void MergeSortIt(int *pole, int lavy, int pravy);

/* hlavný program */

int main()
{
int pole[] = {12, 11, 13, 5, 6, 7, 19};
int dlzka_pola = sizeof(pole) / sizeof(pole[0]);

printf("Pôvodné pole %d: \n", dlzka_pola);

for (int i = 0; i < dlzka_pola; ++i)
{
printf("%d ", pole[i]);
}

MergeSortIt(pole, 0, dlzka_pola - 1);

printf("\nUtriedené pole: \n");

for (int i = 0; i < dlzka_pola; ++i)
{
printf("%d ", pole[i]);
}

return 0;
}

void Merge(int pole[], int lavy, int stred, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči */

if (lavy >= pravy)
{
return;
}

/* vyrátaj dĺžky oboch polovíc poľa */

int L_dlzka = stred - lavy + 1;
int P_dlzka = pravy - stred;

/* alokuj dočasné polia, kam uložíš prvky z oboch polovíc poľa */

int *L = (int*)malloc(L_dlzka * sizeof(int));
int *P = (int*)malloc(P_dlzka * sizeof(int));

/* indexy, ktorými iterujeme všetky polia: i pre L, j pre P, k pre pole */

int i, j, k;

/* skopíruj obsah oboch polovíc poľa do dočasných polí L a P */

for (i = 0; i < L_dlzka; ++i)
{
L[i] = pole[lavy + i];
}

for (j = 0; j < P_dlzka; ++j)
{
P[j] = pole[stred + 1 + j];
}

/* nastav indexy na začiatok daných polí */

i = 0; j = 0; k = lavy;

/* zlučuj dočasné polia L a P do finálneho poľa pole */

while(i < L_dlzka && j < P_dlzka)
{
if(L[i] <= P[j])
{
pole[k++] = L[i++];
}
else
{
pole[k++] = P[j++];
}
}

/* ak ostali nejaké prvky v dočasnom poli L, skopíruj ich do finálneho poľa */

while(i < L_dlzka)
{
pole[k++] = L[i++];
}

/* ak ostali nejaké prvky v dočasnom poli P, skopíruj ich do finálneho poľa */

while(j < P_dlzka)
{
pole[k++] = P[j++];
}

/* uvoľni použitú pamäť */

free(L);
free(P);
}

void MergeSortIt(int *pole, int lavy, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči volanie */

if(lavy >= pravy)
{
return;
}

int stred, koniec;

for (int dlzka_zoznamu = 1; dlzka_zoznamu <= pravy ; dlzka_zoznamu *= 2)
{
for (int zaciatok = lavy; zaciatok < pravy ; zaciatok += 2 * dlzka_zoznamu)
{
koniec = (zaciatok + 2 * dlzka_zoznamu - 1 <= pravy) ? zaciatok + 2 * dlzka_zoznamu - 1 : pravy;

stred = (zaciatok + dlzka_zoznamu - 1 <= pravy) ? zaciatok + dlzka_zoznamu - 1 : pravy;

Merge(pole, zaciatok, stred, koniec);

}
}
}

</syntaxhighlight>
</tab>

<tab name="Rekurzívna: C++" block>
<syntaxhighlight lang="C++">
#include <iostream>

using std::cout;
using std::endl;

void Merge(int pole[], int lavy, int stred, int pravy);
void MergeSort(int pole[], int lavy, int pravy);

/* hlavný program */

int main()
{
int pole[] = {12, 11, 13, 5, 6, 7};
int dlzka_pola = sizeof(pole) / sizeof(pole[0]);

printf("Pôvodné pole: \n");

for (auto i: pole)
{
cout<<i<<" ";
}

MergeSort(pole, 0, dlzka_pola - 1);

cout<<endl<<"Utriedené pole:"<<endl;

for (auto i: pole)
{
cout<<i<<" ";
}

return 0;
}

void Merge(int pole[], int lavy, int stred, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči */

if (lavy >= pravy)
{
return;
}

/* vyrátaj dĺžky oboch polovíc poľa */

int L_dlzka = stred - lavy + 1;
int P_dlzka = pravy - stred;

/* alokuj dočasné polia, kam uložíš prvky z oboch polovíc poľa */

int *L = new int[L_dlzka];
int *P = new int[P_dlzka];

/* indexy, ktorými iterujeme všetky polia: i pre L, j pre P, k pre pole */

int i, j, k;

/* skopíruj obsah oboch polovíc poľa do dočasných polí L a P */

for (i = 0; i < L_dlzka; ++i)
{
L[i] = pole[lavy + i];
}

for (j = 0; j < P_dlzka; ++j)
{
P[j] = pole[stred + 1 + j];
}

/* nastav indexy na začiatok daných polí */

i = 0; j = 0; k = lavy;

/* zlučuj dočasné polia L a P do finálneho poľa pole */

while(i < L_dlzka && j < P_dlzka)
{
if(L[i] <= P[j])
{
pole[k++] = L[i++];
}
else
{
pole[k++] = P[j++];
}
}

/* ak ostali nejaké prvky v dočasnom poli L, skopíruj ich do finálneho poľa */

while(i < L_dlzka)
{
pole[k++] = L[i++];
}

/* ak ostali nejaké prvky v dočasnom poli P, skopíruj ich do finálneho poľa */

while(j < P_dlzka)
{
pole[k++] = P[j++];
}

/* uvoľni použitú pamäť */

delete []L;
delete []P;
}

void MergeSort(int pole[], int lavy, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči volanie */

if(lavy >= pravy)
{
return;
}
/* urči si prostredný index */

int stred = lavy + (pravy - lavy) / 2;

/* utrieď ľavú polovicu poľa */

MergeSort(pole, lavy, stred);

/* utrieď pravú polovicu poľa */

MergeSort(pole, stred+1, pravy);

/* zlúč obe polovice dokopy */

Merge(pole, lavy, stred, pravy);
}

</syntaxhighlight>
</tab>

<tab name="Iteračná: C++" block>
<syntaxhighlight lang="C++">
#include <iostream>

using std::cout;
using std::endl;

void Merge(int pole[], int lavy, int stred, int pravy);
void MergeSort(int pole[], int lavy, int pravy);

/* hlavný program */

int main()
{
int pole[] = {12, 11, 13, 5, 6, 7};
int dlzka_pola = sizeof(pole) / sizeof(pole[0]);

printf("Pôvodné pole: \n");

for (auto i: pole)
{
cout<<i<<" ";
}

MergeSort(pole, 0, dlzka_pola - 1);

cout<<endl<<"Utriedené pole:"<<endl;

for (auto i: pole)
{
cout<<i<<" ";
}

return 0;
}

void Merge(int pole[], int lavy, int stred, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči */

if (lavy >= pravy)
{
return;
}

/* vyrátaj dĺžky oboch polovíc poľa */

int L_dlzka = stred - lavy + 1;
int P_dlzka = pravy - stred;

/* alokuj dočasné polia, kam uložíš prvky z oboch polovíc poľa */

int *L = new int[L_dlzka];
int *P = new int[P_dlzka];

/* indexy, ktorými iterujeme všetky polia: i pre L, j pre P, k pre pole */

int i, j, k;

/* skopíruj obsah oboch polovíc poľa do dočasných polí L a P */

for (i = 0; i < L_dlzka; ++i)
{
L[i] = pole[lavy + i];
}

for (j = 0; j < P_dlzka; ++j)
{
P[j] = pole[stred + 1 + j];
}

/* nastav indexy na začiatok daných polí */

i = 0; j = 0; k = lavy;

/* zlučuj dočasné polia L a P do finálneho poľa pole */

while(i < L_dlzka && j < P_dlzka)
{
if(L[i] <= P[j])
{
pole[k++] = L[i++];
}
else
{
pole[k++] = P[j++];
}
}

/* ak ostali nejaké prvky v dočasnom poli L, skopíruj ich do finálneho poľa */

while(i < L_dlzka)
{
pole[k++] = L[i++];
}

/* ak ostali nejaké prvky v dočasnom poli P, skopíruj ich do finálneho poľa */

while(j < P_dlzka)
{
pole[k++] = P[j++];
}

/* uvoľni použitú pamäť */

delete []L;
delete []P;
}

void MergeSort(int *pole, int lavy, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči volanie */

if(lavy >= pravy)
{
return;
}

int stred, koniec;

for (int dlzka_zoznamu = 1; dlzka_zoznamu <= pravy; dlzka_zoznamu *= 2)
{
for (int zaciatok = lavy; zaciatok < pravy; zaciatok += 2 * dlzka_zoznamu)
{
koniec = (zaciatok + 2 * dlzka_zoznamu - 1 <= pravy) ? zaciatok + 2 * dlzka_zoznamu - 1 : pravy;

stred = (zaciatok + dlzka_zoznamu - 1 <= pravy) ? zaciatok + dlzka_zoznamu - 1 : pravy;

Merge(pole, zaciatok, stred, koniec);
}
}
}
</syntaxhighlight>
</tab>

<tab name="Rekurzívna: Java" block>
<syntaxhighlight lang="Java">
class MergeSort
{

/* Funkcia zlúči 2 podpolia, ktoré sme vytvorili z pôvodného poľa.
* Každé podpole má polovičnú dĺžku pôvodného poľa.
* subpole1 [ľavý ... stred]
* subpole2 [stred + 1 ... pravý]
*/

void merge(int[] pole, int lavy, int stred, int pravy)
{

// Výpočet dĺžky 2 podpolí

int n1 = stred - lavy + 1;
int n2 = pravy - stred;

// Vytvorenie pomocných polí

int[] L = new int[n1];
int[] P = new int[n2];

// Načítanie dát do pomocných polí

for (int i = 0; i < n1; i++)
L[i] = pole[lavy + i];

for (int j = 0; j < n2; j++)
P[j] = pole[stred + 1 + j];

// Počiatočné indexy prvého a druhého podpoľa

int i = 0, j = 0;

// Počiatočný index zlúčeného podpoľa

int k = lavy;

// Zlúčenie dvoch podpolí

while (i < n1 && j < n2)
{
if (L[i] <= P[j])
{
pole[k] = L[i];
i++;
}
else
{
pole[k] = P[j];
j++;
}
k++;
}

/* V prípade, že sa v jednom zo podpoli nachádzajú ešte nejaké prvky, ktoré neboli zlúčené do pola,
* tak sa do pola jednoducho skopírujú
*/

while (i < n1)
{
pole[k] = L[i];
i++;
k++;
}

while (j < n2)
{
pole[k] = P[j];
k++;
j++;
}

}

/* Funkcia, ktorá zoradí pole použitím funkcie merge() */

void sort (int[] pole, int lavy, int pravy)
{
if (lavy < pravy)
{
// Musíme nájsť stred pola

int stred = lavy + (pravy - lavy) / 2;

// Zoradíme prvú a druhú polovicu pola samostatne

sort(pole, lavy, stred);
sort(pole, stred + 1, pravy);

// Zlúčime zoradené polovice do jedného pola

merge(pole, lavy, stred, pravy);
}
}
}

public class Main
{
/* Funkcia na výpis pola dĺžky n */

static void vypis_pole(int[] pole)
{

for (int j : pole)
{
System.out.print(j + " ");
}

System.out.println();
}

/* Hlavný program */

public static void main(String[] args)
{
int[] pole = {12, 11, 13, 5, 6, 7};

System.out.println("Zadané pole:");
vypis_pole(pole);

MergeSort ms = new MergeSort();
ms.sort(pole, 0, pole.length - 1);

System.out.println("\nZoradené pole:");
vypis_pole(pole);
}
}
</syntaxhighlight>
</tab>

<tab name="Iteračná: Java" block>
<syntaxhighlight lang="Java">
class MergeSort_iteracia
{
/* Zlúči 2 subpolia, ktoré sa vytvorili z pôvodného pola.
* Každé subpole má polovičnú dĺžku pôvodného pola.
* subpole1 [ľavý..stred]
* subpole2 [stred+1..pravý]
*/

void merge(int[] pole, int lavy, int stred, int pravy)
{
// Výpočet dĺžky 2 subpolí

int n1 = stred - lavy + 1;
int n2 = pravy - stred;

// Vytvorenie pomocných polí

int[] L = new int[n1];
int[] P = new int[n2];

// Načítanie dát do pomocných polí

for (int i = 0; i < n1; i++)
L[i] = pole[lavy + i];

for (int j = 0; j < n2; j++)
P[j] = pole[stred + 1 + j];

// Počiatočné indexy prvého a druhého subpola

int i = 0, j = 0;

// Počiatočný index zlúčeného subpola

int k = lavy;

// Zlúčenie dvoch podpolí

while (i < n1 && j < n2)
{
if (L[i] <= P[j])
{
pole[k] = L[i];
i++;
}
else
{
pole[k] = P[j];
j++;
}
k++;
}

/* V prípade, že v jednom zo subpolí sa nachádzajú prvky, ktoré neboli zlúčené do pola,
* tak sa do pola jednoducho skopírujú
*/

while (i < n1)
{
pole[k] = L[i];
i++;
k++;
}

while (j < n2)
{
pole[k] = P[j];
k++;
j++;
}
}

/* Funkcia, ktorá zoradí pole použitím funkcie merge() */

void sort (int[] pole, int n)
{
/* Dĺžka subpolí, ktoré majú byť zlúčené, hodnoty premennej sa pohybujú v intervale <1;n-1> */

int aktual_dlzka;

/* Začiatočný index ľavého subpola, ktoré má byť zlúčené */

int zaciatok_vlavo;

/* Vzostupné usporiadanie prvkov. Najskôr sa zlúčia subpolia veľkosti 1 do subpolí veľkosti 2,
* potom subpolia veľkosti 2 do subpolí veľkosti 4 a tak ďalej
*/

for (aktual_dlzka = 1; aktual_dlzka <= n - 1; aktual_dlzka *= 2)
{
/* Určenie začiatočného prvku rôznych subpolí aktuálnej dĺžky subpola */

for (zaciatok_vlavo = 0; zaciatok_vlavo < n - 1; zaciatok_vlavo += 2 * aktual_dlzka)
{
/* Nájdenie konečného prvku ľavého subpola, stred+1 je začiatočný prvok pravého subpola */

int stred = Math.min(zaciatok_vlavo + aktual_dlzka - 1, n - 1);
int koniec_vpravo = Math.min(zaciatok_vlavo + 2 * aktual_dlzka - 1, n - 1);

/* Zlúči subpolia L[zaciatok_vlavo .. stred] & P[stred+1 .. koniec_vpravo] */

merge(pole, zaciatok_vlavo, stred, koniec_vpravo);
}
}
}
}

public class Main {

/* Funkcia na výpis pola dĺžky n */

static void vypis_pole(int[] pole)
{
int n = pole.length;

for (int j : pole)
{
System.out.print(j + " ");
}
System.out.println();
}

/* Hlavný program */

public static void main(String[] args) {

/* Inicializácia pola */

int[] pole = {12, 11, 13, 5, 6, 7};

System.out.println("Zadané pole:");
vypis_pole(pole);

MergeSort_iteracia ms_it = new MergeSort_iteracia();
ms_it.sort(pole, pole.length);

System.out.println("Zoradené pole:");
vypis_pole(pole);
}
}
</syntaxhighlight>
</tab>

<tab name="Rekurzívna: Python3" block>
<syntaxhighlight lang="Python3">
def MergeSort(pole):
if len(pole) > 1:

# Nájdenie stredu pola
# zápis len(pole)//2 znamená, že dĺžka pola sa vydelí 2 a výsledok je celé číslo

stred = len(pole) // 2

# Rozdelenie pola na dve časti

L = pole[:stred]
P = pole[stred:]

# Zoradenie najskôr prvej časti pola, potom druhej

MergeSort(L)
MergeSort(P)

i = j = k = 0

# Zlúčenie a zoradenie údajov z pomocných polí do jedného pola

while i < len(L) and j < len(P):
if L[i] < P[j]:
pole[k] = L[i]
i += 1
else:
pole[k] = P[j]
j += 1
k += 1

# Kontrola či všetky prvky boli zlúčené dokopy,
# ak nie, tak sa do zlúčeného pola jednoducho skopírujú

while i < len(L):
pole[k] = L[i]
i += 1
k += 1

while j < len(P):
pole[k] = P[j]
j += 1
k += 1

# Hlavný program

if __name__ == '__main__':

pole = [12, 11, 13, 5, 6, 7]

print("Zadané pole:", end="\n")
print(pole, end="\n")

MergeSort(pole)

print("Zoradené pole:", end="\n")
print(pole, end="\n")

</syntaxhighlight>
</tab>

<tab name="Iteračná: Python3" block>
<syntaxhighlight lang="Python3">
def MergeSort_iteracia(pole):

# Dĺžka subpolí, ktoré majú byť zlúčené, hodnoty premennej sa pohybujú v intervale <1;n-1>

aktual_dlzka = 1

# Vonkajší cyklus, ktorý určuje subpolia aktuálnej dĺžky

while aktual_dlzka < len(pole) - 1:

lavy = 0

# Vnútorný cyklus, ktorý slúži na zlúčenie a zoradenie subpoli do jedného subpola

while lavy < len(pole) - 1:

# Index stredného prvku sa určí, keď k indexu ľavého prvku subpola pripočítame aktuálnu
# dĺžku subpolí a odčítame 1

stred = min((lavy + aktual_dlzka - 1), len(pole) - 1)

# Ak platí podmienka 2 * aktuálna dĺžka < dĺžka pola - 1, tak pravý index = aktuálnej dĺžke subpolí,
# inak pravý index = dĺžke pola - 1

pravy = ((2 * aktual_dlzka + lavy - 1, len(pole) - 1)[2 * aktual_dlzka + lavy - 1 > len(pole) - 1])

# Volanie funkcie merge

merge(pole, lavy, stred, pravy)

lavy = lavy + 2 * aktual_dlzka

# Aktuálna dĺžka sa sa zmení na dvojnásobok jej predošlej hodnoty

aktual_dlzka = 2 * aktual_dlzka

def merge(pole, lavy, stred, pravy):

n1 = stred - lavy + 1
n2 = pravy - stred

# Inicializácia pomocných polí

L = [0] * n1
P = [0] * n2

# Načítanie dát do pomocných polí

for i in range(0, n1):
L[i] = pole[lavy + i]
for i in range(0, n2):
P[i] = pole[stred + i + 1]

i, j, k = 0, 0, lavy

# Zlúčenie a zoradenie údajov z pomocných polí do jedného pola

while i < n1 and j < n2:
if L[i] > P[j]:
pole[k] = P[j]
j += 1
else:
pole[k] = L[i]
i += 1
k += 1

# Kontrola či všetky prvky boli zlúčené dokopy,
# ak nie, tak sa do zlúčeného pola jednoducho skopírujú

while i < n1:
pole[k] = L[i]
i += 1
k += 1

while j < n2:
pole[k] = P[j]
j += 1
k += 1

# Hlavný program

if __name__ == '__main__':

pole = [12, 11, 13, 5, 6, 7]

print("Zadané pole:", end="\n")
print(pole, end="\n")

MergeSort_iteracia(pole)

print("Zoradené pole:", end="\n")
print(pole, end="\n")

</syntaxhighlight>
</tab>

</tabs>

==Odkazy==
# https://www.geeksforgeeks.org/merge-sort/
# https://www.geeksforgeeks.org/iterative-merge-sort/
# https://medium.com/@paulsoham/merge-sort-63d75df76388
# https://www.khanacademy.org/computing/computer-science/algorithms/merge-sort/a/overview-of-merge-sort
# https://www.tutorialspoint.com/data_structures_algorithms/merge_sort_algorithm.htm
# https://www.youtube.com/watch?v=6pV2IF0fgKY
# https://www.youtube.com/watch?v=mB5HXBb_HY8
# https://www.youtube.com/watch?v=ak-pz7tS5DE

Triedenie zlučovaním

2021-03-29T14:55:47Z

Filip Tomek: /* Merge sort */

[[Kategória:Algoritmy triedenia]]
{{Draft}}
{{Skripta programovanie}}
__TOC__
==Zlučovací algoritmus Merge==
[[Súbor:Funkcia merge.png|500px|náhľad|vpravo|Vizualizácia funkcie Merge: Máme pole prvkov ''p = [1, 3, 5, 2, 4, 6]'', ktoré je už čiastočne utriedené. Použijeme algoritmus Merge, ktorý si vytvorí pomocné polia ''L = [1, 3, 5]'' a ''P = [2, 4, 6]''. Všetky polia indexujeme od ''0'', pričom pre pole ''p'' používame index ''k'', pre ''L'' index ''i'' a pre ''P'' index ''j''. Postupnosť krokov je označená číslicami 1 až 6.
]]

Princíp zlučovania tkvie v tom, že máme dva alebo viac utriedených zoznamov, ktoré skombinuje do jedného utriedeného zoznamu (výsledný zoznam musí obsahovať všetky prvky z pôvodných zoznamov). Zoznam môže byť reprezentovaný ako dátová štruktúra pole alebo aj ako lineárny zoznam. V tomto článku sa zameriame na algoritmus pre dátovú štruktúru pole.

Algoritmus ''Merge'' tvorí kľúčovú časť triediaceho algoritmu ''MergeSort''.

===Slovný opis algoritmu===
Nech máme pole, ktoré sa skladá z dvoch už utriedených polovíc. Vytvoríme si dve pomocné polia ''L'' a ''P'' a do každého z nich skopírujeme obsah jednej polovice (''L'' - ľavá polovica, ''P'' - pravá polovica). Potom súčasne prechádzame polia ''L'' a ''P'' od začiatku po koniec, pričom v každom cykle porovnáme prvok poľa ''L'' s prvkom v poli ''P''. Z tejto dvojice následne vyberieme minimum, (keď triedime od najmenšieho po najväčší) ktoré vložíme na prvú voľnú pozíciu pôvodného poľa (na začiatku je to prvá pozícia poľa). Nakoniec zvýšime index pri vstupnom poli a pri pomocnom poli, z ktorého vyberáme daný prvok. Túto postupnosť krokov opakujeme, pokiaľ neprídeme na koniec jedného z polí ''P'' a ''L''. Ak nastane situácia, že prídeme na koniec jedného z pomocných polí (a v druhom nám ostali ešte nejaké prvky), potom už iba naspäť skopírujeme zbytok druhého pomocného poľa na koniec pôvodného poľa.

===Vlastnosti algoritmu===
* vhodný pre dátové štruktúry: pole, lineárny zoznam
* časová náročnosť: vždy lineárna <math>O(n)</math>
* priestorová náročnosť: lineárna <math>O(n)</math> pre pole (alokovanie pomocných polí), <math>O(1)</math> pre lineárny zoznam (pri lineárnom zozname netreba alokovať dočasné polia, stačí iba presmerovať smerníky)
* využitie: kľúčový podprogram pre triediaci algoritmus MergeSort

===Pseudokód===
Nech funkcia ''Merge'' má nasledovný prototyp: <code>Merge(pole[], lavy, stred, pravy)</code>
:1. Je <code>lavy >= pravy ? Ak áno, skonči, inak pokračuj krokom 2.</code>
:2. Nech: <code>i = 0, j = 0, k = lavy </code>
:3. Nech: <code>dlzka_L = stred - lavy + 1, dlzka_P = pravy - stred</code>
:4. Nech: <code> L = pole[lavy ... stred], P = pole[stred + 1 ... pravy] </code>
:5. Je <code>i < dlzka_L</code> a zároveň <code>j < dlzka_P</code> ? Ak áno, pokračuj krokom 5.1., inak skoč na krok 6.
:::5.1. Je <code>L[i] <= P[j]</code>?
:::: Ak áno:
:::::5.1.1. <code>pole[k] = L[i]</code>
:::::5.1.2. <code>k += 1</code>
:::::5.1.3. <code>i += 1</code>
:::::5.1.4. Skoč na krok 5.
:::: Ak nie:
:::::5.1.1. <code>pole[k] = P[j]</code>
:::::5.1.2. <code>k += 1</code>
:::::5.1.3. <code>j += 1</code>
:::::5.1.4. Skoč na krok 5.
:6. Je <code>i < dlzka_L</code> ? Ak áno, pokračuj krokom 6.1., inak skoč na krok 7.
:::6.1. <code>pole[k] = L[i]</code>
:::6.2. <code>k += 1</code>
:::6.3. <code>i += 1</code>
:::6.4. Skoč na krok 6.
:7. Je <code>j < dlzka_P</code> ? Ak áno, pokračuj krokom 7.1., inak skonči.
:::7.1. <code>pole[k] = P[j]</code>
:::7.2. <code>k += 1</code>
:::7.3. <code>j += 1</code>
:::7.4. Skoč na krok 7.

==MergeSort==
''MergeSort'' je triediaci algoritmus, ktorý využíva stratégiu '''"rozdeľuj a panuj"''', čo znamená, že vstupný zoznam najskôr rozdelí na dve polovice, tie zoradí a potom ich zlúči naspäť dokopy. Radí sa medzi najpoužívanejšie a najviac rešpektované triediace algoritmy.

===Vlastnosti algoritmu Merge Sort===
* vhodný pre dátové štruktúry: pole, lineárny zoznam
* časová náročnosť: vždy linearitmická <math> O(n.log(n)) </math>, vďaka ktorej dokáže efektívne triediť veľmi veľké zoznamy
* priestorová náročnosť: lineárna <math>O(n)</math> pre pole (alokovanie dočasných polí), konštantná <math>O(1)</math> pre lineárny zoznam (pri lineárnom zozname stačí iba presmerovať smerníky)
* druh triedenia: triedenie zlučovaním (komparačný algoritmus)
* stabilita triedenia: stabilný
* miesto triedenia: externé triedenie (vhodný na triedenie veľkých objemov dát uložených na disku)

Z hľadiska implementácie môžeme vytvoriť dve základné verzie algoritmu, a to ''rekurzívnu'' a ''iteračnú''.

===Opis rekurzívnej a iteračnej verzie algoritmu Merge Sort===

<tabs>
<tab name="Rekurzívna verzia" block>
[[Súbor:Merge sort.png|400px|náhľad|vpravo|Vizualizácia rekurzívnej verzie algoritmu MergeSort]]

===Princíp algoritmu===
Algoritmus ''MergeSort'' vykonáva 4 základné úlohy:
# Delenie poľa na dve polovice.
# Triedenie ľavej polovice poľa.
# Triedenie pravej polovice poľa.
# Zlúčenie oboch polovíc pomocou funkcie ''Merge''.

===Slovný opis===
Našou úlohou je vzostupne (min -> max) utriediť vstupné pole. Určíme si ''stred'' poľa (pri párnom počte prvkov je to ten menší z prostredných indexov). Následne vykonávame sériu rekurzívnych delení pre ľavú a pravú časť poľa (''začiatok ... stred ; stred + 1 ... koniec'') až do momentu, keď nám ostanú len jednoprvkové podpolia (tie sú už utriedené). Následne v každom volaní obe tieto podpolia zlúčime pomocou algoritmu ''Merge'' do väčších podpolí (2, 4, 8, ...), až nakoniec dostaneme jedno výsledné utriedené pole.

===Pseudokód===
Nech nech má funkcia ''MergeSort'' nasledovný prototyp: <code>MergeSort(pole[], lavy, pravy) </code>
:1. Je <code>lavy >= pravy</code> ? Ak áno, skonči volanie, inak pokračuj krokom 2.
:2. Nech: <code>stred = lavy + (pravy - lavy) / 2</code>, pričom znak ''/'' vyjadruje celočíselné delenie.
:3. Rekurzívne zavolaj funkciu <code>MergeSort(pole[], lavy , stred)</code>
:3. Rekurzívne zavolaj funkciu <code>MergeSort(pole[], stred + 1 , pravy)</code>
:4. Zavolaj funkciu <code>Merge(pole[], lavy, stred, pravy)</code>
:5. Skonči volanie.

</tab>
<tab name="Iteračná verzia" block>
[[Súbor:MergeSort IT.png|400px|náhľad|vpravo]]

===Princíp algoritmu===
Algoritmus ''MergeSort'' vykonáva 3 základné úlohy:
# Vonkajší cyklus: určenie veľkosti zoznamu na zlučovanie.
# Vnútorný cyklus: prechádzanie jednotlivých zoznamov v poli.
# Zlučovanie jednotlivých zoznamov pomocou funkcie ''Merge''.

===Slovný opis===
Vstupné pole, ktoré má ''N'' prvkov, môžeme chápať, ako ''N'' rôznych jednoprvkových (utriedených) podpolí, ktoré máme zlúčiť do jedného výsledného ''N''-prvkového utriedeného poľa. Keďže by bolo veľmi nepraktické zlučovať ''N'' podpolí naraz, zvolíme nasledovnú stratégiu: Budeme prechádzať dané pole od začiatku po koniec a v prvom cykle zlúčime každé dva prvky, takže budeme mať <math>\frac{n}{2}</math> dvojprvkových utriedených podpolí. Potom v druhom cykle zlúčime každé 4 prvky do jedného podpoľa, v treťom cykle každých 8, až do momentu, keď dostaneme jedno utriedené pole.
Aby sme to docielili, potrebujeme dva cykly, vonkajší, ktorý nastaví maximálnu veľkosť podpoľa, ktoré ideme zlučovať (1,2,4,8 ... ''dlzka - 1'') a vnútorný, ktorý prechádza jednotlivé podpolia. Následne už iba voláme funkciu ''Merge'', ktorá dané podpolia zlučuje.

Poznámka, ak máme ''pole'', ktoré má nepárny počet prvkov, tak ten posledný prvok nezlúčime hneď v prvom cykle, ale až v tých ďalších. Takisto, ak ''N'' nie je mocnina čísla 2, tak musíme samozrejme ošetriť situáciu, kedy by sme sa dostali mimo rozsah poľa (Ak máme napríklad ''pole'', čo má 7 prvkov, tak po prvej iterácii budú prvky utiredené podľa vzoru 2 + 2 + 2 + 1, po druhej 4 + 3, a po tretej 7)

===Pseudokód===
Nech nech má funkcia ''MergeSort'' nasledovný prototyp: <code>MergeSort(pole[], lavy, pravy) </code>
:1. Je <code>lavy >= pravy</code> ? Ak áno, skonči, inak pokračuj krokom 2.
:2. Nech: <code>dlzka_subzoznamu = 1 </code>
:3. Nech: <code>zaciatok = lavy</code>
:4. Je<code>dlzka_subzoznamu <= pravy</code> ? Ak áno pokračuj krokom 4.1, inak skonči.
:::4.1. Je<code>zaciatok < pravy</code> Ak áno pokračuj krokom 4.1.1, inak skoč na krok 4.2.
:::::4.1.1. Je <code>zaciatok + 2 * dlzka_zoznamu - 1 <= pravy</code> ?
:::::::Ak áno:
:::::::::4.1.1.1. Nech <code>koniec = zaciatok + 2 * dlzka_zoznamu - 1</code>
:::::::Ak nie:
:::::::::4.1.1.1. Nech <code>koniec = pravy</code>
:::::4.1.2. Je <code>zaciatok + dlzka_zoznamu - 1 <= pravy</code> ?
:::::::Ak áno:
:::::::::4.1.2.1. Nech <code>stred = zaciatok + dlzka_zoznamu - 1</code>
:::::::Ak nie:
:::::::::4.1.2.1. Nech <code>stred = pravy</code>
:::::4.1.3. <code>Merge(pole[], zaciatok, stred, koniec)</code>
:::::4.1.4. <code>zaciatok += 2 * dlzka_subzoznamu</code>
:::::4.1.5. Skoč na krok 4.1.
:::4.2. <code>dlzka_subzoznamu *= 2</code>
:::4.3 Skoč na krok 4.

</tab>
</tabs>

==Implementácia algoritmov Merge a MergeSort v rôznych programovacích jazykoch==
<tabs>
<tab name="Rekurzívna: C " block>
<syntaxhighlight lang="C">
#include <stdio.h>
#include <stdlib.h>

void Merge(int pole[], int lavy, int stred, int pravy);
void MergeSort(int pole[], int lavy, int pravy);

/* hlavný program */

int main()
{
int pole[] = {12, 11, 13, 5, 6, 7};
int dlzka_pola = sizeof(pole) / sizeof(pole[0]);

printf("Pôvodné pole: \n");

for (int i = 0; i < dlzka_pola; ++i)
{
printf("%d ", pole[i]);
}

MergeSort(pole, 0, dlzka_pola - 1);

printf("\nUtriedené pole: \n");

for (int i = 0; i < dlzka_pola; ++i)
{
printf("%d ", pole[i]);
}

return 0;
}

void Merge(int pole[], int lavy, int stred, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči */

if (lavy >= pravy)
{
return;
}

/* vyrátaj dĺžky oboch polovíc poľa */

int L_dlzka = stred - lavy + 1;
int P_dlzka = pravy - stred;

/* alokuj dočasné polia, kam uložíš prvky z oboch polovíc poľa */

int *L = (int*)malloc(L_dlzka * sizeof(int));
int *P = (int*)malloc(P_dlzka * sizeof(int));

/* indexy, ktorými iterujeme všetky polia: i pre L, j pre P, k pre pole */

int i, j, k;

/* skopíruj obsah oboch polovíc poľa do dočasných polí L a P */

for (i = 0; i < L_dlzka; ++i)
{
L[i] = pole[lavy + i];
}

for (j = 0; j < P_dlzka; ++j)
{
P[j] = pole[stred + 1 + j];
}

/* nastav indexy na začiatok daných polí */

i = 0; j = 0; k = lavy;

/* zlučuj dočasné polia L a P do finálneho poľa pole */

while(i < L_dlzka && j < P_dlzka)
{
if(L[i] <= P[j])
{
pole[k++] = L[i++];
}
else
{
pole[k++] = P[j++];
}
}

/* ak ostali nejaké prvky v dočasnom poli L, skopíruj ich do finálneho poľa */

while(i < L_dlzka)
{
pole[k++] = L[i++];
}

/* ak ostali nejaké prvky v dočasnom poli P, skopíruj ich do finálneho poľa */

while(j < P_dlzka)
{
pole[k++] = P[j++];
}

/* uvoľni použitú pamäť */

free(L);
free(P);
}

void MergeSort(int pole[], int lavy, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči volanie */

if(lavy >= pravy)
{
return;
}
/* urči si prostredný index */

int stred = lavy + (pravy - lavy) / 2;

/* utrieď ľavú polovicu poľa */

MergeSort(pole, lavy, stred);

/* utrieď pravú polovicu poľa */

MergeSort(pole, stred+1, pravy);

/* zlúč obe polovice dokopy */

Merge(pole, lavy, stred, pravy);
}
</syntaxhighlight>
</tab>

<tab name="Iteračná: C" block>
<syntaxhighlight lang="C">
#include <stdio.h>
#include <stdlib.h>

void Merge(int pole[], int lavy, int stred, int pravy);
void MergeSortIt(int *pole, int lavy, int pravy);

/* hlavný program */

int main()
{
int pole[] = {12, 11, 13, 5, 6, 7, 19};
int dlzka_pola = sizeof(pole) / sizeof(pole[0]);

printf("Pôvodné pole %d: \n", dlzka_pola);

for (int i = 0; i < dlzka_pola; ++i)
{
printf("%d ", pole[i]);
}

MergeSortIt(pole, 0, dlzka_pola - 1);

printf("\nUtriedené pole: \n");

for (int i = 0; i < dlzka_pola; ++i)
{
printf("%d ", pole[i]);
}

return 0;
}

void Merge(int pole[], int lavy, int stred, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči */

if (lavy >= pravy)
{
return;
}

/* vyrátaj dĺžky oboch polovíc poľa */

int L_dlzka = stred - lavy + 1;
int P_dlzka = pravy - stred;

/* alokuj dočasné polia, kam uložíš prvky z oboch polovíc poľa */

int *L = (int*)malloc(L_dlzka * sizeof(int));
int *P = (int*)malloc(P_dlzka * sizeof(int));

/* indexy, ktorými iterujeme všetky polia: i pre L, j pre P, k pre pole */

int i, j, k;

/* skopíruj obsah oboch polovíc poľa do dočasných polí L a P */

for (i = 0; i < L_dlzka; ++i)
{
L[i] = pole[lavy + i];
}

for (j = 0; j < P_dlzka; ++j)
{
P[j] = pole[stred + 1 + j];
}

/* nastav indexy na začiatok daných polí */

i = 0; j = 0; k = lavy;

/* zlučuj dočasné polia L a P do finálneho poľa pole */

while(i < L_dlzka && j < P_dlzka)
{
if(L[i] <= P[j])
{
pole[k++] = L[i++];
}
else
{
pole[k++] = P[j++];
}
}

/* ak ostali nejaké prvky v dočasnom poli L, skopíruj ich do finálneho poľa */

while(i < L_dlzka)
{
pole[k++] = L[i++];
}

/* ak ostali nejaké prvky v dočasnom poli P, skopíruj ich do finálneho poľa */

while(j < P_dlzka)
{
pole[k++] = P[j++];
}

/* uvoľni použitú pamäť */

free(L);
free(P);
}

void MergeSortIt(int *pole, int lavy, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči volanie */

if(lavy >= pravy)
{
return;
}

int stred, koniec;

for (int dlzka_zoznamu = 1; dlzka_zoznamu <= pravy ; dlzka_zoznamu *= 2)
{
for (int zaciatok = lavy; zaciatok < pravy ; zaciatok += 2 * dlzka_zoznamu)
{
koniec = (zaciatok + 2 * dlzka_zoznamu - 1 <= pravy) ? zaciatok + 2 * dlzka_zoznamu - 1 : pravy;

stred = (zaciatok + dlzka_zoznamu - 1 <= pravy) ? zaciatok + dlzka_zoznamu - 1 : pravy;

Merge(pole, zaciatok, stred, koniec);

}
}
}

</syntaxhighlight>
</tab>

<tab name="Rekurzívna: C++" block>
<syntaxhighlight lang="C++">
#include <iostream>

using std::cout;
using std::endl;

void Merge(int pole[], int lavy, int stred, int pravy);
void MergeSort(int pole[], int lavy, int pravy);

/* hlavný program */

int main()
{
int pole[] = {12, 11, 13, 5, 6, 7};
int dlzka_pola = sizeof(pole) / sizeof(pole[0]);

printf("Pôvodné pole: \n");

for (auto i: pole)
{
cout<<i<<" ";
}

MergeSort(pole, 0, dlzka_pola - 1);

cout<<endl<<"Utriedené pole:"<<endl;

for (auto i: pole)
{
cout<<i<<" ";
}

return 0;
}

void Merge(int pole[], int lavy, int stred, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči */

if (lavy >= pravy)
{
return;
}

/* vyrátaj dĺžky oboch polovíc poľa */

int L_dlzka = stred - lavy + 1;
int P_dlzka = pravy - stred;

/* alokuj dočasné polia, kam uložíš prvky z oboch polovíc poľa */

int *L = new int[L_dlzka];
int *P = new int[P_dlzka];

/* indexy, ktorými iterujeme všetky polia: i pre L, j pre P, k pre pole */

int i, j, k;

/* skopíruj obsah oboch polovíc poľa do dočasných polí L a P */

for (i = 0; i < L_dlzka; ++i)
{
L[i] = pole[lavy + i];
}

for (j = 0; j < P_dlzka; ++j)
{
P[j] = pole[stred + 1 + j];
}

/* nastav indexy na začiatok daných polí */

i = 0; j = 0; k = lavy;

/* zlučuj dočasné polia L a P do finálneho poľa pole */

while(i < L_dlzka && j < P_dlzka)
{
if(L[i] <= P[j])
{
pole[k++] = L[i++];
}
else
{
pole[k++] = P[j++];
}
}

/* ak ostali nejaké prvky v dočasnom poli L, skopíruj ich do finálneho poľa */

while(i < L_dlzka)
{
pole[k++] = L[i++];
}

/* ak ostali nejaké prvky v dočasnom poli P, skopíruj ich do finálneho poľa */

while(j < P_dlzka)
{
pole[k++] = P[j++];
}

/* uvoľni použitú pamäť */

delete []L;
delete []P;
}

void MergeSort(int pole[], int lavy, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči volanie */

if(lavy >= pravy)
{
return;
}
/* urči si prostredný index */

int stred = lavy + (pravy - lavy) / 2;

/* utrieď ľavú polovicu poľa */

MergeSort(pole, lavy, stred);

/* utrieď pravú polovicu poľa */

MergeSort(pole, stred+1, pravy);

/* zlúč obe polovice dokopy */

Merge(pole, lavy, stred, pravy);
}

</syntaxhighlight>
</tab>

<tab name="Iteračná: C++" block>
<syntaxhighlight lang="C++">
#include <iostream>

using std::cout;
using std::endl;

void Merge(int pole[], int lavy, int stred, int pravy);
void MergeSort(int pole[], int lavy, int pravy);

/* hlavný program */

int main()
{
int pole[] = {12, 11, 13, 5, 6, 7};
int dlzka_pola = sizeof(pole) / sizeof(pole[0]);

printf("Pôvodné pole: \n");

for (auto i: pole)
{
cout<<i<<" ";
}

MergeSort(pole, 0, dlzka_pola - 1);

cout<<endl<<"Utriedené pole:"<<endl;

for (auto i: pole)
{
cout<<i<<" ";
}

return 0;
}

void Merge(int pole[], int lavy, int stred, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči */

if (lavy >= pravy)
{
return;
}

/* vyrátaj dĺžky oboch polovíc poľa */

int L_dlzka = stred - lavy + 1;
int P_dlzka = pravy - stred;

/* alokuj dočasné polia, kam uložíš prvky z oboch polovíc poľa */

int *L = new int[L_dlzka];
int *P = new int[P_dlzka];

/* indexy, ktorými iterujeme všetky polia: i pre L, j pre P, k pre pole */

int i, j, k;

/* skopíruj obsah oboch polovíc poľa do dočasných polí L a P */

for (i = 0; i < L_dlzka; ++i)
{
L[i] = pole[lavy + i];
}

for (j = 0; j < P_dlzka; ++j)
{
P[j] = pole[stred + 1 + j];
}

/* nastav indexy na začiatok daných polí */

i = 0; j = 0; k = lavy;

/* zlučuj dočasné polia L a P do finálneho poľa pole */

while(i < L_dlzka && j < P_dlzka)
{
if(L[i] <= P[j])
{
pole[k++] = L[i++];
}
else
{
pole[k++] = P[j++];
}
}

/* ak ostali nejaké prvky v dočasnom poli L, skopíruj ich do finálneho poľa */

while(i < L_dlzka)
{
pole[k++] = L[i++];
}

/* ak ostali nejaké prvky v dočasnom poli P, skopíruj ich do finálneho poľa */

while(j < P_dlzka)
{
pole[k++] = P[j++];
}

/* uvoľni použitú pamäť */

delete []L;
delete []P;
}

void MergeSort(int *pole, int lavy, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči volanie */

if(lavy >= pravy)
{
return;
}

int stred, koniec;

for (int dlzka_zoznamu = 1; dlzka_zoznamu <= pravy; dlzka_zoznamu *= 2)
{
for (int zaciatok = lavy; zaciatok < pravy; zaciatok += 2 * dlzka_zoznamu)
{
koniec = (zaciatok + 2 * dlzka_zoznamu - 1 <= pravy) ? zaciatok + 2 * dlzka_zoznamu - 1 : pravy;

stred = (zaciatok + dlzka_zoznamu - 1 <= pravy) ? zaciatok + dlzka_zoznamu - 1 : pravy;

Merge(pole, zaciatok, stred, koniec);
}
}
}
</syntaxhighlight>
</tab>

<tab name="Rekurzívna: Java" block>
<syntaxhighlight lang="Java">
class MergeSort
{

/* Funkcia zlúči 2 podpolia, ktoré sme vytvorili z pôvodného poľa.
* Každé podpole má polovičnú dĺžku pôvodného poľa.
* subpole1 [ľavý ... stred]
* subpole2 [stred + 1 ... pravý] */

void merge(int[] pole, int lavy, int stred, int pravy)
{

// Výpočet dĺžky 2 podpolí

int n1 = stred - lavy + 1;
int n2 = pravy - stred;

// Vytvorenie pomocných polí

int[] L = new int[n1];
int[] P = new int[n2];

// Načítanie dát do pomocných polí

for (int i = 0; i < n1; i++)
L[i] = pole[lavy + i];

for (int j = 0; j < n2; j++)
P[j] = pole[stred + 1 + j];

// Počiatočné indexy prvého a druhého podpoľa

int i = 0, j = 0;

// Počiatočný index zlúčeného podpoľa

int k = lavy;

// Zlúčenie dvoch podpolí

while (i < n1 && j < n2)
{
if (L[i] <= P[j])
{
pole[k] = L[i];
i++;
}
else
{
pole[k] = P[j];
j++;
}
k++;
}

/* V prípade, že sa v jednom zo podpoli nachádzajú ešte nejaké prvky, ktoré neboli zlúčené do pola,
* tak sa do pola jednoducho skopírujú */

while (i < n1)
{
pole[k] = L[i];
i++;
k++;
}

while (j < n2)
{
pole[k] = P[j];
k++;
j++;
}

}

/* Funkcia, ktorá zoradí pole použitím funkcie merge() */

void sort (int[] pole, int lavy, int pravy)
{
if (lavy < pravy)
{
// Musíme nájsť stred pola

int stred = lavy + (pravy - lavy) / 2;

// Zoradíme prvú a druhú polovicu pola samostatne

sort(pole, lavy, stred);
sort(pole, stred + 1, pravy);

// Zlúčime zoradené polovice do jedného pola

merge(pole, lavy, stred, pravy);
}
}
}

public class Main
{
/* Funkcia na výpis pola dĺžky n */

static void vypis_pole(int[] pole)
{

for (int j : pole)
{
System.out.print(j + " ");
}

System.out.println();
}

/* Hlavný program */

public static void main(String[] args)
{
int[] pole = {12, 11, 13, 5, 6, 7};

System.out.println("Zadané pole:");
vypis_pole(pole);

MergeSort ms = new MergeSort();
ms.sort(pole, 0, pole.length - 1);

System.out.println("\nZoradené pole:");
vypis_pole(pole);
}
}
</syntaxhighlight>
</tab>

<tab name="Iteračná: Java" block>
<syntaxhighlight lang="Java">
class MergeSort_iteracia {
/* Zlúči 2 subpolia, ktoré sa vytvorili z pôvodného pola.
* Každé subpole má polovičnú dĺžku pôvodného pola.
* subpole1 [ľavý..stred]
* subpole2 [stred+1..pravý] */
void merge(int[] pole, int lavy, int stred, int pravy) {
// Výpočet dĺžky 2 subpolí
int n1 = stred - lavy + 1;
int n2 = pravy - stred;

// Vytvorenie pomocných polí
int[] L = new int[n1];
int[] P = new int[n2];

// Načítanie dát do pomocných polí
for (int i = 0; i < n1; i++)
L[i] = pole[lavy + i];

for (int j = 0; j < n2; j++)
P[j] = pole[stred + 1 + j];

// Počiatočné indexy prvého a druhého subpola
int i = 0, j = 0;
// Počiatočný index zlúčeného subpola
int k = lavy;

// Zlúčenie dvoch podpolí
while (i < n1 && j < n2) {
if (L[i] <= P[j]) {
pole[k] = L[i];
i++;
}
else {
pole[k] = P[j];
j++;
}
k++;
}

/* V prípade, že v jednom zo subpolí sa nachádzajú prvky, ktoré neboli zlúčené do pola,
* tak sa do pola jednoducho skopírujú */
while (i < n1) {
pole[k] = L[i];
i++;
k++;
}

while (j < n2) {
pole[k] = P[j];
k++;
j++;
}
}

/* Funkcia, ktorá zoradí pole použitím funkcie merge() */
void sort (int[] pole, int n) {
/* Dĺžka subpolí, ktoré majú byť zlúčené, hodnoty premennej sa pohybujú v intervale <1;n-1> */
int aktual_dlzka;
/* Začiatočný index ľavého subpola, ktoré má byť zlúčené */
int zaciatok_vlavo;

/* Vzostupné usporiadanie prvkov. Najskôr sa zlúčia subpolia veľkosti 1 do subpolí veľkosti 2,
* potom subpolia veľkosti 2 do subpolí veľkosti 4 a tak ďalej */
for (aktual_dlzka = 1; aktual_dlzka <= n - 1; aktual_dlzka *= 2) {
/* Určenie začiatočného prvku rôznych subpolí aktuálnej dĺžky subpola */
for (zaciatok_vlavo = 0; zaciatok_vlavo < n - 1; zaciatok_vlavo += 2 * aktual_dlzka) {
/* Nájdenie konečného prvku ľavého subpola, stred+1 je začiatočný prvok pravého subpola */
int stred = Math.min(zaciatok_vlavo + aktual_dlzka - 1, n - 1);
int koniec_vpravo = Math.min(zaciatok_vlavo + 2 * aktual_dlzka - 1, n - 1);

/* Zlúči subpolia L[zaciatok_vlavo .. stred] & P[stred+1 .. koniec_vpravo] */
merge(pole, zaciatok_vlavo, stred, koniec_vpravo);
}
}
}
}

public class Main {
/* Funkcia na výpis pola dĺžky n */
static void vypis_pole(int[] pole) {
int n = pole.length;

for (int j : pole) {
System.out.print(j + " ");
}
System.out.println();
}

/* Hlavný program */
public static void main(String[] args) {

/* Inicializácia pola */
int[] pole = {12, 11, 13, 5, 6, 7};

System.out.println("Zadané pole:");
vypis_pole(pole);

MergeSort_iteracia ms_it = new MergeSort_iteracia();
ms_it.sort(pole, pole.length);

System.out.println("Zoradené pole:");
vypis_pole(pole);
}
}
</syntaxhighlight>
</tab>

<tab name="Rekurzívna: Python3" block>
<syntaxhighlight lang="Python3">
def MergeSort(pole):
if len(pole) > 1:
# Nájdenie stredu pola
# zápis len(pole)//2 znamená, že dĺžka pola sa vydelí 2 a výsledok je celé číslo
stred = len(pole) // 2

# Rozdelenie pola na dve časti
L = pole[:stred]
P = pole[stred:]

# Zoradenie najskôr prvej časti pola, potom druhej
MergeSort(L)
MergeSort(P)

i = j = k = 0

# Zlúčenie a zoradenie údajov z pomocných polí do jedného pola
while i < len(L) and j < len(P):
if L[i] < P[j]:
pole[k] = L[i]
i += 1
else:
pole[k] = P[j]
j += 1
k += 1

# Kontrola či všetky prvky boli zlúčené dokopy,
# ak nie, tak sa do zlúčeného pola jednoducho skopírujú
while i < len(L):
pole[k] = L[i]
i += 1
k += 1

while j < len(P):
pole[k] = P[j]
j += 1
k += 1

# Hlavný program
if __name__ == '__main__':
pole = [12, 11, 13, 5, 6, 7]

print("Zadané pole:", end="\n")
print(pole, end="\n")

MergeSort(pole)

print("Zoradené pole:", end="\n")
print(pole, end="\n")

</syntaxhighlight>
</tab>

<tab name="Iteračná: Python3" block>
<syntaxhighlight lang="Python3">
def MergeSort_iteracia(pole):
# Dĺžka subpolí, ktoré majú byť zlúčené, hodnoty premennej sa pohybujú v intervale <1;n-1>
aktual_dlzka = 1

# Vonkajší cyklus, ktorý určuje subpolia aktuálnej dĺžky
while aktual_dlzka < len(pole) - 1:
lavy = 0

# Vnútorný cyklus, ktorý slúži na zlúčenie a zoradenie subpoli do jedného subpola
while lavy < len(pole) - 1:
# Index stredného prvku sa určí, keď k indexu ľavého prvku subpola pripočítame aktuálnu
# dĺžku subpolí a odčítame 1
stred = min((lavy + aktual_dlzka - 1), len(pole) - 1)

# Ak platí podmienka 2 * aktuálna dĺžka < dĺžka pola - 1, tak pravý index = aktuálnej dĺžke subpolí,
# inak pravý index = dĺžke pola - 1
pravy = ((2 * aktual_dlzka + lavy - 1, len(pole) - 1)[2 * aktual_dlzka + lavy - 1 > len(pole) - 1])

# Volanie funkcie merge
merge(pole, lavy, stred, pravy)

lavy = lavy + 2 * aktual_dlzka

# Aktuálna dĺžka sa sa zmení na dvojnásobok jej predošlej hodnoty
aktual_dlzka = 2 * aktual_dlzka

def merge(pole, lavy, stred, pravy):
n1 = stred - lavy + 1
n2 = pravy - stred

# Inicializácia pomocných polí
L = [0] * n1
P = [0] * n2

# Načítanie dát do pomocných polí
for i in range(0, n1):
L[i] = pole[lavy + i]
for i in range(0, n2):
P[i] = pole[stred + i + 1]

i, j, k = 0, 0, lavy

# Zlúčenie a zoradenie údajov z pomocných polí do jedného pola
while i < n1 and j < n2:
if L[i] > P[j]:
pole[k] = P[j]
j += 1
else:
pole[k] = L[i]
i += 1
k += 1

# Kontrola či všetky prvky boli zlúčené dokopy,
# ak nie, tak sa do zlúčeného pola jednoducho skopírujú
while i < n1:
pole[k] = L[i]
i += 1
k += 1

while j < n2:
pole[k] = P[j]
j += 1
k += 1

# Hlavný program
if __name__ == '__main__':
pole = [12, 11, 13, 5, 6, 7]

print("Zadané pole:", end="\n")
print(pole, end="\n")

MergeSort_iteracia(pole)

print("Zoradené pole:", end="\n")
print(pole, end="\n")

</syntaxhighlight>
</tab>

</tabs>

==Odkazy==
# https://www.geeksforgeeks.org/merge-sort/
# https://www.geeksforgeeks.org/iterative-merge-sort/
# https://medium.com/@paulsoham/merge-sort-63d75df76388
# https://www.khanacademy.org/computing/computer-science/algorithms/merge-sort/a/overview-of-merge-sort
# https://www.tutorialspoint.com/data_structures_algorithms/merge_sort_algorithm.htm
# https://www.youtube.com/watch?v=6pV2IF0fgKY
# https://www.youtube.com/watch?v=mB5HXBb_HY8
# https://www.youtube.com/watch?v=ak-pz7tS5DE

Triedenie zlučovaním

2021-03-29T14:51:00Z

Filip Tomek: /* Pseudokód */

[[Kategória:Algoritmy triedenia]]
{{Draft}}
{{Skripta programovanie}}
__TOC__
==Zlučovací algoritmus Merge==
[[Súbor:Funkcia merge.png|500px|náhľad|vpravo|Vizualizácia funkcie Merge: Máme pole prvkov ''p = [1, 3, 5, 2, 4, 6]'', ktoré je už čiastočne utriedené. Použijeme algoritmus Merge, ktorý si vytvorí pomocné polia ''L = [1, 3, 5]'' a ''P = [2, 4, 6]''. Všetky polia indexujeme od ''0'', pričom pre pole ''p'' používame index ''k'', pre ''L'' index ''i'' a pre ''P'' index ''j''. Postupnosť krokov je označená číslicami 1 až 6.
]]

Princíp zlučovania tkvie v tom, že máme dva alebo viac utriedených zoznamov, ktoré skombinuje do jedného utriedeného zoznamu (výsledný zoznam musí obsahovať všetky prvky z pôvodných zoznamov). Zoznam môže byť reprezentovaný ako dátová štruktúra pole alebo aj ako lineárny zoznam. V tomto článku sa zameriame na algoritmus pre dátovú štruktúru pole.

Algoritmus ''Merge'' tvorí kľúčovú časť triediaceho algoritmu ''MergeSort''.

===Slovný opis algoritmu===
Nech máme pole, ktoré sa skladá z dvoch už utriedených polovíc. Vytvoríme si dve pomocné polia ''L'' a ''P'' a do každého z nich skopírujeme obsah jednej polovice (''L'' - ľavá polovica, ''P'' - pravá polovica). Potom súčasne prechádzame polia ''L'' a ''P'' od začiatku po koniec, pričom v každom cykle porovnáme prvok poľa ''L'' s prvkom v poli ''P''. Z tejto dvojice následne vyberieme minimum, (keď triedime od najmenšieho po najväčší) ktoré vložíme na prvú voľnú pozíciu pôvodného poľa (na začiatku je to prvá pozícia poľa). Nakoniec zvýšime index pri vstupnom poli a pri pomocnom poli, z ktorého vyberáme daný prvok. Túto postupnosť krokov opakujeme, pokiaľ neprídeme na koniec jedného z polí ''P'' a ''L''. Ak nastane situácia, že prídeme na koniec jedného z pomocných polí (a v druhom nám ostali ešte nejaké prvky), potom už iba naspäť skopírujeme zbytok druhého pomocného poľa na koniec pôvodného poľa.

===Vlastnosti algoritmu===
* vhodný pre dátové štruktúry: pole, lineárny zoznam
* časová náročnosť: vždy lineárna <math>O(n)</math>
* priestorová náročnosť: lineárna <math>O(n)</math> pre pole (alokovanie pomocných polí), <math>O(1)</math> pre lineárny zoznam (pri lineárnom zozname netreba alokovať dočasné polia, stačí iba presmerovať smerníky)
* využitie: kľúčový podprogram pre triediaci algoritmus MergeSort

===Pseudokód===
Nech funkcia ''Merge'' má nasledovný prototyp: <code>Merge(pole[], lavy, stred, pravy)</code>
:1. Je <code>lavy >= pravy ? Ak áno, skonči, inak pokračuj krokom 2.</code>
:2. Nech: <code>i = 0, j = 0, k = lavy </code>
:3. Nech: <code>dlzka_L = stred - lavy + 1, dlzka_P = pravy - stred</code>
:4. Nech: <code> L = pole[lavy ... stred], P = pole[stred + 1 ... pravy] </code>
:5. Je <code>i < dlzka_L</code> a zároveň <code>j < dlzka_P</code> ? Ak áno, pokračuj krokom 5.1., inak skoč na krok 6.
:::5.1. Je <code>L[i] <= P[j]</code>?
:::: Ak áno:
:::::5.1.1. <code>pole[k] = L[i]</code>
:::::5.1.2. <code>k += 1</code>
:::::5.1.3. <code>i += 1</code>
:::::5.1.4. Skoč na krok 5.
:::: Ak nie:
:::::5.1.1. <code>pole[k] = P[j]</code>
:::::5.1.2. <code>k += 1</code>
:::::5.1.3. <code>j += 1</code>
:::::5.1.4. Skoč na krok 5.
:6. Je <code>i < dlzka_L</code> ? Ak áno, pokračuj krokom 6.1., inak skoč na krok 7.
:::6.1. <code>pole[k] = L[i]</code>
:::6.2. <code>k += 1</code>
:::6.3. <code>i += 1</code>
:::6.4. Skoč na krok 6.
:7. Je <code>j < dlzka_P</code> ? Ak áno, pokračuj krokom 7.1., inak skonči.
:::7.1. <code>pole[k] = P[j]</code>
:::7.2. <code>k += 1</code>
:::7.3. <code>j += 1</code>
:::7.4. Skoč na krok 7.

==Merge sort==
Merge Sort je triediaci algoritmus, ktorý využíva stratégiu '''"rozdeľuj a panuj"''', čo znamená, že vstupný zoznam najskôr rozdelí na dve polovice, tie zoradí a potom ich zlúči naspäť dokopy. Radí sa medzi najpoužívanejšie a najviac rešpektované triediace algoritmy.

===Vlastnosti algoritmu Merge Sort===
* vhodný pre dátové štruktúry: pole, lineárny zoznam
* časová náročnosť: vždy linearitmická <math> O(n.log(n)) </math>, vďaka ktorej dokáže efektívne triediť veľmi veľké zoznamy
* priestorová náročnosť: lineárna <math>O(n)</math> pre pole (alokovanie dočasných polí), konštantná <math>O(1)</math> pre lineárny zoznam (pri lineárnom zozname stačí iba presmerovať smerníky)
* druh triedenia: triedenie zlučovaním (komparačný algoritmus)
* stabilita triedenia: stabilný
* miesto triedenia: externé triedenie (vhodný na triedenie veľkých objemov dát uložených na disku)

Z hľadiska implementácie môžeme vytvoriť dve základné verzie algoritmu, a to rekurzívnu a iteračnú.

===Opis rekurzívnej a iteračnej verzie algoritmu Merge Sort===

<tabs>
<tab name="Rekurzívna verzia" block>
[[Súbor:Merge sort.png|400px|náhľad|vpravo|Vizualizácia rekurzívnej verzie algoritmu MergeSort]]

===Princíp algoritmu===
Algoritmus MergeSort vykonáva 4 základné úlohy:
# Delenie poľa na dve polovice.
# Triedenie ľavej polovice poľa.
# Triedenie pravej polovice poľa.
# Zlúčenie oboch polovíc pomocou funkcie Merge.

===Slovný opis===
Našou úlohou je vzostupne (min -> max) utriediť vstupné pole. Určíme si stred poľa (pri párnom počte prvkov je to ten menší z prostredných indexov). Následne vykonávame sériu rekurzívnych delení pre ľavú a pravú časť poľa (''začiatok ... stred ; stred + 1 ... koniec'') až do momentu, keď nám ostanú len jednoprvkové podpolia (tie sú už utriedené). Následne v každom volaní obe tieto podpolia zlúčime pomocou algoritmu ''Merge'' do väčších podpolí (2, 4, 8, ...), až nakoniec dostaneme jedno výsledné utriedené pole.

===Pseudokód===
Nech nech má funkcia MergeSort nasledovný prototyp: <code>MergeSort(pole[], lavy, pravy) </code>
:1. Je <code>lavy >= pravy</code> ? Ak áno, skonči volanie, inak pokračuj krokom 2.
:2. Nech: <code>stred = lavy + (pravy - lavy) / 2</code>, pričom znak ''/'' vyjadruje celočíselné delenie.
:3. Rekurzívne zavolaj funkciu <code>MergeSort(pole[], lavy , stred)</code>
:3. Rekurzívne zavolaj funkciu <code>MergeSort(pole[], stred + 1 , pravy)</code>
:4. Zavolaj funkciu <code>Merge(pole[], lavy, stred, pravy)</code>
:5. Skonči volanie.

</tab>
<tab name="Iteračná verzia" block>
[[Súbor:MergeSort IT.png|400px|náhľad|vpravo]]

===Princíp algoritmu===
Algoritmus Merge vykonáva 3 základné úlohy:
# Vonkajší cyklus: určenie veľkosti zoznamu na zlučovanie.
# Vnútorný cyklus: prechádzanie jednotlivých zoznamov v poli.
# Zlučovanie jednotlivých zoznamov pomocou funkcie Merge.

===Slovný opis===
Vstupné pole, ktoré má ''N'' prvkov, môžeme chápať, ako ''N'' rôznych jednoprvkových (utriedených) podpolí, ktoré máme zlúčiť do jedného výsledného ''N''-prvkového utriedeného poľa. Keďže by bolo veľmi nepraktické zlučovať ''N'' podpolí naraz, zvolíme nasledovnú stratégiu: Budeme prechádzať dané pole od začiatku po koniec a v prvom cykle zlúčime každé dva prvky, takže budeme mať <math>\frac{n}{2}</math> dvojprvkových utriedených podpolí. Potom v druhom cykle zlúčime každé 4 prvky do jedného podpoľa, v treťom cykle každých 8, až do momentu, keď dostaneme jedno utriedené pole.
Aby sme to docielili, potrebujeme dva cykly, vonkajší, ktorý nastaví maximálnu veľkosť podpoľa, ktoré ideme zlučovať (1,2,4,8 ... dlzka - 1) a vnútorný, ktorý prechádza jednotlivé podpolia. Následne už iba voláme funkciu Merge, ktorá dané podpolia zlučuje.

Poznámka, ak máme pole, ktoré má nepárny počet prvkov, tak ten posledný prvok nezlúčime hneď v prvom cykle, ale až v tých ďalších. Takisto, ak n nie je mocnina čísla 2, tak musíme samozrejme ošetriť situáciu, kedy by sme sa dostali mimo rozsah poľa (Ak máme napríklad pole, čo má 7 prvkov, tak po prvej iterácii budú prvky utiredené podľa vzoru 2 + 2 + 2 + 1, po druhej 4 + 3, a po tretej 7)

===Pseudokód===
Nech nech má funkcia MergeSort nasledovný prototyp: <code>MergeSort(pole[], lavy, pravy) </code>
:1. Je <code>lavy >= pravy</code> ? Ak áno, skonči, inak pokračuj krokom 2.
:2. Nech: <code>dlzka_subzoznamu = 1 </code>
:3. Nech: <code>zaciatok = lavy</code>
:4. Je<code>dlzka_subzoznamu <= pravy</code> ? Ak áno pokračuj krokom 4.1, inak skonči.
:::4.1. Je<code>zaciatok < pravy</code> Ak áno pokračuj krokom 4.1.1, inak skoč na krok 4.2.
:::::4.1.1. Je <code>zaciatok + 2 * dlzka_zoznamu - 1 <= pravy</code> ?
:::::::Ak áno:
:::::::::4.1.1.1. Nech <code>koniec = zaciatok + 2 * dlzka_zoznamu - 1</code>
:::::::Ak nie:
:::::::::4.1.1.1. Nech <code>koniec = pravy</code>
:::::4.1.2. Je <code>zaciatok + dlzka_zoznamu - 1 <= pravy</code> ?
:::::::Ak áno:
:::::::::4.1.2.1. Nech <code>stred = zaciatok + dlzka_zoznamu - 1</code>
:::::::Ak nie:
:::::::::4.1.2.1. Nech <code>stred = pravy</code>
:::::4.1.3. <code>Merge(pole[], zaciatok, stred, koniec)</code>
:::::4.1.4. <code>zaciatok += 2 * dlzka_subzoznamu</code>
:::::4.1.5. Skoč na krok 4.1.
:::4.2. <code>dlzka_subzoznamu *= 2</code>
:::4.3 Skoč na krok 4.

</tab>
</tabs>

==Implementácia algoritmov Merge a MergeSort v rôznych programovacích jazykoch==
<tabs>
<tab name="Rekurzívna: C " block>
<syntaxhighlight lang="C">
#include <stdio.h>
#include <stdlib.h>

void Merge(int pole[], int lavy, int stred, int pravy);
void MergeSort(int pole[], int lavy, int pravy);

/* hlavný program */

int main()
{
int pole[] = {12, 11, 13, 5, 6, 7};
int dlzka_pola = sizeof(pole) / sizeof(pole[0]);

printf("Pôvodné pole: \n");

for (int i = 0; i < dlzka_pola; ++i)
{
printf("%d ", pole[i]);
}

MergeSort(pole, 0, dlzka_pola - 1);

printf("\nUtriedené pole: \n");

for (int i = 0; i < dlzka_pola; ++i)
{
printf("%d ", pole[i]);
}

return 0;
}

void Merge(int pole[], int lavy, int stred, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči */

if (lavy >= pravy)
{
return;
}

/* vyrátaj dĺžky oboch polovíc poľa */

int L_dlzka = stred - lavy + 1;
int P_dlzka = pravy - stred;

/* alokuj dočasné polia, kam uložíš prvky z oboch polovíc poľa */

int *L = (int*)malloc(L_dlzka * sizeof(int));
int *P = (int*)malloc(P_dlzka * sizeof(int));

/* indexy, ktorými iterujeme všetky polia: i pre L, j pre P, k pre pole */

int i, j, k;

/* skopíruj obsah oboch polovíc poľa do dočasných polí L a P */

for (i = 0; i < L_dlzka; ++i)
{
L[i] = pole[lavy + i];
}

for (j = 0; j < P_dlzka; ++j)
{
P[j] = pole[stred + 1 + j];
}

/* nastav indexy na začiatok daných polí */

i = 0; j = 0; k = lavy;

/* zlučuj dočasné polia L a P do finálneho poľa pole */

while(i < L_dlzka && j < P_dlzka)
{
if(L[i] <= P[j])
{
pole[k++] = L[i++];
}
else
{
pole[k++] = P[j++];
}
}

/* ak ostali nejaké prvky v dočasnom poli L, skopíruj ich do finálneho poľa */

while(i < L_dlzka)
{
pole[k++] = L[i++];
}

/* ak ostali nejaké prvky v dočasnom poli P, skopíruj ich do finálneho poľa */

while(j < P_dlzka)
{
pole[k++] = P[j++];
}

/* uvoľni použitú pamäť */

free(L);
free(P);
}

void MergeSort(int pole[], int lavy, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči volanie */

if(lavy >= pravy)
{
return;
}
/* urči si prostredný index */

int stred = lavy + (pravy - lavy) / 2;

/* utrieď ľavú polovicu poľa */

MergeSort(pole, lavy, stred);

/* utrieď pravú polovicu poľa */

MergeSort(pole, stred+1, pravy);

/* zlúč obe polovice dokopy */

Merge(pole, lavy, stred, pravy);
}
</syntaxhighlight>
</tab>

<tab name="Iteračná: C" block>
<syntaxhighlight lang="C">
#include <stdio.h>
#include <stdlib.h>

void Merge(int pole[], int lavy, int stred, int pravy);
void MergeSortIt(int *pole, int lavy, int pravy);

/* hlavný program */

int main()
{
int pole[] = {12, 11, 13, 5, 6, 7, 19};
int dlzka_pola = sizeof(pole) / sizeof(pole[0]);

printf("Pôvodné pole %d: \n", dlzka_pola);

for (int i = 0; i < dlzka_pola; ++i)
{
printf("%d ", pole[i]);
}

MergeSortIt(pole, 0, dlzka_pola - 1);

printf("\nUtriedené pole: \n");

for (int i = 0; i < dlzka_pola; ++i)
{
printf("%d ", pole[i]);
}

return 0;
}

void Merge(int pole[], int lavy, int stred, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči */

if (lavy >= pravy)
{
return;
}

/* vyrátaj dĺžky oboch polovíc poľa */

int L_dlzka = stred - lavy + 1;
int P_dlzka = pravy - stred;

/* alokuj dočasné polia, kam uložíš prvky z oboch polovíc poľa */

int *L = (int*)malloc(L_dlzka * sizeof(int));
int *P = (int*)malloc(P_dlzka * sizeof(int));

/* indexy, ktorými iterujeme všetky polia: i pre L, j pre P, k pre pole */

int i, j, k;

/* skopíruj obsah oboch polovíc poľa do dočasných polí L a P */

for (i = 0; i < L_dlzka; ++i)
{
L[i] = pole[lavy + i];
}

for (j = 0; j < P_dlzka; ++j)
{
P[j] = pole[stred + 1 + j];
}

/* nastav indexy na začiatok daných polí */

i = 0; j = 0; k = lavy;

/* zlučuj dočasné polia L a P do finálneho poľa pole */

while(i < L_dlzka && j < P_dlzka)
{
if(L[i] <= P[j])
{
pole[k++] = L[i++];
}
else
{
pole[k++] = P[j++];
}
}

/* ak ostali nejaké prvky v dočasnom poli L, skopíruj ich do finálneho poľa */

while(i < L_dlzka)
{
pole[k++] = L[i++];
}

/* ak ostali nejaké prvky v dočasnom poli P, skopíruj ich do finálneho poľa */

while(j < P_dlzka)
{
pole[k++] = P[j++];
}

/* uvoľni použitú pamäť */

free(L);
free(P);
}

void MergeSortIt(int *pole, int lavy, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči volanie */

if(lavy >= pravy)
{
return;
}

int stred, koniec;

for (int dlzka_zoznamu = 1; dlzka_zoznamu <= pravy ; dlzka_zoznamu *= 2)
{
for (int zaciatok = lavy; zaciatok < pravy ; zaciatok += 2 * dlzka_zoznamu)
{
koniec = (zaciatok + 2 * dlzka_zoznamu - 1 <= pravy) ? zaciatok + 2 * dlzka_zoznamu - 1 : pravy;

stred = (zaciatok + dlzka_zoznamu - 1 <= pravy) ? zaciatok + dlzka_zoznamu - 1 : pravy;

Merge(pole, zaciatok, stred, koniec);

}
}
}

</syntaxhighlight>
</tab>

<tab name="Rekurzívna: C++" block>
<syntaxhighlight lang="C++">
#include <iostream>

using std::cout;
using std::endl;

void Merge(int pole[], int lavy, int stred, int pravy);
void MergeSort(int pole[], int lavy, int pravy);

/* hlavný program */

int main()
{
int pole[] = {12, 11, 13, 5, 6, 7};
int dlzka_pola = sizeof(pole) / sizeof(pole[0]);

printf("Pôvodné pole: \n");

for (auto i: pole)
{
cout<<i<<" ";
}

MergeSort(pole, 0, dlzka_pola - 1);

cout<<endl<<"Utriedené pole:"<<endl;

for (auto i: pole)
{
cout<<i<<" ";
}

return 0;
}

void Merge(int pole[], int lavy, int stred, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči */

if (lavy >= pravy)
{
return;
}

/* vyrátaj dĺžky oboch polovíc poľa */

int L_dlzka = stred - lavy + 1;
int P_dlzka = pravy - stred;

/* alokuj dočasné polia, kam uložíš prvky z oboch polovíc poľa */

int *L = new int[L_dlzka];
int *P = new int[P_dlzka];

/* indexy, ktorými iterujeme všetky polia: i pre L, j pre P, k pre pole */

int i, j, k;

/* skopíruj obsah oboch polovíc poľa do dočasných polí L a P */

for (i = 0; i < L_dlzka; ++i)
{
L[i] = pole[lavy + i];
}

for (j = 0; j < P_dlzka; ++j)
{
P[j] = pole[stred + 1 + j];
}

/* nastav indexy na začiatok daných polí */

i = 0; j = 0; k = lavy;

/* zlučuj dočasné polia L a P do finálneho poľa pole */

while(i < L_dlzka && j < P_dlzka)
{
if(L[i] <= P[j])
{
pole[k++] = L[i++];
}
else
{
pole[k++] = P[j++];
}
}

/* ak ostali nejaké prvky v dočasnom poli L, skopíruj ich do finálneho poľa */

while(i < L_dlzka)
{
pole[k++] = L[i++];
}

/* ak ostali nejaké prvky v dočasnom poli P, skopíruj ich do finálneho poľa */

while(j < P_dlzka)
{
pole[k++] = P[j++];
}

/* uvoľni použitú pamäť */

delete []L;
delete []P;
}

void MergeSort(int pole[], int lavy, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči volanie */

if(lavy >= pravy)
{
return;
}
/* urči si prostredný index */

int stred = lavy + (pravy - lavy) / 2;

/* utrieď ľavú polovicu poľa */

MergeSort(pole, lavy, stred);

/* utrieď pravú polovicu poľa */

MergeSort(pole, stred+1, pravy);

/* zlúč obe polovice dokopy */

Merge(pole, lavy, stred, pravy);
}

</syntaxhighlight>
</tab>

<tab name="Iteračná: C++" block>
<syntaxhighlight lang="C++">
#include <iostream>

using std::cout;
using std::endl;

void Merge(int pole[], int lavy, int stred, int pravy);
void MergeSort(int pole[], int lavy, int pravy);

/* hlavný program */

int main()
{
int pole[] = {12, 11, 13, 5, 6, 7};
int dlzka_pola = sizeof(pole) / sizeof(pole[0]);

printf("Pôvodné pole: \n");

for (auto i: pole)
{
cout<<i<<" ";
}

MergeSort(pole, 0, dlzka_pola - 1);

cout<<endl<<"Utriedené pole:"<<endl;

for (auto i: pole)
{
cout<<i<<" ";
}

return 0;
}

void Merge(int pole[], int lavy, int stred, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči */

if (lavy >= pravy)
{
return;
}

/* vyrátaj dĺžky oboch polovíc poľa */

int L_dlzka = stred - lavy + 1;
int P_dlzka = pravy - stred;

/* alokuj dočasné polia, kam uložíš prvky z oboch polovíc poľa */

int *L = new int[L_dlzka];
int *P = new int[P_dlzka];

/* indexy, ktorými iterujeme všetky polia: i pre L, j pre P, k pre pole */

int i, j, k;

/* skopíruj obsah oboch polovíc poľa do dočasných polí L a P */

for (i = 0; i < L_dlzka; ++i)
{
L[i] = pole[lavy + i];
}

for (j = 0; j < P_dlzka; ++j)
{
P[j] = pole[stred + 1 + j];
}

/* nastav indexy na začiatok daných polí */

i = 0; j = 0; k = lavy;

/* zlučuj dočasné polia L a P do finálneho poľa pole */

while(i < L_dlzka && j < P_dlzka)
{
if(L[i] <= P[j])
{
pole[k++] = L[i++];
}
else
{
pole[k++] = P[j++];
}
}

/* ak ostali nejaké prvky v dočasnom poli L, skopíruj ich do finálneho poľa */

while(i < L_dlzka)
{
pole[k++] = L[i++];
}

/* ak ostali nejaké prvky v dočasnom poli P, skopíruj ich do finálneho poľa */

while(j < P_dlzka)
{
pole[k++] = P[j++];
}

/* uvoľni použitú pamäť */

delete []L;
delete []P;
}

void MergeSort(int *pole, int lavy, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči volanie */

if(lavy >= pravy)
{
return;
}

int stred, koniec;

for (int dlzka_zoznamu = 1; dlzka_zoznamu <= pravy; dlzka_zoznamu *= 2)
{
for (int zaciatok = lavy; zaciatok < pravy; zaciatok += 2 * dlzka_zoznamu)
{
koniec = (zaciatok + 2 * dlzka_zoznamu - 1 <= pravy) ? zaciatok + 2 * dlzka_zoznamu - 1 : pravy;

stred = (zaciatok + dlzka_zoznamu - 1 <= pravy) ? zaciatok + dlzka_zoznamu - 1 : pravy;

Merge(pole, zaciatok, stred, koniec);
}
}
}
</syntaxhighlight>
</tab>

<tab name="Rekurzívna: Java" block>
<syntaxhighlight lang="Java">
class MergeSort
{

/* Funkcia zlúči 2 podpolia, ktoré sme vytvorili z pôvodného poľa.
* Každé podpole má polovičnú dĺžku pôvodného poľa.
* subpole1 [ľavý ... stred]
* subpole2 [stred + 1 ... pravý] */

void merge(int[] pole, int lavy, int stred, int pravy)
{

// Výpočet dĺžky 2 podpolí

int n1 = stred - lavy + 1;
int n2 = pravy - stred;

// Vytvorenie pomocných polí

int[] L = new int[n1];
int[] P = new int[n2];

// Načítanie dát do pomocných polí

for (int i = 0; i < n1; i++)
L[i] = pole[lavy + i];

for (int j = 0; j < n2; j++)
P[j] = pole[stred + 1 + j];

// Počiatočné indexy prvého a druhého podpoľa

int i = 0, j = 0;

// Počiatočný index zlúčeného podpoľa

int k = lavy;

// Zlúčenie dvoch podpolí

while (i < n1 && j < n2)
{
if (L[i] <= P[j])
{
pole[k] = L[i];
i++;
}
else
{
pole[k] = P[j];
j++;
}
k++;
}

/* V prípade, že sa v jednom zo podpoli nachádzajú ešte nejaké prvky, ktoré neboli zlúčené do pola,
* tak sa do pola jednoducho skopírujú */

while (i < n1)
{
pole[k] = L[i];
i++;
k++;
}

while (j < n2)
{
pole[k] = P[j];
k++;
j++;
}

}

/* Funkcia, ktorá zoradí pole použitím funkcie merge() */

void sort (int[] pole, int lavy, int pravy)
{
if (lavy < pravy)
{
// Musíme nájsť stred pola

int stred = lavy + (pravy - lavy) / 2;

// Zoradíme prvú a druhú polovicu pola samostatne

sort(pole, lavy, stred);
sort(pole, stred + 1, pravy);

// Zlúčime zoradené polovice do jedného pola

merge(pole, lavy, stred, pravy);
}
}
}

public class Main
{
/* Funkcia na výpis pola dĺžky n */

static void vypis_pole(int[] pole)
{

for (int j : pole)
{
System.out.print(j + " ");
}

System.out.println();
}

/* Hlavný program */

public static void main(String[] args)
{
int[] pole = {12, 11, 13, 5, 6, 7};

System.out.println("Zadané pole:");
vypis_pole(pole);

MergeSort ms = new MergeSort();
ms.sort(pole, 0, pole.length - 1);

System.out.println("\nZoradené pole:");
vypis_pole(pole);
}
}
</syntaxhighlight>
</tab>

<tab name="Iteračná: Java" block>
<syntaxhighlight lang="Java">
class MergeSort_iteracia {
/* Zlúči 2 subpolia, ktoré sa vytvorili z pôvodného pola.
* Každé subpole má polovičnú dĺžku pôvodného pola.
* subpole1 [ľavý..stred]
* subpole2 [stred+1..pravý] */
void merge(int[] pole, int lavy, int stred, int pravy) {
// Výpočet dĺžky 2 subpolí
int n1 = stred - lavy + 1;
int n2 = pravy - stred;

// Vytvorenie pomocných polí
int[] L = new int[n1];
int[] P = new int[n2];

// Načítanie dát do pomocných polí
for (int i = 0; i < n1; i++)
L[i] = pole[lavy + i];

for (int j = 0; j < n2; j++)
P[j] = pole[stred + 1 + j];

// Počiatočné indexy prvého a druhého subpola
int i = 0, j = 0;
// Počiatočný index zlúčeného subpola
int k = lavy;

// Zlúčenie dvoch podpolí
while (i < n1 && j < n2) {
if (L[i] <= P[j]) {
pole[k] = L[i];
i++;
}
else {
pole[k] = P[j];
j++;
}
k++;
}

/* V prípade, že v jednom zo subpolí sa nachádzajú prvky, ktoré neboli zlúčené do pola,
* tak sa do pola jednoducho skopírujú */
while (i < n1) {
pole[k] = L[i];
i++;
k++;
}

while (j < n2) {
pole[k] = P[j];
k++;
j++;
}
}

/* Funkcia, ktorá zoradí pole použitím funkcie merge() */
void sort (int[] pole, int n) {
/* Dĺžka subpolí, ktoré majú byť zlúčené, hodnoty premennej sa pohybujú v intervale <1;n-1> */
int aktual_dlzka;
/* Začiatočný index ľavého subpola, ktoré má byť zlúčené */
int zaciatok_vlavo;

/* Vzostupné usporiadanie prvkov. Najskôr sa zlúčia subpolia veľkosti 1 do subpolí veľkosti 2,
* potom subpolia veľkosti 2 do subpolí veľkosti 4 a tak ďalej */
for (aktual_dlzka = 1; aktual_dlzka <= n - 1; aktual_dlzka *= 2) {
/* Určenie začiatočného prvku rôznych subpolí aktuálnej dĺžky subpola */
for (zaciatok_vlavo = 0; zaciatok_vlavo < n - 1; zaciatok_vlavo += 2 * aktual_dlzka) {
/* Nájdenie konečného prvku ľavého subpola, stred+1 je začiatočný prvok pravého subpola */
int stred = Math.min(zaciatok_vlavo + aktual_dlzka - 1, n - 1);
int koniec_vpravo = Math.min(zaciatok_vlavo + 2 * aktual_dlzka - 1, n - 1);

/* Zlúči subpolia L[zaciatok_vlavo .. stred] & P[stred+1 .. koniec_vpravo] */
merge(pole, zaciatok_vlavo, stred, koniec_vpravo);
}
}
}
}

public class Main {
/* Funkcia na výpis pola dĺžky n */
static void vypis_pole(int[] pole) {
int n = pole.length;

for (int j : pole) {
System.out.print(j + " ");
}
System.out.println();
}

/* Hlavný program */
public static void main(String[] args) {

/* Inicializácia pola */
int[] pole = {12, 11, 13, 5, 6, 7};

System.out.println("Zadané pole:");
vypis_pole(pole);

MergeSort_iteracia ms_it = new MergeSort_iteracia();
ms_it.sort(pole, pole.length);

System.out.println("Zoradené pole:");
vypis_pole(pole);
}
}
</syntaxhighlight>
</tab>

<tab name="Rekurzívna: Python3" block>
<syntaxhighlight lang="Python3">
def MergeSort(pole):
if len(pole) > 1:
# Nájdenie stredu pola
# zápis len(pole)//2 znamená, že dĺžka pola sa vydelí 2 a výsledok je celé číslo
stred = len(pole) // 2

# Rozdelenie pola na dve časti
L = pole[:stred]
P = pole[stred:]

# Zoradenie najskôr prvej časti pola, potom druhej
MergeSort(L)
MergeSort(P)

i = j = k = 0

# Zlúčenie a zoradenie údajov z pomocných polí do jedného pola
while i < len(L) and j < len(P):
if L[i] < P[j]:
pole[k] = L[i]
i += 1
else:
pole[k] = P[j]
j += 1
k += 1

# Kontrola či všetky prvky boli zlúčené dokopy,
# ak nie, tak sa do zlúčeného pola jednoducho skopírujú
while i < len(L):
pole[k] = L[i]
i += 1
k += 1

while j < len(P):
pole[k] = P[j]
j += 1
k += 1

# Hlavný program
if __name__ == '__main__':
pole = [12, 11, 13, 5, 6, 7]

print("Zadané pole:", end="\n")
print(pole, end="\n")

MergeSort(pole)

print("Zoradené pole:", end="\n")
print(pole, end="\n")

</syntaxhighlight>
</tab>

<tab name="Iteračná: Python3" block>
<syntaxhighlight lang="Python3">
def MergeSort_iteracia(pole):
# Dĺžka subpolí, ktoré majú byť zlúčené, hodnoty premennej sa pohybujú v intervale <1;n-1>
aktual_dlzka = 1

# Vonkajší cyklus, ktorý určuje subpolia aktuálnej dĺžky
while aktual_dlzka < len(pole) - 1:
lavy = 0

# Vnútorný cyklus, ktorý slúži na zlúčenie a zoradenie subpoli do jedného subpola
while lavy < len(pole) - 1:
# Index stredného prvku sa určí, keď k indexu ľavého prvku subpola pripočítame aktuálnu
# dĺžku subpolí a odčítame 1
stred = min((lavy + aktual_dlzka - 1), len(pole) - 1)

# Ak platí podmienka 2 * aktuálna dĺžka < dĺžka pola - 1, tak pravý index = aktuálnej dĺžke subpolí,
# inak pravý index = dĺžke pola - 1
pravy = ((2 * aktual_dlzka + lavy - 1, len(pole) - 1)[2 * aktual_dlzka + lavy - 1 > len(pole) - 1])

# Volanie funkcie merge
merge(pole, lavy, stred, pravy)

lavy = lavy + 2 * aktual_dlzka

# Aktuálna dĺžka sa sa zmení na dvojnásobok jej predošlej hodnoty
aktual_dlzka = 2 * aktual_dlzka

def merge(pole, lavy, stred, pravy):
n1 = stred - lavy + 1
n2 = pravy - stred

# Inicializácia pomocných polí
L = [0] * n1
P = [0] * n2

# Načítanie dát do pomocných polí
for i in range(0, n1):
L[i] = pole[lavy + i]
for i in range(0, n2):
P[i] = pole[stred + i + 1]

i, j, k = 0, 0, lavy

# Zlúčenie a zoradenie údajov z pomocných polí do jedného pola
while i < n1 and j < n2:
if L[i] > P[j]:
pole[k] = P[j]
j += 1
else:
pole[k] = L[i]
i += 1
k += 1

# Kontrola či všetky prvky boli zlúčené dokopy,
# ak nie, tak sa do zlúčeného pola jednoducho skopírujú
while i < n1:
pole[k] = L[i]
i += 1
k += 1

while j < n2:
pole[k] = P[j]
j += 1
k += 1

# Hlavný program
if __name__ == '__main__':
pole = [12, 11, 13, 5, 6, 7]

print("Zadané pole:", end="\n")
print(pole, end="\n")

MergeSort_iteracia(pole)

print("Zoradené pole:", end="\n")
print(pole, end="\n")

</syntaxhighlight>
</tab>

</tabs>

==Odkazy==
# https://www.geeksforgeeks.org/merge-sort/
# https://www.geeksforgeeks.org/iterative-merge-sort/
# https://medium.com/@paulsoham/merge-sort-63d75df76388
# https://www.khanacademy.org/computing/computer-science/algorithms/merge-sort/a/overview-of-merge-sort
# https://www.tutorialspoint.com/data_structures_algorithms/merge_sort_algorithm.htm
# https://www.youtube.com/watch?v=6pV2IF0fgKY
# https://www.youtube.com/watch?v=mB5HXBb_HY8
# https://www.youtube.com/watch?v=ak-pz7tS5DE

Triedenie zlučovaním

2021-03-29T14:50:33Z

Filip Tomek: /* Zlučovací algoritmus Merge */

[[Kategória:Algoritmy triedenia]]
{{Draft}}
{{Skripta programovanie}}
__TOC__
==Zlučovací algoritmus Merge==
[[Súbor:Funkcia merge.png|500px|náhľad|vpravo|Vizualizácia funkcie Merge: Máme pole prvkov ''p = [1, 3, 5, 2, 4, 6]'', ktoré je už čiastočne utriedené. Použijeme algoritmus Merge, ktorý si vytvorí pomocné polia ''L = [1, 3, 5]'' a ''P = [2, 4, 6]''. Všetky polia indexujeme od ''0'', pričom pre pole ''p'' používame index ''k'', pre ''L'' index ''i'' a pre ''P'' index ''j''. Postupnosť krokov je označená číslicami 1 až 6.
]]

Princíp zlučovania tkvie v tom, že máme dva alebo viac utriedených zoznamov, ktoré skombinuje do jedného utriedeného zoznamu (výsledný zoznam musí obsahovať všetky prvky z pôvodných zoznamov). Zoznam môže byť reprezentovaný ako dátová štruktúra pole alebo aj ako lineárny zoznam. V tomto článku sa zameriame na algoritmus pre dátovú štruktúru pole.

Algoritmus ''Merge'' tvorí kľúčovú časť triediaceho algoritmu ''MergeSort''.

===Slovný opis algoritmu===
Nech máme pole, ktoré sa skladá z dvoch už utriedených polovíc. Vytvoríme si dve pomocné polia ''L'' a ''P'' a do každého z nich skopírujeme obsah jednej polovice (''L'' - ľavá polovica, ''P'' - pravá polovica). Potom súčasne prechádzame polia ''L'' a ''P'' od začiatku po koniec, pričom v každom cykle porovnáme prvok poľa ''L'' s prvkom v poli ''P''. Z tejto dvojice následne vyberieme minimum, (keď triedime od najmenšieho po najväčší) ktoré vložíme na prvú voľnú pozíciu pôvodného poľa (na začiatku je to prvá pozícia poľa). Nakoniec zvýšime index pri vstupnom poli a pri pomocnom poli, z ktorého vyberáme daný prvok. Túto postupnosť krokov opakujeme, pokiaľ neprídeme na koniec jedného z polí ''P'' a ''L''. Ak nastane situácia, že prídeme na koniec jedného z pomocných polí (a v druhom nám ostali ešte nejaké prvky), potom už iba naspäť skopírujeme zbytok druhého pomocného poľa na koniec pôvodného poľa.

===Vlastnosti algoritmu===
* vhodný pre dátové štruktúry: pole, lineárny zoznam
* časová náročnosť: vždy lineárna <math>O(n)</math>
* priestorová náročnosť: lineárna <math>O(n)</math> pre pole (alokovanie pomocných polí), <math>O(1)</math> pre lineárny zoznam (pri lineárnom zozname netreba alokovať dočasné polia, stačí iba presmerovať smerníky)
* využitie: kľúčový podprogram pre triediaci algoritmus MergeSort

===Pseudokód===
Nech funkcia Merge má nasledovný prototyp: <code>Merge(pole[], lavy, stred, pravy)</code>
:1. Je <code>lavy >= pravy ? Ak áno, skonči, inak pokračuj krokom 2.</code>
:2. Nech: <code>i = 0, j = 0, k = lavy </code>
:3. Nech: <code>dlzka_L = stred - lavy + 1, dlzka_P = pravy - stred</code>
:4. Nech: <code> L = pole[lavy ... stred], P = pole[stred + 1 ... pravy] </code>
:5. Je <code>i < dlzka_L</code> a zároveň <code>j < dlzka_P</code> ? Ak áno, pokračuj krokom 5.1., inak skoč na krok 6.
:::5.1. Je <code>L[i] <= P[j]</code>?
:::: Ak áno:
:::::5.1.1. <code>pole[k] = L[i]</code>
:::::5.1.2. <code>k += 1</code>
:::::5.1.3. <code>i += 1</code>
:::::5.1.4. Skoč na krok 5.
:::: Ak nie:
:::::5.1.1. <code>pole[k] = P[j]</code>
:::::5.1.2. <code>k += 1</code>
:::::5.1.3. <code>j += 1</code>
:::::5.1.4. Skoč na krok 5.
:6. Je <code>i < dlzka_L</code> ? Ak áno, pokračuj krokom 6.1., inak skoč na krok 7.
:::6.1. <code>pole[k] = L[i]</code>
:::6.2. <code>k += 1</code>
:::6.3. <code>i += 1</code>
:::6.4. Skoč na krok 6.
:7. Je <code>j < dlzka_P</code> ? Ak áno, pokračuj krokom 7.1., inak skonči.
:::7.1. <code>pole[k] = P[j]</code>
:::7.2. <code>k += 1</code>
:::7.3. <code>j += 1</code>
:::7.4. Skoč na krok 7.

==Merge sort==
Merge Sort je triediaci algoritmus, ktorý využíva stratégiu '''"rozdeľuj a panuj"''', čo znamená, že vstupný zoznam najskôr rozdelí na dve polovice, tie zoradí a potom ich zlúči naspäť dokopy. Radí sa medzi najpoužívanejšie a najviac rešpektované triediace algoritmy.

===Vlastnosti algoritmu Merge Sort===
* vhodný pre dátové štruktúry: pole, lineárny zoznam
* časová náročnosť: vždy linearitmická <math> O(n.log(n)) </math>, vďaka ktorej dokáže efektívne triediť veľmi veľké zoznamy
* priestorová náročnosť: lineárna <math>O(n)</math> pre pole (alokovanie dočasných polí), konštantná <math>O(1)</math> pre lineárny zoznam (pri lineárnom zozname stačí iba presmerovať smerníky)
* druh triedenia: triedenie zlučovaním (komparačný algoritmus)
* stabilita triedenia: stabilný
* miesto triedenia: externé triedenie (vhodný na triedenie veľkých objemov dát uložených na disku)

Z hľadiska implementácie môžeme vytvoriť dve základné verzie algoritmu, a to rekurzívnu a iteračnú.

===Opis rekurzívnej a iteračnej verzie algoritmu Merge Sort===

<tabs>
<tab name="Rekurzívna verzia" block>
[[Súbor:Merge sort.png|400px|náhľad|vpravo|Vizualizácia rekurzívnej verzie algoritmu MergeSort]]

===Princíp algoritmu===
Algoritmus MergeSort vykonáva 4 základné úlohy:
# Delenie poľa na dve polovice.
# Triedenie ľavej polovice poľa.
# Triedenie pravej polovice poľa.
# Zlúčenie oboch polovíc pomocou funkcie Merge.

===Slovný opis===
Našou úlohou je vzostupne (min -> max) utriediť vstupné pole. Určíme si stred poľa (pri párnom počte prvkov je to ten menší z prostredných indexov). Následne vykonávame sériu rekurzívnych delení pre ľavú a pravú časť poľa (''začiatok ... stred ; stred + 1 ... koniec'') až do momentu, keď nám ostanú len jednoprvkové podpolia (tie sú už utriedené). Následne v každom volaní obe tieto podpolia zlúčime pomocou algoritmu ''Merge'' do väčších podpolí (2, 4, 8, ...), až nakoniec dostaneme jedno výsledné utriedené pole.

===Pseudokód===
Nech nech má funkcia MergeSort nasledovný prototyp: <code>MergeSort(pole[], lavy, pravy) </code>
:1. Je <code>lavy >= pravy</code> ? Ak áno, skonči volanie, inak pokračuj krokom 2.
:2. Nech: <code>stred = lavy + (pravy - lavy) / 2</code>, pričom znak ''/'' vyjadruje celočíselné delenie.
:3. Rekurzívne zavolaj funkciu <code>MergeSort(pole[], lavy , stred)</code>
:3. Rekurzívne zavolaj funkciu <code>MergeSort(pole[], stred + 1 , pravy)</code>
:4. Zavolaj funkciu <code>Merge(pole[], lavy, stred, pravy)</code>
:5. Skonči volanie.

</tab>
<tab name="Iteračná verzia" block>
[[Súbor:MergeSort IT.png|400px|náhľad|vpravo]]

===Princíp algoritmu===
Algoritmus Merge vykonáva 3 základné úlohy:
# Vonkajší cyklus: určenie veľkosti zoznamu na zlučovanie.
# Vnútorný cyklus: prechádzanie jednotlivých zoznamov v poli.
# Zlučovanie jednotlivých zoznamov pomocou funkcie Merge.

===Slovný opis===
Vstupné pole, ktoré má ''N'' prvkov, môžeme chápať, ako ''N'' rôznych jednoprvkových (utriedených) podpolí, ktoré máme zlúčiť do jedného výsledného ''N''-prvkového utriedeného poľa. Keďže by bolo veľmi nepraktické zlučovať ''N'' podpolí naraz, zvolíme nasledovnú stratégiu: Budeme prechádzať dané pole od začiatku po koniec a v prvom cykle zlúčime každé dva prvky, takže budeme mať <math>\frac{n}{2}</math> dvojprvkových utriedených podpolí. Potom v druhom cykle zlúčime každé 4 prvky do jedného podpoľa, v treťom cykle každých 8, až do momentu, keď dostaneme jedno utriedené pole.
Aby sme to docielili, potrebujeme dva cykly, vonkajší, ktorý nastaví maximálnu veľkosť podpoľa, ktoré ideme zlučovať (1,2,4,8 ... dlzka - 1) a vnútorný, ktorý prechádza jednotlivé podpolia. Následne už iba voláme funkciu Merge, ktorá dané podpolia zlučuje.

Poznámka, ak máme pole, ktoré má nepárny počet prvkov, tak ten posledný prvok nezlúčime hneď v prvom cykle, ale až v tých ďalších. Takisto, ak n nie je mocnina čísla 2, tak musíme samozrejme ošetriť situáciu, kedy by sme sa dostali mimo rozsah poľa (Ak máme napríklad pole, čo má 7 prvkov, tak po prvej iterácii budú prvky utiredené podľa vzoru 2 + 2 + 2 + 1, po druhej 4 + 3, a po tretej 7)

===Pseudokód===
Nech nech má funkcia MergeSort nasledovný prototyp: <code>MergeSort(pole[], lavy, pravy) </code>
:1. Je <code>lavy >= pravy</code> ? Ak áno, skonči, inak pokračuj krokom 2.
:2. Nech: <code>dlzka_subzoznamu = 1 </code>
:3. Nech: <code>zaciatok = lavy</code>
:4. Je<code>dlzka_subzoznamu <= pravy</code> ? Ak áno pokračuj krokom 4.1, inak skonči.
:::4.1. Je<code>zaciatok < pravy</code> Ak áno pokračuj krokom 4.1.1, inak skoč na krok 4.2.
:::::4.1.1. Je <code>zaciatok + 2 * dlzka_zoznamu - 1 <= pravy</code> ?
:::::::Ak áno:
:::::::::4.1.1.1. Nech <code>koniec = zaciatok + 2 * dlzka_zoznamu - 1</code>
:::::::Ak nie:
:::::::::4.1.1.1. Nech <code>koniec = pravy</code>
:::::4.1.2. Je <code>zaciatok + dlzka_zoznamu - 1 <= pravy</code> ?
:::::::Ak áno:
:::::::::4.1.2.1. Nech <code>stred = zaciatok + dlzka_zoznamu - 1</code>
:::::::Ak nie:
:::::::::4.1.2.1. Nech <code>stred = pravy</code>
:::::4.1.3. <code>Merge(pole[], zaciatok, stred, koniec)</code>
:::::4.1.4. <code>zaciatok += 2 * dlzka_subzoznamu</code>
:::::4.1.5. Skoč na krok 4.1.
:::4.2. <code>dlzka_subzoznamu *= 2</code>
:::4.3 Skoč na krok 4.

</tab>
</tabs>

==Implementácia algoritmov Merge a MergeSort v rôznych programovacích jazykoch==
<tabs>
<tab name="Rekurzívna: C " block>
<syntaxhighlight lang="C">
#include <stdio.h>
#include <stdlib.h>

void Merge(int pole[], int lavy, int stred, int pravy);
void MergeSort(int pole[], int lavy, int pravy);

/* hlavný program */

int main()
{
int pole[] = {12, 11, 13, 5, 6, 7};
int dlzka_pola = sizeof(pole) / sizeof(pole[0]);

printf("Pôvodné pole: \n");

for (int i = 0; i < dlzka_pola; ++i)
{
printf("%d ", pole[i]);
}

MergeSort(pole, 0, dlzka_pola - 1);

printf("\nUtriedené pole: \n");

for (int i = 0; i < dlzka_pola; ++i)
{
printf("%d ", pole[i]);
}

return 0;
}

void Merge(int pole[], int lavy, int stred, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči */

if (lavy >= pravy)
{
return;
}

/* vyrátaj dĺžky oboch polovíc poľa */

int L_dlzka = stred - lavy + 1;
int P_dlzka = pravy - stred;

/* alokuj dočasné polia, kam uložíš prvky z oboch polovíc poľa */

int *L = (int*)malloc(L_dlzka * sizeof(int));
int *P = (int*)malloc(P_dlzka * sizeof(int));

/* indexy, ktorými iterujeme všetky polia: i pre L, j pre P, k pre pole */

int i, j, k;

/* skopíruj obsah oboch polovíc poľa do dočasných polí L a P */

for (i = 0; i < L_dlzka; ++i)
{
L[i] = pole[lavy + i];
}

for (j = 0; j < P_dlzka; ++j)
{
P[j] = pole[stred + 1 + j];
}

/* nastav indexy na začiatok daných polí */

i = 0; j = 0; k = lavy;

/* zlučuj dočasné polia L a P do finálneho poľa pole */

while(i < L_dlzka && j < P_dlzka)
{
if(L[i] <= P[j])
{
pole[k++] = L[i++];
}
else
{
pole[k++] = P[j++];
}
}

/* ak ostali nejaké prvky v dočasnom poli L, skopíruj ich do finálneho poľa */

while(i < L_dlzka)
{
pole[k++] = L[i++];
}

/* ak ostali nejaké prvky v dočasnom poli P, skopíruj ich do finálneho poľa */

while(j < P_dlzka)
{
pole[k++] = P[j++];
}

/* uvoľni použitú pamäť */

free(L);
free(P);
}

void MergeSort(int pole[], int lavy, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči volanie */

if(lavy >= pravy)
{
return;
}
/* urči si prostredný index */

int stred = lavy + (pravy - lavy) / 2;

/* utrieď ľavú polovicu poľa */

MergeSort(pole, lavy, stred);

/* utrieď pravú polovicu poľa */

MergeSort(pole, stred+1, pravy);

/* zlúč obe polovice dokopy */

Merge(pole, lavy, stred, pravy);
}
</syntaxhighlight>
</tab>

<tab name="Iteračná: C" block>
<syntaxhighlight lang="C">
#include <stdio.h>
#include <stdlib.h>

void Merge(int pole[], int lavy, int stred, int pravy);
void MergeSortIt(int *pole, int lavy, int pravy);

/* hlavný program */

int main()
{
int pole[] = {12, 11, 13, 5, 6, 7, 19};
int dlzka_pola = sizeof(pole) / sizeof(pole[0]);

printf("Pôvodné pole %d: \n", dlzka_pola);

for (int i = 0; i < dlzka_pola; ++i)
{
printf("%d ", pole[i]);
}

MergeSortIt(pole, 0, dlzka_pola - 1);

printf("\nUtriedené pole: \n");

for (int i = 0; i < dlzka_pola; ++i)
{
printf("%d ", pole[i]);
}

return 0;
}

void Merge(int pole[], int lavy, int stred, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči */

if (lavy >= pravy)
{
return;
}

/* vyrátaj dĺžky oboch polovíc poľa */

int L_dlzka = stred - lavy + 1;
int P_dlzka = pravy - stred;

/* alokuj dočasné polia, kam uložíš prvky z oboch polovíc poľa */

int *L = (int*)malloc(L_dlzka * sizeof(int));
int *P = (int*)malloc(P_dlzka * sizeof(int));

/* indexy, ktorými iterujeme všetky polia: i pre L, j pre P, k pre pole */

int i, j, k;

/* skopíruj obsah oboch polovíc poľa do dočasných polí L a P */

for (i = 0; i < L_dlzka; ++i)
{
L[i] = pole[lavy + i];
}

for (j = 0; j < P_dlzka; ++j)
{
P[j] = pole[stred + 1 + j];
}

/* nastav indexy na začiatok daných polí */

i = 0; j = 0; k = lavy;

/* zlučuj dočasné polia L a P do finálneho poľa pole */

while(i < L_dlzka && j < P_dlzka)
{
if(L[i] <= P[j])
{
pole[k++] = L[i++];
}
else
{
pole[k++] = P[j++];
}
}

/* ak ostali nejaké prvky v dočasnom poli L, skopíruj ich do finálneho poľa */

while(i < L_dlzka)
{
pole[k++] = L[i++];
}

/* ak ostali nejaké prvky v dočasnom poli P, skopíruj ich do finálneho poľa */

while(j < P_dlzka)
{
pole[k++] = P[j++];
}

/* uvoľni použitú pamäť */

free(L);
free(P);
}

void MergeSortIt(int *pole, int lavy, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči volanie */

if(lavy >= pravy)
{
return;
}

int stred, koniec;

for (int dlzka_zoznamu = 1; dlzka_zoznamu <= pravy ; dlzka_zoznamu *= 2)
{
for (int zaciatok = lavy; zaciatok < pravy ; zaciatok += 2 * dlzka_zoznamu)
{
koniec = (zaciatok + 2 * dlzka_zoznamu - 1 <= pravy) ? zaciatok + 2 * dlzka_zoznamu - 1 : pravy;

stred = (zaciatok + dlzka_zoznamu - 1 <= pravy) ? zaciatok + dlzka_zoznamu - 1 : pravy;

Merge(pole, zaciatok, stred, koniec);

}
}
}

</syntaxhighlight>
</tab>

<tab name="Rekurzívna: C++" block>
<syntaxhighlight lang="C++">
#include <iostream>

using std::cout;
using std::endl;

void Merge(int pole[], int lavy, int stred, int pravy);
void MergeSort(int pole[], int lavy, int pravy);

/* hlavný program */

int main()
{
int pole[] = {12, 11, 13, 5, 6, 7};
int dlzka_pola = sizeof(pole) / sizeof(pole[0]);

printf("Pôvodné pole: \n");

for (auto i: pole)
{
cout<<i<<" ";
}

MergeSort(pole, 0, dlzka_pola - 1);

cout<<endl<<"Utriedené pole:"<<endl;

for (auto i: pole)
{
cout<<i<<" ";
}

return 0;
}

void Merge(int pole[], int lavy, int stred, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči */

if (lavy >= pravy)
{
return;
}

/* vyrátaj dĺžky oboch polovíc poľa */

int L_dlzka = stred - lavy + 1;
int P_dlzka = pravy - stred;

/* alokuj dočasné polia, kam uložíš prvky z oboch polovíc poľa */

int *L = new int[L_dlzka];
int *P = new int[P_dlzka];

/* indexy, ktorými iterujeme všetky polia: i pre L, j pre P, k pre pole */

int i, j, k;

/* skopíruj obsah oboch polovíc poľa do dočasných polí L a P */

for (i = 0; i < L_dlzka; ++i)
{
L[i] = pole[lavy + i];
}

for (j = 0; j < P_dlzka; ++j)
{
P[j] = pole[stred + 1 + j];
}

/* nastav indexy na začiatok daných polí */

i = 0; j = 0; k = lavy;

/* zlučuj dočasné polia L a P do finálneho poľa pole */

while(i < L_dlzka && j < P_dlzka)
{
if(L[i] <= P[j])
{
pole[k++] = L[i++];
}
else
{
pole[k++] = P[j++];
}
}

/* ak ostali nejaké prvky v dočasnom poli L, skopíruj ich do finálneho poľa */

while(i < L_dlzka)
{
pole[k++] = L[i++];
}

/* ak ostali nejaké prvky v dočasnom poli P, skopíruj ich do finálneho poľa */

while(j < P_dlzka)
{
pole[k++] = P[j++];
}

/* uvoľni použitú pamäť */

delete []L;
delete []P;
}

void MergeSort(int pole[], int lavy, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči volanie */

if(lavy >= pravy)
{
return;
}
/* urči si prostredný index */

int stred = lavy + (pravy - lavy) / 2;

/* utrieď ľavú polovicu poľa */

MergeSort(pole, lavy, stred);

/* utrieď pravú polovicu poľa */

MergeSort(pole, stred+1, pravy);

/* zlúč obe polovice dokopy */

Merge(pole, lavy, stred, pravy);
}

</syntaxhighlight>
</tab>

<tab name="Iteračná: C++" block>
<syntaxhighlight lang="C++">
#include <iostream>

using std::cout;
using std::endl;

void Merge(int pole[], int lavy, int stred, int pravy);
void MergeSort(int pole[], int lavy, int pravy);

/* hlavný program */

int main()
{
int pole[] = {12, 11, 13, 5, 6, 7};
int dlzka_pola = sizeof(pole) / sizeof(pole[0]);

printf("Pôvodné pole: \n");

for (auto i: pole)
{
cout<<i<<" ";
}

MergeSort(pole, 0, dlzka_pola - 1);

cout<<endl<<"Utriedené pole:"<<endl;

for (auto i: pole)
{
cout<<i<<" ";
}

return 0;
}

void Merge(int pole[], int lavy, int stred, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči */

if (lavy >= pravy)
{
return;
}

/* vyrátaj dĺžky oboch polovíc poľa */

int L_dlzka = stred - lavy + 1;
int P_dlzka = pravy - stred;

/* alokuj dočasné polia, kam uložíš prvky z oboch polovíc poľa */

int *L = new int[L_dlzka];
int *P = new int[P_dlzka];

/* indexy, ktorými iterujeme všetky polia: i pre L, j pre P, k pre pole */

int i, j, k;

/* skopíruj obsah oboch polovíc poľa do dočasných polí L a P */

for (i = 0; i < L_dlzka; ++i)
{
L[i] = pole[lavy + i];
}

for (j = 0; j < P_dlzka; ++j)
{
P[j] = pole[stred + 1 + j];
}

/* nastav indexy na začiatok daných polí */

i = 0; j = 0; k = lavy;

/* zlučuj dočasné polia L a P do finálneho poľa pole */

while(i < L_dlzka && j < P_dlzka)
{
if(L[i] <= P[j])
{
pole[k++] = L[i++];
}
else
{
pole[k++] = P[j++];
}
}

/* ak ostali nejaké prvky v dočasnom poli L, skopíruj ich do finálneho poľa */

while(i < L_dlzka)
{
pole[k++] = L[i++];
}

/* ak ostali nejaké prvky v dočasnom poli P, skopíruj ich do finálneho poľa */

while(j < P_dlzka)
{
pole[k++] = P[j++];
}

/* uvoľni použitú pamäť */

delete []L;
delete []P;
}

void MergeSort(int *pole, int lavy, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči volanie */

if(lavy >= pravy)
{
return;
}

int stred, koniec;

for (int dlzka_zoznamu = 1; dlzka_zoznamu <= pravy; dlzka_zoznamu *= 2)
{
for (int zaciatok = lavy; zaciatok < pravy; zaciatok += 2 * dlzka_zoznamu)
{
koniec = (zaciatok + 2 * dlzka_zoznamu - 1 <= pravy) ? zaciatok + 2 * dlzka_zoznamu - 1 : pravy;

stred = (zaciatok + dlzka_zoznamu - 1 <= pravy) ? zaciatok + dlzka_zoznamu - 1 : pravy;

Merge(pole, zaciatok, stred, koniec);
}
}
}
</syntaxhighlight>
</tab>

<tab name="Rekurzívna: Java" block>
<syntaxhighlight lang="Java">
class MergeSort
{

/* Funkcia zlúči 2 podpolia, ktoré sme vytvorili z pôvodného poľa.
* Každé podpole má polovičnú dĺžku pôvodného poľa.
* subpole1 [ľavý ... stred]
* subpole2 [stred + 1 ... pravý] */

void merge(int[] pole, int lavy, int stred, int pravy)
{

// Výpočet dĺžky 2 podpolí

int n1 = stred - lavy + 1;
int n2 = pravy - stred;

// Vytvorenie pomocných polí

int[] L = new int[n1];
int[] P = new int[n2];

// Načítanie dát do pomocných polí

for (int i = 0; i < n1; i++)
L[i] = pole[lavy + i];

for (int j = 0; j < n2; j++)
P[j] = pole[stred + 1 + j];

// Počiatočné indexy prvého a druhého podpoľa

int i = 0, j = 0;

// Počiatočný index zlúčeného podpoľa

int k = lavy;

// Zlúčenie dvoch podpolí

while (i < n1 && j < n2)
{
if (L[i] <= P[j])
{
pole[k] = L[i];
i++;
}
else
{
pole[k] = P[j];
j++;
}
k++;
}

/* V prípade, že sa v jednom zo podpoli nachádzajú ešte nejaké prvky, ktoré neboli zlúčené do pola,
* tak sa do pola jednoducho skopírujú */

while (i < n1)
{
pole[k] = L[i];
i++;
k++;
}

while (j < n2)
{
pole[k] = P[j];
k++;
j++;
}

}

/* Funkcia, ktorá zoradí pole použitím funkcie merge() */

void sort (int[] pole, int lavy, int pravy)
{
if (lavy < pravy)
{
// Musíme nájsť stred pola

int stred = lavy + (pravy - lavy) / 2;

// Zoradíme prvú a druhú polovicu pola samostatne

sort(pole, lavy, stred);
sort(pole, stred + 1, pravy);

// Zlúčime zoradené polovice do jedného pola

merge(pole, lavy, stred, pravy);
}
}
}

public class Main
{
/* Funkcia na výpis pola dĺžky n */

static void vypis_pole(int[] pole)
{

for (int j : pole)
{
System.out.print(j + " ");
}

System.out.println();
}

/* Hlavný program */

public static void main(String[] args)
{
int[] pole = {12, 11, 13, 5, 6, 7};

System.out.println("Zadané pole:");
vypis_pole(pole);

MergeSort ms = new MergeSort();
ms.sort(pole, 0, pole.length - 1);

System.out.println("\nZoradené pole:");
vypis_pole(pole);
}
}
</syntaxhighlight>
</tab>

<tab name="Iteračná: Java" block>
<syntaxhighlight lang="Java">
class MergeSort_iteracia {
/* Zlúči 2 subpolia, ktoré sa vytvorili z pôvodného pola.
* Každé subpole má polovičnú dĺžku pôvodného pola.
* subpole1 [ľavý..stred]
* subpole2 [stred+1..pravý] */
void merge(int[] pole, int lavy, int stred, int pravy) {
// Výpočet dĺžky 2 subpolí
int n1 = stred - lavy + 1;
int n2 = pravy - stred;

// Vytvorenie pomocných polí
int[] L = new int[n1];
int[] P = new int[n2];

// Načítanie dát do pomocných polí
for (int i = 0; i < n1; i++)
L[i] = pole[lavy + i];

for (int j = 0; j < n2; j++)
P[j] = pole[stred + 1 + j];

// Počiatočné indexy prvého a druhého subpola
int i = 0, j = 0;
// Počiatočný index zlúčeného subpola
int k = lavy;

// Zlúčenie dvoch podpolí
while (i < n1 && j < n2) {
if (L[i] <= P[j]) {
pole[k] = L[i];
i++;
}
else {
pole[k] = P[j];
j++;
}
k++;
}

/* V prípade, že v jednom zo subpolí sa nachádzajú prvky, ktoré neboli zlúčené do pola,
* tak sa do pola jednoducho skopírujú */
while (i < n1) {
pole[k] = L[i];
i++;
k++;
}

while (j < n2) {
pole[k] = P[j];
k++;
j++;
}
}

/* Funkcia, ktorá zoradí pole použitím funkcie merge() */
void sort (int[] pole, int n) {
/* Dĺžka subpolí, ktoré majú byť zlúčené, hodnoty premennej sa pohybujú v intervale <1;n-1> */
int aktual_dlzka;
/* Začiatočný index ľavého subpola, ktoré má byť zlúčené */
int zaciatok_vlavo;

/* Vzostupné usporiadanie prvkov. Najskôr sa zlúčia subpolia veľkosti 1 do subpolí veľkosti 2,
* potom subpolia veľkosti 2 do subpolí veľkosti 4 a tak ďalej */
for (aktual_dlzka = 1; aktual_dlzka <= n - 1; aktual_dlzka *= 2) {
/* Určenie začiatočného prvku rôznych subpolí aktuálnej dĺžky subpola */
for (zaciatok_vlavo = 0; zaciatok_vlavo < n - 1; zaciatok_vlavo += 2 * aktual_dlzka) {
/* Nájdenie konečného prvku ľavého subpola, stred+1 je začiatočný prvok pravého subpola */
int stred = Math.min(zaciatok_vlavo + aktual_dlzka - 1, n - 1);
int koniec_vpravo = Math.min(zaciatok_vlavo + 2 * aktual_dlzka - 1, n - 1);

/* Zlúči subpolia L[zaciatok_vlavo .. stred] & P[stred+1 .. koniec_vpravo] */
merge(pole, zaciatok_vlavo, stred, koniec_vpravo);
}
}
}
}

public class Main {
/* Funkcia na výpis pola dĺžky n */
static void vypis_pole(int[] pole) {
int n = pole.length;

for (int j : pole) {
System.out.print(j + " ");
}
System.out.println();
}

/* Hlavný program */
public static void main(String[] args) {

/* Inicializácia pola */
int[] pole = {12, 11, 13, 5, 6, 7};

System.out.println("Zadané pole:");
vypis_pole(pole);

MergeSort_iteracia ms_it = new MergeSort_iteracia();
ms_it.sort(pole, pole.length);

System.out.println("Zoradené pole:");
vypis_pole(pole);
}
}
</syntaxhighlight>
</tab>

<tab name="Rekurzívna: Python3" block>
<syntaxhighlight lang="Python3">
def MergeSort(pole):
if len(pole) > 1:
# Nájdenie stredu pola
# zápis len(pole)//2 znamená, že dĺžka pola sa vydelí 2 a výsledok je celé číslo
stred = len(pole) // 2

# Rozdelenie pola na dve časti
L = pole[:stred]
P = pole[stred:]

# Zoradenie najskôr prvej časti pola, potom druhej
MergeSort(L)
MergeSort(P)

i = j = k = 0

# Zlúčenie a zoradenie údajov z pomocných polí do jedného pola
while i < len(L) and j < len(P):
if L[i] < P[j]:
pole[k] = L[i]
i += 1
else:
pole[k] = P[j]
j += 1
k += 1

# Kontrola či všetky prvky boli zlúčené dokopy,
# ak nie, tak sa do zlúčeného pola jednoducho skopírujú
while i < len(L):
pole[k] = L[i]
i += 1
k += 1

while j < len(P):
pole[k] = P[j]
j += 1
k += 1

# Hlavný program
if __name__ == '__main__':
pole = [12, 11, 13, 5, 6, 7]

print("Zadané pole:", end="\n")
print(pole, end="\n")

MergeSort(pole)

print("Zoradené pole:", end="\n")
print(pole, end="\n")

</syntaxhighlight>
</tab>

<tab name="Iteračná: Python3" block>
<syntaxhighlight lang="Python3">
def MergeSort_iteracia(pole):
# Dĺžka subpolí, ktoré majú byť zlúčené, hodnoty premennej sa pohybujú v intervale <1;n-1>
aktual_dlzka = 1

# Vonkajší cyklus, ktorý určuje subpolia aktuálnej dĺžky
while aktual_dlzka < len(pole) - 1:
lavy = 0

# Vnútorný cyklus, ktorý slúži na zlúčenie a zoradenie subpoli do jedného subpola
while lavy < len(pole) - 1:
# Index stredného prvku sa určí, keď k indexu ľavého prvku subpola pripočítame aktuálnu
# dĺžku subpolí a odčítame 1
stred = min((lavy + aktual_dlzka - 1), len(pole) - 1)

# Ak platí podmienka 2 * aktuálna dĺžka < dĺžka pola - 1, tak pravý index = aktuálnej dĺžke subpolí,
# inak pravý index = dĺžke pola - 1
pravy = ((2 * aktual_dlzka + lavy - 1, len(pole) - 1)[2 * aktual_dlzka + lavy - 1 > len(pole) - 1])

# Volanie funkcie merge
merge(pole, lavy, stred, pravy)

lavy = lavy + 2 * aktual_dlzka

# Aktuálna dĺžka sa sa zmení na dvojnásobok jej predošlej hodnoty
aktual_dlzka = 2 * aktual_dlzka

def merge(pole, lavy, stred, pravy):
n1 = stred - lavy + 1
n2 = pravy - stred

# Inicializácia pomocných polí
L = [0] * n1
P = [0] * n2

# Načítanie dát do pomocných polí
for i in range(0, n1):
L[i] = pole[lavy + i]
for i in range(0, n2):
P[i] = pole[stred + i + 1]

i, j, k = 0, 0, lavy

# Zlúčenie a zoradenie údajov z pomocných polí do jedného pola
while i < n1 and j < n2:
if L[i] > P[j]:
pole[k] = P[j]
j += 1
else:
pole[k] = L[i]
i += 1
k += 1

# Kontrola či všetky prvky boli zlúčené dokopy,
# ak nie, tak sa do zlúčeného pola jednoducho skopírujú
while i < n1:
pole[k] = L[i]
i += 1
k += 1

while j < n2:
pole[k] = P[j]
j += 1
k += 1

# Hlavný program
if __name__ == '__main__':
pole = [12, 11, 13, 5, 6, 7]

print("Zadané pole:", end="\n")
print(pole, end="\n")

MergeSort_iteracia(pole)

print("Zoradené pole:", end="\n")
print(pole, end="\n")

</syntaxhighlight>
</tab>

</tabs>

==Odkazy==
# https://www.geeksforgeeks.org/merge-sort/
# https://www.geeksforgeeks.org/iterative-merge-sort/
# https://medium.com/@paulsoham/merge-sort-63d75df76388
# https://www.khanacademy.org/computing/computer-science/algorithms/merge-sort/a/overview-of-merge-sort
# https://www.tutorialspoint.com/data_structures_algorithms/merge_sort_algorithm.htm
# https://www.youtube.com/watch?v=6pV2IF0fgKY
# https://www.youtube.com/watch?v=mB5HXBb_HY8
# https://www.youtube.com/watch?v=ak-pz7tS5DE

Triedenie zlučovaním

2021-03-29T14:40:05Z

Filip Tomek: /* Opis rekurzívnej a iteračnej verzie algoritmu Merge Sort */

[[Kategória:Algoritmy triedenia]]
{{Draft}}
{{Skripta programovanie}}
__TOC__
==TODO: Pseudokód treba opraviť, text refaktorovať, otestovať kódy, zvýrazniť veci v texte, opraviť preklepy, opraviť popis obrázkov, pridať nové odkazy==

==Zlučovací algoritmus Merge==
[[Súbor:Funkcia merge.png|500px|náhľad|vpravo|Vizualizácia funkcie Merge: Máme pole prvkov ''p = [1, 3, 5, 2, 4, 6]'', ktoré je už čiastočne utriedené. Použijeme algoritmus Merge, ktorý si vytvorí pomocné polia ''L = [1, 3, 5]'' a ''P = [2, 4, 6]''. Všetky polia indexujeme od ''0'', pričom pre pole ''p'' používame index ''k'', pre ''L'' index ''i'' a pre ''P'' index ''j''. Postupnosť krokov je označená číslicami 1 až 6.
]]

Princíp zlučovania tkvie v tom, že máme dva alebo viac utriedených zoznamov, ktoré skombinuje do jedného utriedeného zoznamu (výsledný zoznam musí obsahovať všetky prvky z pôvodných zoznamov). Zoznam môže byť reprezentovaný ako dátová štruktúra pole alebo aj ako lineárny zoznam. V tomto článku sa zameriame na algoritmus pre dátovú štruktúru pole.

Algoritmus Merge tvorí kľúčovú časť triediaceho algoritmu MergeSort.

===Slovný opis algoritmu===
Nech máme pole, ktoré sa skladá z dvoch už utriedených polovíc. Vytvoríme si dve pomocné polia ''L'' a ''P'' a do každého z nich skopírujeme obsah jednej polovice (''L'' - ľavá polovica, ''P'' - pravá polovica). Potom súčasne prechádzame polia ''L'' a ''P'' od začiatku po koniec, pričom v každom cykle porovnáme prvok poľa ''L'' s prvkom v poli ''P''. Z tejto dvojice následne vyberieme minimum, (keď triedime od najmenšieho po najväčší) ktoré vložíme na prvú voľnú pozíciu pôvodného poľa (na začiatku je to prvá pozícia poľa). Nakoniec zvýšime index pri vstupnom poli a pri pomocnom poli, z ktorého vyberáme daný prvok. Túto postupnosť krokov opakujeme, pokiaľ neprídeme na koniec jedného z polí ''P'' a ''L''. Ak nastane situácia, že prídeme na koniec jedného z pomocných polí (a v druhom nám ostali ešte nejaké prvky), potom už iba naspäť skopírujeme zbytok druhého pomocného poľa na koniec pôvodného poľa.

===Vlastnosti algoritmu===
* vhodný pre dátové štruktúry: pole, lineárny zoznam
* časová náročnosť: vždy lineárna <math>O(n)</math>
* priestorová náročnosť: lineárna <math>O(n)</math> pre pole (alokovanie pomocných polí), <math>O(1)</math> pre lineárny zoznam (pri lineárnom zozname netreba alokovať dočasné polia, stačí iba presmerovať smerníky)
* využitie: kľúčový podprogram pre triediaci algoritmus MergeSort

===Pseudokód===
Nech funkcia Merge má nasledovný prototyp: <code>Merge(pole[], lavy, stred, pravy)</code>
:1. Je <code>lavy >= pravy ? Ak áno, skonči, inak pokračuj krokom 2.</code>
:2. Nech: <code>i = 0, j = 0, k = lavy </code>
:3. Nech: <code>dlzka_L = stred - lavy + 1, dlzka_P = pravy - stred</code>
:4. Nech: <code> L = pole[lavy ... stred], P = pole[stred + 1 ... pravy] </code>
:5. Je <code>i < dlzka_L</code> a zároveň <code>j < dlzka_P</code> ? Ak áno, pokračuj krokom 5.1., inak skoč na krok 6.
:::5.1. Je <code>L[i] <= P[j]</code>?
:::: Ak áno:
:::::5.1.1. <code>pole[k] = L[i]</code>
:::::5.1.2. <code>k += 1</code>
:::::5.1.3. <code>i += 1</code>
:::::5.1.4. Skoč na krok 5.
:::: Ak nie:
:::::5.1.1. <code>pole[k] = P[j]</code>
:::::5.1.2. <code>k += 1</code>
:::::5.1.3. <code>j += 1</code>
:::::5.1.4. Skoč na krok 5.
:6. Je <code>i < dlzka_L</code> ? Ak áno, pokračuj krokom 6.1., inak skoč na krok 7.
:::6.1. <code>pole[k] = L[i]</code>
:::6.2. <code>k += 1</code>
:::6.3. <code>i += 1</code>
:::6.4. Skoč na krok 6.
:7. Je <code>j < dlzka_P</code> ? Ak áno, pokračuj krokom 7.1., inak skonči.
:::7.1. <code>pole[k] = P[j]</code>
:::7.2. <code>k += 1</code>
:::7.3. <code>j += 1</code>
:::7.4. Skoč na krok 7.

==Merge sort==
Merge Sort je triediaci algoritmus, ktorý využíva stratégiu '''"rozdeľuj a panuj"''', čo znamená, že vstupný zoznam najskôr rozdelí na dve polovice, tie zoradí a potom ich zlúči naspäť dokopy. Radí sa medzi najpoužívanejšie a najviac rešpektované triediace algoritmy.

===Vlastnosti algoritmu Merge Sort===
* vhodný pre dátové štruktúry: pole, lineárny zoznam
* časová náročnosť: vždy linearitmická <math> O(n.log(n)) </math>, vďaka ktorej dokáže efektívne triediť veľmi veľké zoznamy
* priestorová náročnosť: lineárna <math>O(n)</math> pre pole (alokovanie dočasných polí), konštantná <math>O(1)</math> pre lineárny zoznam (pri lineárnom zozname stačí iba presmerovať smerníky)
* druh triedenia: triedenie zlučovaním (komparačný algoritmus)
* stabilita triedenia: stabilný
* miesto triedenia: externé triedenie (vhodný na triedenie veľkých objemov dát uložených na disku)

Z hľadiska implementácie môžeme vytvoriť dve základné verzie algoritmu, a to rekurzívnu a iteračnú.

===Opis rekurzívnej a iteračnej verzie algoritmu Merge Sort===

<tabs>
<tab name="Rekurzívna verzia" block>
[[Súbor:Merge sort.png|400px|náhľad|vpravo|Vizualizácia rekurzívnej verzie algoritmu MergeSort]]

===Princíp algoritmu===
Algoritmus MergeSort vykonáva 4 základné úlohy:
# Delenie poľa na dve polovice.
# Triedenie ľavej polovice poľa.
# Triedenie pravej polovice poľa.
# Zlúčenie oboch polovíc pomocou funkcie Merge.

===Slovný opis===
Našou úlohou je vzostupne (min -> max) utriediť vstupné pole. Určíme si stred poľa (pri párnom počte prvkov je to ten menší z prostredných indexov). Následne vykonávame sériu rekurzívnych delení pre ľavú a pravú časť poľa (''začiatok ... stred ; stred + 1 ... koniec'') až do momentu, keď nám ostanú len jednoprvkové podpolia (tie sú už utriedené). Následne v každom volaní obe tieto podpolia zlúčime pomocou algoritmu ''Merge'' do väčších podpolí (2, 4, 8, ...), až nakoniec dostaneme jedno výsledné utriedené pole.

===Pseudokód===
Nech nech má funkcia MergeSort nasledovný prototyp: <code>MergeSort(pole[], lavy, pravy) </code>
:1. Je <code>lavy >= pravy</code> ? Ak áno, skonči volanie, inak pokračuj krokom 2.
:2. Nech: <code>stred = lavy + (pravy - lavy) / 2</code>, pričom znak ''/'' vyjadruje celočíselné delenie.
:3. Rekurzívne zavolaj funkciu <code>MergeSort(pole[], lavy , stred)</code>
:3. Rekurzívne zavolaj funkciu <code>MergeSort(pole[], stred + 1 , pravy)</code>
:4. Zavolaj funkciu <code>Merge(pole[], lavy, stred, pravy)</code>
:5. Skonči volanie.

</tab>
<tab name="Iteračná verzia" block>
[[Súbor:MergeSort IT.png|400px|náhľad|vpravo]]

===Princíp algoritmu===
Algoritmus Merge vykonáva 3 základné úlohy:
# Vonkajší cyklus: určenie veľkosti zoznamu na zlučovanie.
# Vnútorný cyklus: prechádzanie jednotlivých zoznamov v poli.
# Zlučovanie jednotlivých zoznamov pomocou funkcie Merge.

===Slovný opis===
Vstupné pole, ktoré má ''N'' prvkov, môžeme chápať, ako ''N'' rôznych jednoprvkových (utriedených) podpolí, ktoré máme zlúčiť do jedného výsledného ''N''-prvkového utriedeného poľa. Keďže by bolo veľmi nepraktické zlučovať ''N'' podpolí naraz, zvolíme nasledovnú stratégiu: Budeme prechádzať dané pole od začiatku po koniec a v prvom cykle zlúčime každé dva prvky, takže budeme mať <math>\frac{n}{2}</math> dvojprvkových utriedených podpolí. Potom v druhom cykle zlúčime každé 4 prvky do jedného podpoľa, v treťom cykle každých 8, až do momentu, keď dostaneme jedno utriedené pole.
Aby sme to docielili, potrebujeme dva cykly, vonkajší, ktorý nastaví maximálnu veľkosť podpoľa, ktoré ideme zlučovať (1,2,4,8 ... dlzka - 1) a vnútorný, ktorý prechádza jednotlivé podpolia. Následne už iba voláme funkciu Merge, ktorá dané podpolia zlučuje.

Poznámka, ak máme pole, ktoré má nepárny počet prvkov, tak ten posledný prvok nezlúčime hneď v prvom cykle, ale až v tých ďalších. Takisto, ak n nie je mocnina čísla 2, tak musíme samozrejme ošetriť situáciu, kedy by sme sa dostali mimo rozsah poľa (Ak máme napríklad pole, čo má 7 prvkov, tak po prvej iterácii budú prvky utiredené podľa vzoru 2 + 2 + 2 + 1, po druhej 4 + 3, a po tretej 7)

===Pseudokód===
Nech nech má funkcia MergeSort nasledovný prototyp: <code>MergeSort(pole[], lavy, pravy) </code>
:1. Je <code>lavy >= pravy</code> ? Ak áno, skonči, inak pokračuj krokom 2.
:2. Nech: <code>dlzka_subzoznamu = 1 </code>
:3. Nech: <code>zaciatok = lavy</code>
:4. Je<code>dlzka_subzoznamu <= pravy</code> ? Ak áno pokračuj krokom 4.1, inak skonči.
:::4.1. Je<code>zaciatok < pravy</code> Ak áno pokračuj krokom 4.1.1, inak skoč na krok 4.2.
:::::4.1.1. Je <code>zaciatok + 2 * dlzka_zoznamu - 1 <= pravy</code> ?
:::::::Ak áno:
:::::::::4.1.1.1. Nech <code>koniec = zaciatok + 2 * dlzka_zoznamu - 1</code>
:::::::Ak nie:
:::::::::4.1.1.1. Nech <code>koniec = pravy</code>
:::::4.1.2. Je <code>zaciatok + dlzka_zoznamu - 1 <= pravy</code> ?
:::::::Ak áno:
:::::::::4.1.2.1. Nech <code>stred = zaciatok + dlzka_zoznamu - 1</code>
:::::::Ak nie:
:::::::::4.1.2.1. Nech <code>stred = pravy</code>
:::::4.1.3. <code>Merge(pole[], zaciatok, stred, koniec)</code>
:::::4.1.4. <code>zaciatok += 2 * dlzka_subzoznamu</code>
:::::4.1.5. Skoč na krok 4.1.
:::4.2. <code>dlzka_subzoznamu *= 2</code>
:::4.3 Skoč na krok 4.

</tab>
</tabs>

==Implementácia algoritmov Merge a MergeSort v rôznych programovacích jazykoch==
<tabs>
<tab name="Rekurzívna: C " block>
<syntaxhighlight lang="C">
#include <stdio.h>
#include <stdlib.h>

void Merge(int pole[], int lavy, int stred, int pravy);
void MergeSort(int pole[], int lavy, int pravy);

/* hlavný program */

int main()
{
int pole[] = {12, 11, 13, 5, 6, 7};
int dlzka_pola = sizeof(pole) / sizeof(pole[0]);

printf("Pôvodné pole: \n");

for (int i = 0; i < dlzka_pola; ++i)
{
printf("%d ", pole[i]);
}

MergeSort(pole, 0, dlzka_pola - 1);

printf("\nUtriedené pole: \n");

for (int i = 0; i < dlzka_pola; ++i)
{
printf("%d ", pole[i]);
}

return 0;
}

void Merge(int pole[], int lavy, int stred, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči */

if (lavy >= pravy)
{
return;
}

/* vyrátaj dĺžky oboch polovíc poľa */

int L_dlzka = stred - lavy + 1;
int P_dlzka = pravy - stred;

/* alokuj dočasné polia, kam uložíš prvky z oboch polovíc poľa */

int *L = (int*)malloc(L_dlzka * sizeof(int));
int *P = (int*)malloc(P_dlzka * sizeof(int));

/* indexy, ktorými iterujeme všetky polia: i pre L, j pre P, k pre pole */

int i, j, k;

/* skopíruj obsah oboch polovíc poľa do dočasných polí L a P */

for (i = 0; i < L_dlzka; ++i)
{
L[i] = pole[lavy + i];
}

for (j = 0; j < P_dlzka; ++j)
{
P[j] = pole[stred + 1 + j];
}

/* nastav indexy na začiatok daných polí */

i = 0; j = 0; k = lavy;

/* zlučuj dočasné polia L a P do finálneho poľa pole */

while(i < L_dlzka && j < P_dlzka)
{
if(L[i] <= P[j])
{
pole[k++] = L[i++];
}
else
{
pole[k++] = P[j++];
}
}

/* ak ostali nejaké prvky v dočasnom poli L, skopíruj ich do finálneho poľa */

while(i < L_dlzka)
{
pole[k++] = L[i++];
}

/* ak ostali nejaké prvky v dočasnom poli P, skopíruj ich do finálneho poľa */

while(j < P_dlzka)
{
pole[k++] = P[j++];
}

/* uvoľni použitú pamäť */

free(L);
free(P);
}

void MergeSort(int pole[], int lavy, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči volanie */

if(lavy >= pravy)
{
return;
}
/* urči si prostredný index */

int stred = lavy + (pravy - lavy) / 2;

/* utrieď ľavú polovicu poľa */

MergeSort(pole, lavy, stred);

/* utrieď pravú polovicu poľa */

MergeSort(pole, stred+1, pravy);

/* zlúč obe polovice dokopy */

Merge(pole, lavy, stred, pravy);
}
</syntaxhighlight>
</tab>

<tab name="Iteračná: C" block>
<syntaxhighlight lang="C">
#include <stdio.h>
#include <stdlib.h>

void Merge(int pole[], int lavy, int stred, int pravy);
void MergeSortIt(int *pole, int lavy, int pravy);

/* hlavný program */

int main()
{
int pole[] = {12, 11, 13, 5, 6, 7, 19};
int dlzka_pola = sizeof(pole) / sizeof(pole[0]);

printf("Pôvodné pole %d: \n", dlzka_pola);

for (int i = 0; i < dlzka_pola; ++i)
{
printf("%d ", pole[i]);
}

MergeSortIt(pole, 0, dlzka_pola - 1);

printf("\nUtriedené pole: \n");

for (int i = 0; i < dlzka_pola; ++i)
{
printf("%d ", pole[i]);
}

return 0;
}

void Merge(int pole[], int lavy, int stred, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči */

if (lavy >= pravy)
{
return;
}

/* vyrátaj dĺžky oboch polovíc poľa */

int L_dlzka = stred - lavy + 1;
int P_dlzka = pravy - stred;

/* alokuj dočasné polia, kam uložíš prvky z oboch polovíc poľa */

int *L = (int*)malloc(L_dlzka * sizeof(int));
int *P = (int*)malloc(P_dlzka * sizeof(int));

/* indexy, ktorými iterujeme všetky polia: i pre L, j pre P, k pre pole */

int i, j, k;

/* skopíruj obsah oboch polovíc poľa do dočasných polí L a P */

for (i = 0; i < L_dlzka; ++i)
{
L[i] = pole[lavy + i];
}

for (j = 0; j < P_dlzka; ++j)
{
P[j] = pole[stred + 1 + j];
}

/* nastav indexy na začiatok daných polí */

i = 0; j = 0; k = lavy;

/* zlučuj dočasné polia L a P do finálneho poľa pole */

while(i < L_dlzka && j < P_dlzka)
{
if(L[i] <= P[j])
{
pole[k++] = L[i++];
}
else
{
pole[k++] = P[j++];
}
}

/* ak ostali nejaké prvky v dočasnom poli L, skopíruj ich do finálneho poľa */

while(i < L_dlzka)
{
pole[k++] = L[i++];
}

/* ak ostali nejaké prvky v dočasnom poli P, skopíruj ich do finálneho poľa */

while(j < P_dlzka)
{
pole[k++] = P[j++];
}

/* uvoľni použitú pamäť */

free(L);
free(P);
}

void MergeSortIt(int *pole, int lavy, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči volanie */

if(lavy >= pravy)
{
return;
}

int stred, koniec;

for (int dlzka_zoznamu = 1; dlzka_zoznamu <= pravy ; dlzka_zoznamu *= 2)
{
for (int zaciatok = lavy; zaciatok < pravy ; zaciatok += 2 * dlzka_zoznamu)
{
koniec = (zaciatok + 2 * dlzka_zoznamu - 1 <= pravy) ? zaciatok + 2 * dlzka_zoznamu - 1 : pravy;

stred = (zaciatok + dlzka_zoznamu - 1 <= pravy) ? zaciatok + dlzka_zoznamu - 1 : pravy;

Merge(pole, zaciatok, stred, koniec);

}
}
}

</syntaxhighlight>
</tab>

<tab name="Rekurzívna: C++" block>
<syntaxhighlight lang="C++">
#include <iostream>

using std::cout;
using std::endl;

void Merge(int pole[], int lavy, int stred, int pravy);
void MergeSort(int pole[], int lavy, int pravy);

/* hlavný program */

int main()
{
int pole[] = {12, 11, 13, 5, 6, 7};
int dlzka_pola = sizeof(pole) / sizeof(pole[0]);

printf("Pôvodné pole: \n");

for (auto i: pole)
{
cout<<i<<" ";
}

MergeSort(pole, 0, dlzka_pola - 1);

cout<<endl<<"Utriedené pole:"<<endl;

for (auto i: pole)
{
cout<<i<<" ";
}

return 0;
}

void Merge(int pole[], int lavy, int stred, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči */

if (lavy >= pravy)
{
return;
}

/* vyrátaj dĺžky oboch polovíc poľa */

int L_dlzka = stred - lavy + 1;
int P_dlzka = pravy - stred;

/* alokuj dočasné polia, kam uložíš prvky z oboch polovíc poľa */

int *L = new int[L_dlzka];
int *P = new int[P_dlzka];

/* indexy, ktorými iterujeme všetky polia: i pre L, j pre P, k pre pole */

int i, j, k;

/* skopíruj obsah oboch polovíc poľa do dočasných polí L a P */

for (i = 0; i < L_dlzka; ++i)
{
L[i] = pole[lavy + i];
}

for (j = 0; j < P_dlzka; ++j)
{
P[j] = pole[stred + 1 + j];
}

/* nastav indexy na začiatok daných polí */

i = 0; j = 0; k = lavy;

/* zlučuj dočasné polia L a P do finálneho poľa pole */

while(i < L_dlzka && j < P_dlzka)
{
if(L[i] <= P[j])
{
pole[k++] = L[i++];
}
else
{
pole[k++] = P[j++];
}
}

/* ak ostali nejaké prvky v dočasnom poli L, skopíruj ich do finálneho poľa */

while(i < L_dlzka)
{
pole[k++] = L[i++];
}

/* ak ostali nejaké prvky v dočasnom poli P, skopíruj ich do finálneho poľa */

while(j < P_dlzka)
{
pole[k++] = P[j++];
}

/* uvoľni použitú pamäť */

delete []L;
delete []P;
}

void MergeSort(int pole[], int lavy, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči volanie */

if(lavy >= pravy)
{
return;
}
/* urči si prostredný index */

int stred = lavy + (pravy - lavy) / 2;

/* utrieď ľavú polovicu poľa */

MergeSort(pole, lavy, stred);

/* utrieď pravú polovicu poľa */

MergeSort(pole, stred+1, pravy);

/* zlúč obe polovice dokopy */

Merge(pole, lavy, stred, pravy);
}

</syntaxhighlight>
</tab>

<tab name="Iteračná: C++" block>
<syntaxhighlight lang="C++">
#include <iostream>

using std::cout;
using std::endl;

void Merge(int pole[], int lavy, int stred, int pravy);
void MergeSort(int pole[], int lavy, int pravy);

/* hlavný program */

int main()
{
int pole[] = {12, 11, 13, 5, 6, 7};
int dlzka_pola = sizeof(pole) / sizeof(pole[0]);

printf("Pôvodné pole: \n");

for (auto i: pole)
{
cout<<i<<" ";
}

MergeSort(pole, 0, dlzka_pola - 1);

cout<<endl<<"Utriedené pole:"<<endl;

for (auto i: pole)
{
cout<<i<<" ";
}

return 0;
}

void Merge(int pole[], int lavy, int stred, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči */

if (lavy >= pravy)
{
return;
}

/* vyrátaj dĺžky oboch polovíc poľa */

int L_dlzka = stred - lavy + 1;
int P_dlzka = pravy - stred;

/* alokuj dočasné polia, kam uložíš prvky z oboch polovíc poľa */

int *L = new int[L_dlzka];
int *P = new int[P_dlzka];

/* indexy, ktorými iterujeme všetky polia: i pre L, j pre P, k pre pole */

int i, j, k;

/* skopíruj obsah oboch polovíc poľa do dočasných polí L a P */

for (i = 0; i < L_dlzka; ++i)
{
L[i] = pole[lavy + i];
}

for (j = 0; j < P_dlzka; ++j)
{
P[j] = pole[stred + 1 + j];
}

/* nastav indexy na začiatok daných polí */

i = 0; j = 0; k = lavy;

/* zlučuj dočasné polia L a P do finálneho poľa pole */

while(i < L_dlzka && j < P_dlzka)
{
if(L[i] <= P[j])
{
pole[k++] = L[i++];
}
else
{
pole[k++] = P[j++];
}
}

/* ak ostali nejaké prvky v dočasnom poli L, skopíruj ich do finálneho poľa */

while(i < L_dlzka)
{
pole[k++] = L[i++];
}

/* ak ostali nejaké prvky v dočasnom poli P, skopíruj ich do finálneho poľa */

while(j < P_dlzka)
{
pole[k++] = P[j++];
}

/* uvoľni použitú pamäť */

delete []L;
delete []P;
}

void MergeSort(int *pole, int lavy, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči volanie */

if(lavy >= pravy)
{
return;
}

int stred, koniec;

for (int dlzka_zoznamu = 1; dlzka_zoznamu <= pravy; dlzka_zoznamu *= 2)
{
for (int zaciatok = lavy; zaciatok < pravy; zaciatok += 2 * dlzka_zoznamu)
{
koniec = (zaciatok + 2 * dlzka_zoznamu - 1 <= pravy) ? zaciatok + 2 * dlzka_zoznamu - 1 : pravy;

stred = (zaciatok + dlzka_zoznamu - 1 <= pravy) ? zaciatok + dlzka_zoznamu - 1 : pravy;

Merge(pole, zaciatok, stred, koniec);
}
}
}
</syntaxhighlight>
</tab>

<tab name="Rekurzívna: Java" block>
<syntaxhighlight lang="Java">
class MergeSort
{

/* Funkcia zlúči 2 podpolia, ktoré sme vytvorili z pôvodného poľa.
* Každé podpole má polovičnú dĺžku pôvodného poľa.
* subpole1 [ľavý ... stred]
* subpole2 [stred + 1 ... pravý] */

void merge(int[] pole, int lavy, int stred, int pravy)
{

// Výpočet dĺžky 2 podpolí

int n1 = stred - lavy + 1;
int n2 = pravy - stred;

// Vytvorenie pomocných polí

int[] L = new int[n1];
int[] P = new int[n2];

// Načítanie dát do pomocných polí

for (int i = 0; i < n1; i++)
L[i] = pole[lavy + i];

for (int j = 0; j < n2; j++)
P[j] = pole[stred + 1 + j];

// Počiatočné indexy prvého a druhého podpoľa

int i = 0, j = 0;

// Počiatočný index zlúčeného podpoľa

int k = lavy;

// Zlúčenie dvoch podpolí

while (i < n1 && j < n2)
{
if (L[i] <= P[j])
{
pole[k] = L[i];
i++;
}
else
{
pole[k] = P[j];
j++;
}
k++;
}

/* V prípade, že sa v jednom zo podpoli nachádzajú ešte nejaké prvky, ktoré neboli zlúčené do pola,
* tak sa do pola jednoducho skopírujú */

while (i < n1)
{
pole[k] = L[i];
i++;
k++;
}

while (j < n2)
{
pole[k] = P[j];
k++;
j++;
}

}

/* Funkcia, ktorá zoradí pole použitím funkcie merge() */

void sort (int[] pole, int lavy, int pravy)
{
if (lavy < pravy)
{
// Musíme nájsť stred pola

int stred = lavy + (pravy - lavy) / 2;

// Zoradíme prvú a druhú polovicu pola samostatne

sort(pole, lavy, stred);
sort(pole, stred + 1, pravy);

// Zlúčime zoradené polovice do jedného pola

merge(pole, lavy, stred, pravy);
}
}
}

public class Main
{
/* Funkcia na výpis pola dĺžky n */

static void vypis_pole(int[] pole)
{

for (int j : pole)
{
System.out.print(j + " ");
}

System.out.println();
}

/* Hlavný program */

public static void main(String[] args)
{
int[] pole = {12, 11, 13, 5, 6, 7};

System.out.println("Zadané pole:");
vypis_pole(pole);

MergeSort ms = new MergeSort();
ms.sort(pole, 0, pole.length - 1);

System.out.println("\nZoradené pole:");
vypis_pole(pole);
}
}
</syntaxhighlight>
</tab>

<tab name="Iteračná: Java" block>
<syntaxhighlight lang="Java">
class MergeSort_iteracia {
/* Zlúči 2 subpolia, ktoré sa vytvorili z pôvodného pola.
* Každé subpole má polovičnú dĺžku pôvodného pola.
* subpole1 [ľavý..stred]
* subpole2 [stred+1..pravý] */
void merge(int[] pole, int lavy, int stred, int pravy) {
// Výpočet dĺžky 2 subpolí
int n1 = stred - lavy + 1;
int n2 = pravy - stred;

// Vytvorenie pomocných polí
int[] L = new int[n1];
int[] P = new int[n2];

// Načítanie dát do pomocných polí
for (int i = 0; i < n1; i++)
L[i] = pole[lavy + i];

for (int j = 0; j < n2; j++)
P[j] = pole[stred + 1 + j];

// Počiatočné indexy prvého a druhého subpola
int i = 0, j = 0;
// Počiatočný index zlúčeného subpola
int k = lavy;

// Zlúčenie dvoch podpolí
while (i < n1 && j < n2) {
if (L[i] <= P[j]) {
pole[k] = L[i];
i++;
}
else {
pole[k] = P[j];
j++;
}
k++;
}

/* V prípade, že v jednom zo subpolí sa nachádzajú prvky, ktoré neboli zlúčené do pola,
* tak sa do pola jednoducho skopírujú */
while (i < n1) {
pole[k] = L[i];
i++;
k++;
}

while (j < n2) {
pole[k] = P[j];
k++;
j++;
}
}

/* Funkcia, ktorá zoradí pole použitím funkcie merge() */
void sort (int[] pole, int n) {
/* Dĺžka subpolí, ktoré majú byť zlúčené, hodnoty premennej sa pohybujú v intervale <1;n-1> */
int aktual_dlzka;
/* Začiatočný index ľavého subpola, ktoré má byť zlúčené */
int zaciatok_vlavo;

/* Vzostupné usporiadanie prvkov. Najskôr sa zlúčia subpolia veľkosti 1 do subpolí veľkosti 2,
* potom subpolia veľkosti 2 do subpolí veľkosti 4 a tak ďalej */
for (aktual_dlzka = 1; aktual_dlzka <= n - 1; aktual_dlzka *= 2) {
/* Určenie začiatočného prvku rôznych subpolí aktuálnej dĺžky subpola */
for (zaciatok_vlavo = 0; zaciatok_vlavo < n - 1; zaciatok_vlavo += 2 * aktual_dlzka) {
/* Nájdenie konečného prvku ľavého subpola, stred+1 je začiatočný prvok pravého subpola */
int stred = Math.min(zaciatok_vlavo + aktual_dlzka - 1, n - 1);
int koniec_vpravo = Math.min(zaciatok_vlavo + 2 * aktual_dlzka - 1, n - 1);

/* Zlúči subpolia L[zaciatok_vlavo .. stred] & P[stred+1 .. koniec_vpravo] */
merge(pole, zaciatok_vlavo, stred, koniec_vpravo);
}
}
}
}

public class Main {
/* Funkcia na výpis pola dĺžky n */
static void vypis_pole(int[] pole) {
int n = pole.length;

for (int j : pole) {
System.out.print(j + " ");
}
System.out.println();
}

/* Hlavný program */
public static void main(String[] args) {

/* Inicializácia pola */
int[] pole = {12, 11, 13, 5, 6, 7};

System.out.println("Zadané pole:");
vypis_pole(pole);

MergeSort_iteracia ms_it = new MergeSort_iteracia();
ms_it.sort(pole, pole.length);

System.out.println("Zoradené pole:");
vypis_pole(pole);
}
}
</syntaxhighlight>
</tab>

<tab name="Rekurzívna: Python3" block>
<syntaxhighlight lang="Python3">
def MergeSort(pole):
if len(pole) > 1:
# Nájdenie stredu pola
# zápis len(pole)//2 znamená, že dĺžka pola sa vydelí 2 a výsledok je celé číslo
stred = len(pole) // 2

# Rozdelenie pola na dve časti
L = pole[:stred]
P = pole[stred:]

# Zoradenie najskôr prvej časti pola, potom druhej
MergeSort(L)
MergeSort(P)

i = j = k = 0

# Zlúčenie a zoradenie údajov z pomocných polí do jedného pola
while i < len(L) and j < len(P):
if L[i] < P[j]:
pole[k] = L[i]
i += 1
else:
pole[k] = P[j]
j += 1
k += 1

# Kontrola či všetky prvky boli zlúčené dokopy,
# ak nie, tak sa do zlúčeného pola jednoducho skopírujú
while i < len(L):
pole[k] = L[i]
i += 1
k += 1

while j < len(P):
pole[k] = P[j]
j += 1
k += 1

# Hlavný program
if __name__ == '__main__':
pole = [12, 11, 13, 5, 6, 7]

print("Zadané pole:", end="\n")
print(pole, end="\n")

MergeSort(pole)

print("Zoradené pole:", end="\n")
print(pole, end="\n")

</syntaxhighlight>
</tab>

<tab name="Iteračná: Python3" block>
<syntaxhighlight lang="Python3">
def MergeSort_iteracia(pole):
# Dĺžka subpolí, ktoré majú byť zlúčené, hodnoty premennej sa pohybujú v intervale <1;n-1>
aktual_dlzka = 1

# Vonkajší cyklus, ktorý určuje subpolia aktuálnej dĺžky
while aktual_dlzka < len(pole) - 1:
lavy = 0

# Vnútorný cyklus, ktorý slúži na zlúčenie a zoradenie subpoli do jedného subpola
while lavy < len(pole) - 1:
# Index stredného prvku sa určí, keď k indexu ľavého prvku subpola pripočítame aktuálnu
# dĺžku subpolí a odčítame 1
stred = min((lavy + aktual_dlzka - 1), len(pole) - 1)

# Ak platí podmienka 2 * aktuálna dĺžka < dĺžka pola - 1, tak pravý index = aktuálnej dĺžke subpolí,
# inak pravý index = dĺžke pola - 1
pravy = ((2 * aktual_dlzka + lavy - 1, len(pole) - 1)[2 * aktual_dlzka + lavy - 1 > len(pole) - 1])

# Volanie funkcie merge
merge(pole, lavy, stred, pravy)

lavy = lavy + 2 * aktual_dlzka

# Aktuálna dĺžka sa sa zmení na dvojnásobok jej predošlej hodnoty
aktual_dlzka = 2 * aktual_dlzka

def merge(pole, lavy, stred, pravy):
n1 = stred - lavy + 1
n2 = pravy - stred

# Inicializácia pomocných polí
L = [0] * n1
P = [0] * n2

# Načítanie dát do pomocných polí
for i in range(0, n1):
L[i] = pole[lavy + i]
for i in range(0, n2):
P[i] = pole[stred + i + 1]

i, j, k = 0, 0, lavy

# Zlúčenie a zoradenie údajov z pomocných polí do jedného pola
while i < n1 and j < n2:
if L[i] > P[j]:
pole[k] = P[j]
j += 1
else:
pole[k] = L[i]
i += 1
k += 1

# Kontrola či všetky prvky boli zlúčené dokopy,
# ak nie, tak sa do zlúčeného pola jednoducho skopírujú
while i < n1:
pole[k] = L[i]
i += 1
k += 1

while j < n2:
pole[k] = P[j]
j += 1
k += 1

# Hlavný program
if __name__ == '__main__':
pole = [12, 11, 13, 5, 6, 7]

print("Zadané pole:", end="\n")
print(pole, end="\n")

MergeSort_iteracia(pole)

print("Zoradené pole:", end="\n")
print(pole, end="\n")

</syntaxhighlight>
</tab>

</tabs>

==Odkazy==
# https://www.geeksforgeeks.org/merge-sort/
# https://www.geeksforgeeks.org/iterative-merge-sort/
# https://medium.com/@paulsoham/merge-sort-63d75df76388
# https://www.khanacademy.org/computing/computer-science/algorithms/merge-sort/a/overview-of-merge-sort
# https://www.tutorialspoint.com/data_structures_algorithms/merge_sort_algorithm.htm
# https://www.youtube.com/watch?v=6pV2IF0fgKY
# https://www.youtube.com/watch?v=mB5HXBb_HY8
# https://www.youtube.com/watch?v=ak-pz7tS5DE

Triedenie zlučovaním

2021-03-29T11:18:16Z

Filip Tomek: /* Vlastnosti algoritmu Merge Sort */

[[Kategória:Algoritmy triedenia]]
{{Draft}}
{{Skripta programovanie}}
__TOC__
==TODO: Pseudokód treba opraviť, text refaktorovať, otestovať kódy, zvýrazniť veci v texte, opraviť preklepy, opraviť popis obrázkov, pridať nové odkazy==

==Zlučovací algoritmus Merge==
[[Súbor:Funkcia merge.png|500px|náhľad|vpravo|Vizualizácia funkcie Merge: Máme pole prvkov ''p = [1, 3, 5, 2, 4, 6]'', ktoré je už čiastočne utriedené. Použijeme algoritmus Merge, ktorý si vytvorí pomocné polia ''L = [1, 3, 5]'' a ''P = [2, 4, 6]''. Všetky polia indexujeme od ''0'', pričom pre pole ''p'' používame index ''k'', pre ''L'' index ''i'' a pre ''P'' index ''j''. Postupnosť krokov je označená číslicami 1 až 6.
]]

Princíp zlučovania tkvie v tom, že máme dva alebo viac utriedených zoznamov, ktoré skombinuje do jedného utriedeného zoznamu (výsledný zoznam musí obsahovať všetky prvky z pôvodných zoznamov). Zoznam môže byť reprezentovaný ako dátová štruktúra pole alebo aj ako lineárny zoznam. V tomto článku sa zameriame na algoritmus pre dátovú štruktúru pole.

Algoritmus Merge tvorí kľúčovú časť triediaceho algoritmu MergeSort.

===Slovný opis algoritmu===
Nech máme pole, ktoré sa skladá z dvoch už utriedených polovíc. Vytvoríme si dve pomocné polia ''L'' a ''P'' a do každého z nich skopírujeme obsah jednej polovice (''L'' - ľavá polovica, ''P'' - pravá polovica). Potom súčasne prechádzame polia ''L'' a ''P'' od začiatku po koniec, pričom v každom cykle porovnáme prvok poľa ''L'' s prvkom v poli ''P''. Z tejto dvojice následne vyberieme minimum, (keď triedime od najmenšieho po najväčší) ktoré vložíme na prvú voľnú pozíciu pôvodného poľa (na začiatku je to prvá pozícia poľa). Nakoniec zvýšime index pri vstupnom poli a pri pomocnom poli, z ktorého vyberáme daný prvok. Túto postupnosť krokov opakujeme, pokiaľ neprídeme na koniec jedného z polí ''P'' a ''L''. Ak nastane situácia, že prídeme na koniec jedného z pomocných polí (a v druhom nám ostali ešte nejaké prvky), potom už iba naspäť skopírujeme zbytok druhého pomocného poľa na koniec pôvodného poľa.

===Vlastnosti algoritmu===
* vhodný pre dátové štruktúry: pole, lineárny zoznam
* časová náročnosť: vždy lineárna <math>O(n)</math>
* priestorová náročnosť: lineárna <math>O(n)</math> pre pole (alokovanie pomocných polí), <math>O(1)</math> pre lineárny zoznam (pri lineárnom zozname netreba alokovať dočasné polia, stačí iba presmerovať smerníky)
* využitie: kľúčový podprogram pre triediaci algoritmus MergeSort

===Pseudokód===
Nech funkcia Merge má nasledovný prototyp: <code>Merge(pole[], lavy, stred, pravy)</code>
:1. Je <code>lavy >= pravy ? Ak áno, skonči, inak pokračuj krokom 2.</code>
:2. Nech: <code>i = 0, j = 0, k = lavy </code>
:3. Nech: <code>dlzka_L = stred - lavy + 1, dlzka_P = pravy - stred</code>
:4. Nech: <code> L = pole[lavy ... stred], P = pole[stred + 1 ... pravy] </code>
:5. Je <code>i < dlzka_L</code> a zároveň <code>j < dlzka_P</code> ? Ak áno, pokračuj krokom 5.1., inak skoč na krok 6.
:::5.1. Je <code>L[i] <= P[j]</code>?
:::: Ak áno:
:::::5.1.1. <code>pole[k] = L[i]</code>
:::::5.1.2. <code>k += 1</code>
:::::5.1.3. <code>i += 1</code>
:::::5.1.4. Skoč na krok 5.
:::: Ak nie:
:::::5.1.1. <code>pole[k] = P[j]</code>
:::::5.1.2. <code>k += 1</code>
:::::5.1.3. <code>j += 1</code>
:::::5.1.4. Skoč na krok 5.
:6. Je <code>i < dlzka_L</code> ? Ak áno, pokračuj krokom 6.1., inak skoč na krok 7.
:::6.1. <code>pole[k] = L[i]</code>
:::6.2. <code>k += 1</code>
:::6.3. <code>i += 1</code>
:::6.4. Skoč na krok 6.
:7. Je <code>j < dlzka_P</code> ? Ak áno, pokračuj krokom 7.1., inak skonči.
:::7.1. <code>pole[k] = P[j]</code>
:::7.2. <code>k += 1</code>
:::7.3. <code>j += 1</code>
:::7.4. Skoč na krok 7.

==Merge sort==
Merge Sort je triediaci algoritmus, ktorý využíva stratégiu '''"rozdeľuj a panuj"''', čo znamená, že vstupný zoznam najskôr rozdelí na dve polovice, tie zoradí a potom ich zlúči naspäť dokopy. Radí sa medzi najpoužívanejšie a najviac rešpektované triediace algoritmy.

===Vlastnosti algoritmu Merge Sort===
* vhodný pre dátové štruktúry: pole, lineárny zoznam
* časová náročnosť: vždy linearitmická <math> O(n.log(n)) </math>, vďaka ktorej dokáže efektívne triediť veľmi veľké zoznamy
* priestorová náročnosť: lineárna <math>O(n)</math> pre pole (alokovanie dočasných polí), konštantná <math>O(1)</math> pre lineárny zoznam (pri lineárnom zozname stačí iba presmerovať smerníky)
* druh triedenia: triedenie zlučovaním (komparačný algoritmus)
* stabilita triedenia: stabilný
* miesto triedenia: externé triedenie (vhodný na triedenie veľkých objemov dát uložených na disku)

Z hľadiska implementácie môžeme vytvoriť dve základné verzie algoritmu, a to rekurzívnu a iteračnú.

===Opis rekurzívnej a iteračnej verzie algoritmu Merge Sort===

<tabs>
<tab name="Rekurzívna verzia" block>
[[Súbor:Merge sort.png|400px|náhľad|vpravo|Vizualizácia rekurzívnej verzie algoritmu MergeSort]]

===Princíp algoritmu===
Algoritmus MergeSort vykonáva 4 základné úlohy:
# Delenie poľa na dve polovice.
# Triedenie ľavej polovice poľa.
# Triedenie pravej polovice poľa.
# Zlúčenie oboch polovíc pomocou funkcie Merge.

===Slovný opis===
Našou úlohou je vzostupne (min - max) utriediť vstupné pole. Určíme si stred poľa (pri párnom počte prvkov je to ten menší z prostredných indexov). Následne vykonávame sériu rekurzívnych delení pre ľavú a pravú časť poľa (začiatok ... stred ; stred + 1 ... koniec) až do momentu, keď nám ostanú len jednoprvkové podpolia (tie sú už utriedené). Následne v každom volaní obe tieto podpolia zlúčime pomocou algoritmu Merge do väčších podpolí (2, 4, 8, ...), až nakoniec dostaneme jedno výsledné utriedené pole.

===Pseudokód===
Nech nech má funkcia MergeSort nasledovný prototyp: <code>MergeSort(pole[], lavy, pravy) </code>
:1. Je <code>lavy >= pravy</code> ? Ak áno, skonči volanie, inak pokračuj krokom 2.
:2. Nech: <code>stred = lavy + (pravy - lavy) / 2</code>, pričom znak ''/'' vyjadruje celočíselné delenie.
:3. Rekurzívne zavolaj funkciu <code>MergeSort(pole[], lavy , stred)</code>
:3. Rekurzívne zavolaj funkciu <code>MergeSort(pole[], stred + 1 , pravy)</code>
:4. Zavolaj funkciu <code>Merge(pole[], lavy, stred, pravy)</code>
:5. Skonči volanie.

</tab>
<tab name="Iteračná verzia" block>
[[Súbor:MergeSort IT.png|400px|náhľad|vpravo]]

===Princíp algoritmu===
Algoritmus Merge vykonáva 3 základné úlohy:
# Vonkajší cyklus: určenie veľkosti zoznamu na zlučovanie.
# Vnútorný cyklus: prechádzanie jednotlivých zoznamov v poli.
# Zlučovanie jednotlivých zoznamov pomocou funkcie Merge.

===Slovný opis===
Vstupné pole, ktoré má ''N'' prvkov, môžeme chápať, ako ''N'' rôznych jednoprvkových (utriedených) podpolí, ktoré máme zlúčiť do jedného výsledného ''N''-prvkového utriedeného poľa. Keďže by bolo veľmi nepraktické zlučovať ''N'' podpolí naraz, zvolíme nasledovnú stratégiu: Budeme prechádzať dané pole od začiatku po koniec a v prvom cykle zlúčime každé dva prvky, takže budeme mať <math>\frac{n}{2}</math> dvojprvkových utriedených podpolí. Potom v druhom cykle zlúčime každé 4 prvky do jedného podpoľa, v treťom cykle každých 8, až do momentu, keď dostaneme jedno utriedené pole.
Aby sme to docielili, potrebujeme dva cykly, vonkajší, ktorý nastaví maximálnu veľkosť podpoľa, ktoré ideme zlučovať (1,2,4,8 ... dlzka - 1) a vnútorný, ktorý prechádza jednotlivé podpolia. Následne už iba voláme funkciu Merge, ktorá dané podpolia zlučuje.

Poznámka, ak máme pole, ktoré má nepárny počet prvkov, tak ten posledný prvok nezlúčime hneď v prvom cykle, ale až v tých ďalších. Takisto, ak n nie je mocnina čísla 2, tak musíme samozrejme ošetriť situáciu, kedy by sme sa dostali mimo rozsah poľa (Ak máme napríklad pole, čo má 7 prvkov, tak po prvej iterácii budú prvky utiredené podľa vzoru 2 + 2 + 2 + 1, po druhej 4 + 3, a po tretej 7)

===Pseudokód===
Nech nech má funkcia MergeSort nasledovný prototyp: <code>MergeSort(pole[], lavy, pravy) </code>
:1. Je <code>lavy >= pravy</code> ? Ak áno, skonči, inak pokračuj krokom 2.
:2. Nech: <code>dlzka_subzoznamu = 1 </code>
:3. Nech: <code>zaciatok = lavy</code>
:4. Je<code>dlzka_subzoznamu <= pravy</code> ? Ak áno pokračuj krokom 4.1, inak skonči.
:::4.1. Je<code>zaciatok < pravy</code> Ak áno pokračuj krokom 4.1.1, inak skoč na krok 4.2.
:::::4.1.1. Je <code>zaciatok + 2 * dlzka_zoznamu - 1 <= pravy</code> ?
:::::::Ak áno:
:::::::::4.1.1.1. Nech <code>koniec = zaciatok + 2 * dlzka_zoznamu - 1</code>
:::::::Ak nie:
:::::::::4.1.1.1. Nech <code>koniec = pravy</code>
:::::4.1.2. Je <code>zaciatok + dlzka_zoznamu - 1 <= pravy</code> ?
:::::::Ak áno:
:::::::::4.1.2.1. Nech <code>stred = zaciatok + dlzka_zoznamu - 1</code>
:::::::Ak nie:
:::::::::4.1.2.1. Nech <code>stred = pravy</code>
:::::4.1.3. <code>Merge(pole[], zaciatok, stred, koniec)</code>
:::::4.1.4. <code>zaciatok += 2 * dlzka_subzoznamu</code>
:::::4.1.5. Skoč na krok 4.1.
:::4.2. <code>dlzka_subzoznamu *= 2</code>
:::4.3 Skoč na krok 4.

</tab>
</tabs>

==Implementácia algoritmov Merge a MergeSort v rôznych programovacích jazykoch==
<tabs>
<tab name="Rekurzívna: C " block>
<syntaxhighlight lang="C">
#include <stdio.h>
#include <stdlib.h>

void Merge(int pole[], int lavy, int stred, int pravy);
void MergeSort(int pole[], int lavy, int pravy);

/* hlavný program */

int main()
{
int pole[] = {12, 11, 13, 5, 6, 7};
int dlzka_pola = sizeof(pole) / sizeof(pole[0]);

printf("Pôvodné pole: \n");

for (int i = 0; i < dlzka_pola; ++i)
{
printf("%d ", pole[i]);
}

MergeSort(pole, 0, dlzka_pola - 1);

printf("\nUtriedené pole: \n");

for (int i = 0; i < dlzka_pola; ++i)
{
printf("%d ", pole[i]);
}

return 0;
}

void Merge(int pole[], int lavy, int stred, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči */

if (lavy >= pravy)
{
return;
}

/* vyrátaj dĺžky oboch polovíc poľa */

int L_dlzka = stred - lavy + 1;
int P_dlzka = pravy - stred;

/* alokuj dočasné polia, kam uložíš prvky z oboch polovíc poľa */

int *L = (int*)malloc(L_dlzka * sizeof(int));
int *P = (int*)malloc(P_dlzka * sizeof(int));

/* indexy, ktorými iterujeme všetky polia: i pre L, j pre P, k pre pole */

int i, j, k;

/* skopíruj obsah oboch polovíc poľa do dočasných polí L a P */

for (i = 0; i < L_dlzka; ++i)
{
L[i] = pole[lavy + i];
}

for (j = 0; j < P_dlzka; ++j)
{
P[j] = pole[stred + 1 + j];
}

/* nastav indexy na začiatok daných polí */

i = 0; j = 0; k = lavy;

/* zlučuj dočasné polia L a P do finálneho poľa pole */

while(i < L_dlzka && j < P_dlzka)
{
if(L[i] <= P[j])
{
pole[k++] = L[i++];
}
else
{
pole[k++] = P[j++];
}
}

/* ak ostali nejaké prvky v dočasnom poli L, skopíruj ich do finálneho poľa */

while(i < L_dlzka)
{
pole[k++] = L[i++];
}

/* ak ostali nejaké prvky v dočasnom poli P, skopíruj ich do finálneho poľa */

while(j < P_dlzka)
{
pole[k++] = P[j++];
}

/* uvoľni použitú pamäť */

free(L);
free(P);
}

void MergeSort(int pole[], int lavy, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči volanie */

if(lavy >= pravy)
{
return;
}
/* urči si prostredný index */

int stred = lavy + (pravy - lavy) / 2;

/* utrieď ľavú polovicu poľa */

MergeSort(pole, lavy, stred);

/* utrieď pravú polovicu poľa */

MergeSort(pole, stred+1, pravy);

/* zlúč obe polovice dokopy */

Merge(pole, lavy, stred, pravy);
}
</syntaxhighlight>
</tab>

<tab name="Iteračná: C" block>
<syntaxhighlight lang="C">
#include <stdio.h>
#include <stdlib.h>

void Merge(int pole[], int lavy, int stred, int pravy);
void MergeSortIt(int *pole, int lavy, int pravy);

/* hlavný program */

int main()
{
int pole[] = {12, 11, 13, 5, 6, 7, 19};
int dlzka_pola = sizeof(pole) / sizeof(pole[0]);

printf("Pôvodné pole %d: \n", dlzka_pola);

for (int i = 0; i < dlzka_pola; ++i)
{
printf("%d ", pole[i]);
}

MergeSortIt(pole, 0, dlzka_pola - 1);

printf("\nUtriedené pole: \n");

for (int i = 0; i < dlzka_pola; ++i)
{
printf("%d ", pole[i]);
}

return 0;
}

void Merge(int pole[], int lavy, int stred, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči */

if (lavy >= pravy)
{
return;
}

/* vyrátaj dĺžky oboch polovíc poľa */

int L_dlzka = stred - lavy + 1;
int P_dlzka = pravy - stred;

/* alokuj dočasné polia, kam uložíš prvky z oboch polovíc poľa */

int *L = (int*)malloc(L_dlzka * sizeof(int));
int *P = (int*)malloc(P_dlzka * sizeof(int));

/* indexy, ktorými iterujeme všetky polia: i pre L, j pre P, k pre pole */

int i, j, k;

/* skopíruj obsah oboch polovíc poľa do dočasných polí L a P */

for (i = 0; i < L_dlzka; ++i)
{
L[i] = pole[lavy + i];
}

for (j = 0; j < P_dlzka; ++j)
{
P[j] = pole[stred + 1 + j];
}

/* nastav indexy na začiatok daných polí */

i = 0; j = 0; k = lavy;

/* zlučuj dočasné polia L a P do finálneho poľa pole */

while(i < L_dlzka && j < P_dlzka)
{
if(L[i] <= P[j])
{
pole[k++] = L[i++];
}
else
{
pole[k++] = P[j++];
}
}

/* ak ostali nejaké prvky v dočasnom poli L, skopíruj ich do finálneho poľa */

while(i < L_dlzka)
{
pole[k++] = L[i++];
}

/* ak ostali nejaké prvky v dočasnom poli P, skopíruj ich do finálneho poľa */

while(j < P_dlzka)
{
pole[k++] = P[j++];
}

/* uvoľni použitú pamäť */

free(L);
free(P);
}

void MergeSortIt(int *pole, int lavy, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči volanie */

if(lavy >= pravy)
{
return;
}

int stred, koniec;

for (int dlzka_zoznamu = 1; dlzka_zoznamu <= pravy ; dlzka_zoznamu *= 2)
{
for (int zaciatok = lavy; zaciatok < pravy ; zaciatok += 2 * dlzka_zoznamu)
{
koniec = (zaciatok + 2 * dlzka_zoznamu - 1 <= pravy) ? zaciatok + 2 * dlzka_zoznamu - 1 : pravy;

stred = (zaciatok + dlzka_zoznamu - 1 <= pravy) ? zaciatok + dlzka_zoznamu - 1 : pravy;

Merge(pole, zaciatok, stred, koniec);

}
}
}

</syntaxhighlight>
</tab>

<tab name="Rekurzívna: C++" block>
<syntaxhighlight lang="C++">
#include <iostream>

using std::cout;
using std::endl;

void Merge(int pole[], int lavy, int stred, int pravy);
void MergeSort(int pole[], int lavy, int pravy);

/* hlavný program */

int main()
{
int pole[] = {12, 11, 13, 5, 6, 7};
int dlzka_pola = sizeof(pole) / sizeof(pole[0]);

printf("Pôvodné pole: \n");

for (auto i: pole)
{
cout<<i<<" ";
}

MergeSort(pole, 0, dlzka_pola - 1);

cout<<endl<<"Utriedené pole:"<<endl;

for (auto i: pole)
{
cout<<i<<" ";
}

return 0;
}

void Merge(int pole[], int lavy, int stred, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči */

if (lavy >= pravy)
{
return;
}

/* vyrátaj dĺžky oboch polovíc poľa */

int L_dlzka = stred - lavy + 1;
int P_dlzka = pravy - stred;

/* alokuj dočasné polia, kam uložíš prvky z oboch polovíc poľa */

int *L = new int[L_dlzka];
int *P = new int[P_dlzka];

/* indexy, ktorými iterujeme všetky polia: i pre L, j pre P, k pre pole */

int i, j, k;

/* skopíruj obsah oboch polovíc poľa do dočasných polí L a P */

for (i = 0; i < L_dlzka; ++i)
{
L[i] = pole[lavy + i];
}

for (j = 0; j < P_dlzka; ++j)
{
P[j] = pole[stred + 1 + j];
}

/* nastav indexy na začiatok daných polí */

i = 0; j = 0; k = lavy;

/* zlučuj dočasné polia L a P do finálneho poľa pole */

while(i < L_dlzka && j < P_dlzka)
{
if(L[i] <= P[j])
{
pole[k++] = L[i++];
}
else
{
pole[k++] = P[j++];
}
}

/* ak ostali nejaké prvky v dočasnom poli L, skopíruj ich do finálneho poľa */

while(i < L_dlzka)
{
pole[k++] = L[i++];
}

/* ak ostali nejaké prvky v dočasnom poli P, skopíruj ich do finálneho poľa */

while(j < P_dlzka)
{
pole[k++] = P[j++];
}

/* uvoľni použitú pamäť */

delete []L;
delete []P;
}

void MergeSort(int pole[], int lavy, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči volanie */

if(lavy >= pravy)
{
return;
}
/* urči si prostredný index */

int stred = lavy + (pravy - lavy) / 2;

/* utrieď ľavú polovicu poľa */

MergeSort(pole, lavy, stred);

/* utrieď pravú polovicu poľa */

MergeSort(pole, stred+1, pravy);

/* zlúč obe polovice dokopy */

Merge(pole, lavy, stred, pravy);
}

</syntaxhighlight>
</tab>

<tab name="Iteračná: C++" block>
<syntaxhighlight lang="C++">
#include <iostream>

using std::cout;
using std::endl;

void Merge(int pole[], int lavy, int stred, int pravy);
void MergeSort(int pole[], int lavy, int pravy);

/* hlavný program */

int main()
{
int pole[] = {12, 11, 13, 5, 6, 7};
int dlzka_pola = sizeof(pole) / sizeof(pole[0]);

printf("Pôvodné pole: \n");

for (auto i: pole)
{
cout<<i<<" ";
}

MergeSort(pole, 0, dlzka_pola - 1);

cout<<endl<<"Utriedené pole:"<<endl;

for (auto i: pole)
{
cout<<i<<" ";
}

return 0;
}

void Merge(int pole[], int lavy, int stred, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči */

if (lavy >= pravy)
{
return;
}

/* vyrátaj dĺžky oboch polovíc poľa */

int L_dlzka = stred - lavy + 1;
int P_dlzka = pravy - stred;

/* alokuj dočasné polia, kam uložíš prvky z oboch polovíc poľa */

int *L = new int[L_dlzka];
int *P = new int[P_dlzka];

/* indexy, ktorými iterujeme všetky polia: i pre L, j pre P, k pre pole */

int i, j, k;

/* skopíruj obsah oboch polovíc poľa do dočasných polí L a P */

for (i = 0; i < L_dlzka; ++i)
{
L[i] = pole[lavy + i];
}

for (j = 0; j < P_dlzka; ++j)
{
P[j] = pole[stred + 1 + j];
}

/* nastav indexy na začiatok daných polí */

i = 0; j = 0; k = lavy;

/* zlučuj dočasné polia L a P do finálneho poľa pole */

while(i < L_dlzka && j < P_dlzka)
{
if(L[i] <= P[j])
{
pole[k++] = L[i++];
}
else
{
pole[k++] = P[j++];
}
}

/* ak ostali nejaké prvky v dočasnom poli L, skopíruj ich do finálneho poľa */

while(i < L_dlzka)
{
pole[k++] = L[i++];
}

/* ak ostali nejaké prvky v dočasnom poli P, skopíruj ich do finálneho poľa */

while(j < P_dlzka)
{
pole[k++] = P[j++];
}

/* uvoľni použitú pamäť */

delete []L;
delete []P;
}

void MergeSort(int *pole, int lavy, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči volanie */

if(lavy >= pravy)
{
return;
}

int stred, koniec;

for (int dlzka_zoznamu = 1; dlzka_zoznamu <= pravy; dlzka_zoznamu *= 2)
{
for (int zaciatok = lavy; zaciatok < pravy; zaciatok += 2 * dlzka_zoznamu)
{
koniec = (zaciatok + 2 * dlzka_zoznamu - 1 <= pravy) ? zaciatok + 2 * dlzka_zoznamu - 1 : pravy;

stred = (zaciatok + dlzka_zoznamu - 1 <= pravy) ? zaciatok + dlzka_zoznamu - 1 : pravy;

Merge(pole, zaciatok, stred, koniec);
}
}
}
</syntaxhighlight>
</tab>

<tab name="Rekurzívna: Java" block>
<syntaxhighlight lang="Java">
class MergeSort
{

/* Funkcia zlúči 2 podpolia, ktoré sme vytvorili z pôvodného poľa.
* Každé podpole má polovičnú dĺžku pôvodného poľa.
* subpole1 [ľavý ... stred]
* subpole2 [stred + 1 ... pravý] */

void merge(int[] pole, int lavy, int stred, int pravy)
{

// Výpočet dĺžky 2 podpolí

int n1 = stred - lavy + 1;
int n2 = pravy - stred;

// Vytvorenie pomocných polí

int[] L = new int[n1];
int[] P = new int[n2];

// Načítanie dát do pomocných polí

for (int i = 0; i < n1; i++)
L[i] = pole[lavy + i];

for (int j = 0; j < n2; j++)
P[j] = pole[stred + 1 + j];

// Počiatočné indexy prvého a druhého podpoľa

int i = 0, j = 0;

// Počiatočný index zlúčeného podpoľa

int k = lavy;

// Zlúčenie dvoch podpolí

while (i < n1 && j < n2)
{
if (L[i] <= P[j])
{
pole[k] = L[i];
i++;
}
else
{
pole[k] = P[j];
j++;
}
k++;
}

/* V prípade, že sa v jednom zo podpoli nachádzajú ešte nejaké prvky, ktoré neboli zlúčené do pola,
* tak sa do pola jednoducho skopírujú */

while (i < n1)
{
pole[k] = L[i];
i++;
k++;
}

while (j < n2)
{
pole[k] = P[j];
k++;
j++;
}

}

/* Funkcia, ktorá zoradí pole použitím funkcie merge() */

void sort (int[] pole, int lavy, int pravy)
{
if (lavy < pravy)
{
// Musíme nájsť stred pola

int stred = lavy + (pravy - lavy) / 2;

// Zoradíme prvú a druhú polovicu pola samostatne

sort(pole, lavy, stred);
sort(pole, stred + 1, pravy);

// Zlúčime zoradené polovice do jedného pola

merge(pole, lavy, stred, pravy);
}
}
}

public class Main
{
/* Funkcia na výpis pola dĺžky n */

static void vypis_pole(int[] pole)
{

for (int j : pole)
{
System.out.print(j + " ");
}

System.out.println();
}

/* Hlavný program */

public static void main(String[] args)
{
int[] pole = {12, 11, 13, 5, 6, 7};

System.out.println("Zadané pole:");
vypis_pole(pole);

MergeSort ms = new MergeSort();
ms.sort(pole, 0, pole.length - 1);

System.out.println("\nZoradené pole:");
vypis_pole(pole);
}
}
</syntaxhighlight>
</tab>

<tab name="Iteračná: Java" block>
<syntaxhighlight lang="Java">
class MergeSort_iteracia {
/* Zlúči 2 subpolia, ktoré sa vytvorili z pôvodného pola.
* Každé subpole má polovičnú dĺžku pôvodného pola.
* subpole1 [ľavý..stred]
* subpole2 [stred+1..pravý] */
void merge(int[] pole, int lavy, int stred, int pravy) {
// Výpočet dĺžky 2 subpolí
int n1 = stred - lavy + 1;
int n2 = pravy - stred;

// Vytvorenie pomocných polí
int[] L = new int[n1];
int[] P = new int[n2];

// Načítanie dát do pomocných polí
for (int i = 0; i < n1; i++)
L[i] = pole[lavy + i];

for (int j = 0; j < n2; j++)
P[j] = pole[stred + 1 + j];

// Počiatočné indexy prvého a druhého subpola
int i = 0, j = 0;
// Počiatočný index zlúčeného subpola
int k = lavy;

// Zlúčenie dvoch podpolí
while (i < n1 && j < n2) {
if (L[i] <= P[j]) {
pole[k] = L[i];
i++;
}
else {
pole[k] = P[j];
j++;
}
k++;
}

/* V prípade, že v jednom zo subpolí sa nachádzajú prvky, ktoré neboli zlúčené do pola,
* tak sa do pola jednoducho skopírujú */
while (i < n1) {
pole[k] = L[i];
i++;
k++;
}

while (j < n2) {
pole[k] = P[j];
k++;
j++;
}
}

/* Funkcia, ktorá zoradí pole použitím funkcie merge() */
void sort (int[] pole, int n) {
/* Dĺžka subpolí, ktoré majú byť zlúčené, hodnoty premennej sa pohybujú v intervale <1;n-1> */
int aktual_dlzka;
/* Začiatočný index ľavého subpola, ktoré má byť zlúčené */
int zaciatok_vlavo;

/* Vzostupné usporiadanie prvkov. Najskôr sa zlúčia subpolia veľkosti 1 do subpolí veľkosti 2,
* potom subpolia veľkosti 2 do subpolí veľkosti 4 a tak ďalej */
for (aktual_dlzka = 1; aktual_dlzka <= n - 1; aktual_dlzka *= 2) {
/* Určenie začiatočného prvku rôznych subpolí aktuálnej dĺžky subpola */
for (zaciatok_vlavo = 0; zaciatok_vlavo < n - 1; zaciatok_vlavo += 2 * aktual_dlzka) {
/* Nájdenie konečného prvku ľavého subpola, stred+1 je začiatočný prvok pravého subpola */
int stred = Math.min(zaciatok_vlavo + aktual_dlzka - 1, n - 1);
int koniec_vpravo = Math.min(zaciatok_vlavo + 2 * aktual_dlzka - 1, n - 1);

/* Zlúči subpolia L[zaciatok_vlavo .. stred] & P[stred+1 .. koniec_vpravo] */
merge(pole, zaciatok_vlavo, stred, koniec_vpravo);
}
}
}
}

public class Main {
/* Funkcia na výpis pola dĺžky n */
static void vypis_pole(int[] pole) {
int n = pole.length;

for (int j : pole) {
System.out.print(j + " ");
}
System.out.println();
}

/* Hlavný program */
public static void main(String[] args) {

/* Inicializácia pola */
int[] pole = {12, 11, 13, 5, 6, 7};

System.out.println("Zadané pole:");
vypis_pole(pole);

MergeSort_iteracia ms_it = new MergeSort_iteracia();
ms_it.sort(pole, pole.length);

System.out.println("Zoradené pole:");
vypis_pole(pole);
}
}
</syntaxhighlight>
</tab>

<tab name="Rekurzívna: Python3" block>
<syntaxhighlight lang="Python3">
def MergeSort(pole):
if len(pole) > 1:
# Nájdenie stredu pola
# zápis len(pole)//2 znamená, že dĺžka pola sa vydelí 2 a výsledok je celé číslo
stred = len(pole) // 2

# Rozdelenie pola na dve časti
L = pole[:stred]
P = pole[stred:]

# Zoradenie najskôr prvej časti pola, potom druhej
MergeSort(L)
MergeSort(P)

i = j = k = 0

# Zlúčenie a zoradenie údajov z pomocných polí do jedného pola
while i < len(L) and j < len(P):
if L[i] < P[j]:
pole[k] = L[i]
i += 1
else:
pole[k] = P[j]
j += 1
k += 1

# Kontrola či všetky prvky boli zlúčené dokopy,
# ak nie, tak sa do zlúčeného pola jednoducho skopírujú
while i < len(L):
pole[k] = L[i]
i += 1
k += 1

while j < len(P):
pole[k] = P[j]
j += 1
k += 1

# Hlavný program
if __name__ == '__main__':
pole = [12, 11, 13, 5, 6, 7]

print("Zadané pole:", end="\n")
print(pole, end="\n")

MergeSort(pole)

print("Zoradené pole:", end="\n")
print(pole, end="\n")

</syntaxhighlight>
</tab>

<tab name="Iteračná: Python3" block>
<syntaxhighlight lang="Python3">
def MergeSort_iteracia(pole):
# Dĺžka subpolí, ktoré majú byť zlúčené, hodnoty premennej sa pohybujú v intervale <1;n-1>
aktual_dlzka = 1

# Vonkajší cyklus, ktorý určuje subpolia aktuálnej dĺžky
while aktual_dlzka < len(pole) - 1:
lavy = 0

# Vnútorný cyklus, ktorý slúži na zlúčenie a zoradenie subpoli do jedného subpola
while lavy < len(pole) - 1:
# Index stredného prvku sa určí, keď k indexu ľavého prvku subpola pripočítame aktuálnu
# dĺžku subpolí a odčítame 1
stred = min((lavy + aktual_dlzka - 1), len(pole) - 1)

# Ak platí podmienka 2 * aktuálna dĺžka < dĺžka pola - 1, tak pravý index = aktuálnej dĺžke subpolí,
# inak pravý index = dĺžke pola - 1
pravy = ((2 * aktual_dlzka + lavy - 1, len(pole) - 1)[2 * aktual_dlzka + lavy - 1 > len(pole) - 1])

# Volanie funkcie merge
merge(pole, lavy, stred, pravy)

lavy = lavy + 2 * aktual_dlzka

# Aktuálna dĺžka sa sa zmení na dvojnásobok jej predošlej hodnoty
aktual_dlzka = 2 * aktual_dlzka

def merge(pole, lavy, stred, pravy):
n1 = stred - lavy + 1
n2 = pravy - stred

# Inicializácia pomocných polí
L = [0] * n1
P = [0] * n2

# Načítanie dát do pomocných polí
for i in range(0, n1):
L[i] = pole[lavy + i]
for i in range(0, n2):
P[i] = pole[stred + i + 1]

i, j, k = 0, 0, lavy

# Zlúčenie a zoradenie údajov z pomocných polí do jedného pola
while i < n1 and j < n2:
if L[i] > P[j]:
pole[k] = P[j]
j += 1
else:
pole[k] = L[i]
i += 1
k += 1

# Kontrola či všetky prvky boli zlúčené dokopy,
# ak nie, tak sa do zlúčeného pola jednoducho skopírujú
while i < n1:
pole[k] = L[i]
i += 1
k += 1

while j < n2:
pole[k] = P[j]
j += 1
k += 1

# Hlavný program
if __name__ == '__main__':
pole = [12, 11, 13, 5, 6, 7]

print("Zadané pole:", end="\n")
print(pole, end="\n")

MergeSort_iteracia(pole)

print("Zoradené pole:", end="\n")
print(pole, end="\n")

</syntaxhighlight>
</tab>

</tabs>

==Odkazy==
# https://www.geeksforgeeks.org/merge-sort/
# https://www.geeksforgeeks.org/iterative-merge-sort/
# https://medium.com/@paulsoham/merge-sort-63d75df76388
# https://www.khanacademy.org/computing/computer-science/algorithms/merge-sort/a/overview-of-merge-sort
# https://www.tutorialspoint.com/data_structures_algorithms/merge_sort_algorithm.htm
# https://www.youtube.com/watch?v=6pV2IF0fgKY
# https://www.youtube.com/watch?v=mB5HXBb_HY8
# https://www.youtube.com/watch?v=ak-pz7tS5DE

Triedenie zlučovaním

2021-03-29T11:17:30Z

Filip Tomek: /* Vlastnosti algoritmu */

[[Kategória:Algoritmy triedenia]]
{{Draft}}
{{Skripta programovanie}}
__TOC__
==TODO: Pseudokód treba opraviť, text refaktorovať, otestovať kódy, zvýrazniť veci v texte, opraviť preklepy, opraviť popis obrázkov, pridať nové odkazy==

==Zlučovací algoritmus Merge==
[[Súbor:Funkcia merge.png|500px|náhľad|vpravo|Vizualizácia funkcie Merge: Máme pole prvkov ''p = [1, 3, 5, 2, 4, 6]'', ktoré je už čiastočne utriedené. Použijeme algoritmus Merge, ktorý si vytvorí pomocné polia ''L = [1, 3, 5]'' a ''P = [2, 4, 6]''. Všetky polia indexujeme od ''0'', pričom pre pole ''p'' používame index ''k'', pre ''L'' index ''i'' a pre ''P'' index ''j''. Postupnosť krokov je označená číslicami 1 až 6.
]]

Princíp zlučovania tkvie v tom, že máme dva alebo viac utriedených zoznamov, ktoré skombinuje do jedného utriedeného zoznamu (výsledný zoznam musí obsahovať všetky prvky z pôvodných zoznamov). Zoznam môže byť reprezentovaný ako dátová štruktúra pole alebo aj ako lineárny zoznam. V tomto článku sa zameriame na algoritmus pre dátovú štruktúru pole.

Algoritmus Merge tvorí kľúčovú časť triediaceho algoritmu MergeSort.

===Slovný opis algoritmu===
Nech máme pole, ktoré sa skladá z dvoch už utriedených polovíc. Vytvoríme si dve pomocné polia ''L'' a ''P'' a do každého z nich skopírujeme obsah jednej polovice (''L'' - ľavá polovica, ''P'' - pravá polovica). Potom súčasne prechádzame polia ''L'' a ''P'' od začiatku po koniec, pričom v každom cykle porovnáme prvok poľa ''L'' s prvkom v poli ''P''. Z tejto dvojice následne vyberieme minimum, (keď triedime od najmenšieho po najväčší) ktoré vložíme na prvú voľnú pozíciu pôvodného poľa (na začiatku je to prvá pozícia poľa). Nakoniec zvýšime index pri vstupnom poli a pri pomocnom poli, z ktorého vyberáme daný prvok. Túto postupnosť krokov opakujeme, pokiaľ neprídeme na koniec jedného z polí ''P'' a ''L''. Ak nastane situácia, že prídeme na koniec jedného z pomocných polí (a v druhom nám ostali ešte nejaké prvky), potom už iba naspäť skopírujeme zbytok druhého pomocného poľa na koniec pôvodného poľa.

===Vlastnosti algoritmu===
* vhodný pre dátové štruktúry: pole, lineárny zoznam
* časová náročnosť: vždy lineárna <math>O(n)</math>
* priestorová náročnosť: lineárna <math>O(n)</math> pre pole (alokovanie pomocných polí), <math>O(1)</math> pre lineárny zoznam (pri lineárnom zozname netreba alokovať dočasné polia, stačí iba presmerovať smerníky)
* využitie: kľúčový podprogram pre triediaci algoritmus MergeSort

===Pseudokód===
Nech funkcia Merge má nasledovný prototyp: <code>Merge(pole[], lavy, stred, pravy)</code>
:1. Je <code>lavy >= pravy ? Ak áno, skonči, inak pokračuj krokom 2.</code>
:2. Nech: <code>i = 0, j = 0, k = lavy </code>
:3. Nech: <code>dlzka_L = stred - lavy + 1, dlzka_P = pravy - stred</code>
:4. Nech: <code> L = pole[lavy ... stred], P = pole[stred + 1 ... pravy] </code>
:5. Je <code>i < dlzka_L</code> a zároveň <code>j < dlzka_P</code> ? Ak áno, pokračuj krokom 5.1., inak skoč na krok 6.
:::5.1. Je <code>L[i] <= P[j]</code>?
:::: Ak áno:
:::::5.1.1. <code>pole[k] = L[i]</code>
:::::5.1.2. <code>k += 1</code>
:::::5.1.3. <code>i += 1</code>
:::::5.1.4. Skoč na krok 5.
:::: Ak nie:
:::::5.1.1. <code>pole[k] = P[j]</code>
:::::5.1.2. <code>k += 1</code>
:::::5.1.3. <code>j += 1</code>
:::::5.1.4. Skoč na krok 5.
:6. Je <code>i < dlzka_L</code> ? Ak áno, pokračuj krokom 6.1., inak skoč na krok 7.
:::6.1. <code>pole[k] = L[i]</code>
:::6.2. <code>k += 1</code>
:::6.3. <code>i += 1</code>
:::6.4. Skoč na krok 6.
:7. Je <code>j < dlzka_P</code> ? Ak áno, pokračuj krokom 7.1., inak skonči.
:::7.1. <code>pole[k] = P[j]</code>
:::7.2. <code>k += 1</code>
:::7.3. <code>j += 1</code>
:::7.4. Skoč na krok 7.

==Merge sort==
Merge Sort je triediaci algoritmus, ktorý využíva stratégiu '''"rozdeľuj a panuj"''', čo znamená, že vstupný zoznam najskôr rozdelí na dve polovice, tie zoradí a potom ich zlúči naspäť dokopy. Radí sa medzi najpoužívanejšie a najviac rešpektované triediace algoritmy.

===Vlastnosti algoritmu Merge Sort===
* vhodný pre dátové štruktúry: pole, lineárny zoznam
* časová náročnosť: vždy linearitmická <math> O(n.log(n)) </math>, vďaka ktorej dokáže efektívne triediť veľmi veľké zoznamy
* priestorová náročnosť: lineárna <math>O(n)</math> pre pole (alokovanie dočasných polí), konštantná <math>O(1)</math> pre lineárny zoznam (pri LZ stačí iba presmerovať smerníky)
* druh triedenia: triedenie zlučovaním (komparačný algoritmus)
* stabilita triedenia: stabilný
* miesto triedenia: externé triedenie (vhodný na triedenie veľkých objemov dát uložených na disku)

Z hľadiska implementácie môžeme vytvoriť dve základné verzie algoritmu, a to rekurzívnu a iteračnú.
===Opis rekurzívnej a iteračnej verzie algoritmu Merge Sort===

<tabs>
<tab name="Rekurzívna verzia" block>
[[Súbor:Merge sort.png|400px|náhľad|vpravo|Vizualizácia rekurzívnej verzie algoritmu MergeSort]]

===Princíp algoritmu===
Algoritmus MergeSort vykonáva 4 základné úlohy:
# Delenie poľa na dve polovice.
# Triedenie ľavej polovice poľa.
# Triedenie pravej polovice poľa.
# Zlúčenie oboch polovíc pomocou funkcie Merge.

===Slovný opis===
Našou úlohou je vzostupne (min - max) utriediť vstupné pole. Určíme si stred poľa (pri párnom počte prvkov je to ten menší z prostredných indexov). Následne vykonávame sériu rekurzívnych delení pre ľavú a pravú časť poľa (začiatok ... stred ; stred + 1 ... koniec) až do momentu, keď nám ostanú len jednoprvkové podpolia (tie sú už utriedené). Následne v každom volaní obe tieto podpolia zlúčime pomocou algoritmu Merge do väčších podpolí (2, 4, 8, ...), až nakoniec dostaneme jedno výsledné utriedené pole.

===Pseudokód===
Nech nech má funkcia MergeSort nasledovný prototyp: <code>MergeSort(pole[], lavy, pravy) </code>
:1. Je <code>lavy >= pravy</code> ? Ak áno, skonči volanie, inak pokračuj krokom 2.
:2. Nech: <code>stred = lavy + (pravy - lavy) / 2</code>, pričom znak ''/'' vyjadruje celočíselné delenie.
:3. Rekurzívne zavolaj funkciu <code>MergeSort(pole[], lavy , stred)</code>
:3. Rekurzívne zavolaj funkciu <code>MergeSort(pole[], stred + 1 , pravy)</code>
:4. Zavolaj funkciu <code>Merge(pole[], lavy, stred, pravy)</code>
:5. Skonči volanie.

</tab>
<tab name="Iteračná verzia" block>
[[Súbor:MergeSort IT.png|400px|náhľad|vpravo]]

===Princíp algoritmu===
Algoritmus Merge vykonáva 3 základné úlohy:
# Vonkajší cyklus: určenie veľkosti zoznamu na zlučovanie.
# Vnútorný cyklus: prechádzanie jednotlivých zoznamov v poli.
# Zlučovanie jednotlivých zoznamov pomocou funkcie Merge.

===Slovný opis===
Vstupné pole, ktoré má ''N'' prvkov, môžeme chápať, ako ''N'' rôznych jednoprvkových (utriedených) podpolí, ktoré máme zlúčiť do jedného výsledného ''N''-prvkového utriedeného poľa. Keďže by bolo veľmi nepraktické zlučovať ''N'' podpolí naraz, zvolíme nasledovnú stratégiu: Budeme prechádzať dané pole od začiatku po koniec a v prvom cykle zlúčime každé dva prvky, takže budeme mať <math>\frac{n}{2}</math> dvojprvkových utriedených podpolí. Potom v druhom cykle zlúčime každé 4 prvky do jedného podpoľa, v treťom cykle každých 8, až do momentu, keď dostaneme jedno utriedené pole.
Aby sme to docielili, potrebujeme dva cykly, vonkajší, ktorý nastaví maximálnu veľkosť podpoľa, ktoré ideme zlučovať (1,2,4,8 ... dlzka - 1) a vnútorný, ktorý prechádza jednotlivé podpolia. Následne už iba voláme funkciu Merge, ktorá dané podpolia zlučuje.

Poznámka, ak máme pole, ktoré má nepárny počet prvkov, tak ten posledný prvok nezlúčime hneď v prvom cykle, ale až v tých ďalších. Takisto, ak n nie je mocnina čísla 2, tak musíme samozrejme ošetriť situáciu, kedy by sme sa dostali mimo rozsah poľa (Ak máme napríklad pole, čo má 7 prvkov, tak po prvej iterácii budú prvky utiredené podľa vzoru 2 + 2 + 2 + 1, po druhej 4 + 3, a po tretej 7)

===Pseudokód===
Nech nech má funkcia MergeSort nasledovný prototyp: <code>MergeSort(pole[], lavy, pravy) </code>
:1. Je <code>lavy >= pravy</code> ? Ak áno, skonči, inak pokračuj krokom 2.
:2. Nech: <code>dlzka_subzoznamu = 1 </code>
:3. Nech: <code>zaciatok = lavy</code>
:4. Je<code>dlzka_subzoznamu <= pravy</code> ? Ak áno pokračuj krokom 4.1, inak skonči.
:::4.1. Je<code>zaciatok < pravy</code> Ak áno pokračuj krokom 4.1.1, inak skoč na krok 4.2.
:::::4.1.1. Je <code>zaciatok + 2 * dlzka_zoznamu - 1 <= pravy</code> ?
:::::::Ak áno:
:::::::::4.1.1.1. Nech <code>koniec = zaciatok + 2 * dlzka_zoznamu - 1</code>
:::::::Ak nie:
:::::::::4.1.1.1. Nech <code>koniec = pravy</code>
:::::4.1.2. Je <code>zaciatok + dlzka_zoznamu - 1 <= pravy</code> ?
:::::::Ak áno:
:::::::::4.1.2.1. Nech <code>stred = zaciatok + dlzka_zoznamu - 1</code>
:::::::Ak nie:
:::::::::4.1.2.1. Nech <code>stred = pravy</code>
:::::4.1.3. <code>Merge(pole[], zaciatok, stred, koniec)</code>
:::::4.1.4. <code>zaciatok += 2 * dlzka_subzoznamu</code>
:::::4.1.5. Skoč na krok 4.1.
:::4.2. <code>dlzka_subzoznamu *= 2</code>
:::4.3 Skoč na krok 4.

</tab>
</tabs>

==Implementácia algoritmov Merge a MergeSort v rôznych programovacích jazykoch==
<tabs>
<tab name="Rekurzívna: C " block>
<syntaxhighlight lang="C">
#include <stdio.h>
#include <stdlib.h>

void Merge(int pole[], int lavy, int stred, int pravy);
void MergeSort(int pole[], int lavy, int pravy);

/* hlavný program */

int main()
{
int pole[] = {12, 11, 13, 5, 6, 7};
int dlzka_pola = sizeof(pole) / sizeof(pole[0]);

printf("Pôvodné pole: \n");

for (int i = 0; i < dlzka_pola; ++i)
{
printf("%d ", pole[i]);
}

MergeSort(pole, 0, dlzka_pola - 1);

printf("\nUtriedené pole: \n");

for (int i = 0; i < dlzka_pola; ++i)
{
printf("%d ", pole[i]);
}

return 0;
}

void Merge(int pole[], int lavy, int stred, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči */

if (lavy >= pravy)
{
return;
}

/* vyrátaj dĺžky oboch polovíc poľa */

int L_dlzka = stred - lavy + 1;
int P_dlzka = pravy - stred;

/* alokuj dočasné polia, kam uložíš prvky z oboch polovíc poľa */

int *L = (int*)malloc(L_dlzka * sizeof(int));
int *P = (int*)malloc(P_dlzka * sizeof(int));

/* indexy, ktorými iterujeme všetky polia: i pre L, j pre P, k pre pole */

int i, j, k;

/* skopíruj obsah oboch polovíc poľa do dočasných polí L a P */

for (i = 0; i < L_dlzka; ++i)
{
L[i] = pole[lavy + i];
}

for (j = 0; j < P_dlzka; ++j)
{
P[j] = pole[stred + 1 + j];
}

/* nastav indexy na začiatok daných polí */

i = 0; j = 0; k = lavy;

/* zlučuj dočasné polia L a P do finálneho poľa pole */

while(i < L_dlzka && j < P_dlzka)
{
if(L[i] <= P[j])
{
pole[k++] = L[i++];
}
else
{
pole[k++] = P[j++];
}
}

/* ak ostali nejaké prvky v dočasnom poli L, skopíruj ich do finálneho poľa */

while(i < L_dlzka)
{
pole[k++] = L[i++];
}

/* ak ostali nejaké prvky v dočasnom poli P, skopíruj ich do finálneho poľa */

while(j < P_dlzka)
{
pole[k++] = P[j++];
}

/* uvoľni použitú pamäť */

free(L);
free(P);
}

void MergeSort(int pole[], int lavy, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči volanie */

if(lavy >= pravy)
{
return;
}
/* urči si prostredný index */

int stred = lavy + (pravy - lavy) / 2;

/* utrieď ľavú polovicu poľa */

MergeSort(pole, lavy, stred);

/* utrieď pravú polovicu poľa */

MergeSort(pole, stred+1, pravy);

/* zlúč obe polovice dokopy */

Merge(pole, lavy, stred, pravy);
}
</syntaxhighlight>
</tab>

<tab name="Iteračná: C" block>
<syntaxhighlight lang="C">
#include <stdio.h>
#include <stdlib.h>

void Merge(int pole[], int lavy, int stred, int pravy);
void MergeSortIt(int *pole, int lavy, int pravy);

/* hlavný program */

int main()
{
int pole[] = {12, 11, 13, 5, 6, 7, 19};
int dlzka_pola = sizeof(pole) / sizeof(pole[0]);

printf("Pôvodné pole %d: \n", dlzka_pola);

for (int i = 0; i < dlzka_pola; ++i)
{
printf("%d ", pole[i]);
}

MergeSortIt(pole, 0, dlzka_pola - 1);

printf("\nUtriedené pole: \n");

for (int i = 0; i < dlzka_pola; ++i)
{
printf("%d ", pole[i]);
}

return 0;
}

void Merge(int pole[], int lavy, int stred, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči */

if (lavy >= pravy)
{
return;
}

/* vyrátaj dĺžky oboch polovíc poľa */

int L_dlzka = stred - lavy + 1;
int P_dlzka = pravy - stred;

/* alokuj dočasné polia, kam uložíš prvky z oboch polovíc poľa */

int *L = (int*)malloc(L_dlzka * sizeof(int));
int *P = (int*)malloc(P_dlzka * sizeof(int));

/* indexy, ktorými iterujeme všetky polia: i pre L, j pre P, k pre pole */

int i, j, k;

/* skopíruj obsah oboch polovíc poľa do dočasných polí L a P */

for (i = 0; i < L_dlzka; ++i)
{
L[i] = pole[lavy + i];
}

for (j = 0; j < P_dlzka; ++j)
{
P[j] = pole[stred + 1 + j];
}

/* nastav indexy na začiatok daných polí */

i = 0; j = 0; k = lavy;

/* zlučuj dočasné polia L a P do finálneho poľa pole */

while(i < L_dlzka && j < P_dlzka)
{
if(L[i] <= P[j])
{
pole[k++] = L[i++];
}
else
{
pole[k++] = P[j++];
}
}

/* ak ostali nejaké prvky v dočasnom poli L, skopíruj ich do finálneho poľa */

while(i < L_dlzka)
{
pole[k++] = L[i++];
}

/* ak ostali nejaké prvky v dočasnom poli P, skopíruj ich do finálneho poľa */

while(j < P_dlzka)
{
pole[k++] = P[j++];
}

/* uvoľni použitú pamäť */

free(L);
free(P);
}

void MergeSortIt(int *pole, int lavy, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči volanie */

if(lavy >= pravy)
{
return;
}

int stred, koniec;

for (int dlzka_zoznamu = 1; dlzka_zoznamu <= pravy ; dlzka_zoznamu *= 2)
{
for (int zaciatok = lavy; zaciatok < pravy ; zaciatok += 2 * dlzka_zoznamu)
{
koniec = (zaciatok + 2 * dlzka_zoznamu - 1 <= pravy) ? zaciatok + 2 * dlzka_zoznamu - 1 : pravy;

stred = (zaciatok + dlzka_zoznamu - 1 <= pravy) ? zaciatok + dlzka_zoznamu - 1 : pravy;

Merge(pole, zaciatok, stred, koniec);

}
}
}

</syntaxhighlight>
</tab>

<tab name="Rekurzívna: C++" block>
<syntaxhighlight lang="C++">
#include <iostream>

using std::cout;
using std::endl;

void Merge(int pole[], int lavy, int stred, int pravy);
void MergeSort(int pole[], int lavy, int pravy);

/* hlavný program */

int main()
{
int pole[] = {12, 11, 13, 5, 6, 7};
int dlzka_pola = sizeof(pole) / sizeof(pole[0]);

printf("Pôvodné pole: \n");

for (auto i: pole)
{
cout<<i<<" ";
}

MergeSort(pole, 0, dlzka_pola - 1);

cout<<endl<<"Utriedené pole:"<<endl;

for (auto i: pole)
{
cout<<i<<" ";
}

return 0;
}

void Merge(int pole[], int lavy, int stred, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči */

if (lavy >= pravy)
{
return;
}

/* vyrátaj dĺžky oboch polovíc poľa */

int L_dlzka = stred - lavy + 1;
int P_dlzka = pravy - stred;

/* alokuj dočasné polia, kam uložíš prvky z oboch polovíc poľa */

int *L = new int[L_dlzka];
int *P = new int[P_dlzka];

/* indexy, ktorými iterujeme všetky polia: i pre L, j pre P, k pre pole */

int i, j, k;

/* skopíruj obsah oboch polovíc poľa do dočasných polí L a P */

for (i = 0; i < L_dlzka; ++i)
{
L[i] = pole[lavy + i];
}

for (j = 0; j < P_dlzka; ++j)
{
P[j] = pole[stred + 1 + j];
}

/* nastav indexy na začiatok daných polí */

i = 0; j = 0; k = lavy;

/* zlučuj dočasné polia L a P do finálneho poľa pole */

while(i < L_dlzka && j < P_dlzka)
{
if(L[i] <= P[j])
{
pole[k++] = L[i++];
}
else
{
pole[k++] = P[j++];
}
}

/* ak ostali nejaké prvky v dočasnom poli L, skopíruj ich do finálneho poľa */

while(i < L_dlzka)
{
pole[k++] = L[i++];
}

/* ak ostali nejaké prvky v dočasnom poli P, skopíruj ich do finálneho poľa */

while(j < P_dlzka)
{
pole[k++] = P[j++];
}

/* uvoľni použitú pamäť */

delete []L;
delete []P;
}

void MergeSort(int pole[], int lavy, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči volanie */

if(lavy >= pravy)
{
return;
}
/* urči si prostredný index */

int stred = lavy + (pravy - lavy) / 2;

/* utrieď ľavú polovicu poľa */

MergeSort(pole, lavy, stred);

/* utrieď pravú polovicu poľa */

MergeSort(pole, stred+1, pravy);

/* zlúč obe polovice dokopy */

Merge(pole, lavy, stred, pravy);
}

</syntaxhighlight>
</tab>

<tab name="Iteračná: C++" block>
<syntaxhighlight lang="C++">
#include <iostream>

using std::cout;
using std::endl;

void Merge(int pole[], int lavy, int stred, int pravy);
void MergeSort(int pole[], int lavy, int pravy);

/* hlavný program */

int main()
{
int pole[] = {12, 11, 13, 5, 6, 7};
int dlzka_pola = sizeof(pole) / sizeof(pole[0]);

printf("Pôvodné pole: \n");

for (auto i: pole)
{
cout<<i<<" ";
}

MergeSort(pole, 0, dlzka_pola - 1);

cout<<endl<<"Utriedené pole:"<<endl;

for (auto i: pole)
{
cout<<i<<" ";
}

return 0;
}

void Merge(int pole[], int lavy, int stred, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči */

if (lavy >= pravy)
{
return;
}

/* vyrátaj dĺžky oboch polovíc poľa */

int L_dlzka = stred - lavy + 1;
int P_dlzka = pravy - stred;

/* alokuj dočasné polia, kam uložíš prvky z oboch polovíc poľa */

int *L = new int[L_dlzka];
int *P = new int[P_dlzka];

/* indexy, ktorými iterujeme všetky polia: i pre L, j pre P, k pre pole */

int i, j, k;

/* skopíruj obsah oboch polovíc poľa do dočasných polí L a P */

for (i = 0; i < L_dlzka; ++i)
{
L[i] = pole[lavy + i];
}

for (j = 0; j < P_dlzka; ++j)
{
P[j] = pole[stred + 1 + j];
}

/* nastav indexy na začiatok daných polí */

i = 0; j = 0; k = lavy;

/* zlučuj dočasné polia L a P do finálneho poľa pole */

while(i < L_dlzka && j < P_dlzka)
{
if(L[i] <= P[j])
{
pole[k++] = L[i++];
}
else
{
pole[k++] = P[j++];
}
}

/* ak ostali nejaké prvky v dočasnom poli L, skopíruj ich do finálneho poľa */

while(i < L_dlzka)
{
pole[k++] = L[i++];
}

/* ak ostali nejaké prvky v dočasnom poli P, skopíruj ich do finálneho poľa */

while(j < P_dlzka)
{
pole[k++] = P[j++];
}

/* uvoľni použitú pamäť */

delete []L;
delete []P;
}

void MergeSort(int *pole, int lavy, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči volanie */

if(lavy >= pravy)
{
return;
}

int stred, koniec;

for (int dlzka_zoznamu = 1; dlzka_zoznamu <= pravy; dlzka_zoznamu *= 2)
{
for (int zaciatok = lavy; zaciatok < pravy; zaciatok += 2 * dlzka_zoznamu)
{
koniec = (zaciatok + 2 * dlzka_zoznamu - 1 <= pravy) ? zaciatok + 2 * dlzka_zoznamu - 1 : pravy;

stred = (zaciatok + dlzka_zoznamu - 1 <= pravy) ? zaciatok + dlzka_zoznamu - 1 : pravy;

Merge(pole, zaciatok, stred, koniec);
}
}
}
</syntaxhighlight>
</tab>

<tab name="Rekurzívna: Java" block>
<syntaxhighlight lang="Java">
class MergeSort
{

/* Funkcia zlúči 2 podpolia, ktoré sme vytvorili z pôvodného poľa.
* Každé podpole má polovičnú dĺžku pôvodného poľa.
* subpole1 [ľavý ... stred]
* subpole2 [stred + 1 ... pravý] */

void merge(int[] pole, int lavy, int stred, int pravy)
{

// Výpočet dĺžky 2 podpolí

int n1 = stred - lavy + 1;
int n2 = pravy - stred;

// Vytvorenie pomocných polí

int[] L = new int[n1];
int[] P = new int[n2];

// Načítanie dát do pomocných polí

for (int i = 0; i < n1; i++)
L[i] = pole[lavy + i];

for (int j = 0; j < n2; j++)
P[j] = pole[stred + 1 + j];

// Počiatočné indexy prvého a druhého podpoľa

int i = 0, j = 0;

// Počiatočný index zlúčeného podpoľa

int k = lavy;

// Zlúčenie dvoch podpolí

while (i < n1 && j < n2)
{
if (L[i] <= P[j])
{
pole[k] = L[i];
i++;
}
else
{
pole[k] = P[j];
j++;
}
k++;
}

/* V prípade, že sa v jednom zo podpoli nachádzajú ešte nejaké prvky, ktoré neboli zlúčené do pola,
* tak sa do pola jednoducho skopírujú */

while (i < n1)
{
pole[k] = L[i];
i++;
k++;
}

while (j < n2)
{
pole[k] = P[j];
k++;
j++;
}

}

/* Funkcia, ktorá zoradí pole použitím funkcie merge() */

void sort (int[] pole, int lavy, int pravy)
{
if (lavy < pravy)
{
// Musíme nájsť stred pola

int stred = lavy + (pravy - lavy) / 2;

// Zoradíme prvú a druhú polovicu pola samostatne

sort(pole, lavy, stred);
sort(pole, stred + 1, pravy);

// Zlúčime zoradené polovice do jedného pola

merge(pole, lavy, stred, pravy);
}
}
}

public class Main
{
/* Funkcia na výpis pola dĺžky n */

static void vypis_pole(int[] pole)
{

for (int j : pole)
{
System.out.print(j + " ");
}

System.out.println();
}

/* Hlavný program */

public static void main(String[] args)
{
int[] pole = {12, 11, 13, 5, 6, 7};

System.out.println("Zadané pole:");
vypis_pole(pole);

MergeSort ms = new MergeSort();
ms.sort(pole, 0, pole.length - 1);

System.out.println("\nZoradené pole:");
vypis_pole(pole);
}
}
</syntaxhighlight>
</tab>

<tab name="Iteračná: Java" block>
<syntaxhighlight lang="Java">
class MergeSort_iteracia {
/* Zlúči 2 subpolia, ktoré sa vytvorili z pôvodného pola.
* Každé subpole má polovičnú dĺžku pôvodného pola.
* subpole1 [ľavý..stred]
* subpole2 [stred+1..pravý] */
void merge(int[] pole, int lavy, int stred, int pravy) {
// Výpočet dĺžky 2 subpolí
int n1 = stred - lavy + 1;
int n2 = pravy - stred;

// Vytvorenie pomocných polí
int[] L = new int[n1];
int[] P = new int[n2];

// Načítanie dát do pomocných polí
for (int i = 0; i < n1; i++)
L[i] = pole[lavy + i];

for (int j = 0; j < n2; j++)
P[j] = pole[stred + 1 + j];

// Počiatočné indexy prvého a druhého subpola
int i = 0, j = 0;
// Počiatočný index zlúčeného subpola
int k = lavy;

// Zlúčenie dvoch podpolí
while (i < n1 && j < n2) {
if (L[i] <= P[j]) {
pole[k] = L[i];
i++;
}
else {
pole[k] = P[j];
j++;
}
k++;
}

/* V prípade, že v jednom zo subpolí sa nachádzajú prvky, ktoré neboli zlúčené do pola,
* tak sa do pola jednoducho skopírujú */
while (i < n1) {
pole[k] = L[i];
i++;
k++;
}

while (j < n2) {
pole[k] = P[j];
k++;
j++;
}
}

/* Funkcia, ktorá zoradí pole použitím funkcie merge() */
void sort (int[] pole, int n) {
/* Dĺžka subpolí, ktoré majú byť zlúčené, hodnoty premennej sa pohybujú v intervale <1;n-1> */
int aktual_dlzka;
/* Začiatočný index ľavého subpola, ktoré má byť zlúčené */
int zaciatok_vlavo;

/* Vzostupné usporiadanie prvkov. Najskôr sa zlúčia subpolia veľkosti 1 do subpolí veľkosti 2,
* potom subpolia veľkosti 2 do subpolí veľkosti 4 a tak ďalej */
for (aktual_dlzka = 1; aktual_dlzka <= n - 1; aktual_dlzka *= 2) {
/* Určenie začiatočného prvku rôznych subpolí aktuálnej dĺžky subpola */
for (zaciatok_vlavo = 0; zaciatok_vlavo < n - 1; zaciatok_vlavo += 2 * aktual_dlzka) {
/* Nájdenie konečného prvku ľavého subpola, stred+1 je začiatočný prvok pravého subpola */
int stred = Math.min(zaciatok_vlavo + aktual_dlzka - 1, n - 1);
int koniec_vpravo = Math.min(zaciatok_vlavo + 2 * aktual_dlzka - 1, n - 1);

/* Zlúči subpolia L[zaciatok_vlavo .. stred] & P[stred+1 .. koniec_vpravo] */
merge(pole, zaciatok_vlavo, stred, koniec_vpravo);
}
}
}
}

public class Main {
/* Funkcia na výpis pola dĺžky n */
static void vypis_pole(int[] pole) {
int n = pole.length;

for (int j : pole) {
System.out.print(j + " ");
}
System.out.println();
}

/* Hlavný program */
public static void main(String[] args) {

/* Inicializácia pola */
int[] pole = {12, 11, 13, 5, 6, 7};

System.out.println("Zadané pole:");
vypis_pole(pole);

MergeSort_iteracia ms_it = new MergeSort_iteracia();
ms_it.sort(pole, pole.length);

System.out.println("Zoradené pole:");
vypis_pole(pole);
}
}
</syntaxhighlight>
</tab>

<tab name="Rekurzívna: Python3" block>
<syntaxhighlight lang="Python3">
def MergeSort(pole):
if len(pole) > 1:
# Nájdenie stredu pola
# zápis len(pole)//2 znamená, že dĺžka pola sa vydelí 2 a výsledok je celé číslo
stred = len(pole) // 2

# Rozdelenie pola na dve časti
L = pole[:stred]
P = pole[stred:]

# Zoradenie najskôr prvej časti pola, potom druhej
MergeSort(L)
MergeSort(P)

i = j = k = 0

# Zlúčenie a zoradenie údajov z pomocných polí do jedného pola
while i < len(L) and j < len(P):
if L[i] < P[j]:
pole[k] = L[i]
i += 1
else:
pole[k] = P[j]
j += 1
k += 1

# Kontrola či všetky prvky boli zlúčené dokopy,
# ak nie, tak sa do zlúčeného pola jednoducho skopírujú
while i < len(L):
pole[k] = L[i]
i += 1
k += 1

while j < len(P):
pole[k] = P[j]
j += 1
k += 1

# Hlavný program
if __name__ == '__main__':
pole = [12, 11, 13, 5, 6, 7]

print("Zadané pole:", end="\n")
print(pole, end="\n")

MergeSort(pole)

print("Zoradené pole:", end="\n")
print(pole, end="\n")

</syntaxhighlight>
</tab>

<tab name="Iteračná: Python3" block>
<syntaxhighlight lang="Python3">
def MergeSort_iteracia(pole):
# Dĺžka subpolí, ktoré majú byť zlúčené, hodnoty premennej sa pohybujú v intervale <1;n-1>
aktual_dlzka = 1

# Vonkajší cyklus, ktorý určuje subpolia aktuálnej dĺžky
while aktual_dlzka < len(pole) - 1:
lavy = 0

# Vnútorný cyklus, ktorý slúži na zlúčenie a zoradenie subpoli do jedného subpola
while lavy < len(pole) - 1:
# Index stredného prvku sa určí, keď k indexu ľavého prvku subpola pripočítame aktuálnu
# dĺžku subpolí a odčítame 1
stred = min((lavy + aktual_dlzka - 1), len(pole) - 1)

# Ak platí podmienka 2 * aktuálna dĺžka < dĺžka pola - 1, tak pravý index = aktuálnej dĺžke subpolí,
# inak pravý index = dĺžke pola - 1
pravy = ((2 * aktual_dlzka + lavy - 1, len(pole) - 1)[2 * aktual_dlzka + lavy - 1 > len(pole) - 1])

# Volanie funkcie merge
merge(pole, lavy, stred, pravy)

lavy = lavy + 2 * aktual_dlzka

# Aktuálna dĺžka sa sa zmení na dvojnásobok jej predošlej hodnoty
aktual_dlzka = 2 * aktual_dlzka

def merge(pole, lavy, stred, pravy):
n1 = stred - lavy + 1
n2 = pravy - stred

# Inicializácia pomocných polí
L = [0] * n1
P = [0] * n2

# Načítanie dát do pomocných polí
for i in range(0, n1):
L[i] = pole[lavy + i]
for i in range(0, n2):
P[i] = pole[stred + i + 1]

i, j, k = 0, 0, lavy

# Zlúčenie a zoradenie údajov z pomocných polí do jedného pola
while i < n1 and j < n2:
if L[i] > P[j]:
pole[k] = P[j]
j += 1
else:
pole[k] = L[i]
i += 1
k += 1

# Kontrola či všetky prvky boli zlúčené dokopy,
# ak nie, tak sa do zlúčeného pola jednoducho skopírujú
while i < n1:
pole[k] = L[i]
i += 1
k += 1

while j < n2:
pole[k] = P[j]
j += 1
k += 1

# Hlavný program
if __name__ == '__main__':
pole = [12, 11, 13, 5, 6, 7]

print("Zadané pole:", end="\n")
print(pole, end="\n")

MergeSort_iteracia(pole)

print("Zoradené pole:", end="\n")
print(pole, end="\n")

</syntaxhighlight>
</tab>

</tabs>

==Odkazy==
# https://www.geeksforgeeks.org/merge-sort/
# https://www.geeksforgeeks.org/iterative-merge-sort/
# https://medium.com/@paulsoham/merge-sort-63d75df76388
# https://www.khanacademy.org/computing/computer-science/algorithms/merge-sort/a/overview-of-merge-sort
# https://www.tutorialspoint.com/data_structures_algorithms/merge_sort_algorithm.htm
# https://www.youtube.com/watch?v=6pV2IF0fgKY
# https://www.youtube.com/watch?v=mB5HXBb_HY8
# https://www.youtube.com/watch?v=ak-pz7tS5DE

Triedenie zlučovaním

2021-03-29T11:10:21Z

Filip Tomek: /* Zlučovací algoritmus Merge */

[[Kategória:Algoritmy triedenia]]
{{Draft}}
{{Skripta programovanie}}
__TOC__
==TODO: Pseudokód treba opraviť, text refaktorovať, otestovať kódy, zvýrazniť veci v texte, opraviť preklepy, opraviť popis obrázkov, pridať nové odkazy==

==Zlučovací algoritmus Merge==
[[Súbor:Funkcia merge.png|500px|náhľad|vpravo|Vizualizácia funkcie Merge: Máme pole prvkov ''p = [1, 3, 5, 2, 4, 6]'', ktoré je už čiastočne utriedené. Použijeme algoritmus Merge, ktorý si vytvorí pomocné polia ''L = [1, 3, 5]'' a ''P = [2, 4, 6]''. Všetky polia indexujeme od ''0'', pričom pre pole ''p'' používame index ''k'', pre ''L'' index ''i'' a pre ''P'' index ''j''. Postupnosť krokov je označená číslicami 1 až 6.
]]

Princíp zlučovania tkvie v tom, že máme dva alebo viac utriedených zoznamov, ktoré skombinuje do jedného utriedeného zoznamu (výsledný zoznam musí obsahovať všetky prvky z pôvodných zoznamov). Zoznam môže byť reprezentovaný ako dátová štruktúra pole alebo aj ako lineárny zoznam. V tomto článku sa zameriame na algoritmus pre dátovú štruktúru pole.

Algoritmus Merge tvorí kľúčovú časť triediaceho algoritmu MergeSort.

===Slovný opis algoritmu===
Nech máme pole, ktoré sa skladá z dvoch už utriedených polovíc. Vytvoríme si dve pomocné polia ''L'' a ''P'' a do každého z nich skopírujeme obsah jednej polovice (''L'' - ľavá polovica, ''P'' - pravá polovica). Potom súčasne prechádzame polia ''L'' a ''P'' od začiatku po koniec, pričom v každom cykle porovnáme prvok poľa ''L'' s prvkom v poli ''P''. Z tejto dvojice následne vyberieme minimum, (keď triedime od najmenšieho po najväčší) ktoré vložíme na prvú voľnú pozíciu pôvodného poľa (na začiatku je to prvá pozícia poľa). Nakoniec zvýšime index pri vstupnom poli a pri pomocnom poli, z ktorého vyberáme daný prvok. Túto postupnosť krokov opakujeme, pokiaľ neprídeme na koniec jedného z polí ''P'' a ''L''. Ak nastane situácia, že prídeme na koniec jedného z pomocných polí (a v druhom nám ostali ešte nejaké prvky), potom už iba naspäť skopírujeme zbytok druhého pomocného poľa na koniec pôvodného poľa.

===Vlastnosti algoritmu===
* vhodný pre dátové štruktúry: pole, lineárny zoznam
* časová náročnosť: vždy lineárna <math>O(n)</math>
* priestorová náročnosť: lineárna <math>O(n)</math> pre pole (alokovanie pomocných polí), <math>O(1)</math> pre lineárny zoznam (pri LZ netreba alokovať dočasné polia, stačí iba presmerovať smerníky)
* využitie: kľúčový podprogram pre triediaci algoritmus MergeSort

===Pseudokód===
Nech funkcia Merge má nasledovný prototyp: <code>Merge(pole[], lavy, stred, pravy)</code>
:1. Je <code>lavy >= pravy ? Ak áno, skonči, inak pokračuj krokom 2.</code>
:2. Nech: <code>i = 0, j = 0, k = lavy </code>
:3. Nech: <code>dlzka_L = stred - lavy + 1, dlzka_P = pravy - stred</code>
:4. Nech: <code> L = pole[lavy ... stred], P = pole[stred + 1 ... pravy] </code>
:5. Je <code>i < dlzka_L</code> a zároveň <code>j < dlzka_P</code> ? Ak áno, pokračuj krokom 5.1., inak skoč na krok 6.
:::5.1. Je <code>L[i] <= P[j]</code>?
:::: Ak áno:
:::::5.1.1. <code>pole[k] = L[i]</code>
:::::5.1.2. <code>k += 1</code>
:::::5.1.3. <code>i += 1</code>
:::::5.1.4. Skoč na krok 5.
:::: Ak nie:
:::::5.1.1. <code>pole[k] = P[j]</code>
:::::5.1.2. <code>k += 1</code>
:::::5.1.3. <code>j += 1</code>
:::::5.1.4. Skoč na krok 5.
:6. Je <code>i < dlzka_L</code> ? Ak áno, pokračuj krokom 6.1., inak skoč na krok 7.
:::6.1. <code>pole[k] = L[i]</code>
:::6.2. <code>k += 1</code>
:::6.3. <code>i += 1</code>
:::6.4. Skoč na krok 6.
:7. Je <code>j < dlzka_P</code> ? Ak áno, pokračuj krokom 7.1., inak skonči.
:::7.1. <code>pole[k] = P[j]</code>
:::7.2. <code>k += 1</code>
:::7.3. <code>j += 1</code>
:::7.4. Skoč na krok 7.

==Merge sort==
Merge Sort je triediaci algoritmus, ktorý využíva stratégiu '''"rozdeľuj a panuj"''', čo znamená, že vstupný zoznam najskôr rozdelí na dve polovice, tie zoradí a potom ich zlúči naspäť dokopy. Radí sa medzi najpoužívanejšie a najviac rešpektované triediace algoritmy.

===Vlastnosti algoritmu Merge Sort===
* vhodný pre dátové štruktúry: pole, lineárny zoznam
* časová náročnosť: vždy linearitmická <math> O(n.log(n)) </math>, vďaka ktorej dokáže efektívne triediť veľmi veľké zoznamy
* priestorová náročnosť: lineárna <math>O(n)</math> pre pole (alokovanie dočasných polí), konštantná <math>O(1)</math> pre lineárny zoznam (pri LZ stačí iba presmerovať smerníky)
* druh triedenia: triedenie zlučovaním (komparačný algoritmus)
* stabilita triedenia: stabilný
* miesto triedenia: externé triedenie (vhodný na triedenie veľkých objemov dát uložených na disku)

Z hľadiska implementácie môžeme vytvoriť dve základné verzie algoritmu, a to rekurzívnu a iteračnú.
===Opis rekurzívnej a iteračnej verzie algoritmu Merge Sort===

<tabs>
<tab name="Rekurzívna verzia" block>
[[Súbor:Merge sort.png|400px|náhľad|vpravo|Vizualizácia rekurzívnej verzie algoritmu MergeSort]]

===Princíp algoritmu===
Algoritmus MergeSort vykonáva 4 základné úlohy:
# Delenie poľa na dve polovice.
# Triedenie ľavej polovice poľa.
# Triedenie pravej polovice poľa.
# Zlúčenie oboch polovíc pomocou funkcie Merge.

===Slovný opis===
Našou úlohou je vzostupne (min - max) utriediť vstupné pole. Určíme si stred poľa (pri párnom počte prvkov je to ten menší z prostredných indexov). Následne vykonávame sériu rekurzívnych delení pre ľavú a pravú časť poľa (začiatok ... stred ; stred + 1 ... koniec) až do momentu, keď nám ostanú len jednoprvkové podpolia (tie sú už utriedené). Následne v každom volaní obe tieto podpolia zlúčime pomocou algoritmu Merge do väčších podpolí (2, 4, 8, ...), až nakoniec dostaneme jedno výsledné utriedené pole.

===Pseudokód===
Nech nech má funkcia MergeSort nasledovný prototyp: <code>MergeSort(pole[], lavy, pravy) </code>
:1. Je <code>lavy >= pravy</code> ? Ak áno, skonči volanie, inak pokračuj krokom 2.
:2. Nech: <code>stred = lavy + (pravy - lavy) / 2</code>, pričom znak ''/'' vyjadruje celočíselné delenie.
:3. Rekurzívne zavolaj funkciu <code>MergeSort(pole[], lavy , stred)</code>
:3. Rekurzívne zavolaj funkciu <code>MergeSort(pole[], stred + 1 , pravy)</code>
:4. Zavolaj funkciu <code>Merge(pole[], lavy, stred, pravy)</code>
:5. Skonči volanie.

</tab>
<tab name="Iteračná verzia" block>
[[Súbor:MergeSort IT.png|400px|náhľad|vpravo]]

===Princíp algoritmu===
Algoritmus Merge vykonáva 3 základné úlohy:
# Vonkajší cyklus: určenie veľkosti zoznamu na zlučovanie.
# Vnútorný cyklus: prechádzanie jednotlivých zoznamov v poli.
# Zlučovanie jednotlivých zoznamov pomocou funkcie Merge.

===Slovný opis===
Vstupné pole, ktoré má ''N'' prvkov, môžeme chápať, ako ''N'' rôznych jednoprvkových (utriedených) podpolí, ktoré máme zlúčiť do jedného výsledného ''N''-prvkového utriedeného poľa. Keďže by bolo veľmi nepraktické zlučovať ''N'' podpolí naraz, zvolíme nasledovnú stratégiu: Budeme prechádzať dané pole od začiatku po koniec a v prvom cykle zlúčime každé dva prvky, takže budeme mať <math>\frac{n}{2}</math> dvojprvkových utriedených podpolí. Potom v druhom cykle zlúčime každé 4 prvky do jedného podpoľa, v treťom cykle každých 8, až do momentu, keď dostaneme jedno utriedené pole.
Aby sme to docielili, potrebujeme dva cykly, vonkajší, ktorý nastaví maximálnu veľkosť podpoľa, ktoré ideme zlučovať (1,2,4,8 ... dlzka - 1) a vnútorný, ktorý prechádza jednotlivé podpolia. Následne už iba voláme funkciu Merge, ktorá dané podpolia zlučuje.

Poznámka, ak máme pole, ktoré má nepárny počet prvkov, tak ten posledný prvok nezlúčime hneď v prvom cykle, ale až v tých ďalších. Takisto, ak n nie je mocnina čísla 2, tak musíme samozrejme ošetriť situáciu, kedy by sme sa dostali mimo rozsah poľa (Ak máme napríklad pole, čo má 7 prvkov, tak po prvej iterácii budú prvky utiredené podľa vzoru 2 + 2 + 2 + 1, po druhej 4 + 3, a po tretej 7)

===Pseudokód===
Nech nech má funkcia MergeSort nasledovný prototyp: <code>MergeSort(pole[], lavy, pravy) </code>
:1. Je <code>lavy >= pravy</code> ? Ak áno, skonči, inak pokračuj krokom 2.
:2. Nech: <code>dlzka_subzoznamu = 1 </code>
:3. Nech: <code>zaciatok = lavy</code>
:4. Je<code>dlzka_subzoznamu <= pravy</code> ? Ak áno pokračuj krokom 4.1, inak skonči.
:::4.1. Je<code>zaciatok < pravy</code> Ak áno pokračuj krokom 4.1.1, inak skoč na krok 4.2.
:::::4.1.1. Je <code>zaciatok + 2 * dlzka_zoznamu - 1 <= pravy</code> ?
:::::::Ak áno:
:::::::::4.1.1.1. Nech <code>koniec = zaciatok + 2 * dlzka_zoznamu - 1</code>
:::::::Ak nie:
:::::::::4.1.1.1. Nech <code>koniec = pravy</code>
:::::4.1.2. Je <code>zaciatok + dlzka_zoznamu - 1 <= pravy</code> ?
:::::::Ak áno:
:::::::::4.1.2.1. Nech <code>stred = zaciatok + dlzka_zoznamu - 1</code>
:::::::Ak nie:
:::::::::4.1.2.1. Nech <code>stred = pravy</code>
:::::4.1.3. <code>Merge(pole[], zaciatok, stred, koniec)</code>
:::::4.1.4. <code>zaciatok += 2 * dlzka_subzoznamu</code>
:::::4.1.5. Skoč na krok 4.1.
:::4.2. <code>dlzka_subzoznamu *= 2</code>
:::4.3 Skoč na krok 4.

</tab>
</tabs>

==Implementácia algoritmov Merge a MergeSort v rôznych programovacích jazykoch==
<tabs>
<tab name="Rekurzívna: C " block>
<syntaxhighlight lang="C">
#include <stdio.h>
#include <stdlib.h>

void Merge(int pole[], int lavy, int stred, int pravy);
void MergeSort(int pole[], int lavy, int pravy);

/* hlavný program */

int main()
{
int pole[] = {12, 11, 13, 5, 6, 7};
int dlzka_pola = sizeof(pole) / sizeof(pole[0]);

printf("Pôvodné pole: \n");

for (int i = 0; i < dlzka_pola; ++i)
{
printf("%d ", pole[i]);
}

MergeSort(pole, 0, dlzka_pola - 1);

printf("\nUtriedené pole: \n");

for (int i = 0; i < dlzka_pola; ++i)
{
printf("%d ", pole[i]);
}

return 0;
}

void Merge(int pole[], int lavy, int stred, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči */

if (lavy >= pravy)
{
return;
}

/* vyrátaj dĺžky oboch polovíc poľa */

int L_dlzka = stred - lavy + 1;
int P_dlzka = pravy - stred;

/* alokuj dočasné polia, kam uložíš prvky z oboch polovíc poľa */

int *L = (int*)malloc(L_dlzka * sizeof(int));
int *P = (int*)malloc(P_dlzka * sizeof(int));

/* indexy, ktorými iterujeme všetky polia: i pre L, j pre P, k pre pole */

int i, j, k;

/* skopíruj obsah oboch polovíc poľa do dočasných polí L a P */

for (i = 0; i < L_dlzka; ++i)
{
L[i] = pole[lavy + i];
}

for (j = 0; j < P_dlzka; ++j)
{
P[j] = pole[stred + 1 + j];
}

/* nastav indexy na začiatok daných polí */

i = 0; j = 0; k = lavy;

/* zlučuj dočasné polia L a P do finálneho poľa pole */

while(i < L_dlzka && j < P_dlzka)
{
if(L[i] <= P[j])
{
pole[k++] = L[i++];
}
else
{
pole[k++] = P[j++];
}
}

/* ak ostali nejaké prvky v dočasnom poli L, skopíruj ich do finálneho poľa */

while(i < L_dlzka)
{
pole[k++] = L[i++];
}

/* ak ostali nejaké prvky v dočasnom poli P, skopíruj ich do finálneho poľa */

while(j < P_dlzka)
{
pole[k++] = P[j++];
}

/* uvoľni použitú pamäť */

free(L);
free(P);
}

void MergeSort(int pole[], int lavy, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči volanie */

if(lavy >= pravy)
{
return;
}
/* urči si prostredný index */

int stred = lavy + (pravy - lavy) / 2;

/* utrieď ľavú polovicu poľa */

MergeSort(pole, lavy, stred);

/* utrieď pravú polovicu poľa */

MergeSort(pole, stred+1, pravy);

/* zlúč obe polovice dokopy */

Merge(pole, lavy, stred, pravy);
}
</syntaxhighlight>
</tab>

<tab name="Iteračná: C" block>
<syntaxhighlight lang="C">
#include <stdio.h>
#include <stdlib.h>

void Merge(int pole[], int lavy, int stred, int pravy);
void MergeSortIt(int *pole, int lavy, int pravy);

/* hlavný program */

int main()
{
int pole[] = {12, 11, 13, 5, 6, 7, 19};
int dlzka_pola = sizeof(pole) / sizeof(pole[0]);

printf("Pôvodné pole %d: \n", dlzka_pola);

for (int i = 0; i < dlzka_pola; ++i)
{
printf("%d ", pole[i]);
}

MergeSortIt(pole, 0, dlzka_pola - 1);

printf("\nUtriedené pole: \n");

for (int i = 0; i < dlzka_pola; ++i)
{
printf("%d ", pole[i]);
}

return 0;
}

void Merge(int pole[], int lavy, int stred, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči */

if (lavy >= pravy)
{
return;
}

/* vyrátaj dĺžky oboch polovíc poľa */

int L_dlzka = stred - lavy + 1;
int P_dlzka = pravy - stred;

/* alokuj dočasné polia, kam uložíš prvky z oboch polovíc poľa */

int *L = (int*)malloc(L_dlzka * sizeof(int));
int *P = (int*)malloc(P_dlzka * sizeof(int));

/* indexy, ktorými iterujeme všetky polia: i pre L, j pre P, k pre pole */

int i, j, k;

/* skopíruj obsah oboch polovíc poľa do dočasných polí L a P */

for (i = 0; i < L_dlzka; ++i)
{
L[i] = pole[lavy + i];
}

for (j = 0; j < P_dlzka; ++j)
{
P[j] = pole[stred + 1 + j];
}

/* nastav indexy na začiatok daných polí */

i = 0; j = 0; k = lavy;

/* zlučuj dočasné polia L a P do finálneho poľa pole */

while(i < L_dlzka && j < P_dlzka)
{
if(L[i] <= P[j])
{
pole[k++] = L[i++];
}
else
{
pole[k++] = P[j++];
}
}

/* ak ostali nejaké prvky v dočasnom poli L, skopíruj ich do finálneho poľa */

while(i < L_dlzka)
{
pole[k++] = L[i++];
}

/* ak ostali nejaké prvky v dočasnom poli P, skopíruj ich do finálneho poľa */

while(j < P_dlzka)
{
pole[k++] = P[j++];
}

/* uvoľni použitú pamäť */

free(L);
free(P);
}

void MergeSortIt(int *pole, int lavy, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči volanie */

if(lavy >= pravy)
{
return;
}

int stred, koniec;

for (int dlzka_zoznamu = 1; dlzka_zoznamu <= pravy ; dlzka_zoznamu *= 2)
{
for (int zaciatok = lavy; zaciatok < pravy ; zaciatok += 2 * dlzka_zoznamu)
{
koniec = (zaciatok + 2 * dlzka_zoznamu - 1 <= pravy) ? zaciatok + 2 * dlzka_zoznamu - 1 : pravy;

stred = (zaciatok + dlzka_zoznamu - 1 <= pravy) ? zaciatok + dlzka_zoznamu - 1 : pravy;

Merge(pole, zaciatok, stred, koniec);

}
}
}

</syntaxhighlight>
</tab>

<tab name="Rekurzívna: C++" block>
<syntaxhighlight lang="C++">
#include <iostream>

using std::cout;
using std::endl;

void Merge(int pole[], int lavy, int stred, int pravy);
void MergeSort(int pole[], int lavy, int pravy);

/* hlavný program */

int main()
{
int pole[] = {12, 11, 13, 5, 6, 7};
int dlzka_pola = sizeof(pole) / sizeof(pole[0]);

printf("Pôvodné pole: \n");

for (auto i: pole)
{
cout<<i<<" ";
}

MergeSort(pole, 0, dlzka_pola - 1);

cout<<endl<<"Utriedené pole:"<<endl;

for (auto i: pole)
{
cout<<i<<" ";
}

return 0;
}

void Merge(int pole[], int lavy, int stred, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči */

if (lavy >= pravy)
{
return;
}

/* vyrátaj dĺžky oboch polovíc poľa */

int L_dlzka = stred - lavy + 1;
int P_dlzka = pravy - stred;

/* alokuj dočasné polia, kam uložíš prvky z oboch polovíc poľa */

int *L = new int[L_dlzka];
int *P = new int[P_dlzka];

/* indexy, ktorými iterujeme všetky polia: i pre L, j pre P, k pre pole */

int i, j, k;

/* skopíruj obsah oboch polovíc poľa do dočasných polí L a P */

for (i = 0; i < L_dlzka; ++i)
{
L[i] = pole[lavy + i];
}

for (j = 0; j < P_dlzka; ++j)
{
P[j] = pole[stred + 1 + j];
}

/* nastav indexy na začiatok daných polí */

i = 0; j = 0; k = lavy;

/* zlučuj dočasné polia L a P do finálneho poľa pole */

while(i < L_dlzka && j < P_dlzka)
{
if(L[i] <= P[j])
{
pole[k++] = L[i++];
}
else
{
pole[k++] = P[j++];
}
}

/* ak ostali nejaké prvky v dočasnom poli L, skopíruj ich do finálneho poľa */

while(i < L_dlzka)
{
pole[k++] = L[i++];
}

/* ak ostali nejaké prvky v dočasnom poli P, skopíruj ich do finálneho poľa */

while(j < P_dlzka)
{
pole[k++] = P[j++];
}

/* uvoľni použitú pamäť */

delete []L;
delete []P;
}

void MergeSort(int pole[], int lavy, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči volanie */

if(lavy >= pravy)
{
return;
}
/* urči si prostredný index */

int stred = lavy + (pravy - lavy) / 2;

/* utrieď ľavú polovicu poľa */

MergeSort(pole, lavy, stred);

/* utrieď pravú polovicu poľa */

MergeSort(pole, stred+1, pravy);

/* zlúč obe polovice dokopy */

Merge(pole, lavy, stred, pravy);
}

</syntaxhighlight>
</tab>

<tab name="Iteračná: C++" block>
<syntaxhighlight lang="C++">
#include <iostream>

using std::cout;
using std::endl;

void Merge(int pole[], int lavy, int stred, int pravy);
void MergeSort(int pole[], int lavy, int pravy);

/* hlavný program */

int main()
{
int pole[] = {12, 11, 13, 5, 6, 7};
int dlzka_pola = sizeof(pole) / sizeof(pole[0]);

printf("Pôvodné pole: \n");

for (auto i: pole)
{
cout<<i<<" ";
}

MergeSort(pole, 0, dlzka_pola - 1);

cout<<endl<<"Utriedené pole:"<<endl;

for (auto i: pole)
{
cout<<i<<" ";
}

return 0;
}

void Merge(int pole[], int lavy, int stred, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči */

if (lavy >= pravy)
{
return;
}

/* vyrátaj dĺžky oboch polovíc poľa */

int L_dlzka = stred - lavy + 1;
int P_dlzka = pravy - stred;

/* alokuj dočasné polia, kam uložíš prvky z oboch polovíc poľa */

int *L = new int[L_dlzka];
int *P = new int[P_dlzka];

/* indexy, ktorými iterujeme všetky polia: i pre L, j pre P, k pre pole */

int i, j, k;

/* skopíruj obsah oboch polovíc poľa do dočasných polí L a P */

for (i = 0; i < L_dlzka; ++i)
{
L[i] = pole[lavy + i];
}

for (j = 0; j < P_dlzka; ++j)
{
P[j] = pole[stred + 1 + j];
}

/* nastav indexy na začiatok daných polí */

i = 0; j = 0; k = lavy;

/* zlučuj dočasné polia L a P do finálneho poľa pole */

while(i < L_dlzka && j < P_dlzka)
{
if(L[i] <= P[j])
{
pole[k++] = L[i++];
}
else
{
pole[k++] = P[j++];
}
}

/* ak ostali nejaké prvky v dočasnom poli L, skopíruj ich do finálneho poľa */

while(i < L_dlzka)
{
pole[k++] = L[i++];
}

/* ak ostali nejaké prvky v dočasnom poli P, skopíruj ich do finálneho poľa */

while(j < P_dlzka)
{
pole[k++] = P[j++];
}

/* uvoľni použitú pamäť */

delete []L;
delete []P;
}

void MergeSort(int *pole, int lavy, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči volanie */

if(lavy >= pravy)
{
return;
}

int stred, koniec;

for (int dlzka_zoznamu = 1; dlzka_zoznamu <= pravy; dlzka_zoznamu *= 2)
{
for (int zaciatok = lavy; zaciatok < pravy; zaciatok += 2 * dlzka_zoznamu)
{
koniec = (zaciatok + 2 * dlzka_zoznamu - 1 <= pravy) ? zaciatok + 2 * dlzka_zoznamu - 1 : pravy;

stred = (zaciatok + dlzka_zoznamu - 1 <= pravy) ? zaciatok + dlzka_zoznamu - 1 : pravy;

Merge(pole, zaciatok, stred, koniec);
}
}
}
</syntaxhighlight>
</tab>

<tab name="Rekurzívna: Java" block>
<syntaxhighlight lang="Java">
class MergeSort
{

/* Funkcia zlúči 2 podpolia, ktoré sme vytvorili z pôvodného poľa.
* Každé podpole má polovičnú dĺžku pôvodného poľa.
* subpole1 [ľavý ... stred]
* subpole2 [stred + 1 ... pravý] */

void merge(int[] pole, int lavy, int stred, int pravy)
{

// Výpočet dĺžky 2 podpolí

int n1 = stred - lavy + 1;
int n2 = pravy - stred;

// Vytvorenie pomocných polí

int[] L = new int[n1];
int[] P = new int[n2];

// Načítanie dát do pomocných polí

for (int i = 0; i < n1; i++)
L[i] = pole[lavy + i];

for (int j = 0; j < n2; j++)
P[j] = pole[stred + 1 + j];

// Počiatočné indexy prvého a druhého podpoľa

int i = 0, j = 0;

// Počiatočný index zlúčeného podpoľa

int k = lavy;

// Zlúčenie dvoch podpolí

while (i < n1 && j < n2)
{
if (L[i] <= P[j])
{
pole[k] = L[i];
i++;
}
else
{
pole[k] = P[j];
j++;
}
k++;
}

/* V prípade, že sa v jednom zo podpoli nachádzajú ešte nejaké prvky, ktoré neboli zlúčené do pola,
* tak sa do pola jednoducho skopírujú */

while (i < n1)
{
pole[k] = L[i];
i++;
k++;
}

while (j < n2)
{
pole[k] = P[j];
k++;
j++;
}

}

/* Funkcia, ktorá zoradí pole použitím funkcie merge() */

void sort (int[] pole, int lavy, int pravy)
{
if (lavy < pravy)
{
// Musíme nájsť stred pola

int stred = lavy + (pravy - lavy) / 2;

// Zoradíme prvú a druhú polovicu pola samostatne

sort(pole, lavy, stred);
sort(pole, stred + 1, pravy);

// Zlúčime zoradené polovice do jedného pola

merge(pole, lavy, stred, pravy);
}
}
}

public class Main
{
/* Funkcia na výpis pola dĺžky n */

static void vypis_pole(int[] pole)
{

for (int j : pole)
{
System.out.print(j + " ");
}

System.out.println();
}

/* Hlavný program */

public static void main(String[] args)
{
int[] pole = {12, 11, 13, 5, 6, 7};

System.out.println("Zadané pole:");
vypis_pole(pole);

MergeSort ms = new MergeSort();
ms.sort(pole, 0, pole.length - 1);

System.out.println("\nZoradené pole:");
vypis_pole(pole);
}
}
</syntaxhighlight>
</tab>

<tab name="Iteračná: Java" block>
<syntaxhighlight lang="Java">
class MergeSort_iteracia {
/* Zlúči 2 subpolia, ktoré sa vytvorili z pôvodného pola.
* Každé subpole má polovičnú dĺžku pôvodného pola.
* subpole1 [ľavý..stred]
* subpole2 [stred+1..pravý] */
void merge(int[] pole, int lavy, int stred, int pravy) {
// Výpočet dĺžky 2 subpolí
int n1 = stred - lavy + 1;
int n2 = pravy - stred;

// Vytvorenie pomocných polí
int[] L = new int[n1];
int[] P = new int[n2];

// Načítanie dát do pomocných polí
for (int i = 0; i < n1; i++)
L[i] = pole[lavy + i];

for (int j = 0; j < n2; j++)
P[j] = pole[stred + 1 + j];

// Počiatočné indexy prvého a druhého subpola
int i = 0, j = 0;
// Počiatočný index zlúčeného subpola
int k = lavy;

// Zlúčenie dvoch podpolí
while (i < n1 && j < n2) {
if (L[i] <= P[j]) {
pole[k] = L[i];
i++;
}
else {
pole[k] = P[j];
j++;
}
k++;
}

/* V prípade, že v jednom zo subpolí sa nachádzajú prvky, ktoré neboli zlúčené do pola,
* tak sa do pola jednoducho skopírujú */
while (i < n1) {
pole[k] = L[i];
i++;
k++;
}

while (j < n2) {
pole[k] = P[j];
k++;
j++;
}
}

/* Funkcia, ktorá zoradí pole použitím funkcie merge() */
void sort (int[] pole, int n) {
/* Dĺžka subpolí, ktoré majú byť zlúčené, hodnoty premennej sa pohybujú v intervale <1;n-1> */
int aktual_dlzka;
/* Začiatočný index ľavého subpola, ktoré má byť zlúčené */
int zaciatok_vlavo;

/* Vzostupné usporiadanie prvkov. Najskôr sa zlúčia subpolia veľkosti 1 do subpolí veľkosti 2,
* potom subpolia veľkosti 2 do subpolí veľkosti 4 a tak ďalej */
for (aktual_dlzka = 1; aktual_dlzka <= n - 1; aktual_dlzka *= 2) {
/* Určenie začiatočného prvku rôznych subpolí aktuálnej dĺžky subpola */
for (zaciatok_vlavo = 0; zaciatok_vlavo < n - 1; zaciatok_vlavo += 2 * aktual_dlzka) {
/* Nájdenie konečného prvku ľavého subpola, stred+1 je začiatočný prvok pravého subpola */
int stred = Math.min(zaciatok_vlavo + aktual_dlzka - 1, n - 1);
int koniec_vpravo = Math.min(zaciatok_vlavo + 2 * aktual_dlzka - 1, n - 1);

/* Zlúči subpolia L[zaciatok_vlavo .. stred] & P[stred+1 .. koniec_vpravo] */
merge(pole, zaciatok_vlavo, stred, koniec_vpravo);
}
}
}
}

public class Main {
/* Funkcia na výpis pola dĺžky n */
static void vypis_pole(int[] pole) {
int n = pole.length;

for (int j : pole) {
System.out.print(j + " ");
}
System.out.println();
}

/* Hlavný program */
public static void main(String[] args) {

/* Inicializácia pola */
int[] pole = {12, 11, 13, 5, 6, 7};

System.out.println("Zadané pole:");
vypis_pole(pole);

MergeSort_iteracia ms_it = new MergeSort_iteracia();
ms_it.sort(pole, pole.length);

System.out.println("Zoradené pole:");
vypis_pole(pole);
}
}
</syntaxhighlight>
</tab>

<tab name="Rekurzívna: Python3" block>
<syntaxhighlight lang="Python3">
def MergeSort(pole):
if len(pole) > 1:
# Nájdenie stredu pola
# zápis len(pole)//2 znamená, že dĺžka pola sa vydelí 2 a výsledok je celé číslo
stred = len(pole) // 2

# Rozdelenie pola na dve časti
L = pole[:stred]
P = pole[stred:]

# Zoradenie najskôr prvej časti pola, potom druhej
MergeSort(L)
MergeSort(P)

i = j = k = 0

# Zlúčenie a zoradenie údajov z pomocných polí do jedného pola
while i < len(L) and j < len(P):
if L[i] < P[j]:
pole[k] = L[i]
i += 1
else:
pole[k] = P[j]
j += 1
k += 1

# Kontrola či všetky prvky boli zlúčené dokopy,
# ak nie, tak sa do zlúčeného pola jednoducho skopírujú
while i < len(L):
pole[k] = L[i]
i += 1
k += 1

while j < len(P):
pole[k] = P[j]
j += 1
k += 1

# Hlavný program
if __name__ == '__main__':
pole = [12, 11, 13, 5, 6, 7]

print("Zadané pole:", end="\n")
print(pole, end="\n")

MergeSort(pole)

print("Zoradené pole:", end="\n")
print(pole, end="\n")

</syntaxhighlight>
</tab>

<tab name="Iteračná: Python3" block>
<syntaxhighlight lang="Python3">
def MergeSort_iteracia(pole):
# Dĺžka subpolí, ktoré majú byť zlúčené, hodnoty premennej sa pohybujú v intervale <1;n-1>
aktual_dlzka = 1

# Vonkajší cyklus, ktorý určuje subpolia aktuálnej dĺžky
while aktual_dlzka < len(pole) - 1:
lavy = 0

# Vnútorný cyklus, ktorý slúži na zlúčenie a zoradenie subpoli do jedného subpola
while lavy < len(pole) - 1:
# Index stredného prvku sa určí, keď k indexu ľavého prvku subpola pripočítame aktuálnu
# dĺžku subpolí a odčítame 1
stred = min((lavy + aktual_dlzka - 1), len(pole) - 1)

# Ak platí podmienka 2 * aktuálna dĺžka < dĺžka pola - 1, tak pravý index = aktuálnej dĺžke subpolí,
# inak pravý index = dĺžke pola - 1
pravy = ((2 * aktual_dlzka + lavy - 1, len(pole) - 1)[2 * aktual_dlzka + lavy - 1 > len(pole) - 1])

# Volanie funkcie merge
merge(pole, lavy, stred, pravy)

lavy = lavy + 2 * aktual_dlzka

# Aktuálna dĺžka sa sa zmení na dvojnásobok jej predošlej hodnoty
aktual_dlzka = 2 * aktual_dlzka

def merge(pole, lavy, stred, pravy):
n1 = stred - lavy + 1
n2 = pravy - stred

# Inicializácia pomocných polí
L = [0] * n1
P = [0] * n2

# Načítanie dát do pomocných polí
for i in range(0, n1):
L[i] = pole[lavy + i]
for i in range(0, n2):
P[i] = pole[stred + i + 1]

i, j, k = 0, 0, lavy

# Zlúčenie a zoradenie údajov z pomocných polí do jedného pola
while i < n1 and j < n2:
if L[i] > P[j]:
pole[k] = P[j]
j += 1
else:
pole[k] = L[i]
i += 1
k += 1

# Kontrola či všetky prvky boli zlúčené dokopy,
# ak nie, tak sa do zlúčeného pola jednoducho skopírujú
while i < n1:
pole[k] = L[i]
i += 1
k += 1

while j < n2:
pole[k] = P[j]
j += 1
k += 1

# Hlavný program
if __name__ == '__main__':
pole = [12, 11, 13, 5, 6, 7]

print("Zadané pole:", end="\n")
print(pole, end="\n")

MergeSort_iteracia(pole)

print("Zoradené pole:", end="\n")
print(pole, end="\n")

</syntaxhighlight>
</tab>

</tabs>

==Odkazy==
# https://www.geeksforgeeks.org/merge-sort/
# https://www.geeksforgeeks.org/iterative-merge-sort/
# https://medium.com/@paulsoham/merge-sort-63d75df76388
# https://www.khanacademy.org/computing/computer-science/algorithms/merge-sort/a/overview-of-merge-sort
# https://www.tutorialspoint.com/data_structures_algorithms/merge_sort_algorithm.htm
# https://www.youtube.com/watch?v=6pV2IF0fgKY
# https://www.youtube.com/watch?v=mB5HXBb_HY8
# https://www.youtube.com/watch?v=ak-pz7tS5DE

Triedenie zlučovaním

2021-03-29T10:18:22Z

Filip Tomek: /* Implementácia algoritmov Merge a MergeSortv rôznych programovacích jazykoch */

[[Kategória:Algoritmy triedenia]]
{{Draft}}
{{Skripta programovanie}}
__TOC__
==TODO: Pseudokód treba opraviť, text refaktorovať, otestovať kódy, zvýrazniť veci v texte, opraviť preklepy, opraviť popis obrázkov, pridať nové odkazy==

==Zlučovací algoritmus Merge==

Princíp zlučovania tkvie v tom, že máme dva alebo viac utriedených zoznamov, ktoré skombinuje do jedného utriedeného zoznamu (výsledný zoznam musí obsahovať všetky prvky z pôvodných zoznamov). Zoznam môže byť reprezentovaný ako dátová štruktúra pole alebo aj ako lineárny zoznam. V tomto článku sa zameriame na algoritmus pre dátovú štruktúru pole.

Algoritmus Merge tvorí kľúčovú časť triediaceho algoritmu MergeSort.

[[Súbor:Funkcia merge.png|500px|náhľad|vpravo|Vizualizácia funkcie Merge: Máme pole prvkov p = [1, 3, 5, 2, 4, 6], ktoré je už čiastočne utriedené. Použijeme algoritmus Merge, ktorý si vytvorí pomocné polia L = [1, 3, 5] a P = [2, 4, 6]. Všetky polia indexujeme od 0, pričom pre pole p používame index k, pre L index i a pre P index j. Postupnosť krokov je označená číslicami 1 až 6.
]]

===Slovný opis algoritmu===
Nech máme pole, ktoré sa skladá z dvoch už utriedených polovíc. Vytvoríme si dve pomocné polia L a P a do každého z nich skopírujeme obsah jednej polovice (L - ľavá polovica, P - pravá polovica). Potom súčasne prechádzame polia L a P od začiatku po koniec, pričom v každom cykle porovnáme prvok poľa L s prvkom v poli P. Z tejto dvojice následne vyberieme minimum, (keď triedime od najmenšieho po najväčší) ktoré vložíme na prvú voľnú pozíciu pôvodného poľa (na začiatku je to prvá pozícia poľa). Nakoniec zvýšime index pri vstupnom poli a pri pomocnom poli, z ktorého vyberáme daný prvok. Túto postupnosť krokov opakujeme, pokiaľ neprídeme na koniec jedného z polí P a L. Ak nastane situácia, že prídeme na koniec jedného z pomocných polí (a v druhom nám ostali ešte nejaké prvky), potom už iba naspäť skopírujeme zbytok druhého pomocného poľa na koniec pôvodného poľa.

===Vlastnosti algoritmu===
* vhodný pre dátové štruktúry: pole, lineárny zoznam
* časová náročnosť: vždy lineárna <math>O(n)</math>
* priestorová náročnosť: lineárna <math>O(n)</math> pre pole (alokovanie pomocných polí), <math>O(1)</math> pre lineárny zoznam (pri LZ netreba alokovať dočasné polia, stačí iba presmerovať smerníky)
* využitie: kľúčový podprogram pre triediaci algoritmus MergeSort

===Pseudokód===
Nech funkcia Merge má nasledovný prototyp: <code>Merge(pole[], lavy, stred, pravy)</code>
:1. Je <code>lavy >= pravy ? Ak áno, skonči, inak pokračuj krokom 2.</code>
:2. Nech: <code>i = 0, j = 0, k = lavy </code>
:3. Nech: <code>dlzka_L = stred - lavy + 1, dlzka_P = pravy - stred</code>
:4. Nech: <code> L = pole[lavy ... stred], P = pole[stred + 1 ... pravy] </code>
:5. Je <code>i < dlzka_L</code> a zároveň <code>j < dlzka_P</code> ? Ak áno, pokračuj krokom 5.1., inak skoč na krok 6.
:::5.1. Je <code>L[i] <= P[j]</code>?
:::: Ak áno:
:::::5.1.1. <code>pole[k] = L[i]</code>
:::::5.1.2. <code>k += 1</code>
:::::5.1.3. <code>i += 1</code>
:::::5.1.4. Skoč na krok 5.
:::: Ak nie:
:::::5.1.1. <code>pole[k] = P[j]</code>
:::::5.1.2. <code>k += 1</code>
:::::5.1.3. <code>j += 1</code>
:::::5.1.4. Skoč na krok 5.
:6. Je <code>i < dlzka_L</code> ? Ak áno, pokračuj krokom 6.1., inak skoč na krok 7.
:::6.1. <code>pole[k] = L[i]</code>
:::6.2. <code>k += 1</code>
:::6.3. <code>i += 1</code>
:::6.4. Skoč na krok 6.
:7. Je <code>j < dlzka_P</code> ? Ak áno, pokračuj krokom 7.1., inak skonči.
:::7.1. <code>pole[k] = P[j]</code>
:::7.2. <code>k += 1</code>
:::7.3. <code>j += 1</code>
:::7.4. Skoč na krok 7.

==Merge sort==
Merge Sort je triediaci algoritmus, ktorý využíva stratégiu '''"rozdeľuj a panuj"''', čo znamená, že vstupný zoznam najskôr rozdelí na dve polovice, tie zoradí a potom ich zlúči naspäť dokopy. Radí sa medzi najpoužívanejšie a najviac rešpektované triediace algoritmy.

===Vlastnosti algoritmu Merge Sort===
* vhodný pre dátové štruktúry: pole, lineárny zoznam
* časová náročnosť: vždy linearitmická <math> O(n.log(n)) </math>, vďaka ktorej dokáže efektívne triediť veľmi veľké zoznamy
* priestorová náročnosť: lineárna <math>O(n)</math> pre pole (alokovanie dočasných polí), konštantná <math>O(1)</math> pre lineárny zoznam (pri LZ stačí iba presmerovať smerníky)
* druh triedenia: triedenie zlučovaním (komparačný algoritmus)
* stabilita triedenia: stabilný
* miesto triedenia: externé triedenie (vhodný na triedenie veľkých objemov dát uložených na disku)

Z hľadiska implementácie môžeme vytvoriť dve základné verzie algoritmu, a to rekurzívnu a iteračnú.
===Opis rekurzívnej a iteračnej verzie algoritmu Merge Sort===

<tabs>
<tab name="Rekurzívna verzia" block>
[[Súbor:Merge sort.png|400px|náhľad|vpravo|Vizualizácia rekurzívnej verzie algoritmu MergeSort]]

===Princíp algoritmu===
Algoritmus MergeSort vykonáva 4 základné úlohy:
# Delenie poľa na dve polovice.
# Triedenie ľavej polovice poľa.
# Triedenie pravej polovice poľa.
# Zlúčenie oboch polovíc pomocou funkcie Merge.

===Slovný opis===
Našou úlohou je vzostupne (min - max) utriediť vstupné pole. Určíme si stred poľa (pri párnom počte prvkov je to ten menší z prostredných indexov). Následne vykonávame sériu rekurzívnych delení pre ľavú a pravú časť poľa (začiatok ... stred ; stred + 1 ... koniec) až do momentu, keď nám ostanú len jednoprvkové podpolia (tie sú už utriedené). Následne v každom volaní obe tieto podpolia zlúčime pomocou algoritmu Merge do väčších podpolí (2, 4, 8, ...), až nakoniec dostaneme jedno výsledné utriedené pole.

===Pseudokód===
Nech nech má funkcia MergeSort nasledovný prototyp: <code>MergeSort(pole[], lavy, pravy) </code>
:1. Je <code>lavy >= pravy</code> ? Ak áno, skonči volanie, inak pokračuj krokom 2.
:2. Nech: <code>stred = lavy + (pravy - lavy) / 2</code>, pričom znak ''/'' vyjadruje celočíselné delenie.
:3. Rekurzívne zavolaj funkciu <code>MergeSort(pole[], lavy , stred)</code>
:3. Rekurzívne zavolaj funkciu <code>MergeSort(pole[], stred + 1 , pravy)</code>
:4. Zavolaj funkciu <code>Merge(pole[], lavy, stred, pravy)</code>
:5. Skonči volanie.

</tab>
<tab name="Iteračná verzia" block>
[[Súbor:MergeSort It.png|400px|náhľad|vpravo|Vizualizácia iteračnej verzie algoritmu MergeSort]]

===Princíp algoritmu===
Algoritmus Merge vykonáva 3 základné úlohy:
# Vonkajší cyklus: určenie veľkosti zoznamu na zlučovanie.
# Vnútorný cyklus: prechádzanie jednotlivých zoznamov v poli.
# Zlučovanie jednotlivých zoznamov pomocou funkcie Merge.

===Slovný opis===
Vstupné pole, ktoré má ''N'' prvkov, môžeme chápať, ako ''N'' rôznych jednoprvkových (utriedených) podpolí, ktoré máme zlúčiť do jedného výsledného ''N''-prvkového utriedeného poľa. Keďže by bolo veľmi nepraktické zlučovať ''N'' podpolí naraz, zvolíme nasledovnú stratégiu: Budeme prechádzať dané pole od začiatku po koniec a v prvom cykle zlúčime každé dva prvky, takže budeme mať <math>\frac{n}{2}</math> dvojprvkových utriedených podpolí. Potom v druhom cykle zlúčime každé 4 prvky do jedného podpoľa, v treťom cykle každých 8, až do momentu, keď dostaneme jedno utriedené pole.
Aby sme to docielili, potrebujeme dva cykly, vonkajší, ktorý nastaví maximálnu veľkosť podpoľa, ktoré ideme zlučovať (1,2,4,8 ... dlzka - 1) a vnútorný, ktorý prechádza jednotlivé podpolia. Následne už iba voláme funkciu Merge, ktorá dané podpolia zlučuje.

Poznámka, ak máme pole, ktoré má nepárny počet prvkov, tak ten posledný prvok nezlúčime hneď v prvom cykle, ale až v tých ďalších. Takisto, ak n nie je mocnina čísla 2, tak musíme samozrejme ošetriť situáciu, kedy by sme sa dostali mimo rozsah poľa (Ak máme napríklad pole, čo má 7 prvkov, tak po prvej iterácii budú prvky utiredené podľa vzoru 2 + 2 + 2 + 1, po druhej 4 + 3, a po tretej 7)

===Pseudokód===
Nech nech má funkcia MergeSort nasledovný prototyp: <code>MergeSort(pole[], lavy, pravy) </code>
:1. Je <code>lavy >= pravy</code> ? Ak áno, skonči, inak pokračuj krokom 2.
:2. Nech: <code>dlzka_subzoznamu = 1 </code>
:3. Nech: <code>zaciatok = lavy</code>
:4. Je<code>dlzka_subzoznamu <= pravy</code> ? Ak áno pokračuj krokom 4.1, inak skonči.
:::4.1. Je<code>zaciatok < pravy</code> Ak áno pokračuj krokom 4.1.1, inak skoč na krok 4.2.
:::::4.1.1. Je <code>zaciatok + 2 * dlzka_zoznamu - 1 <= pravy</code> ?
:::::::Ak áno:
:::::::::4.1.1.1. Nech <code>koniec = zaciatok + 2 * dlzka_zoznamu - 1</code>
:::::::Ak nie:
:::::::::4.1.1.1. Nech <code>koniec = pravy</code>
:::::4.1.2. Je <code>zaciatok + dlzka_zoznamu - 1 <= pravy</code> ?
:::::::Ak áno:
:::::::::4.1.2.1. Nech <code>stred = zaciatok + dlzka_zoznamu - 1</code>
:::::::Ak nie:
:::::::::4.1.2.1. Nech <code>stred = pravy</code>
:::::4.1.3. <code>Merge(pole[], zaciatok, stred, koniec)</code>
:::::4.1.4. <code>zaciatok += 2 * dlzka_subzoznamu</code>
:::::4.1.5. Skoč na krok 4.1.
:::4.2. <code>dlzka_subzoznamu *= 2</code>
:::4.3 Skoč na krok 4.

</tab>
</tabs>

==Implementácia algoritmov Merge a MergeSort v rôznych programovacích jazykoch==
<tabs>
<tab name="Rekurzívna: C " block>
<syntaxhighlight lang="C">
#include <stdio.h>
#include <stdlib.h>

void Merge(int pole[], int lavy, int stred, int pravy);
void MergeSort(int pole[], int lavy, int pravy);

/* hlavný program */

int main()
{
int pole[] = {12, 11, 13, 5, 6, 7};
int dlzka_pola = sizeof(pole) / sizeof(pole[0]);

printf("Pôvodné pole: \n");

for (int i = 0; i < dlzka_pola; ++i)
{
printf("%d ", pole[i]);
}

MergeSort(pole, 0, dlzka_pola - 1);

printf("\nUtriedené pole: \n");

for (int i = 0; i < dlzka_pola; ++i)
{
printf("%d ", pole[i]);
}

return 0;
}

void Merge(int pole[], int lavy, int stred, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči */

if (lavy >= pravy)
{
return;
}

/* vyrátaj dĺžky oboch polovíc poľa */

int L_dlzka = stred - lavy + 1;
int P_dlzka = pravy - stred;

/* alokuj dočasné polia, kam uložíš prvky z oboch polovíc poľa */

int *L = (int*)malloc(L_dlzka * sizeof(int));
int *P = (int*)malloc(P_dlzka * sizeof(int));

/* indexy, ktorými iterujeme všetky polia: i pre L, j pre P, k pre pole */

int i, j, k;

/* skopíruj obsah oboch polovíc poľa do dočasných polí L a P */

for (i = 0; i < L_dlzka; ++i)
{
L[i] = pole[lavy + i];
}

for (j = 0; j < P_dlzka; ++j)
{
P[j] = pole[stred + 1 + j];
}

/* nastav indexy na začiatok daných polí */

i = 0; j = 0; k = lavy;

/* zlučuj dočasné polia L a P do finálneho poľa pole */

while(i < L_dlzka && j < P_dlzka)
{
if(L[i] <= P[j])
{
pole[k++] = L[i++];
}
else
{
pole[k++] = P[j++];
}
}

/* ak ostali nejaké prvky v dočasnom poli L, skopíruj ich do finálneho poľa */

while(i < L_dlzka)
{
pole[k++] = L[i++];
}

/* ak ostali nejaké prvky v dočasnom poli P, skopíruj ich do finálneho poľa */

while(j < P_dlzka)
{
pole[k++] = P[j++];
}

/* uvoľni použitú pamäť */

free(L);
free(P);
}

void MergeSort(int pole[], int lavy, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči volanie */

if(lavy >= pravy)
{
return;
}
/* urči si prostredný index */

int stred = lavy + (pravy - lavy) / 2;

/* utrieď ľavú polovicu poľa */

MergeSort(pole, lavy, stred);

/* utrieď pravú polovicu poľa */

MergeSort(pole, stred+1, pravy);

/* zlúč obe polovice dokopy */

Merge(pole, lavy, stred, pravy);
}
</syntaxhighlight>
</tab>

<tab name="Iteračná: C" block>
<syntaxhighlight lang="C">
#include <stdio.h>
#include <stdlib.h>

void Merge(int pole[], int lavy, int stred, int pravy);
void MergeSortIt(int *pole, int lavy, int pravy);

/* hlavný program */

int main()
{
int pole[] = {12, 11, 13, 5, 6, 7, 19};
int dlzka_pola = sizeof(pole) / sizeof(pole[0]);

printf("Pôvodné pole %d: \n", dlzka_pola);

for (int i = 0; i < dlzka_pola; ++i)
{
printf("%d ", pole[i]);
}

MergeSortIt(pole, 0, dlzka_pola - 1);

printf("\nUtriedené pole: \n");

for (int i = 0; i < dlzka_pola; ++i)
{
printf("%d ", pole[i]);
}

return 0;
}

void Merge(int pole[], int lavy, int stred, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči */

if (lavy >= pravy)
{
return;
}

/* vyrátaj dĺžky oboch polovíc poľa */

int L_dlzka = stred - lavy + 1;
int P_dlzka = pravy - stred;

/* alokuj dočasné polia, kam uložíš prvky z oboch polovíc poľa */

int *L = (int*)malloc(L_dlzka * sizeof(int));
int *P = (int*)malloc(P_dlzka * sizeof(int));

/* indexy, ktorými iterujeme všetky polia: i pre L, j pre P, k pre pole */

int i, j, k;

/* skopíruj obsah oboch polovíc poľa do dočasných polí L a P */

for (i = 0; i < L_dlzka; ++i)
{
L[i] = pole[lavy + i];
}

for (j = 0; j < P_dlzka; ++j)
{
P[j] = pole[stred + 1 + j];
}

/* nastav indexy na začiatok daných polí */

i = 0; j = 0; k = lavy;

/* zlučuj dočasné polia L a P do finálneho poľa pole */

while(i < L_dlzka && j < P_dlzka)
{
if(L[i] <= P[j])
{
pole[k++] = L[i++];
}
else
{
pole[k++] = P[j++];
}
}

/* ak ostali nejaké prvky v dočasnom poli L, skopíruj ich do finálneho poľa */

while(i < L_dlzka)
{
pole[k++] = L[i++];
}

/* ak ostali nejaké prvky v dočasnom poli P, skopíruj ich do finálneho poľa */

while(j < P_dlzka)
{
pole[k++] = P[j++];
}

/* uvoľni použitú pamäť */

free(L);
free(P);
}

void MergeSortIt(int *pole, int lavy, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči volanie */

if(lavy >= pravy)
{
return;
}

int stred, koniec;

for (int dlzka_zoznamu = 1; dlzka_zoznamu <= pravy ; dlzka_zoznamu *= 2)
{
for (int zaciatok = lavy; zaciatok < pravy ; zaciatok += 2 * dlzka_zoznamu)
{
koniec = (zaciatok + 2 * dlzka_zoznamu - 1 <= pravy) ? zaciatok + 2 * dlzka_zoznamu - 1 : pravy;

stred = (zaciatok + dlzka_zoznamu - 1 <= pravy) ? zaciatok + dlzka_zoznamu - 1 : pravy;

Merge(pole, zaciatok, stred, koniec);

}
}
}

</syntaxhighlight>
</tab>

<tab name="Rekurzívna: C++" block>
<syntaxhighlight lang="C++">
#include <iostream>

using std::cout;
using std::endl;

void Merge(int pole[], int lavy, int stred, int pravy);
void MergeSort(int pole[], int lavy, int pravy);

/* hlavný program */

int main()
{
int pole[] = {12, 11, 13, 5, 6, 7};
int dlzka_pola = sizeof(pole) / sizeof(pole[0]);

printf("Pôvodné pole: \n");

for (auto i: pole)
{
cout<<i<<" ";
}

MergeSort(pole, 0, dlzka_pola - 1);

cout<<endl<<"Utriedené pole:"<<endl;

for (auto i: pole)
{
cout<<i<<" ";
}

return 0;
}

void Merge(int pole[], int lavy, int stred, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči */

if (lavy >= pravy)
{
return;
}

/* vyrátaj dĺžky oboch polovíc poľa */

int L_dlzka = stred - lavy + 1;
int P_dlzka = pravy - stred;

/* alokuj dočasné polia, kam uložíš prvky z oboch polovíc poľa */

int *L = new int[L_dlzka];
int *P = new int[P_dlzka];

/* indexy, ktorými iterujeme všetky polia: i pre L, j pre P, k pre pole */

int i, j, k;

/* skopíruj obsah oboch polovíc poľa do dočasných polí L a P */

for (i = 0; i < L_dlzka; ++i)
{
L[i] = pole[lavy + i];
}

for (j = 0; j < P_dlzka; ++j)
{
P[j] = pole[stred + 1 + j];
}

/* nastav indexy na začiatok daných polí */

i = 0; j = 0; k = lavy;

/* zlučuj dočasné polia L a P do finálneho poľa pole */

while(i < L_dlzka && j < P_dlzka)
{
if(L[i] <= P[j])
{
pole[k++] = L[i++];
}
else
{
pole[k++] = P[j++];
}
}

/* ak ostali nejaké prvky v dočasnom poli L, skopíruj ich do finálneho poľa */

while(i < L_dlzka)
{
pole[k++] = L[i++];
}

/* ak ostali nejaké prvky v dočasnom poli P, skopíruj ich do finálneho poľa */

while(j < P_dlzka)
{
pole[k++] = P[j++];
}

/* uvoľni použitú pamäť */

delete []L;
delete []P;
}

void MergeSort(int pole[], int lavy, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči volanie */

if(lavy >= pravy)
{
return;
}
/* urči si prostredný index */

int stred = lavy + (pravy - lavy) / 2;

/* utrieď ľavú polovicu poľa */

MergeSort(pole, lavy, stred);

/* utrieď pravú polovicu poľa */

MergeSort(pole, stred+1, pravy);

/* zlúč obe polovice dokopy */

Merge(pole, lavy, stred, pravy);
}

</syntaxhighlight>
</tab>

<tab name="Iteračná: C++" block>
<syntaxhighlight lang="C++">
#include <iostream>

using std::cout;
using std::endl;

void Merge(int pole[], int lavy, int stred, int pravy);
void MergeSort(int pole[], int lavy, int pravy);

/* hlavný program */

int main()
{
int pole[] = {12, 11, 13, 5, 6, 7};
int dlzka_pola = sizeof(pole) / sizeof(pole[0]);

printf("Pôvodné pole: \n");

for (auto i: pole)
{
cout<<i<<" ";
}

MergeSort(pole, 0, dlzka_pola - 1);

cout<<endl<<"Utriedené pole:"<<endl;

for (auto i: pole)
{
cout<<i<<" ";
}

return 0;
}

void Merge(int pole[], int lavy, int stred, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči */

if (lavy >= pravy)
{
return;
}

/* vyrátaj dĺžky oboch polovíc poľa */

int L_dlzka = stred - lavy + 1;
int P_dlzka = pravy - stred;

/* alokuj dočasné polia, kam uložíš prvky z oboch polovíc poľa */

int *L = new int[L_dlzka];
int *P = new int[P_dlzka];

/* indexy, ktorými iterujeme všetky polia: i pre L, j pre P, k pre pole */

int i, j, k;

/* skopíruj obsah oboch polovíc poľa do dočasných polí L a P */

for (i = 0; i < L_dlzka; ++i)
{
L[i] = pole[lavy + i];
}

for (j = 0; j < P_dlzka; ++j)
{
P[j] = pole[stred + 1 + j];
}

/* nastav indexy na začiatok daných polí */

i = 0; j = 0; k = lavy;

/* zlučuj dočasné polia L a P do finálneho poľa pole */

while(i < L_dlzka && j < P_dlzka)
{
if(L[i] <= P[j])
{
pole[k++] = L[i++];
}
else
{
pole[k++] = P[j++];
}
}

/* ak ostali nejaké prvky v dočasnom poli L, skopíruj ich do finálneho poľa */

while(i < L_dlzka)
{
pole[k++] = L[i++];
}

/* ak ostali nejaké prvky v dočasnom poli P, skopíruj ich do finálneho poľa */

while(j < P_dlzka)
{
pole[k++] = P[j++];
}

/* uvoľni použitú pamäť */

delete []L;
delete []P;
}

void MergeSort(int *pole, int lavy, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči volanie */

if(lavy >= pravy)
{
return;
}

int stred, koniec;

for (int dlzka_zoznamu = 1; dlzka_zoznamu <= pravy; dlzka_zoznamu *= 2)
{
for (int zaciatok = lavy; zaciatok < pravy; zaciatok += 2 * dlzka_zoznamu)
{
koniec = (zaciatok + 2 * dlzka_zoznamu - 1 <= pravy) ? zaciatok + 2 * dlzka_zoznamu - 1 : pravy;

stred = (zaciatok + dlzka_zoznamu - 1 <= pravy) ? zaciatok + dlzka_zoznamu - 1 : pravy;

Merge(pole, zaciatok, stred, koniec);
}
}
}
</syntaxhighlight>
</tab>

<tab name="Rekurzívna: Java" block>
<syntaxhighlight lang="Java">
class MergeSort
{

/* Funkcia zlúči 2 podpolia, ktoré sme vytvorili z pôvodného poľa.
* Každé podpole má polovičnú dĺžku pôvodného poľa.
* subpole1 [ľavý ... stred]
* subpole2 [stred + 1 ... pravý] */

void merge(int[] pole, int lavy, int stred, int pravy)
{

// Výpočet dĺžky 2 podpolí

int n1 = stred - lavy + 1;
int n2 = pravy - stred;

// Vytvorenie pomocných polí

int[] L = new int[n1];
int[] P = new int[n2];

// Načítanie dát do pomocných polí

for (int i = 0; i < n1; i++)
L[i] = pole[lavy + i];

for (int j = 0; j < n2; j++)
P[j] = pole[stred + 1 + j];

// Počiatočné indexy prvého a druhého podpoľa

int i = 0, j = 0;

// Počiatočný index zlúčeného podpoľa

int k = lavy;

// Zlúčenie dvoch podpolí

while (i < n1 && j < n2)
{
if (L[i] <= P[j])
{
pole[k] = L[i];
i++;
}
else
{
pole[k] = P[j];
j++;
}
k++;
}

/* V prípade, že sa v jednom zo podpoli nachádzajú ešte nejaké prvky, ktoré neboli zlúčené do pola,
* tak sa do pola jednoducho skopírujú */

while (i < n1)
{
pole[k] = L[i];
i++;
k++;
}

while (j < n2)
{
pole[k] = P[j];
k++;
j++;
}

}

/* Funkcia, ktorá zoradí pole použitím funkcie merge() */

void sort (int[] pole, int lavy, int pravy)
{
if (lavy < pravy)
{
// Musíme nájsť stred pola

int stred = lavy + (pravy - lavy) / 2;

// Zoradíme prvú a druhú polovicu pola samostatne

sort(pole, lavy, stred);
sort(pole, stred + 1, pravy);

// Zlúčime zoradené polovice do jedného pola

merge(pole, lavy, stred, pravy);
}
}
}

public class Main
{
/* Funkcia na výpis pola dĺžky n */

static void vypis_pole(int[] pole)
{

for (int j : pole)
{
System.out.print(j + " ");
}

System.out.println();
}

/* Hlavný program */

public static void main(String[] args)
{
int[] pole = {12, 11, 13, 5, 6, 7};

System.out.println("Zadané pole:");
vypis_pole(pole);

MergeSort ms = new MergeSort();
ms.sort(pole, 0, pole.length - 1);

System.out.println("\nZoradené pole:");
vypis_pole(pole);
}
}
</syntaxhighlight>
</tab>

<tab name="Iteračná: Java" block>
<syntaxhighlight lang="Java">
class MergeSort_iteracia {
/* Zlúči 2 subpolia, ktoré sa vytvorili z pôvodného pola.
* Každé subpole má polovičnú dĺžku pôvodného pola.
* subpole1 [ľavý..stred]
* subpole2 [stred+1..pravý] */
void merge(int[] pole, int lavy, int stred, int pravy) {
// Výpočet dĺžky 2 subpolí
int n1 = stred - lavy + 1;
int n2 = pravy - stred;

// Vytvorenie pomocných polí
int[] L = new int[n1];
int[] P = new int[n2];

// Načítanie dát do pomocných polí
for (int i = 0; i < n1; i++)
L[i] = pole[lavy + i];

for (int j = 0; j < n2; j++)
P[j] = pole[stred + 1 + j];

// Počiatočné indexy prvého a druhého subpola
int i = 0, j = 0;
// Počiatočný index zlúčeného subpola
int k = lavy;

// Zlúčenie dvoch podpolí
while (i < n1 && j < n2) {
if (L[i] <= P[j]) {
pole[k] = L[i];
i++;
}
else {
pole[k] = P[j];
j++;
}
k++;
}

/* V prípade, že v jednom zo subpolí sa nachádzajú prvky, ktoré neboli zlúčené do pola,
* tak sa do pola jednoducho skopírujú */
while (i < n1) {
pole[k] = L[i];
i++;
k++;
}

while (j < n2) {
pole[k] = P[j];
k++;
j++;
}
}

/* Funkcia, ktorá zoradí pole použitím funkcie merge() */
void sort (int[] pole, int n) {
/* Dĺžka subpolí, ktoré majú byť zlúčené, hodnoty premennej sa pohybujú v intervale <1;n-1> */
int aktual_dlzka;
/* Začiatočný index ľavého subpola, ktoré má byť zlúčené */
int zaciatok_vlavo;

/* Vzostupné usporiadanie prvkov. Najskôr sa zlúčia subpolia veľkosti 1 do subpolí veľkosti 2,
* potom subpolia veľkosti 2 do subpolí veľkosti 4 a tak ďalej */
for (aktual_dlzka = 1; aktual_dlzka <= n - 1; aktual_dlzka *= 2) {
/* Určenie začiatočného prvku rôznych subpolí aktuálnej dĺžky subpola */
for (zaciatok_vlavo = 0; zaciatok_vlavo < n - 1; zaciatok_vlavo += 2 * aktual_dlzka) {
/* Nájdenie konečného prvku ľavého subpola, stred+1 je začiatočný prvok pravého subpola */
int stred = Math.min(zaciatok_vlavo + aktual_dlzka - 1, n - 1);
int koniec_vpravo = Math.min(zaciatok_vlavo + 2 * aktual_dlzka - 1, n - 1);

/* Zlúči subpolia L[zaciatok_vlavo .. stred] & P[stred+1 .. koniec_vpravo] */
merge(pole, zaciatok_vlavo, stred, koniec_vpravo);
}
}
}
}

public class Main {
/* Funkcia na výpis pola dĺžky n */
static void vypis_pole(int[] pole) {
int n = pole.length;

for (int j : pole) {
System.out.print(j + " ");
}
System.out.println();
}

/* Hlavný program */
public static void main(String[] args) {

/* Inicializácia pola */
int[] pole = {12, 11, 13, 5, 6, 7};

System.out.println("Zadané pole:");
vypis_pole(pole);

MergeSort_iteracia ms_it = new MergeSort_iteracia();
ms_it.sort(pole, pole.length);

System.out.println("Zoradené pole:");
vypis_pole(pole);
}
}
</syntaxhighlight>
</tab>

<tab name="Rekurzívna: Python3" block>
<syntaxhighlight lang="Python3">
def MergeSort(pole):
if len(pole) > 1:
# Nájdenie stredu pola
# zápis len(pole)//2 znamená, že dĺžka pola sa vydelí 2 a výsledok je celé číslo
stred = len(pole) // 2

# Rozdelenie pola na dve časti
L = pole[:stred]
P = pole[stred:]

# Zoradenie najskôr prvej časti pola, potom druhej
MergeSort(L)
MergeSort(P)

i = j = k = 0

# Zlúčenie a zoradenie údajov z pomocných polí do jedného pola
while i < len(L) and j < len(P):
if L[i] < P[j]:
pole[k] = L[i]
i += 1
else:
pole[k] = P[j]
j += 1
k += 1

# Kontrola či všetky prvky boli zlúčené dokopy,
# ak nie, tak sa do zlúčeného pola jednoducho skopírujú
while i < len(L):
pole[k] = L[i]
i += 1
k += 1

while j < len(P):
pole[k] = P[j]
j += 1
k += 1

# Hlavný program
if __name__ == '__main__':
pole = [12, 11, 13, 5, 6, 7]

print("Zadané pole:", end="\n")
print(pole, end="\n")

MergeSort(pole)

print("Zoradené pole:", end="\n")
print(pole, end="\n")

</syntaxhighlight>
</tab>

<tab name="Iteračná: Python3" block>
<syntaxhighlight lang="Python3">
def MergeSort_iteracia(pole):
# Dĺžka subpolí, ktoré majú byť zlúčené, hodnoty premennej sa pohybujú v intervale <1;n-1>
aktual_dlzka = 1

# Vonkajší cyklus, ktorý určuje subpolia aktuálnej dĺžky
while aktual_dlzka < len(pole) - 1:
lavy = 0

# Vnútorný cyklus, ktorý slúži na zlúčenie a zoradenie subpoli do jedného subpola
while lavy < len(pole) - 1:
# Index stredného prvku sa určí, keď k indexu ľavého prvku subpola pripočítame aktuálnu
# dĺžku subpolí a odčítame 1
stred = min((lavy + aktual_dlzka - 1), len(pole) - 1)

# Ak platí podmienka 2 * aktuálna dĺžka < dĺžka pola - 1, tak pravý index = aktuálnej dĺžke subpolí,
# inak pravý index = dĺžke pola - 1
pravy = ((2 * aktual_dlzka + lavy - 1, len(pole) - 1)[2 * aktual_dlzka + lavy - 1 > len(pole) - 1])

# Volanie funkcie merge
merge(pole, lavy, stred, pravy)

lavy = lavy + 2 * aktual_dlzka

# Aktuálna dĺžka sa sa zmení na dvojnásobok jej predošlej hodnoty
aktual_dlzka = 2 * aktual_dlzka

def merge(pole, lavy, stred, pravy):
n1 = stred - lavy + 1
n2 = pravy - stred

# Inicializácia pomocných polí
L = [0] * n1
P = [0] * n2

# Načítanie dát do pomocných polí
for i in range(0, n1):
L[i] = pole[lavy + i]
for i in range(0, n2):
P[i] = pole[stred + i + 1]

i, j, k = 0, 0, lavy

# Zlúčenie a zoradenie údajov z pomocných polí do jedného pola
while i < n1 and j < n2:
if L[i] > P[j]:
pole[k] = P[j]
j += 1
else:
pole[k] = L[i]
i += 1
k += 1

# Kontrola či všetky prvky boli zlúčené dokopy,
# ak nie, tak sa do zlúčeného pola jednoducho skopírujú
while i < n1:
pole[k] = L[i]
i += 1
k += 1

while j < n2:
pole[k] = P[j]
j += 1
k += 1

# Hlavný program
if __name__ == '__main__':
pole = [12, 11, 13, 5, 6, 7]

print("Zadané pole:", end="\n")
print(pole, end="\n")

MergeSort_iteracia(pole)

print("Zoradené pole:", end="\n")
print(pole, end="\n")

</syntaxhighlight>
</tab>

</tabs>

==Odkazy==
# https://www.geeksforgeeks.org/merge-sort/
# https://www.geeksforgeeks.org/iterative-merge-sort/
# https://medium.com/@paulsoham/merge-sort-63d75df76388
# https://www.khanacademy.org/computing/computer-science/algorithms/merge-sort/a/overview-of-merge-sort
# https://www.tutorialspoint.com/data_structures_algorithms/merge_sort_algorithm.htm
# https://www.youtube.com/watch?v=6pV2IF0fgKY
# https://www.youtube.com/watch?v=mB5HXBb_HY8
# https://www.youtube.com/watch?v=ak-pz7tS5DE

Triedenie zlučovaním

2021-03-29T10:17:53Z

Filip Tomek: /* Implementácia algoritmov Merge a MergeSort programovacích jazykoch */

[[Kategória:Algoritmy triedenia]]
{{Draft}}
{{Skripta programovanie}}
__TOC__
==TODO: Pseudokód treba opraviť, text refaktorovať, otestovať kódy, zvýrazniť veci v texte, opraviť preklepy, opraviť popis obrázkov, pridať nové odkazy==

==Zlučovací algoritmus Merge==

Princíp zlučovania tkvie v tom, že máme dva alebo viac utriedených zoznamov, ktoré skombinuje do jedného utriedeného zoznamu (výsledný zoznam musí obsahovať všetky prvky z pôvodných zoznamov). Zoznam môže byť reprezentovaný ako dátová štruktúra pole alebo aj ako lineárny zoznam. V tomto článku sa zameriame na algoritmus pre dátovú štruktúru pole.

Algoritmus Merge tvorí kľúčovú časť triediaceho algoritmu MergeSort.

[[Súbor:Funkcia merge.png|500px|náhľad|vpravo|Vizualizácia funkcie Merge: Máme pole prvkov p = [1, 3, 5, 2, 4, 6], ktoré je už čiastočne utriedené. Použijeme algoritmus Merge, ktorý si vytvorí pomocné polia L = [1, 3, 5] a P = [2, 4, 6]. Všetky polia indexujeme od 0, pričom pre pole p používame index k, pre L index i a pre P index j. Postupnosť krokov je označená číslicami 1 až 6.
]]

===Slovný opis algoritmu===
Nech máme pole, ktoré sa skladá z dvoch už utriedených polovíc. Vytvoríme si dve pomocné polia L a P a do každého z nich skopírujeme obsah jednej polovice (L - ľavá polovica, P - pravá polovica). Potom súčasne prechádzame polia L a P od začiatku po koniec, pričom v každom cykle porovnáme prvok poľa L s prvkom v poli P. Z tejto dvojice následne vyberieme minimum, (keď triedime od najmenšieho po najväčší) ktoré vložíme na prvú voľnú pozíciu pôvodného poľa (na začiatku je to prvá pozícia poľa). Nakoniec zvýšime index pri vstupnom poli a pri pomocnom poli, z ktorého vyberáme daný prvok. Túto postupnosť krokov opakujeme, pokiaľ neprídeme na koniec jedného z polí P a L. Ak nastane situácia, že prídeme na koniec jedného z pomocných polí (a v druhom nám ostali ešte nejaké prvky), potom už iba naspäť skopírujeme zbytok druhého pomocného poľa na koniec pôvodného poľa.

===Vlastnosti algoritmu===
* vhodný pre dátové štruktúry: pole, lineárny zoznam
* časová náročnosť: vždy lineárna <math>O(n)</math>
* priestorová náročnosť: lineárna <math>O(n)</math> pre pole (alokovanie pomocných polí), <math>O(1)</math> pre lineárny zoznam (pri LZ netreba alokovať dočasné polia, stačí iba presmerovať smerníky)
* využitie: kľúčový podprogram pre triediaci algoritmus MergeSort

===Pseudokód===
Nech funkcia Merge má nasledovný prototyp: <code>Merge(pole[], lavy, stred, pravy)</code>
:1. Je <code>lavy >= pravy ? Ak áno, skonči, inak pokračuj krokom 2.</code>
:2. Nech: <code>i = 0, j = 0, k = lavy </code>
:3. Nech: <code>dlzka_L = stred - lavy + 1, dlzka_P = pravy - stred</code>
:4. Nech: <code> L = pole[lavy ... stred], P = pole[stred + 1 ... pravy] </code>
:5. Je <code>i < dlzka_L</code> a zároveň <code>j < dlzka_P</code> ? Ak áno, pokračuj krokom 5.1., inak skoč na krok 6.
:::5.1. Je <code>L[i] <= P[j]</code>?
:::: Ak áno:
:::::5.1.1. <code>pole[k] = L[i]</code>
:::::5.1.2. <code>k += 1</code>
:::::5.1.3. <code>i += 1</code>
:::::5.1.4. Skoč na krok 5.
:::: Ak nie:
:::::5.1.1. <code>pole[k] = P[j]</code>
:::::5.1.2. <code>k += 1</code>
:::::5.1.3. <code>j += 1</code>
:::::5.1.4. Skoč na krok 5.
:6. Je <code>i < dlzka_L</code> ? Ak áno, pokračuj krokom 6.1., inak skoč na krok 7.
:::6.1. <code>pole[k] = L[i]</code>
:::6.2. <code>k += 1</code>
:::6.3. <code>i += 1</code>
:::6.4. Skoč na krok 6.
:7. Je <code>j < dlzka_P</code> ? Ak áno, pokračuj krokom 7.1., inak skonči.
:::7.1. <code>pole[k] = P[j]</code>
:::7.2. <code>k += 1</code>
:::7.3. <code>j += 1</code>
:::7.4. Skoč na krok 7.

==Merge sort==
Merge Sort je triediaci algoritmus, ktorý využíva stratégiu '''"rozdeľuj a panuj"''', čo znamená, že vstupný zoznam najskôr rozdelí na dve polovice, tie zoradí a potom ich zlúči naspäť dokopy. Radí sa medzi najpoužívanejšie a najviac rešpektované triediace algoritmy.

===Vlastnosti algoritmu Merge Sort===
* vhodný pre dátové štruktúry: pole, lineárny zoznam
* časová náročnosť: vždy linearitmická <math> O(n.log(n)) </math>, vďaka ktorej dokáže efektívne triediť veľmi veľké zoznamy
* priestorová náročnosť: lineárna <math>O(n)</math> pre pole (alokovanie dočasných polí), konštantná <math>O(1)</math> pre lineárny zoznam (pri LZ stačí iba presmerovať smerníky)
* druh triedenia: triedenie zlučovaním (komparačný algoritmus)
* stabilita triedenia: stabilný
* miesto triedenia: externé triedenie (vhodný na triedenie veľkých objemov dát uložených na disku)

Z hľadiska implementácie môžeme vytvoriť dve základné verzie algoritmu, a to rekurzívnu a iteračnú.
===Opis rekurzívnej a iteračnej verzie algoritmu Merge Sort===

<tabs>
<tab name="Rekurzívna verzia" block>
[[Súbor:Merge sort.png|400px|náhľad|vpravo|Vizualizácia rekurzívnej verzie algoritmu MergeSort]]

===Princíp algoritmu===
Algoritmus MergeSort vykonáva 4 základné úlohy:
# Delenie poľa na dve polovice.
# Triedenie ľavej polovice poľa.
# Triedenie pravej polovice poľa.
# Zlúčenie oboch polovíc pomocou funkcie Merge.

===Slovný opis===
Našou úlohou je vzostupne (min - max) utriediť vstupné pole. Určíme si stred poľa (pri párnom počte prvkov je to ten menší z prostredných indexov). Následne vykonávame sériu rekurzívnych delení pre ľavú a pravú časť poľa (začiatok ... stred ; stred + 1 ... koniec) až do momentu, keď nám ostanú len jednoprvkové podpolia (tie sú už utriedené). Následne v každom volaní obe tieto podpolia zlúčime pomocou algoritmu Merge do väčších podpolí (2, 4, 8, ...), až nakoniec dostaneme jedno výsledné utriedené pole.

===Pseudokód===
Nech nech má funkcia MergeSort nasledovný prototyp: <code>MergeSort(pole[], lavy, pravy) </code>
:1. Je <code>lavy >= pravy</code> ? Ak áno, skonči volanie, inak pokračuj krokom 2.
:2. Nech: <code>stred = lavy + (pravy - lavy) / 2</code>, pričom znak ''/'' vyjadruje celočíselné delenie.
:3. Rekurzívne zavolaj funkciu <code>MergeSort(pole[], lavy , stred)</code>
:3. Rekurzívne zavolaj funkciu <code>MergeSort(pole[], stred + 1 , pravy)</code>
:4. Zavolaj funkciu <code>Merge(pole[], lavy, stred, pravy)</code>
:5. Skonči volanie.

</tab>
<tab name="Iteračná verzia" block>
[[Súbor:MergeSort It.png|400px|náhľad|vpravo|Vizualizácia iteračnej verzie algoritmu MergeSort]]

===Princíp algoritmu===
Algoritmus Merge vykonáva 3 základné úlohy:
# Vonkajší cyklus: určenie veľkosti zoznamu na zlučovanie.
# Vnútorný cyklus: prechádzanie jednotlivých zoznamov v poli.
# Zlučovanie jednotlivých zoznamov pomocou funkcie Merge.

===Slovný opis===
Vstupné pole, ktoré má ''N'' prvkov, môžeme chápať, ako ''N'' rôznych jednoprvkových (utriedených) podpolí, ktoré máme zlúčiť do jedného výsledného ''N''-prvkového utriedeného poľa. Keďže by bolo veľmi nepraktické zlučovať ''N'' podpolí naraz, zvolíme nasledovnú stratégiu: Budeme prechádzať dané pole od začiatku po koniec a v prvom cykle zlúčime každé dva prvky, takže budeme mať <math>\frac{n}{2}</math> dvojprvkových utriedených podpolí. Potom v druhom cykle zlúčime každé 4 prvky do jedného podpoľa, v treťom cykle každých 8, až do momentu, keď dostaneme jedno utriedené pole.
Aby sme to docielili, potrebujeme dva cykly, vonkajší, ktorý nastaví maximálnu veľkosť podpoľa, ktoré ideme zlučovať (1,2,4,8 ... dlzka - 1) a vnútorný, ktorý prechádza jednotlivé podpolia. Následne už iba voláme funkciu Merge, ktorá dané podpolia zlučuje.

Poznámka, ak máme pole, ktoré má nepárny počet prvkov, tak ten posledný prvok nezlúčime hneď v prvom cykle, ale až v tých ďalších. Takisto, ak n nie je mocnina čísla 2, tak musíme samozrejme ošetriť situáciu, kedy by sme sa dostali mimo rozsah poľa (Ak máme napríklad pole, čo má 7 prvkov, tak po prvej iterácii budú prvky utiredené podľa vzoru 2 + 2 + 2 + 1, po druhej 4 + 3, a po tretej 7)

===Pseudokód===
Nech nech má funkcia MergeSort nasledovný prototyp: <code>MergeSort(pole[], lavy, pravy) </code>
:1. Je <code>lavy >= pravy</code> ? Ak áno, skonči, inak pokračuj krokom 2.
:2. Nech: <code>dlzka_subzoznamu = 1 </code>
:3. Nech: <code>zaciatok = lavy</code>
:4. Je<code>dlzka_subzoznamu <= pravy</code> ? Ak áno pokračuj krokom 4.1, inak skonči.
:::4.1. Je<code>zaciatok < pravy</code> Ak áno pokračuj krokom 4.1.1, inak skoč na krok 4.2.
:::::4.1.1. Je <code>zaciatok + 2 * dlzka_zoznamu - 1 <= pravy</code> ?
:::::::Ak áno:
:::::::::4.1.1.1. Nech <code>koniec = zaciatok + 2 * dlzka_zoznamu - 1</code>
:::::::Ak nie:
:::::::::4.1.1.1. Nech <code>koniec = pravy</code>
:::::4.1.2. Je <code>zaciatok + dlzka_zoznamu - 1 <= pravy</code> ?
:::::::Ak áno:
:::::::::4.1.2.1. Nech <code>stred = zaciatok + dlzka_zoznamu - 1</code>
:::::::Ak nie:
:::::::::4.1.2.1. Nech <code>stred = pravy</code>
:::::4.1.3. <code>Merge(pole[], zaciatok, stred, koniec)</code>
:::::4.1.4. <code>zaciatok += 2 * dlzka_subzoznamu</code>
:::::4.1.5. Skoč na krok 4.1.
:::4.2. <code>dlzka_subzoznamu *= 2</code>
:::4.3 Skoč na krok 4.

</tab>
</tabs>

==Implementácia algoritmov Merge a MergeSortv rôznych programovacích jazykoch==
<tabs>
<tab name="Rekurzívna: C " block>
<syntaxhighlight lang="C">
#include <stdio.h>
#include <stdlib.h>

void Merge(int pole[], int lavy, int stred, int pravy);
void MergeSort(int pole[], int lavy, int pravy);

/* hlavný program */

int main()
{
int pole[] = {12, 11, 13, 5, 6, 7};
int dlzka_pola = sizeof(pole) / sizeof(pole[0]);

printf("Pôvodné pole: \n");

for (int i = 0; i < dlzka_pola; ++i)
{
printf("%d ", pole[i]);
}

MergeSort(pole, 0, dlzka_pola - 1);

printf("\nUtriedené pole: \n");

for (int i = 0; i < dlzka_pola; ++i)
{
printf("%d ", pole[i]);
}

return 0;
}

void Merge(int pole[], int lavy, int stred, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči */

if (lavy >= pravy)
{
return;
}

/* vyrátaj dĺžky oboch polovíc poľa */

int L_dlzka = stred - lavy + 1;
int P_dlzka = pravy - stred;

/* alokuj dočasné polia, kam uložíš prvky z oboch polovíc poľa */

int *L = (int*)malloc(L_dlzka * sizeof(int));
int *P = (int*)malloc(P_dlzka * sizeof(int));

/* indexy, ktorými iterujeme všetky polia: i pre L, j pre P, k pre pole */

int i, j, k;

/* skopíruj obsah oboch polovíc poľa do dočasných polí L a P */

for (i = 0; i < L_dlzka; ++i)
{
L[i] = pole[lavy + i];
}

for (j = 0; j < P_dlzka; ++j)
{
P[j] = pole[stred + 1 + j];
}

/* nastav indexy na začiatok daných polí */

i = 0; j = 0; k = lavy;

/* zlučuj dočasné polia L a P do finálneho poľa pole */

while(i < L_dlzka && j < P_dlzka)
{
if(L[i] <= P[j])
{
pole[k++] = L[i++];
}
else
{
pole[k++] = P[j++];
}
}

/* ak ostali nejaké prvky v dočasnom poli L, skopíruj ich do finálneho poľa */

while(i < L_dlzka)
{
pole[k++] = L[i++];
}

/* ak ostali nejaké prvky v dočasnom poli P, skopíruj ich do finálneho poľa */

while(j < P_dlzka)
{
pole[k++] = P[j++];
}

/* uvoľni použitú pamäť */

free(L);
free(P);
}

void MergeSort(int pole[], int lavy, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči volanie */

if(lavy >= pravy)
{
return;
}
/* urči si prostredný index */

int stred = lavy + (pravy - lavy) / 2;

/* utrieď ľavú polovicu poľa */

MergeSort(pole, lavy, stred);

/* utrieď pravú polovicu poľa */

MergeSort(pole, stred+1, pravy);

/* zlúč obe polovice dokopy */

Merge(pole, lavy, stred, pravy);
}
</syntaxhighlight>
</tab>

<tab name="Iteračná: C" block>
<syntaxhighlight lang="C">
#include <stdio.h>
#include <stdlib.h>

void Merge(int pole[], int lavy, int stred, int pravy);
void MergeSortIt(int *pole, int lavy, int pravy);

/* hlavný program */

int main()
{
int pole[] = {12, 11, 13, 5, 6, 7, 19};
int dlzka_pola = sizeof(pole) / sizeof(pole[0]);

printf("Pôvodné pole %d: \n", dlzka_pola);

for (int i = 0; i < dlzka_pola; ++i)
{
printf("%d ", pole[i]);
}

MergeSortIt(pole, 0, dlzka_pola - 1);

printf("\nUtriedené pole: \n");

for (int i = 0; i < dlzka_pola; ++i)
{
printf("%d ", pole[i]);
}

return 0;
}

void Merge(int pole[], int lavy, int stred, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči */

if (lavy >= pravy)
{
return;
}

/* vyrátaj dĺžky oboch polovíc poľa */

int L_dlzka = stred - lavy + 1;
int P_dlzka = pravy - stred;

/* alokuj dočasné polia, kam uložíš prvky z oboch polovíc poľa */

int *L = (int*)malloc(L_dlzka * sizeof(int));
int *P = (int*)malloc(P_dlzka * sizeof(int));

/* indexy, ktorými iterujeme všetky polia: i pre L, j pre P, k pre pole */

int i, j, k;

/* skopíruj obsah oboch polovíc poľa do dočasných polí L a P */

for (i = 0; i < L_dlzka; ++i)
{
L[i] = pole[lavy + i];
}

for (j = 0; j < P_dlzka; ++j)
{
P[j] = pole[stred + 1 + j];
}

/* nastav indexy na začiatok daných polí */

i = 0; j = 0; k = lavy;

/* zlučuj dočasné polia L a P do finálneho poľa pole */

while(i < L_dlzka && j < P_dlzka)
{
if(L[i] <= P[j])
{
pole[k++] = L[i++];
}
else
{
pole[k++] = P[j++];
}
}

/* ak ostali nejaké prvky v dočasnom poli L, skopíruj ich do finálneho poľa */

while(i < L_dlzka)
{
pole[k++] = L[i++];
}

/* ak ostali nejaké prvky v dočasnom poli P, skopíruj ich do finálneho poľa */

while(j < P_dlzka)
{
pole[k++] = P[j++];
}

/* uvoľni použitú pamäť */

free(L);
free(P);
}

void MergeSortIt(int *pole, int lavy, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči volanie */

if(lavy >= pravy)
{
return;
}

int stred, koniec;

for (int dlzka_zoznamu = 1; dlzka_zoznamu <= pravy ; dlzka_zoznamu *= 2)
{
for (int zaciatok = lavy; zaciatok < pravy ; zaciatok += 2 * dlzka_zoznamu)
{
koniec = (zaciatok + 2 * dlzka_zoznamu - 1 <= pravy) ? zaciatok + 2 * dlzka_zoznamu - 1 : pravy;

stred = (zaciatok + dlzka_zoznamu - 1 <= pravy) ? zaciatok + dlzka_zoznamu - 1 : pravy;

Merge(pole, zaciatok, stred, koniec);

}
}
}

</syntaxhighlight>
</tab>

<tab name="Rekurzívna: C++" block>
<syntaxhighlight lang="C++">
#include <iostream>

using std::cout;
using std::endl;

void Merge(int pole[], int lavy, int stred, int pravy);
void MergeSort(int pole[], int lavy, int pravy);

/* hlavný program */

int main()
{
int pole[] = {12, 11, 13, 5, 6, 7};
int dlzka_pola = sizeof(pole) / sizeof(pole[0]);

printf("Pôvodné pole: \n");

for (auto i: pole)
{
cout<<i<<" ";
}

MergeSort(pole, 0, dlzka_pola - 1);

cout<<endl<<"Utriedené pole:"<<endl;

for (auto i: pole)
{
cout<<i<<" ";
}

return 0;
}

void Merge(int pole[], int lavy, int stred, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči */

if (lavy >= pravy)
{
return;
}

/* vyrátaj dĺžky oboch polovíc poľa */

int L_dlzka = stred - lavy + 1;
int P_dlzka = pravy - stred;

/* alokuj dočasné polia, kam uložíš prvky z oboch polovíc poľa */

int *L = new int[L_dlzka];
int *P = new int[P_dlzka];

/* indexy, ktorými iterujeme všetky polia: i pre L, j pre P, k pre pole */

int i, j, k;

/* skopíruj obsah oboch polovíc poľa do dočasných polí L a P */

for (i = 0; i < L_dlzka; ++i)
{
L[i] = pole[lavy + i];
}

for (j = 0; j < P_dlzka; ++j)
{
P[j] = pole[stred + 1 + j];
}

/* nastav indexy na začiatok daných polí */

i = 0; j = 0; k = lavy;

/* zlučuj dočasné polia L a P do finálneho poľa pole */

while(i < L_dlzka && j < P_dlzka)
{
if(L[i] <= P[j])
{
pole[k++] = L[i++];
}
else
{
pole[k++] = P[j++];
}
}

/* ak ostali nejaké prvky v dočasnom poli L, skopíruj ich do finálneho poľa */

while(i < L_dlzka)
{
pole[k++] = L[i++];
}

/* ak ostali nejaké prvky v dočasnom poli P, skopíruj ich do finálneho poľa */

while(j < P_dlzka)
{
pole[k++] = P[j++];
}

/* uvoľni použitú pamäť */

delete []L;
delete []P;
}

void MergeSort(int pole[], int lavy, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči volanie */

if(lavy >= pravy)
{
return;
}
/* urči si prostredný index */

int stred = lavy + (pravy - lavy) / 2;

/* utrieď ľavú polovicu poľa */

MergeSort(pole, lavy, stred);

/* utrieď pravú polovicu poľa */

MergeSort(pole, stred+1, pravy);

/* zlúč obe polovice dokopy */

Merge(pole, lavy, stred, pravy);
}

</syntaxhighlight>
</tab>

<tab name="Iteračná: C++" block>
<syntaxhighlight lang="C++">
#include <iostream>

using std::cout;
using std::endl;

void Merge(int pole[], int lavy, int stred, int pravy);
void MergeSort(int pole[], int lavy, int pravy);

/* hlavný program */

int main()
{
int pole[] = {12, 11, 13, 5, 6, 7};
int dlzka_pola = sizeof(pole) / sizeof(pole[0]);

printf("Pôvodné pole: \n");

for (auto i: pole)
{
cout<<i<<" ";
}

MergeSort(pole, 0, dlzka_pola - 1);

cout<<endl<<"Utriedené pole:"<<endl;

for (auto i: pole)
{
cout<<i<<" ";
}

return 0;
}

void Merge(int pole[], int lavy, int stred, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči */

if (lavy >= pravy)
{
return;
}

/* vyrátaj dĺžky oboch polovíc poľa */

int L_dlzka = stred - lavy + 1;
int P_dlzka = pravy - stred;

/* alokuj dočasné polia, kam uložíš prvky z oboch polovíc poľa */

int *L = new int[L_dlzka];
int *P = new int[P_dlzka];

/* indexy, ktorými iterujeme všetky polia: i pre L, j pre P, k pre pole */

int i, j, k;

/* skopíruj obsah oboch polovíc poľa do dočasných polí L a P */

for (i = 0; i < L_dlzka; ++i)
{
L[i] = pole[lavy + i];
}

for (j = 0; j < P_dlzka; ++j)
{
P[j] = pole[stred + 1 + j];
}

/* nastav indexy na začiatok daných polí */

i = 0; j = 0; k = lavy;

/* zlučuj dočasné polia L a P do finálneho poľa pole */

while(i < L_dlzka && j < P_dlzka)
{
if(L[i] <= P[j])
{
pole[k++] = L[i++];
}
else
{
pole[k++] = P[j++];
}
}

/* ak ostali nejaké prvky v dočasnom poli L, skopíruj ich do finálneho poľa */

while(i < L_dlzka)
{
pole[k++] = L[i++];
}

/* ak ostali nejaké prvky v dočasnom poli P, skopíruj ich do finálneho poľa */

while(j < P_dlzka)
{
pole[k++] = P[j++];
}

/* uvoľni použitú pamäť */

delete []L;
delete []P;
}

void MergeSort(int *pole, int lavy, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči volanie */

if(lavy >= pravy)
{
return;
}

int stred, koniec;

for (int dlzka_zoznamu = 1; dlzka_zoznamu <= pravy; dlzka_zoznamu *= 2)
{
for (int zaciatok = lavy; zaciatok < pravy; zaciatok += 2 * dlzka_zoznamu)
{
koniec = (zaciatok + 2 * dlzka_zoznamu - 1 <= pravy) ? zaciatok + 2 * dlzka_zoznamu - 1 : pravy;

stred = (zaciatok + dlzka_zoznamu - 1 <= pravy) ? zaciatok + dlzka_zoznamu - 1 : pravy;

Merge(pole, zaciatok, stred, koniec);
}
}
}
</syntaxhighlight>
</tab>

<tab name="Rekurzívna: Java" block>
<syntaxhighlight lang="Java">
class MergeSort
{

/* Funkcia zlúči 2 podpolia, ktoré sme vytvorili z pôvodného poľa.
* Každé podpole má polovičnú dĺžku pôvodného poľa.
* subpole1 [ľavý ... stred]
* subpole2 [stred + 1 ... pravý] */

void merge(int[] pole, int lavy, int stred, int pravy)
{

// Výpočet dĺžky 2 podpolí

int n1 = stred - lavy + 1;
int n2 = pravy - stred;

// Vytvorenie pomocných polí

int[] L = new int[n1];
int[] P = new int[n2];

// Načítanie dát do pomocných polí

for (int i = 0; i < n1; i++)
L[i] = pole[lavy + i];

for (int j = 0; j < n2; j++)
P[j] = pole[stred + 1 + j];

// Počiatočné indexy prvého a druhého podpoľa

int i = 0, j = 0;

// Počiatočný index zlúčeného podpoľa

int k = lavy;

// Zlúčenie dvoch podpolí

while (i < n1 && j < n2)
{
if (L[i] <= P[j])
{
pole[k] = L[i];
i++;
}
else
{
pole[k] = P[j];
j++;
}
k++;
}

/* V prípade, že sa v jednom zo podpoli nachádzajú ešte nejaké prvky, ktoré neboli zlúčené do pola,
* tak sa do pola jednoducho skopírujú */

while (i < n1)
{
pole[k] = L[i];
i++;
k++;
}

while (j < n2)
{
pole[k] = P[j];
k++;
j++;
}

}

/* Funkcia, ktorá zoradí pole použitím funkcie merge() */

void sort (int[] pole, int lavy, int pravy)
{
if (lavy < pravy)
{
// Musíme nájsť stred pola

int stred = lavy + (pravy - lavy) / 2;

// Zoradíme prvú a druhú polovicu pola samostatne

sort(pole, lavy, stred);
sort(pole, stred + 1, pravy);

// Zlúčime zoradené polovice do jedného pola

merge(pole, lavy, stred, pravy);
}
}
}

public class Main
{
/* Funkcia na výpis pola dĺžky n */

static void vypis_pole(int[] pole)
{

for (int j : pole)
{
System.out.print(j + " ");
}

System.out.println();
}

/* Hlavný program */

public static void main(String[] args)
{
int[] pole = {12, 11, 13, 5, 6, 7};

System.out.println("Zadané pole:");
vypis_pole(pole);

MergeSort ms = new MergeSort();
ms.sort(pole, 0, pole.length - 1);

System.out.println("\nZoradené pole:");
vypis_pole(pole);
}
}
</syntaxhighlight>
</tab>

<tab name="Iteračná: Java" block>
<syntaxhighlight lang="Java">
class MergeSort_iteracia {
/* Zlúči 2 subpolia, ktoré sa vytvorili z pôvodného pola.
* Každé subpole má polovičnú dĺžku pôvodného pola.
* subpole1 [ľavý..stred]
* subpole2 [stred+1..pravý] */
void merge(int[] pole, int lavy, int stred, int pravy) {
// Výpočet dĺžky 2 subpolí
int n1 = stred - lavy + 1;
int n2 = pravy - stred;

// Vytvorenie pomocných polí
int[] L = new int[n1];
int[] P = new int[n2];

// Načítanie dát do pomocných polí
for (int i = 0; i < n1; i++)
L[i] = pole[lavy + i];

for (int j = 0; j < n2; j++)
P[j] = pole[stred + 1 + j];

// Počiatočné indexy prvého a druhého subpola
int i = 0, j = 0;
// Počiatočný index zlúčeného subpola
int k = lavy;

// Zlúčenie dvoch podpolí
while (i < n1 && j < n2) {
if (L[i] <= P[j]) {
pole[k] = L[i];
i++;
}
else {
pole[k] = P[j];
j++;
}
k++;
}

/* V prípade, že v jednom zo subpolí sa nachádzajú prvky, ktoré neboli zlúčené do pola,
* tak sa do pola jednoducho skopírujú */
while (i < n1) {
pole[k] = L[i];
i++;
k++;
}

while (j < n2) {
pole[k] = P[j];
k++;
j++;
}
}

/* Funkcia, ktorá zoradí pole použitím funkcie merge() */
void sort (int[] pole, int n) {
/* Dĺžka subpolí, ktoré majú byť zlúčené, hodnoty premennej sa pohybujú v intervale <1;n-1> */
int aktual_dlzka;
/* Začiatočný index ľavého subpola, ktoré má byť zlúčené */
int zaciatok_vlavo;

/* Vzostupné usporiadanie prvkov. Najskôr sa zlúčia subpolia veľkosti 1 do subpolí veľkosti 2,
* potom subpolia veľkosti 2 do subpolí veľkosti 4 a tak ďalej */
for (aktual_dlzka = 1; aktual_dlzka <= n - 1; aktual_dlzka *= 2) {
/* Určenie začiatočného prvku rôznych subpolí aktuálnej dĺžky subpola */
for (zaciatok_vlavo = 0; zaciatok_vlavo < n - 1; zaciatok_vlavo += 2 * aktual_dlzka) {
/* Nájdenie konečného prvku ľavého subpola, stred+1 je začiatočný prvok pravého subpola */
int stred = Math.min(zaciatok_vlavo + aktual_dlzka - 1, n - 1);
int koniec_vpravo = Math.min(zaciatok_vlavo + 2 * aktual_dlzka - 1, n - 1);

/* Zlúči subpolia L[zaciatok_vlavo .. stred] & P[stred+1 .. koniec_vpravo] */
merge(pole, zaciatok_vlavo, stred, koniec_vpravo);
}
}
}
}

public class Main {
/* Funkcia na výpis pola dĺžky n */
static void vypis_pole(int[] pole) {
int n = pole.length;

for (int j : pole) {
System.out.print(j + " ");
}
System.out.println();
}

/* Hlavný program */
public static void main(String[] args) {

/* Inicializácia pola */
int[] pole = {12, 11, 13, 5, 6, 7};

System.out.println("Zadané pole:");
vypis_pole(pole);

MergeSort_iteracia ms_it = new MergeSort_iteracia();
ms_it.sort(pole, pole.length);

System.out.println("Zoradené pole:");
vypis_pole(pole);
}
}
</syntaxhighlight>
</tab>

<tab name="Rekurzívna: Python3" block>
<syntaxhighlight lang="Python3">
def MergeSort(pole):
if len(pole) > 1:
# Nájdenie stredu pola
# zápis len(pole)//2 znamená, že dĺžka pola sa vydelí 2 a výsledok je celé číslo
stred = len(pole) // 2

# Rozdelenie pola na dve časti
L = pole[:stred]
P = pole[stred:]

# Zoradenie najskôr prvej časti pola, potom druhej
MergeSort(L)
MergeSort(P)

i = j = k = 0

# Zlúčenie a zoradenie údajov z pomocných polí do jedného pola
while i < len(L) and j < len(P):
if L[i] < P[j]:
pole[k] = L[i]
i += 1
else:
pole[k] = P[j]
j += 1
k += 1

# Kontrola či všetky prvky boli zlúčené dokopy,
# ak nie, tak sa do zlúčeného pola jednoducho skopírujú
while i < len(L):
pole[k] = L[i]
i += 1
k += 1

while j < len(P):
pole[k] = P[j]
j += 1
k += 1

# Hlavný program
if __name__ == '__main__':
pole = [12, 11, 13, 5, 6, 7]

print("Zadané pole:", end="\n")
print(pole, end="\n")

MergeSort(pole)

print("Zoradené pole:", end="\n")
print(pole, end="\n")

</syntaxhighlight>
</tab>

<tab name="Iteračná: Python3" block>
<syntaxhighlight lang="Python3">
def MergeSort_iteracia(pole):
# Dĺžka subpolí, ktoré majú byť zlúčené, hodnoty premennej sa pohybujú v intervale <1;n-1>
aktual_dlzka = 1

# Vonkajší cyklus, ktorý určuje subpolia aktuálnej dĺžky
while aktual_dlzka < len(pole) - 1:
lavy = 0

# Vnútorný cyklus, ktorý slúži na zlúčenie a zoradenie subpoli do jedného subpola
while lavy < len(pole) - 1:
# Index stredného prvku sa určí, keď k indexu ľavého prvku subpola pripočítame aktuálnu
# dĺžku subpolí a odčítame 1
stred = min((lavy + aktual_dlzka - 1), len(pole) - 1)

# Ak platí podmienka 2 * aktuálna dĺžka < dĺžka pola - 1, tak pravý index = aktuálnej dĺžke subpolí,
# inak pravý index = dĺžke pola - 1
pravy = ((2 * aktual_dlzka + lavy - 1, len(pole) - 1)[2 * aktual_dlzka + lavy - 1 > len(pole) - 1])

# Volanie funkcie merge
merge(pole, lavy, stred, pravy)

lavy = lavy + 2 * aktual_dlzka

# Aktuálna dĺžka sa sa zmení na dvojnásobok jej predošlej hodnoty
aktual_dlzka = 2 * aktual_dlzka

def merge(pole, lavy, stred, pravy):
n1 = stred - lavy + 1
n2 = pravy - stred

# Inicializácia pomocných polí
L = [0] * n1
P = [0] * n2

# Načítanie dát do pomocných polí
for i in range(0, n1):
L[i] = pole[lavy + i]
for i in range(0, n2):
P[i] = pole[stred + i + 1]

i, j, k = 0, 0, lavy

# Zlúčenie a zoradenie údajov z pomocných polí do jedného pola
while i < n1 and j < n2:
if L[i] > P[j]:
pole[k] = P[j]
j += 1
else:
pole[k] = L[i]
i += 1
k += 1

# Kontrola či všetky prvky boli zlúčené dokopy,
# ak nie, tak sa do zlúčeného pola jednoducho skopírujú
while i < n1:
pole[k] = L[i]
i += 1
k += 1

while j < n2:
pole[k] = P[j]
j += 1
k += 1

# Hlavný program
if __name__ == '__main__':
pole = [12, 11, 13, 5, 6, 7]

print("Zadané pole:", end="\n")
print(pole, end="\n")

MergeSort_iteracia(pole)

print("Zoradené pole:", end="\n")
print(pole, end="\n")

</syntaxhighlight>
</tab>

</tabs>

==Odkazy==
# https://www.geeksforgeeks.org/merge-sort/
# https://www.geeksforgeeks.org/iterative-merge-sort/
# https://medium.com/@paulsoham/merge-sort-63d75df76388
# https://www.khanacademy.org/computing/computer-science/algorithms/merge-sort/a/overview-of-merge-sort
# https://www.tutorialspoint.com/data_structures_algorithms/merge_sort_algorithm.htm
# https://www.youtube.com/watch?v=6pV2IF0fgKY
# https://www.youtube.com/watch?v=mB5HXBb_HY8
# https://www.youtube.com/watch?v=ak-pz7tS5DE

Triedenie zlučovaním

2021-03-29T10:15:28Z

Filip Tomek: /* Implementácia algoritmov Merge a MergeSort programovacích jazykoch */

[[Kategória:Algoritmy triedenia]]
{{Draft}}
{{Skripta programovanie}}
__TOC__
==TODO: Pseudokód treba opraviť, text refaktorovať, otestovať kódy, zvýrazniť veci v texte, opraviť preklepy, opraviť popis obrázkov, pridať nové odkazy==

==Zlučovací algoritmus Merge==

Princíp zlučovania tkvie v tom, že máme dva alebo viac utriedených zoznamov, ktoré skombinuje do jedného utriedeného zoznamu (výsledný zoznam musí obsahovať všetky prvky z pôvodných zoznamov). Zoznam môže byť reprezentovaný ako dátová štruktúra pole alebo aj ako lineárny zoznam. V tomto článku sa zameriame na algoritmus pre dátovú štruktúru pole.

Algoritmus Merge tvorí kľúčovú časť triediaceho algoritmu MergeSort.

[[Súbor:Funkcia merge.png|500px|náhľad|vpravo|Vizualizácia funkcie Merge: Máme pole prvkov p = [1, 3, 5, 2, 4, 6], ktoré je už čiastočne utriedené. Použijeme algoritmus Merge, ktorý si vytvorí pomocné polia L = [1, 3, 5] a P = [2, 4, 6]. Všetky polia indexujeme od 0, pričom pre pole p používame index k, pre L index i a pre P index j. Postupnosť krokov je označená číslicami 1 až 6.
]]

===Slovný opis algoritmu===
Nech máme pole, ktoré sa skladá z dvoch už utriedených polovíc. Vytvoríme si dve pomocné polia L a P a do každého z nich skopírujeme obsah jednej polovice (L - ľavá polovica, P - pravá polovica). Potom súčasne prechádzame polia L a P od začiatku po koniec, pričom v každom cykle porovnáme prvok poľa L s prvkom v poli P. Z tejto dvojice následne vyberieme minimum, (keď triedime od najmenšieho po najväčší) ktoré vložíme na prvú voľnú pozíciu pôvodného poľa (na začiatku je to prvá pozícia poľa). Nakoniec zvýšime index pri vstupnom poli a pri pomocnom poli, z ktorého vyberáme daný prvok. Túto postupnosť krokov opakujeme, pokiaľ neprídeme na koniec jedného z polí P a L. Ak nastane situácia, že prídeme na koniec jedného z pomocných polí (a v druhom nám ostali ešte nejaké prvky), potom už iba naspäť skopírujeme zbytok druhého pomocného poľa na koniec pôvodného poľa.

===Vlastnosti algoritmu===
* vhodný pre dátové štruktúry: pole, lineárny zoznam
* časová náročnosť: vždy lineárna <math>O(n)</math>
* priestorová náročnosť: lineárna <math>O(n)</math> pre pole (alokovanie pomocných polí), <math>O(1)</math> pre lineárny zoznam (pri LZ netreba alokovať dočasné polia, stačí iba presmerovať smerníky)
* využitie: kľúčový podprogram pre triediaci algoritmus MergeSort

===Pseudokód===
Nech funkcia Merge má nasledovný prototyp: <code>Merge(pole[], lavy, stred, pravy)</code>
:1. Je <code>lavy >= pravy ? Ak áno, skonči, inak pokračuj krokom 2.</code>
:2. Nech: <code>i = 0, j = 0, k = lavy </code>
:3. Nech: <code>dlzka_L = stred - lavy + 1, dlzka_P = pravy - stred</code>
:4. Nech: <code> L = pole[lavy ... stred], P = pole[stred + 1 ... pravy] </code>
:5. Je <code>i < dlzka_L</code> a zároveň <code>j < dlzka_P</code> ? Ak áno, pokračuj krokom 5.1., inak skoč na krok 6.
:::5.1. Je <code>L[i] <= P[j]</code>?
:::: Ak áno:
:::::5.1.1. <code>pole[k] = L[i]</code>
:::::5.1.2. <code>k += 1</code>
:::::5.1.3. <code>i += 1</code>
:::::5.1.4. Skoč na krok 5.
:::: Ak nie:
:::::5.1.1. <code>pole[k] = P[j]</code>
:::::5.1.2. <code>k += 1</code>
:::::5.1.3. <code>j += 1</code>
:::::5.1.4. Skoč na krok 5.
:6. Je <code>i < dlzka_L</code> ? Ak áno, pokračuj krokom 6.1., inak skoč na krok 7.
:::6.1. <code>pole[k] = L[i]</code>
:::6.2. <code>k += 1</code>
:::6.3. <code>i += 1</code>
:::6.4. Skoč na krok 6.
:7. Je <code>j < dlzka_P</code> ? Ak áno, pokračuj krokom 7.1., inak skonči.
:::7.1. <code>pole[k] = P[j]</code>
:::7.2. <code>k += 1</code>
:::7.3. <code>j += 1</code>
:::7.4. Skoč na krok 7.

==Merge sort==
Merge Sort je triediaci algoritmus, ktorý využíva stratégiu '''"rozdeľuj a panuj"''', čo znamená, že vstupný zoznam najskôr rozdelí na dve polovice, tie zoradí a potom ich zlúči naspäť dokopy. Radí sa medzi najpoužívanejšie a najviac rešpektované triediace algoritmy.

===Vlastnosti algoritmu Merge Sort===
* vhodný pre dátové štruktúry: pole, lineárny zoznam
* časová náročnosť: vždy linearitmická <math> O(n.log(n)) </math>, vďaka ktorej dokáže efektívne triediť veľmi veľké zoznamy
* priestorová náročnosť: lineárna <math>O(n)</math> pre pole (alokovanie dočasných polí), konštantná <math>O(1)</math> pre lineárny zoznam (pri LZ stačí iba presmerovať smerníky)
* druh triedenia: triedenie zlučovaním (komparačný algoritmus)
* stabilita triedenia: stabilný
* miesto triedenia: externé triedenie (vhodný na triedenie veľkých objemov dát uložených na disku)

Z hľadiska implementácie môžeme vytvoriť dve základné verzie algoritmu, a to rekurzívnu a iteračnú.
===Opis rekurzívnej a iteračnej verzie algoritmu Merge Sort===

<tabs>
<tab name="Rekurzívna verzia" block>
[[Súbor:Merge sort.png|400px|náhľad|vpravo|Vizualizácia rekurzívnej verzie algoritmu MergeSort]]

===Princíp algoritmu===
Algoritmus MergeSort vykonáva 4 základné úlohy:
# Delenie poľa na dve polovice.
# Triedenie ľavej polovice poľa.
# Triedenie pravej polovice poľa.
# Zlúčenie oboch polovíc pomocou funkcie Merge.

===Slovný opis===
Našou úlohou je vzostupne (min - max) utriediť vstupné pole. Určíme si stred poľa (pri párnom počte prvkov je to ten menší z prostredných indexov). Následne vykonávame sériu rekurzívnych delení pre ľavú a pravú časť poľa (začiatok ... stred ; stred + 1 ... koniec) až do momentu, keď nám ostanú len jednoprvkové podpolia (tie sú už utriedené). Následne v každom volaní obe tieto podpolia zlúčime pomocou algoritmu Merge do väčších podpolí (2, 4, 8, ...), až nakoniec dostaneme jedno výsledné utriedené pole.

===Pseudokód===
Nech nech má funkcia MergeSort nasledovný prototyp: <code>MergeSort(pole[], lavy, pravy) </code>
:1. Je <code>lavy >= pravy</code> ? Ak áno, skonči volanie, inak pokračuj krokom 2.
:2. Nech: <code>stred = lavy + (pravy - lavy) / 2</code>, pričom znak ''/'' vyjadruje celočíselné delenie.
:3. Rekurzívne zavolaj funkciu <code>MergeSort(pole[], lavy , stred)</code>
:3. Rekurzívne zavolaj funkciu <code>MergeSort(pole[], stred + 1 , pravy)</code>
:4. Zavolaj funkciu <code>Merge(pole[], lavy, stred, pravy)</code>
:5. Skonči volanie.

</tab>
<tab name="Iteračná verzia" block>
[[Súbor:MergeSort It.png|400px|náhľad|vpravo|Vizualizácia iteračnej verzie algoritmu MergeSort]]

===Princíp algoritmu===
Algoritmus Merge vykonáva 3 základné úlohy:
# Vonkajší cyklus: určenie veľkosti zoznamu na zlučovanie.
# Vnútorný cyklus: prechádzanie jednotlivých zoznamov v poli.
# Zlučovanie jednotlivých zoznamov pomocou funkcie Merge.

===Slovný opis===
Vstupné pole, ktoré má ''N'' prvkov, môžeme chápať, ako ''N'' rôznych jednoprvkových (utriedených) podpolí, ktoré máme zlúčiť do jedného výsledného ''N''-prvkového utriedeného poľa. Keďže by bolo veľmi nepraktické zlučovať ''N'' podpolí naraz, zvolíme nasledovnú stratégiu: Budeme prechádzať dané pole od začiatku po koniec a v prvom cykle zlúčime každé dva prvky, takže budeme mať <math>\frac{n}{2}</math> dvojprvkových utriedených podpolí. Potom v druhom cykle zlúčime každé 4 prvky do jedného podpoľa, v treťom cykle každých 8, až do momentu, keď dostaneme jedno utriedené pole.
Aby sme to docielili, potrebujeme dva cykly, vonkajší, ktorý nastaví maximálnu veľkosť podpoľa, ktoré ideme zlučovať (1,2,4,8 ... dlzka - 1) a vnútorný, ktorý prechádza jednotlivé podpolia. Následne už iba voláme funkciu Merge, ktorá dané podpolia zlučuje.

Poznámka, ak máme pole, ktoré má nepárny počet prvkov, tak ten posledný prvok nezlúčime hneď v prvom cykle, ale až v tých ďalších. Takisto, ak n nie je mocnina čísla 2, tak musíme samozrejme ošetriť situáciu, kedy by sme sa dostali mimo rozsah poľa (Ak máme napríklad pole, čo má 7 prvkov, tak po prvej iterácii budú prvky utiredené podľa vzoru 2 + 2 + 2 + 1, po druhej 4 + 3, a po tretej 7)

===Pseudokód===
Nech nech má funkcia MergeSort nasledovný prototyp: <code>MergeSort(pole[], lavy, pravy) </code>
:1. Je <code>lavy >= pravy</code> ? Ak áno, skonči, inak pokračuj krokom 2.
:2. Nech: <code>dlzka_subzoznamu = 1 </code>
:3. Nech: <code>zaciatok = lavy</code>
:4. Je<code>dlzka_subzoznamu <= pravy</code> ? Ak áno pokračuj krokom 4.1, inak skonči.
:::4.1. Je<code>zaciatok < pravy</code> Ak áno pokračuj krokom 4.1.1, inak skoč na krok 4.2.
:::::4.1.1. Je <code>zaciatok + 2 * dlzka_zoznamu - 1 <= pravy</code> ?
:::::::Ak áno:
:::::::::4.1.1.1. Nech <code>koniec = zaciatok + 2 * dlzka_zoznamu - 1</code>
:::::::Ak nie:
:::::::::4.1.1.1. Nech <code>koniec = pravy</code>
:::::4.1.2. Je <code>zaciatok + dlzka_zoznamu - 1 <= pravy</code> ?
:::::::Ak áno:
:::::::::4.1.2.1. Nech <code>stred = zaciatok + dlzka_zoznamu - 1</code>
:::::::Ak nie:
:::::::::4.1.2.1. Nech <code>stred = pravy</code>
:::::4.1.3. <code>Merge(pole[], zaciatok, stred, koniec)</code>
:::::4.1.4. <code>zaciatok += 2 * dlzka_subzoznamu</code>
:::::4.1.5. Skoč na krok 4.1.
:::4.2. <code>dlzka_subzoznamu *= 2</code>
:::4.3 Skoč na krok 4.

</tab>
</tabs>

==Implementácia algoritmov Merge a MergeSort programovacích jazykoch==
<tabs>
<tab name="Rekurzívna: C " block>
<syntaxhighlight lang="C">
#include <stdio.h>
#include <stdlib.h>

void Merge(int pole[], int lavy, int stred, int pravy);
void MergeSort(int pole[], int lavy, int pravy);

/* hlavný program */

int main()
{
int pole[] = {12, 11, 13, 5, 6, 7};
int dlzka_pola = sizeof(pole) / sizeof(pole[0]);

printf("Pôvodné pole: \n");

for (int i = 0; i < dlzka_pola; ++i)
{
printf("%d ", pole[i]);
}

MergeSort(pole, 0, dlzka_pola - 1);

printf("\nUtriedené pole: \n");

for (int i = 0; i < dlzka_pola; ++i)
{
printf("%d ", pole[i]);
}

return 0;
}

void Merge(int pole[], int lavy, int stred, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči */

if (lavy >= pravy)
{
return;
}

/* vyrátaj dĺžky oboch polovíc poľa */

int L_dlzka = stred - lavy + 1;
int P_dlzka = pravy - stred;

/* alokuj dočasné polia, kam uložíš prvky z oboch polovíc poľa */

int *L = (int*)malloc(L_dlzka * sizeof(int));
int *P = (int*)malloc(P_dlzka * sizeof(int));

/* indexy, ktorými iterujeme všetky polia: i pre L, j pre P, k pre pole */

int i, j, k;

/* skopíruj obsah oboch polovíc poľa do dočasných polí L a P */

for (i = 0; i < L_dlzka; ++i)
{
L[i] = pole[lavy + i];
}

for (j = 0; j < P_dlzka; ++j)
{
P[j] = pole[stred + 1 + j];
}

/* nastav indexy na začiatok daných polí */

i = 0; j = 0; k = lavy;

/* zlučuj dočasné polia L a P do finálneho poľa pole */

while(i < L_dlzka && j < P_dlzka)
{
if(L[i] <= P[j])
{
pole[k++] = L[i++];
}
else
{
pole[k++] = P[j++];
}
}

/* ak ostali nejaké prvky v dočasnom poli L, skopíruj ich do finálneho poľa */

while(i < L_dlzka)
{
pole[k++] = L[i++];
}

/* ak ostali nejaké prvky v dočasnom poli P, skopíruj ich do finálneho poľa */

while(j < P_dlzka)
{
pole[k++] = P[j++];
}

/* uvoľni použitú pamäť */

free(L);
free(P);
}

void MergeSort(int pole[], int lavy, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči volanie */

if(lavy >= pravy)
{
return;
}
/* urči si prostredný index */

int stred = lavy + (pravy - lavy) / 2;

/* utrieď ľavú polovicu poľa */

MergeSort(pole, lavy, stred);

/* utrieď pravú polovicu poľa */

MergeSort(pole, stred+1, pravy);

/* zlúč obe polovice dokopy */

Merge(pole, lavy, stred, pravy);
}
</syntaxhighlight>
</tab>

<tab name="Iteračná: C" block>
<syntaxhighlight lang="C">
#include <stdio.h>
#include <stdlib.h>

void Merge(int pole[], int lavy, int stred, int pravy);
void MergeSortIt(int *pole, int lavy, int pravy);

/* hlavný program */

int main()
{
int pole[] = {12, 11, 13, 5, 6, 7, 19};
int dlzka_pola = sizeof(pole) / sizeof(pole[0]);

printf("Pôvodné pole %d: \n", dlzka_pola);

for (int i = 0; i < dlzka_pola; ++i)
{
printf("%d ", pole[i]);
}

MergeSortIt(pole, 0, dlzka_pola - 1);

printf("\nUtriedené pole: \n");

for (int i = 0; i < dlzka_pola; ++i)
{
printf("%d ", pole[i]);
}

return 0;
}

void Merge(int pole[], int lavy, int stred, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči */

if (lavy >= pravy)
{
return;
}

/* vyrátaj dĺžky oboch polovíc poľa */

int L_dlzka = stred - lavy + 1;
int P_dlzka = pravy - stred;

/* alokuj dočasné polia, kam uložíš prvky z oboch polovíc poľa */

int *L = (int*)malloc(L_dlzka * sizeof(int));
int *P = (int*)malloc(P_dlzka * sizeof(int));

/* indexy, ktorými iterujeme všetky polia: i pre L, j pre P, k pre pole */

int i, j, k;

/* skopíruj obsah oboch polovíc poľa do dočasných polí L a P */

for (i = 0; i < L_dlzka; ++i)
{
L[i] = pole[lavy + i];
}

for (j = 0; j < P_dlzka; ++j)
{
P[j] = pole[stred + 1 + j];
}

/* nastav indexy na začiatok daných polí */

i = 0; j = 0; k = lavy;

/* zlučuj dočasné polia L a P do finálneho poľa pole */

while(i < L_dlzka && j < P_dlzka)
{
if(L[i] <= P[j])
{
pole[k++] = L[i++];
}
else
{
pole[k++] = P[j++];
}
}

/* ak ostali nejaké prvky v dočasnom poli L, skopíruj ich do finálneho poľa */

while(i < L_dlzka)
{
pole[k++] = L[i++];
}

/* ak ostali nejaké prvky v dočasnom poli P, skopíruj ich do finálneho poľa */

while(j < P_dlzka)
{
pole[k++] = P[j++];
}

/* uvoľni použitú pamäť */

free(L);
free(P);
}

void MergeSortIt(int *pole, int lavy, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči volanie */

if(lavy >= pravy)
{
return;
}

int stred, koniec;

for (int dlzka_zoznamu = 1; dlzka_zoznamu <= pravy ; dlzka_zoznamu *= 2)
{
for (int zaciatok = lavy; zaciatok < pravy ; zaciatok += 2 * dlzka_zoznamu)
{
koniec = (zaciatok + 2 * dlzka_zoznamu - 1 <= pravy) ? zaciatok + 2 * dlzka_zoznamu - 1 : pravy;

stred = (zaciatok + dlzka_zoznamu - 1 <= pravy) ? zaciatok + dlzka_zoznamu - 1 : pravy;

Merge(pole, zaciatok, stred, koniec);

}
}
}

</syntaxhighlight>
</tab>

<tab name="Rekurzívna: C++" block>
<syntaxhighlight lang="C++">
#include <iostream>

using std::cout;
using std::endl;

void Merge(int pole[], int lavy, int stred, int pravy);
void MergeSort(int pole[], int lavy, int pravy);

/* hlavný program */

int main()
{
int pole[] = {12, 11, 13, 5, 6, 7};
int dlzka_pola = sizeof(pole) / sizeof(pole[0]);

printf("Pôvodné pole: \n");

for (auto i: pole)
{
cout<<i<<" ";
}

MergeSort(pole, 0, dlzka_pola - 1);

cout<<endl<<"Utriedené pole:"<<endl;

for (auto i: pole)
{
cout<<i<<" ";
}

return 0;
}

void Merge(int pole[], int lavy, int stred, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči */

if (lavy >= pravy)
{
return;
}

/* vyrátaj dĺžky oboch polovíc poľa */

int L_dlzka = stred - lavy + 1;
int P_dlzka = pravy - stred;

/* alokuj dočasné polia, kam uložíš prvky z oboch polovíc poľa */

int *L = new int[L_dlzka];
int *P = new int[P_dlzka];

/* indexy, ktorými iterujeme všetky polia: i pre L, j pre P, k pre pole */

int i, j, k;

/* skopíruj obsah oboch polovíc poľa do dočasných polí L a P */

for (i = 0; i < L_dlzka; ++i)
{
L[i] = pole[lavy + i];
}

for (j = 0; j < P_dlzka; ++j)
{
P[j] = pole[stred + 1 + j];
}

/* nastav indexy na začiatok daných polí */

i = 0; j = 0; k = lavy;

/* zlučuj dočasné polia L a P do finálneho poľa pole */

while(i < L_dlzka && j < P_dlzka)
{
if(L[i] <= P[j])
{
pole[k++] = L[i++];
}
else
{
pole[k++] = P[j++];
}
}

/* ak ostali nejaké prvky v dočasnom poli L, skopíruj ich do finálneho poľa */

while(i < L_dlzka)
{
pole[k++] = L[i++];
}

/* ak ostali nejaké prvky v dočasnom poli P, skopíruj ich do finálneho poľa */

while(j < P_dlzka)
{
pole[k++] = P[j++];
}

/* uvoľni použitú pamäť */

delete []L;
delete []P;
}

void MergeSort(int pole[], int lavy, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči volanie */

if(lavy >= pravy)
{
return;
}
/* urči si prostredný index */

int stred = lavy + (pravy - lavy) / 2;

/* utrieď ľavú polovicu poľa */

MergeSort(pole, lavy, stred);

/* utrieď pravú polovicu poľa */

MergeSort(pole, stred+1, pravy);

/* zlúč obe polovice dokopy */

Merge(pole, lavy, stred, pravy);
}

</syntaxhighlight>
</tab>

<tab name="Iteračná: C++" block>
<syntaxhighlight lang="C++">
#include <iostream>

using std::cout;
using std::endl;

void Merge(int pole[], int lavy, int stred, int pravy);
void MergeSort(int pole[], int lavy, int pravy);

/* hlavný program */

int main()
{
int pole[] = {12, 11, 13, 5, 6, 7};
int dlzka_pola = sizeof(pole) / sizeof(pole[0]);

printf("Pôvodné pole: \n");

for (auto i: pole)
{
cout<<i<<" ";
}

MergeSort(pole, 0, dlzka_pola - 1);

cout<<endl<<"Utriedené pole:"<<endl;

for (auto i: pole)
{
cout<<i<<" ";
}

return 0;
}

void Merge(int pole[], int lavy, int stred, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči */

if (lavy >= pravy)
{
return;
}

/* vyrátaj dĺžky oboch polovíc poľa */

int L_dlzka = stred - lavy + 1;
int P_dlzka = pravy - stred;

/* alokuj dočasné polia, kam uložíš prvky z oboch polovíc poľa */

int *L = new int[L_dlzka];
int *P = new int[P_dlzka];

/* indexy, ktorými iterujeme všetky polia: i pre L, j pre P, k pre pole */

int i, j, k;

/* skopíruj obsah oboch polovíc poľa do dočasných polí L a P */

for (i = 0; i < L_dlzka; ++i)
{
L[i] = pole[lavy + i];
}

for (j = 0; j < P_dlzka; ++j)
{
P[j] = pole[stred + 1 + j];
}

/* nastav indexy na začiatok daných polí */

i = 0; j = 0; k = lavy;

/* zlučuj dočasné polia L a P do finálneho poľa pole */

while(i < L_dlzka && j < P_dlzka)
{
if(L[i] <= P[j])
{
pole[k++] = L[i++];
}
else
{
pole[k++] = P[j++];
}
}

/* ak ostali nejaké prvky v dočasnom poli L, skopíruj ich do finálneho poľa */

while(i < L_dlzka)
{
pole[k++] = L[i++];
}

/* ak ostali nejaké prvky v dočasnom poli P, skopíruj ich do finálneho poľa */

while(j < P_dlzka)
{
pole[k++] = P[j++];
}

/* uvoľni použitú pamäť */

delete []L;
delete []P;
}

void MergeSort(int *pole, int lavy, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči volanie */

if(lavy >= pravy)
{
return;
}

int stred, koniec;

for (int dlzka_zoznamu = 1; dlzka_zoznamu <= pravy; dlzka_zoznamu *= 2)
{
for (int zaciatok = lavy; zaciatok < pravy; zaciatok += 2 * dlzka_zoznamu)
{
koniec = (zaciatok + 2 * dlzka_zoznamu - 1 <= pravy) ? zaciatok + 2 * dlzka_zoznamu - 1 : pravy;

stred = (zaciatok + dlzka_zoznamu - 1 <= pravy) ? zaciatok + dlzka_zoznamu - 1 : pravy;

Merge(pole, zaciatok, stred, koniec);
}
}
}
</syntaxhighlight>
</tab>

<tab name="Rekurzívna: Java" block>
<syntaxhighlight lang="Java">
class MergeSort
{

/* Funkcia zlúči 2 podpolia, ktoré sme vytvorili z pôvodného poľa.
* Každé podpole má polovičnú dĺžku pôvodného poľa.
* subpole1 [ľavý ... stred]
* subpole2 [stred + 1 ... pravý] */

void merge(int[] pole, int lavy, int stred, int pravy)
{

// Výpočet dĺžky 2 podpolí

int n1 = stred - lavy + 1;
int n2 = pravy - stred;

// Vytvorenie pomocných polí

int[] L = new int[n1];
int[] P = new int[n2];

// Načítanie dát do pomocných polí

for (int i = 0; i < n1; i++)
L[i] = pole[lavy + i];

for (int j = 0; j < n2; j++)
P[j] = pole[stred + 1 + j];

// Počiatočné indexy prvého a druhého podpoľa

int i = 0, j = 0;

// Počiatočný index zlúčeného podpoľa

int k = lavy;

// Zlúčenie dvoch podpolí

while (i < n1 && j < n2)
{
if (L[i] <= P[j])
{
pole[k] = L[i];
i++;
}
else
{
pole[k] = P[j];
j++;
}
k++;
}

/* V prípade, že sa v jednom zo podpoli nachádzajú ešte nejaké prvky, ktoré neboli zlúčené do pola,
* tak sa do pola jednoducho skopírujú */

while (i < n1)
{
pole[k] = L[i];
i++;
k++;
}

while (j < n2)
{
pole[k] = P[j];
k++;
j++;
}

}

/* Funkcia, ktorá zoradí pole použitím funkcie merge() */

void sort (int[] pole, int lavy, int pravy)
{
if (lavy < pravy)
{
// Musíme nájsť stred pola

int stred = lavy + (pravy - lavy) / 2;

// Zoradíme prvú a druhú polovicu pola samostatne

sort(pole, lavy, stred);
sort(pole, stred + 1, pravy);

// Zlúčime zoradené polovice do jedného pola

merge(pole, lavy, stred, pravy);
}
}
}

public class Main
{
/* Funkcia na výpis pola dĺžky n */

static void vypis_pole(int[] pole)
{

for (int j : pole)
{
System.out.print(j + " ");
}

System.out.println();
}

/* Hlavný program */

public static void main(String[] args)
{
int[] pole = {12, 11, 13, 5, 6, 7};

System.out.println("Zadané pole:");
vypis_pole(pole);

MergeSort ms = new MergeSort();
ms.sort(pole, 0, pole.length - 1);

System.out.println("\nZoradené pole:");
vypis_pole(pole);
}
}
</syntaxhighlight>
</tab>

<tab name="Iteračná: Java" block>
<syntaxhighlight lang="Java">
class MergeSort_iteracia {
/* Zlúči 2 subpolia, ktoré sa vytvorili z pôvodného pola.
* Každé subpole má polovičnú dĺžku pôvodného pola.
* subpole1 [ľavý..stred]
* subpole2 [stred+1..pravý] */
void merge(int[] pole, int lavy, int stred, int pravy) {
// Výpočet dĺžky 2 subpolí
int n1 = stred - lavy + 1;
int n2 = pravy - stred;

// Vytvorenie pomocných polí
int[] L = new int[n1];
int[] P = new int[n2];

// Načítanie dát do pomocných polí
for (int i = 0; i < n1; i++)
L[i] = pole[lavy + i];

for (int j = 0; j < n2; j++)
P[j] = pole[stred + 1 + j];

// Počiatočné indexy prvého a druhého subpola
int i = 0, j = 0;
// Počiatočný index zlúčeného subpola
int k = lavy;

// Zlúčenie dvoch podpolí
while (i < n1 && j < n2) {
if (L[i] <= P[j]) {
pole[k] = L[i];
i++;
}
else {
pole[k] = P[j];
j++;
}
k++;
}

/* V prípade, že v jednom zo subpolí sa nachádzajú prvky, ktoré neboli zlúčené do pola,
* tak sa do pola jednoducho skopírujú */
while (i < n1) {
pole[k] = L[i];
i++;
k++;
}

while (j < n2) {
pole[k] = P[j];
k++;
j++;
}
}

/* Funkcia, ktorá zoradí pole použitím funkcie merge() */
void sort (int[] pole, int n) {
/* Dĺžka subpolí, ktoré majú byť zlúčené, hodnoty premennej sa pohybujú v intervale <1;n-1> */
int aktual_dlzka;
/* Začiatočný index ľavého subpola, ktoré má byť zlúčené */
int zaciatok_vlavo;

/* Vzostupné usporiadanie prvkov. Najskôr sa zlúčia subpolia veľkosti 1 do subpolí veľkosti 2,
* potom subpolia veľkosti 2 do subpolí veľkosti 4 a tak ďalej */
for (aktual_dlzka = 1; aktual_dlzka <= n - 1; aktual_dlzka *= 2) {
/* Určenie začiatočného prvku rôznych subpolí aktuálnej dĺžky subpola */
for (zaciatok_vlavo = 0; zaciatok_vlavo < n - 1; zaciatok_vlavo += 2 * aktual_dlzka) {
/* Nájdenie konečného prvku ľavého subpola, stred+1 je začiatočný prvok pravého subpola */
int stred = Math.min(zaciatok_vlavo + aktual_dlzka - 1, n - 1);
int koniec_vpravo = Math.min(zaciatok_vlavo + 2 * aktual_dlzka - 1, n - 1);

/* Zlúči subpolia L[zaciatok_vlavo .. stred] & P[stred+1 .. koniec_vpravo] */
merge(pole, zaciatok_vlavo, stred, koniec_vpravo);
}
}
}
}

public class Main {
/* Funkcia na výpis pola dĺžky n */
static void vypis_pole(int[] pole) {
int n = pole.length;

for (int j : pole) {
System.out.print(j + " ");
}
System.out.println();
}

/* Hlavný program */
public static void main(String[] args) {

/* Inicializácia pola */
int[] pole = {12, 11, 13, 5, 6, 7};

System.out.println("Zadané pole:");
vypis_pole(pole);

MergeSort_iteracia ms_it = new MergeSort_iteracia();
ms_it.sort(pole, pole.length);

System.out.println("Zoradené pole:");
vypis_pole(pole);
}
}
</syntaxhighlight>
</tab>

<tab name="Rekurzívna: Python3" block>
<syntaxhighlight lang="Python3">
def MergeSort(pole):
if len(pole) > 1:
# Nájdenie stredu pola
# zápis len(pole)//2 znamená, že dĺžka pola sa vydelí 2 a výsledok je celé číslo
stred = len(pole) // 2

# Rozdelenie pola na dve časti
L = pole[:stred]
P = pole[stred:]

# Zoradenie najskôr prvej časti pola, potom druhej
MergeSort(L)
MergeSort(P)

i = j = k = 0

# Zlúčenie a zoradenie údajov z pomocných polí do jedného pola
while i < len(L) and j < len(P):
if L[i] < P[j]:
pole[k] = L[i]
i += 1
else:
pole[k] = P[j]
j += 1
k += 1

# Kontrola či všetky prvky boli zlúčené dokopy,
# ak nie, tak sa do zlúčeného pola jednoducho skopírujú
while i < len(L):
pole[k] = L[i]
i += 1
k += 1

while j < len(P):
pole[k] = P[j]
j += 1
k += 1

# Hlavný program
if __name__ == '__main__':
pole = [12, 11, 13, 5, 6, 7]

print("Zadané pole:", end="\n")
print(pole, end="\n")

MergeSort(pole)

print("Zoradené pole:", end="\n")
print(pole, end="\n")

</syntaxhighlight>
</tab>

<tab name="Iteračná: Python3" block>
<syntaxhighlight lang="Python3">
def MergeSort_iteracia(pole):
# Dĺžka subpolí, ktoré majú byť zlúčené, hodnoty premennej sa pohybujú v intervale <1;n-1>
aktual_dlzka = 1

# Vonkajší cyklus, ktorý určuje subpolia aktuálnej dĺžky
while aktual_dlzka < len(pole) - 1:
lavy = 0

# Vnútorný cyklus, ktorý slúži na zlúčenie a zoradenie subpoli do jedného subpola
while lavy < len(pole) - 1:
# Index stredného prvku sa určí, keď k indexu ľavého prvku subpola pripočítame aktuálnu
# dĺžku subpolí a odčítame 1
stred = min((lavy + aktual_dlzka - 1), len(pole) - 1)

# Ak platí podmienka 2 * aktuálna dĺžka < dĺžka pola - 1, tak pravý index = aktuálnej dĺžke subpolí,
# inak pravý index = dĺžke pola - 1
pravy = ((2 * aktual_dlzka + lavy - 1, len(pole) - 1)[2 * aktual_dlzka + lavy - 1 > len(pole) - 1])

# Volanie funkcie merge
merge(pole, lavy, stred, pravy)

lavy = lavy + 2 * aktual_dlzka

# Aktuálna dĺžka sa sa zmení na dvojnásobok jej predošlej hodnoty
aktual_dlzka = 2 * aktual_dlzka

def merge(pole, lavy, stred, pravy):
n1 = stred - lavy + 1
n2 = pravy - stred

# Inicializácia pomocných polí
L = [0] * n1
P = [0] * n2

# Načítanie dát do pomocných polí
for i in range(0, n1):
L[i] = pole[lavy + i]
for i in range(0, n2):
P[i] = pole[stred + i + 1]

i, j, k = 0, 0, lavy

# Zlúčenie a zoradenie údajov z pomocných polí do jedného pola
while i < n1 and j < n2:
if L[i] > P[j]:
pole[k] = P[j]
j += 1
else:
pole[k] = L[i]
i += 1
k += 1

# Kontrola či všetky prvky boli zlúčené dokopy,
# ak nie, tak sa do zlúčeného pola jednoducho skopírujú
while i < n1:
pole[k] = L[i]
i += 1
k += 1

while j < n2:
pole[k] = P[j]
j += 1
k += 1

# Hlavný program
if __name__ == '__main__':
pole = [12, 11, 13, 5, 6, 7]

print("Zadané pole:", end="\n")
print(pole, end="\n")

MergeSort_iteracia(pole)

print("Zoradené pole:", end="\n")
print(pole, end="\n")

</syntaxhighlight>
</tab>

</tabs>

==Odkazy==
# https://www.geeksforgeeks.org/merge-sort/
# https://www.geeksforgeeks.org/iterative-merge-sort/
# https://medium.com/@paulsoham/merge-sort-63d75df76388
# https://www.khanacademy.org/computing/computer-science/algorithms/merge-sort/a/overview-of-merge-sort
# https://www.tutorialspoint.com/data_structures_algorithms/merge_sort_algorithm.htm
# https://www.youtube.com/watch?v=6pV2IF0fgKY
# https://www.youtube.com/watch?v=mB5HXBb_HY8
# https://www.youtube.com/watch?v=ak-pz7tS5DE

Triedenie zlučovaním

2021-03-29T09:54:48Z

Filip Tomek: /* Implementácia algoritmov Merge a MergeSort programovacích jazykoch */

[[Kategória:Algoritmy triedenia]]
{{Draft}}
{{Skripta programovanie}}
__TOC__
==TODO: Pseudokód treba opraviť, text refaktorovať, otestovať kódy, zvýrazniť veci v texte, opraviť preklepy, opraviť popis obrázkov, pridať nové odkazy==

==Zlučovací algoritmus Merge==

Princíp zlučovania tkvie v tom, že máme dva alebo viac utriedených zoznamov, ktoré skombinuje do jedného utriedeného zoznamu (výsledný zoznam musí obsahovať všetky prvky z pôvodných zoznamov). Zoznam môže byť reprezentovaný ako dátová štruktúra pole alebo aj ako lineárny zoznam. V tomto článku sa zameriame na algoritmus pre dátovú štruktúru pole.

Algoritmus Merge tvorí kľúčovú časť triediaceho algoritmu MergeSort.

[[Súbor:Funkcia merge.png|500px|náhľad|vpravo|Vizualizácia funkcie Merge: Máme pole prvkov p = [1, 3, 5, 2, 4, 6], ktoré je už čiastočne utriedené. Použijeme algoritmus Merge, ktorý si vytvorí pomocné polia L = [1, 3, 5] a P = [2, 4, 6]. Všetky polia indexujeme od 0, pričom pre pole p používame index k, pre L index i a pre P index j. Postupnosť krokov je označená číslicami 1 až 6.
]]

===Slovný opis algoritmu===
Nech máme pole, ktoré sa skladá z dvoch už utriedených polovíc. Vytvoríme si dve pomocné polia L a P a do každého z nich skopírujeme obsah jednej polovice (L - ľavá polovica, P - pravá polovica). Potom súčasne prechádzame polia L a P od začiatku po koniec, pričom v každom cykle porovnáme prvok poľa L s prvkom v poli P. Z tejto dvojice následne vyberieme minimum, (keď triedime od najmenšieho po najväčší) ktoré vložíme na prvú voľnú pozíciu pôvodného poľa (na začiatku je to prvá pozícia poľa). Nakoniec zvýšime index pri vstupnom poli a pri pomocnom poli, z ktorého vyberáme daný prvok. Túto postupnosť krokov opakujeme, pokiaľ neprídeme na koniec jedného z polí P a L. Ak nastane situácia, že prídeme na koniec jedného z pomocných polí (a v druhom nám ostali ešte nejaké prvky), potom už iba naspäť skopírujeme zbytok druhého pomocného poľa na koniec pôvodného poľa.

===Vlastnosti algoritmu===
* vhodný pre dátové štruktúry: pole, lineárny zoznam
* časová náročnosť: vždy lineárna <math>O(n)</math>
* priestorová náročnosť: lineárna <math>O(n)</math> pre pole (alokovanie pomocných polí), <math>O(1)</math> pre lineárny zoznam (pri LZ netreba alokovať dočasné polia, stačí iba presmerovať smerníky)
* využitie: kľúčový podprogram pre triediaci algoritmus MergeSort

===Pseudokód===
Nech funkcia Merge má nasledovný prototyp: <code>Merge(pole[], lavy, stred, pravy)</code>
:1. Je <code>lavy >= pravy ? Ak áno, skonči, inak pokračuj krokom 2.</code>
:2. Nech: <code>i = 0, j = 0, k = lavy </code>
:3. Nech: <code>dlzka_L = stred - lavy + 1, dlzka_P = pravy - stred</code>
:4. Nech: <code> L = pole[lavy ... stred], P = pole[stred + 1 ... pravy] </code>
:5. Je <code>i < dlzka_L</code> a zároveň <code>j < dlzka_P</code> ? Ak áno, pokračuj krokom 5.1., inak skoč na krok 6.
:::5.1. Je <code>L[i] <= P[j]</code>?
:::: Ak áno:
:::::5.1.1. <code>pole[k] = L[i]</code>
:::::5.1.2. <code>k += 1</code>
:::::5.1.3. <code>i += 1</code>
:::::5.1.4. Skoč na krok 5.
:::: Ak nie:
:::::5.1.1. <code>pole[k] = P[j]</code>
:::::5.1.2. <code>k += 1</code>
:::::5.1.3. <code>j += 1</code>
:::::5.1.4. Skoč na krok 5.
:6. Je <code>i < dlzka_L</code> ? Ak áno, pokračuj krokom 6.1., inak skoč na krok 7.
:::6.1. <code>pole[k] = L[i]</code>
:::6.2. <code>k += 1</code>
:::6.3. <code>i += 1</code>
:::6.4. Skoč na krok 6.
:7. Je <code>j < dlzka_P</code> ? Ak áno, pokračuj krokom 7.1., inak skonči.
:::7.1. <code>pole[k] = P[j]</code>
:::7.2. <code>k += 1</code>
:::7.3. <code>j += 1</code>
:::7.4. Skoč na krok 7.

==Merge sort==
Merge Sort je triediaci algoritmus, ktorý využíva stratégiu '''"rozdeľuj a panuj"''', čo znamená, že vstupný zoznam najskôr rozdelí na dve polovice, tie zoradí a potom ich zlúči naspäť dokopy. Radí sa medzi najpoužívanejšie a najviac rešpektované triediace algoritmy.

===Vlastnosti algoritmu Merge Sort===
* vhodný pre dátové štruktúry: pole, lineárny zoznam
* časová náročnosť: vždy linearitmická <math> O(n.log(n)) </math>, vďaka ktorej dokáže efektívne triediť veľmi veľké zoznamy
* priestorová náročnosť: lineárna <math>O(n)</math> pre pole (alokovanie dočasných polí), konštantná <math>O(1)</math> pre lineárny zoznam (pri LZ stačí iba presmerovať smerníky)
* druh triedenia: triedenie zlučovaním (komparačný algoritmus)
* stabilita triedenia: stabilný
* miesto triedenia: externé triedenie (vhodný na triedenie veľkých objemov dát uložených na disku)

Z hľadiska implementácie môžeme vytvoriť dve základné verzie algoritmu, a to rekurzívnu a iteračnú.
===Opis rekurzívnej a iteračnej verzie algoritmu Merge Sort===

<tabs>
<tab name="Rekurzívna verzia" block>
[[Súbor:Merge sort.png|400px|náhľad|vpravo|Vizualizácia rekurzívnej verzie algoritmu MergeSort]]

===Princíp algoritmu===
Algoritmus MergeSort vykonáva 4 základné úlohy:
# Delenie poľa na dve polovice.
# Triedenie ľavej polovice poľa.
# Triedenie pravej polovice poľa.
# Zlúčenie oboch polovíc pomocou funkcie Merge.

===Slovný opis===
Našou úlohou je vzostupne (min - max) utriediť vstupné pole. Určíme si stred poľa (pri párnom počte prvkov je to ten menší z prostredných indexov). Následne vykonávame sériu rekurzívnych delení pre ľavú a pravú časť poľa (začiatok ... stred ; stred + 1 ... koniec) až do momentu, keď nám ostanú len jednoprvkové podpolia (tie sú už utriedené). Následne v každom volaní obe tieto podpolia zlúčime pomocou algoritmu Merge do väčších podpolí (2, 4, 8, ...), až nakoniec dostaneme jedno výsledné utriedené pole.

===Pseudokód===
Nech nech má funkcia MergeSort nasledovný prototyp: <code>MergeSort(pole[], lavy, pravy) </code>
:1. Je <code>lavy >= pravy</code> ? Ak áno, skonči volanie, inak pokračuj krokom 2.
:2. Nech: <code>stred = lavy + (pravy - lavy) / 2</code>, pričom znak ''/'' vyjadruje celočíselné delenie.
:3. Rekurzívne zavolaj funkciu <code>MergeSort(pole[], lavy , stred)</code>
:3. Rekurzívne zavolaj funkciu <code>MergeSort(pole[], stred + 1 , pravy)</code>
:4. Zavolaj funkciu <code>Merge(pole[], lavy, stred, pravy)</code>
:5. Skonči volanie.

</tab>
<tab name="Iteračná verzia" block>
[[Súbor:MergeSort It.png|400px|náhľad|vpravo|Vizualizácia iteračnej verzie algoritmu MergeSort]]

===Princíp algoritmu===
Algoritmus Merge vykonáva 3 základné úlohy:
# Vonkajší cyklus: určenie veľkosti zoznamu na zlučovanie.
# Vnútorný cyklus: prechádzanie jednotlivých zoznamov v poli.
# Zlučovanie jednotlivých zoznamov pomocou funkcie Merge.

===Slovný opis===
Vstupné pole, ktoré má ''N'' prvkov, môžeme chápať, ako ''N'' rôznych jednoprvkových (utriedených) podpolí, ktoré máme zlúčiť do jedného výsledného ''N''-prvkového utriedeného poľa. Keďže by bolo veľmi nepraktické zlučovať ''N'' podpolí naraz, zvolíme nasledovnú stratégiu: Budeme prechádzať dané pole od začiatku po koniec a v prvom cykle zlúčime každé dva prvky, takže budeme mať <math>\frac{n}{2}</math> dvojprvkových utriedených podpolí. Potom v druhom cykle zlúčime každé 4 prvky do jedného podpoľa, v treťom cykle každých 8, až do momentu, keď dostaneme jedno utriedené pole.
Aby sme to docielili, potrebujeme dva cykly, vonkajší, ktorý nastaví maximálnu veľkosť podpoľa, ktoré ideme zlučovať (1,2,4,8 ... dlzka - 1) a vnútorný, ktorý prechádza jednotlivé podpolia. Následne už iba voláme funkciu Merge, ktorá dané podpolia zlučuje.

Poznámka, ak máme pole, ktoré má nepárny počet prvkov, tak ten posledný prvok nezlúčime hneď v prvom cykle, ale až v tých ďalších. Takisto, ak n nie je mocnina čísla 2, tak musíme samozrejme ošetriť situáciu, kedy by sme sa dostali mimo rozsah poľa (Ak máme napríklad pole, čo má 7 prvkov, tak po prvej iterácii budú prvky utiredené podľa vzoru 2 + 2 + 2 + 1, po druhej 4 + 3, a po tretej 7)

===Pseudokód===
Nech nech má funkcia MergeSort nasledovný prototyp: <code>MergeSort(pole[], lavy, pravy) </code>
:1. Je <code>lavy >= pravy</code> ? Ak áno, skonči, inak pokračuj krokom 2.
:2. Nech: <code>dlzka_subzoznamu = 1 </code>
:3. Nech: <code>zaciatok = lavy</code>
:4. Je<code>dlzka_subzoznamu <= pravy</code> ? Ak áno pokračuj krokom 4.1, inak skonči.
:::4.1. Je<code>zaciatok < pravy</code> Ak áno pokračuj krokom 4.1.1, inak skoč na krok 4.2.
:::::4.1.1. Je <code>zaciatok + 2 * dlzka_zoznamu - 1 <= pravy</code> ?
:::::::Ak áno:
:::::::::4.1.1.1. Nech <code>koniec = zaciatok + 2 * dlzka_zoznamu - 1</code>
:::::::Ak nie:
:::::::::4.1.1.1. Nech <code>koniec = pravy</code>
:::::4.1.2. Je <code>zaciatok + dlzka_zoznamu - 1 <= pravy</code> ?
:::::::Ak áno:
:::::::::4.1.2.1. Nech <code>stred = zaciatok + dlzka_zoznamu - 1</code>
:::::::Ak nie:
:::::::::4.1.2.1. Nech <code>stred = pravy</code>
:::::4.1.3. <code>Merge(pole[], zaciatok, stred, koniec)</code>
:::::4.1.4. <code>zaciatok += 2 * dlzka_subzoznamu</code>
:::::4.1.5. Skoč na krok 4.1.
:::4.2. <code>dlzka_subzoznamu *= 2</code>
:::4.3 Skoč na krok 4.

</tab>
</tabs>

==Implementácia algoritmov Merge a MergeSort programovacích jazykoch==
<tabs>
<tab name="Rekurzívna: C " block>
<syntaxhighlight lang="C">
#include <stdio.h>
#include <stdlib.h>

void Merge(int pole[], int lavy, int stred, int pravy);
void MergeSort(int pole[], int lavy, int pravy);

/* hlavný program */

int main()
{
int pole[] = {12, 11, 13, 5, 6, 7};
int dlzka_pola = sizeof(pole) / sizeof(pole[0]);

printf("Pôvodné pole: \n");

for (int i = 0; i < dlzka_pola; ++i)
{
printf("%d ", pole[i]);
}

MergeSort(pole, 0, dlzka_pola - 1);

printf("\nUtriedené pole: \n");

for (int i = 0; i < dlzka_pola; ++i)
{
printf("%d ", pole[i]);
}

return 0;
}

void Merge(int pole[], int lavy, int stred, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči */

if (lavy >= pravy)
{
return;
}

/* vyrátaj dĺžky oboch polovíc poľa */

int L_dlzka = stred - lavy + 1;
int P_dlzka = pravy - stred;

/* alokuj dočasné polia, kam uložíš prvky z oboch polovíc poľa */

int *L = (int*)malloc(L_dlzka * sizeof(int));
int *P = (int*)malloc(P_dlzka * sizeof(int));

/* indexy, ktorými iterujeme všetky polia: i pre L, j pre P, k pre pole */

int i, j, k;

/* skopíruj obsah oboch polovíc poľa do dočasných polí L a P */

for (i = 0; i < L_dlzka; ++i)
{
L[i] = pole[lavy + i];
}

for (j = 0; j < P_dlzka; ++j)
{
P[j] = pole[stred + 1 + j];
}

/* nastav indexy na začiatok daných polí */

i = 0; j = 0; k = lavy;

/* zlučuj dočasné polia L a P do finálneho poľa pole */

while(i < L_dlzka && j < P_dlzka)
{
if(L[i] <= P[j])
{
pole[k++] = L[i++];
}
else
{
pole[k++] = P[j++];
}
}

/* ak ostali nejaké prvky v dočasnom poli L, skopíruj ich do finálneho poľa */

while(i < L_dlzka)
{
pole[k++] = L[i++];
}

/* ak ostali nejaké prvky v dočasnom poli P, skopíruj ich do finálneho poľa */

while(j < P_dlzka)
{
pole[k++] = P[j++];
}

/* uvoľni použitú pamäť */

free(L);
free(P);
}

void MergeSort(int pole[], int lavy, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči volanie */

if(lavy >= pravy)
{
return;
}
/* urči si prostredný index */

int stred = lavy + (pravy - lavy) / 2;

/* utrieď ľavú polovicu poľa */

MergeSort(pole, lavy, stred);

/* utrieď pravú polovicu poľa */

MergeSort(pole, stred+1, pravy);

/* zlúč obe polovice dokopy */

Merge(pole, lavy, stred, pravy);
}
</syntaxhighlight>
</tab>

<tab name="Iteračná: C" block>
<syntaxhighlight lang="C">
#include <stdio.h>
#include <stdlib.h>

void Merge(int pole[], int lavy, int stred, int pravy);
void MergeSortIt(int *pole, int lavy, int pravy);

/* hlavný program */

int main()
{
int pole[] = {12, 11, 13, 5, 6, 7, 19};
int dlzka_pola = sizeof(pole) / sizeof(pole[0]);

printf("Pôvodné pole %d: \n", dlzka_pola);

for (int i = 0; i < dlzka_pola; ++i)
{
printf("%d ", pole[i]);
}

MergeSortIt(pole, 0, dlzka_pola - 1);

printf("\nUtriedené pole: \n");

for (int i = 0; i < dlzka_pola; ++i)
{
printf("%d ", pole[i]);
}

return 0;
}

void Merge(int pole[], int lavy, int stred, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči */

if (lavy >= pravy)
{
return;
}

/* vyrátaj dĺžky oboch polovíc poľa */

int L_dlzka = stred - lavy + 1;
int P_dlzka = pravy - stred;

/* alokuj dočasné polia, kam uložíš prvky z oboch polovíc poľa */

int *L = (int*)malloc(L_dlzka * sizeof(int));
int *P = (int*)malloc(P_dlzka * sizeof(int));

/* indexy, ktorými iterujeme všetky polia: i pre L, j pre P, k pre pole */

int i, j, k;

/* skopíruj obsah oboch polovíc poľa do dočasných polí L a P */

for (i = 0; i < L_dlzka; ++i)
{
L[i] = pole[lavy + i];
}

for (j = 0; j < P_dlzka; ++j)
{
P[j] = pole[stred + 1 + j];
}

/* nastav indexy na začiatok daných polí */

i = 0; j = 0; k = lavy;

/* zlučuj dočasné polia L a P do finálneho poľa pole */

while(i < L_dlzka && j < P_dlzka)
{
if(L[i] <= P[j])
{
pole[k++] = L[i++];
}
else
{
pole[k++] = P[j++];
}
}

/* ak ostali nejaké prvky v dočasnom poli L, skopíruj ich do finálneho poľa */

while(i < L_dlzka)
{
pole[k++] = L[i++];
}

/* ak ostali nejaké prvky v dočasnom poli P, skopíruj ich do finálneho poľa */

while(j < P_dlzka)
{
pole[k++] = P[j++];
}

/* uvoľni použitú pamäť */

free(L);
free(P);
}

void MergeSortIt(int *pole, int lavy, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči volanie */

if(lavy >= pravy)
{
return;
}

int stred, koniec;

for (int dlzka_zoznamu = 1; dlzka_zoznamu <= pravy ; dlzka_zoznamu *= 2)
{
for (int zaciatok = lavy; zaciatok < pravy ; zaciatok += 2 * dlzka_zoznamu)
{
koniec = (zaciatok + 2 * dlzka_zoznamu - 1 <= pravy) ? zaciatok + 2 * dlzka_zoznamu - 1 : pravy;

stred = (zaciatok + dlzka_zoznamu - 1 <= pravy) ? zaciatok + dlzka_zoznamu - 1 : pravy;

Merge(pole, zaciatok, stred, koniec);

}
}
}

</syntaxhighlight>
</tab>

<tab name="Rekurzívna: C++" block>
<syntaxhighlight lang="C++">
#include <iostream>

using std::cout;
using std::endl;

void Merge(int pole[], int lavy, int stred, int pravy);
void MergeSort(int pole[], int lavy, int pravy);

/* hlavný program */

int main()
{
int pole[] = {12, 11, 13, 5, 6, 7};
int dlzka_pola = sizeof(pole) / sizeof(pole[0]);

printf("Pôvodné pole: \n");

for (auto i: pole)
{
cout<<i<<" ";
}

MergeSort(pole, 0, dlzka_pola - 1);

cout<<endl<<"Utriedené pole:"<<endl;

for (auto i: pole)
{
cout<<i<<" ";
}

return 0;
}

void Merge(int pole[], int lavy, int stred, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči */

if (lavy >= pravy)
{
return;
}

/* vyrátaj dĺžky oboch polovíc poľa */

int L_dlzka = stred - lavy + 1;
int P_dlzka = pravy - stred;

/* alokuj dočasné polia, kam uložíš prvky z oboch polovíc poľa */

int *L = new int[L_dlzka];
int *P = new int[P_dlzka];

/* indexy, ktorými iterujeme všetky polia: i pre L, j pre P, k pre pole */

int i, j, k;

/* skopíruj obsah oboch polovíc poľa do dočasných polí L a P */

for (i = 0; i < L_dlzka; ++i)
{
L[i] = pole[lavy + i];
}

for (j = 0; j < P_dlzka; ++j)
{
P[j] = pole[stred + 1 + j];
}

/* nastav indexy na začiatok daných polí */

i = 0; j = 0; k = lavy;

/* zlučuj dočasné polia L a P do finálneho poľa pole */

while(i < L_dlzka && j < P_dlzka)
{
if(L[i] <= P[j])
{
pole[k++] = L[i++];
}
else
{
pole[k++] = P[j++];
}
}

/* ak ostali nejaké prvky v dočasnom poli L, skopíruj ich do finálneho poľa */

while(i < L_dlzka)
{
pole[k++] = L[i++];
}

/* ak ostali nejaké prvky v dočasnom poli P, skopíruj ich do finálneho poľa */

while(j < P_dlzka)
{
pole[k++] = P[j++];
}

/* uvoľni použitú pamäť */

delete []L;
delete []P;
}

void MergeSort(int pole[], int lavy, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči volanie */

if(lavy >= pravy)
{
return;
}
/* urči si prostredný index */

int stred = lavy + (pravy - lavy) / 2;

/* utrieď ľavú polovicu poľa */

MergeSort(pole, lavy, stred);

/* utrieď pravú polovicu poľa */

MergeSort(pole, stred+1, pravy);

/* zlúč obe polovice dokopy */

Merge(pole, lavy, stred, pravy);
}

</syntaxhighlight>
</tab>

<tab name="Iteračná: C++" block>
<syntaxhighlight lang="C++">
#include <iostream>

using std::cout;
using std::endl;

void Merge(int pole[], int lavy, int stred, int pravy);
void MergeSort(int pole[], int lavy, int pravy);

/* hlavný program */

int main()
{
int pole[] = {12, 11, 13, 5, 6, 7};
int dlzka_pola = sizeof(pole) / sizeof(pole[0]);

printf("Pôvodné pole: \n");

for (auto i: pole)
{
cout<<i<<" ";
}

MergeSort(pole, 0, dlzka_pola - 1);

cout<<endl<<"Utriedené pole:"<<endl;

for (auto i: pole)
{
cout<<i<<" ";
}

return 0;
}

void Merge(int pole[], int lavy, int stred, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči */

if (lavy >= pravy)
{
return;
}

/* vyrátaj dĺžky oboch polovíc poľa */

int L_dlzka = stred - lavy + 1;
int P_dlzka = pravy - stred;

/* alokuj dočasné polia, kam uložíš prvky z oboch polovíc poľa */

int *L = new int[L_dlzka];
int *P = new int[P_dlzka];

/* indexy, ktorými iterujeme všetky polia: i pre L, j pre P, k pre pole */

int i, j, k;

/* skopíruj obsah oboch polovíc poľa do dočasných polí L a P */

for (i = 0; i < L_dlzka; ++i)
{
L[i] = pole[lavy + i];
}

for (j = 0; j < P_dlzka; ++j)
{
P[j] = pole[stred + 1 + j];
}

/* nastav indexy na začiatok daných polí */

i = 0; j = 0; k = lavy;

/* zlučuj dočasné polia L a P do finálneho poľa pole */

while(i < L_dlzka && j < P_dlzka)
{
if(L[i] <= P[j])
{
pole[k++] = L[i++];
}
else
{
pole[k++] = P[j++];
}
}

/* ak ostali nejaké prvky v dočasnom poli L, skopíruj ich do finálneho poľa */

while(i < L_dlzka)
{
pole[k++] = L[i++];
}

/* ak ostali nejaké prvky v dočasnom poli P, skopíruj ich do finálneho poľa */

while(j < P_dlzka)
{
pole[k++] = P[j++];
}

/* uvoľni použitú pamäť */

delete []L;
delete []P;
}

void MergeSort(int *pole, int lavy, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči volanie */

if(lavy >= pravy)
{
return;
}

int stred, koniec;

for (int dlzka_zoznamu = 1; dlzka_zoznamu <= pravy; dlzka_zoznamu *= 2)
{
for (int zaciatok = lavy; zaciatok < pravy; zaciatok += 2 * dlzka_zoznamu)
{
koniec = (zaciatok + 2 * dlzka_zoznamu - 1 <= pravy) ? zaciatok + 2 * dlzka_zoznamu - 1 : pravy;

stred = (zaciatok + dlzka_zoznamu - 1 <= pravy) ? zaciatok + dlzka_zoznamu - 1 : pravy;

Merge(pole, zaciatok, stred, koniec);
}
}
}
</syntaxhighlight>
</tab>

<tab name="Rekurzívna: Java" block>
<syntaxhighlight lang="Java">
class MergeSort
{

/* Funkcia zlúči 2 podpolia, ktoré sme vytvorili z pôvodného poľa.
* Každé podpole má polovičnú dĺžku pôvodného poľa.
* subpole1 [ľavý ... stred]
* subpole2 [stred + 1 ... pravý] */

void merge(int[] pole, int lavy, int stred, int pravy)
{

// Výpočet dĺžky 2 podpolí

int n1 = stred - lavy + 1;
int n2 = pravy - stred;

// Vytvorenie pomocných polí

int[] L = new int[n1];
int[] P = new int[n2];

// Načítanie dát do pomocných polí

for (int i = 0; i < n1; i++)
L[i] = pole[lavy + i];

for (int j = 0; j < n2; j++)
P[j] = pole[stred + 1 + j];

// Počiatočné indexy prvého a druhého podpoľa

int i = 0, j = 0;

// Počiatočný index zlúčeného podpoľa

int k = lavy;

// Zlúčenie dvoch podpolí

while (i < n1 && j < n2)
{
if (L[i] <= P[j])
{
pole[k] = L[i];
i++;
}
else
{
pole[k] = P[j];
j++;
}
k++;
}

/* V prípade, že sa v jednom zo podpoli nachádzajú ešte nejaké prvky, ktoré neboli zlúčené do pola,
* tak sa do pola jednoducho skopírujú */

while (i < n1)
{
pole[k] = L[i];
i++;
k++;
}

while (j < n2)
{
pole[k] = P[j];
k++;
j++;
}

}

/* Funkcia, ktorá zoradí pole použitím funkcie merge() */

void sort (int[] pole, int lavy, int pravy)
{
if (lavy < pravy)
{
// Musíme nájsť stred pola

int stred = lavy + (pravy - lavy) / 2;

// Zoradíme prvú a druhú polovicu pola samostatne

sort(pole, lavy, stred);
sort(pole, stred + 1, pravy);

// Zlúčime zoradené polovice do jedného pola

merge(pole, lavy, stred, pravy);
}
}
}

public class Main
{
/* Funkcia na výpis pola dĺžky n */

static void vypis_pole(int[] pole)
{

for (int j : pole)
{
System.out.print(j + " ");
}

System.out.println();
}

/* Hlavný program */

public static void main(String[] args)
{
int[] pole = {12, 11, 13, 5, 6, 7};

System.out.println("Zadané pole:");
vypis_pole(pole);

MergeSort ms = new MergeSort();
ms.sort(pole, 0, pole.length - 1);

System.out.println("\nZoradené pole:");
vypis_pole(pole);
}
}
</syntaxhighlight>
</tab>

<tab name="Iteračná: Java" block>
<syntaxhighlight lang="Java">
class MergeSort_iteracia {
/* Zlúči 2 subpolia, ktoré sa vytvorili z pôvodného pola.
* Každé subpole má polovičnú dĺžku pôvodného pola.
* subpole1 [ľavý..stred]
* subpole2 [stred+1..pravý] */
void merge(int[] pole, int lavy, int stred, int pravy) {
// Výpočet dĺžky 2 subpolí
int n1 = stred - lavy + 1;
int n2 = pravy - stred;

// Vytvorenie pomocných polí
int[] L = new int[n1];
int[] P = new int[n2];

// Načítanie dát do pomocných polí
for (int i = 0; i < n1; i++)
L[i] = pole[lavy + i];

for (int j = 0; j < n2; j++)
P[j] = pole[stred + 1 + j];

// Počiatočné indexy prvého a druhého subpola
int i = 0, j = 0;
// Počiatočný index zlúčeného subpola
int k = lavy;

// Zlúčenie dvoch podpolí
while (i < n1 && j < n2) {
if (L[i] <= P[j]) {
pole[k] = L[i];
i++;
}
else {
pole[k] = P[j];
j++;
}
k++;
}

/* V prípade, že v jednom zo subpolí sa nachádzajú prvky, ktoré neboli zlúčené do pola,
* tak sa do pola jednoducho skopírujú */
while (i < n1) {
pole[k] = L[i];
i++;
k++;
}

while (j < n2) {
pole[k] = P[j];
k++;
j++;
}
}

/* Funkcia, ktorá zoradí pole použitím funkcie merge() */
void sort (int[] pole, int n) {
/* Dĺžka subpolí, ktoré majú byť zlúčené, hodnoty premennej sa pohybujú v intervale <1;n-1> */
int aktual_dlzka;
/* Začiatočný index ľavého subpola, ktoré má byť zlúčené */
int zaciatok_vlavo;

/* Vzostupné usporiadanie prvkov. Najskôr sa zlúčia subpolia veľkosti 1 do subpolí veľkosti 2,
* potom subpolia veľkosti 2 do subpolí veľkosti 4 a tak ďalej */
for (aktual_dlzka = 1; aktual_dlzka <= n - 1; aktual_dlzka *= 2) {
/* Určenie začiatočného prvku rôznych subpolí aktuálnej dĺžky subpola */
for (zaciatok_vlavo = 0; zaciatok_vlavo < n - 1; zaciatok_vlavo += 2 * aktual_dlzka) {
/* Nájdenie konečného prvku ľavého subpola, stred+1 je začiatočný prvok pravého subpola */
int stred = Math.min(zaciatok_vlavo + aktual_dlzka - 1, n - 1);
int koniec_vpravo = Math.min(zaciatok_vlavo + 2 * aktual_dlzka - 1, n - 1);

/* Zlúči subpolia L[zaciatok_vlavo .. stred] & P[stred+1 .. koniec_vpravo] */
merge(pole, zaciatok_vlavo, stred, koniec_vpravo);
}
}
}
}

public class Main {
/* Funkcia na výpis pola dĺžky n */
static void vypis_pole(int[] pole) {
int n = pole.length;

for (int j : pole) {
System.out.print(j + " ");
}
System.out.println();
}

/* Hlavný program */
public static void main(String[] args) {

/* Inicializácia pola */
int[] pole = {12, 11, 13, 5, 6, 7};

System.out.println("Zadané pole:");
vypis_pole(pole);

MergeSort_iteracia ms_it = new MergeSort_iteracia();
ms_it.sort(pole, pole.length);

System.out.println("Zoradené pole:");
vypis_pole(pole);
}
}
</syntaxhighlight>
</tab>

<tab name="Rekurzívna: Python3" block>
<syntaxhighlight lang="Python3">
def MergeSort(pole):
if len(pole) > 1:
# Nájdenie stredu pola
# zápis len(pole)//2 znamená, že dĺžka pola sa vydelí 2 a výsledok je celé číslo
stred = len(pole) // 2

# Rozdelenie pola na dve časti
L = pole[:stred]
P = pole[stred:]

# Zoradenie najskôr prvej časti pola, potom druhej
MergeSort(L)
MergeSort(P)

i = j = k = 0

# Zlúčenie a zoradenie údajov z pomocných polí do jedného pola
while i < len(L) and j < len(P):
if L[i] < P[j]:
pole[k] = L[i]
i += 1
else:
pole[k] = P[j]
j += 1
k += 1

# Kontrola či všetky prvky boli zlúčené dokopy,
# ak nie, tak sa do zlúčeného pola jednoducho skopírujú
while i < len(L):
pole[k] = L[i]
i += 1
k += 1

while j < len(P):
pole[k] = P[j]
j += 1
k += 1

# Hlavný program
if __name__ == '__main__':
pole = [12, 11, 13, 5, 6, 7]

print("Zadané pole:", end="\n")
print(pole, end="\n")

MergeSort(pole)

print("Zoradené pole:", end="\n")
print(pole, end="\n")

</syntaxhighlight>
</tab>

</tabs>

==Odkazy==
# https://www.geeksforgeeks.org/merge-sort/
# https://www.geeksforgeeks.org/iterative-merge-sort/
# https://medium.com/@paulsoham/merge-sort-63d75df76388
# https://www.khanacademy.org/computing/computer-science/algorithms/merge-sort/a/overview-of-merge-sort
# https://www.tutorialspoint.com/data_structures_algorithms/merge_sort_algorithm.htm
# https://www.youtube.com/watch?v=6pV2IF0fgKY
# https://www.youtube.com/watch?v=mB5HXBb_HY8
# https://www.youtube.com/watch?v=ak-pz7tS5DE

Triedenie zlučovaním

2021-03-29T09:49:58Z

Filip Tomek: /* Implementácia algoritmov Merge a MergeSort programovacích jazykoch */

[[Kategória:Algoritmy triedenia]]
{{Draft}}
{{Skripta programovanie}}
__TOC__
==TODO: Pseudokód treba opraviť, text refaktorovať, otestovať kódy, zvýrazniť veci v texte, opraviť preklepy, opraviť popis obrázkov, pridať nové odkazy==

==Zlučovací algoritmus Merge==

Princíp zlučovania tkvie v tom, že máme dva alebo viac utriedených zoznamov, ktoré skombinuje do jedného utriedeného zoznamu (výsledný zoznam musí obsahovať všetky prvky z pôvodných zoznamov). Zoznam môže byť reprezentovaný ako dátová štruktúra pole alebo aj ako lineárny zoznam. V tomto článku sa zameriame na algoritmus pre dátovú štruktúru pole.

Algoritmus Merge tvorí kľúčovú časť triediaceho algoritmu MergeSort.

[[Súbor:Funkcia merge.png|500px|náhľad|vpravo|Vizualizácia funkcie Merge: Máme pole prvkov p = [1, 3, 5, 2, 4, 6], ktoré je už čiastočne utriedené. Použijeme algoritmus Merge, ktorý si vytvorí pomocné polia L = [1, 3, 5] a P = [2, 4, 6]. Všetky polia indexujeme od 0, pričom pre pole p používame index k, pre L index i a pre P index j. Postupnosť krokov je označená číslicami 1 až 6.
]]

===Slovný opis algoritmu===
Nech máme pole, ktoré sa skladá z dvoch už utriedených polovíc. Vytvoríme si dve pomocné polia L a P a do každého z nich skopírujeme obsah jednej polovice (L - ľavá polovica, P - pravá polovica). Potom súčasne prechádzame polia L a P od začiatku po koniec, pričom v každom cykle porovnáme prvok poľa L s prvkom v poli P. Z tejto dvojice následne vyberieme minimum, (keď triedime od najmenšieho po najväčší) ktoré vložíme na prvú voľnú pozíciu pôvodného poľa (na začiatku je to prvá pozícia poľa). Nakoniec zvýšime index pri vstupnom poli a pri pomocnom poli, z ktorého vyberáme daný prvok. Túto postupnosť krokov opakujeme, pokiaľ neprídeme na koniec jedného z polí P a L. Ak nastane situácia, že prídeme na koniec jedného z pomocných polí (a v druhom nám ostali ešte nejaké prvky), potom už iba naspäť skopírujeme zbytok druhého pomocného poľa na koniec pôvodného poľa.

===Vlastnosti algoritmu===
* vhodný pre dátové štruktúry: pole, lineárny zoznam
* časová náročnosť: vždy lineárna <math>O(n)</math>
* priestorová náročnosť: lineárna <math>O(n)</math> pre pole (alokovanie pomocných polí), <math>O(1)</math> pre lineárny zoznam (pri LZ netreba alokovať dočasné polia, stačí iba presmerovať smerníky)
* využitie: kľúčový podprogram pre triediaci algoritmus MergeSort

===Pseudokód===
Nech funkcia Merge má nasledovný prototyp: <code>Merge(pole[], lavy, stred, pravy)</code>
:1. Je <code>lavy >= pravy ? Ak áno, skonči, inak pokračuj krokom 2.</code>
:2. Nech: <code>i = 0, j = 0, k = lavy </code>
:3. Nech: <code>dlzka_L = stred - lavy + 1, dlzka_P = pravy - stred</code>
:4. Nech: <code> L = pole[lavy ... stred], P = pole[stred + 1 ... pravy] </code>
:5. Je <code>i < dlzka_L</code> a zároveň <code>j < dlzka_P</code> ? Ak áno, pokračuj krokom 5.1., inak skoč na krok 6.
:::5.1. Je <code>L[i] <= P[j]</code>?
:::: Ak áno:
:::::5.1.1. <code>pole[k] = L[i]</code>
:::::5.1.2. <code>k += 1</code>
:::::5.1.3. <code>i += 1</code>
:::::5.1.4. Skoč na krok 5.
:::: Ak nie:
:::::5.1.1. <code>pole[k] = P[j]</code>
:::::5.1.2. <code>k += 1</code>
:::::5.1.3. <code>j += 1</code>
:::::5.1.4. Skoč na krok 5.
:6. Je <code>i < dlzka_L</code> ? Ak áno, pokračuj krokom 6.1., inak skoč na krok 7.
:::6.1. <code>pole[k] = L[i]</code>
:::6.2. <code>k += 1</code>
:::6.3. <code>i += 1</code>
:::6.4. Skoč na krok 6.
:7. Je <code>j < dlzka_P</code> ? Ak áno, pokračuj krokom 7.1., inak skonči.
:::7.1. <code>pole[k] = P[j]</code>
:::7.2. <code>k += 1</code>
:::7.3. <code>j += 1</code>
:::7.4. Skoč na krok 7.

==Merge sort==
Merge Sort je triediaci algoritmus, ktorý využíva stratégiu '''"rozdeľuj a panuj"''', čo znamená, že vstupný zoznam najskôr rozdelí na dve polovice, tie zoradí a potom ich zlúči naspäť dokopy. Radí sa medzi najpoužívanejšie a najviac rešpektované triediace algoritmy.

===Vlastnosti algoritmu Merge Sort===
* vhodný pre dátové štruktúry: pole, lineárny zoznam
* časová náročnosť: vždy linearitmická <math> O(n.log(n)) </math>, vďaka ktorej dokáže efektívne triediť veľmi veľké zoznamy
* priestorová náročnosť: lineárna <math>O(n)</math> pre pole (alokovanie dočasných polí), konštantná <math>O(1)</math> pre lineárny zoznam (pri LZ stačí iba presmerovať smerníky)
* druh triedenia: triedenie zlučovaním (komparačný algoritmus)
* stabilita triedenia: stabilný
* miesto triedenia: externé triedenie (vhodný na triedenie veľkých objemov dát uložených na disku)

Z hľadiska implementácie môžeme vytvoriť dve základné verzie algoritmu, a to rekurzívnu a iteračnú.
===Opis rekurzívnej a iteračnej verzie algoritmu Merge Sort===

<tabs>
<tab name="Rekurzívna verzia" block>
[[Súbor:Merge sort.png|400px|náhľad|vpravo|Vizualizácia rekurzívnej verzie algoritmu MergeSort]]

===Princíp algoritmu===
Algoritmus MergeSort vykonáva 4 základné úlohy:
# Delenie poľa na dve polovice.
# Triedenie ľavej polovice poľa.
# Triedenie pravej polovice poľa.
# Zlúčenie oboch polovíc pomocou funkcie Merge.

===Slovný opis===
Našou úlohou je vzostupne (min - max) utriediť vstupné pole. Určíme si stred poľa (pri párnom počte prvkov je to ten menší z prostredných indexov). Následne vykonávame sériu rekurzívnych delení pre ľavú a pravú časť poľa (začiatok ... stred ; stred + 1 ... koniec) až do momentu, keď nám ostanú len jednoprvkové podpolia (tie sú už utriedené). Následne v každom volaní obe tieto podpolia zlúčime pomocou algoritmu Merge do väčších podpolí (2, 4, 8, ...), až nakoniec dostaneme jedno výsledné utriedené pole.

===Pseudokód===
Nech nech má funkcia MergeSort nasledovný prototyp: <code>MergeSort(pole[], lavy, pravy) </code>
:1. Je <code>lavy >= pravy</code> ? Ak áno, skonči volanie, inak pokračuj krokom 2.
:2. Nech: <code>stred = lavy + (pravy - lavy) / 2</code>, pričom znak ''/'' vyjadruje celočíselné delenie.
:3. Rekurzívne zavolaj funkciu <code>MergeSort(pole[], lavy , stred)</code>
:3. Rekurzívne zavolaj funkciu <code>MergeSort(pole[], stred + 1 , pravy)</code>
:4. Zavolaj funkciu <code>Merge(pole[], lavy, stred, pravy)</code>
:5. Skonči volanie.

</tab>
<tab name="Iteračná verzia" block>
[[Súbor:MergeSort It.png|400px|náhľad|vpravo|Vizualizácia iteračnej verzie algoritmu MergeSort]]

===Princíp algoritmu===
Algoritmus Merge vykonáva 3 základné úlohy:
# Vonkajší cyklus: určenie veľkosti zoznamu na zlučovanie.
# Vnútorný cyklus: prechádzanie jednotlivých zoznamov v poli.
# Zlučovanie jednotlivých zoznamov pomocou funkcie Merge.

===Slovný opis===
Vstupné pole, ktoré má ''N'' prvkov, môžeme chápať, ako ''N'' rôznych jednoprvkových (utriedených) podpolí, ktoré máme zlúčiť do jedného výsledného ''N''-prvkového utriedeného poľa. Keďže by bolo veľmi nepraktické zlučovať ''N'' podpolí naraz, zvolíme nasledovnú stratégiu: Budeme prechádzať dané pole od začiatku po koniec a v prvom cykle zlúčime každé dva prvky, takže budeme mať <math>\frac{n}{2}</math> dvojprvkových utriedených podpolí. Potom v druhom cykle zlúčime každé 4 prvky do jedného podpoľa, v treťom cykle každých 8, až do momentu, keď dostaneme jedno utriedené pole.
Aby sme to docielili, potrebujeme dva cykly, vonkajší, ktorý nastaví maximálnu veľkosť podpoľa, ktoré ideme zlučovať (1,2,4,8 ... dlzka - 1) a vnútorný, ktorý prechádza jednotlivé podpolia. Následne už iba voláme funkciu Merge, ktorá dané podpolia zlučuje.

Poznámka, ak máme pole, ktoré má nepárny počet prvkov, tak ten posledný prvok nezlúčime hneď v prvom cykle, ale až v tých ďalších. Takisto, ak n nie je mocnina čísla 2, tak musíme samozrejme ošetriť situáciu, kedy by sme sa dostali mimo rozsah poľa (Ak máme napríklad pole, čo má 7 prvkov, tak po prvej iterácii budú prvky utiredené podľa vzoru 2 + 2 + 2 + 1, po druhej 4 + 3, a po tretej 7)

===Pseudokód===
Nech nech má funkcia MergeSort nasledovný prototyp: <code>MergeSort(pole[], lavy, pravy) </code>
:1. Je <code>lavy >= pravy</code> ? Ak áno, skonči, inak pokračuj krokom 2.
:2. Nech: <code>dlzka_subzoznamu = 1 </code>
:3. Nech: <code>zaciatok = lavy</code>
:4. Je<code>dlzka_subzoznamu <= pravy</code> ? Ak áno pokračuj krokom 4.1, inak skonči.
:::4.1. Je<code>zaciatok < pravy</code> Ak áno pokračuj krokom 4.1.1, inak skoč na krok 4.2.
:::::4.1.1. Je <code>zaciatok + 2 * dlzka_zoznamu - 1 <= pravy</code> ?
:::::::Ak áno:
:::::::::4.1.1.1. Nech <code>koniec = zaciatok + 2 * dlzka_zoznamu - 1</code>
:::::::Ak nie:
:::::::::4.1.1.1. Nech <code>koniec = pravy</code>
:::::4.1.2. Je <code>zaciatok + dlzka_zoznamu - 1 <= pravy</code> ?
:::::::Ak áno:
:::::::::4.1.2.1. Nech <code>stred = zaciatok + dlzka_zoznamu - 1</code>
:::::::Ak nie:
:::::::::4.1.2.1. Nech <code>stred = pravy</code>
:::::4.1.3. <code>Merge(pole[], zaciatok, stred, koniec)</code>
:::::4.1.4. <code>zaciatok += 2 * dlzka_subzoznamu</code>
:::::4.1.5. Skoč na krok 4.1.
:::4.2. <code>dlzka_subzoznamu *= 2</code>
:::4.3 Skoč na krok 4.

</tab>
</tabs>

==Implementácia algoritmov Merge a MergeSort programovacích jazykoch==
<tabs>
<tab name="Rekurzívna: C " block>
<syntaxhighlight lang="C">
#include <stdio.h>
#include <stdlib.h>

void Merge(int pole[], int lavy, int stred, int pravy);
void MergeSort(int pole[], int lavy, int pravy);

/* hlavný program */

int main()
{
int pole[] = {12, 11, 13, 5, 6, 7};
int dlzka_pola = sizeof(pole) / sizeof(pole[0]);

printf("Pôvodné pole: \n");

for (int i = 0; i < dlzka_pola; ++i)
{
printf("%d ", pole[i]);
}

MergeSort(pole, 0, dlzka_pola - 1);

printf("\nUtriedené pole: \n");

for (int i = 0; i < dlzka_pola; ++i)
{
printf("%d ", pole[i]);
}

return 0;
}

void Merge(int pole[], int lavy, int stred, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči */

if (lavy >= pravy)
{
return;
}

/* vyrátaj dĺžky oboch polovíc poľa */

int L_dlzka = stred - lavy + 1;
int P_dlzka = pravy - stred;

/* alokuj dočasné polia, kam uložíš prvky z oboch polovíc poľa */

int *L = (int*)malloc(L_dlzka * sizeof(int));
int *P = (int*)malloc(P_dlzka * sizeof(int));

/* indexy, ktorými iterujeme všetky polia: i pre L, j pre P, k pre pole */

int i, j, k;

/* skopíruj obsah oboch polovíc poľa do dočasných polí L a P */

for (i = 0; i < L_dlzka; ++i)
{
L[i] = pole[lavy + i];
}

for (j = 0; j < P_dlzka; ++j)
{
P[j] = pole[stred + 1 + j];
}

/* nastav indexy na začiatok daných polí */

i = 0; j = 0; k = lavy;

/* zlučuj dočasné polia L a P do finálneho poľa pole */

while(i < L_dlzka && j < P_dlzka)
{
if(L[i] <= P[j])
{
pole[k++] = L[i++];
}
else
{
pole[k++] = P[j++];
}
}

/* ak ostali nejaké prvky v dočasnom poli L, skopíruj ich do finálneho poľa */

while(i < L_dlzka)
{
pole[k++] = L[i++];
}

/* ak ostali nejaké prvky v dočasnom poli P, skopíruj ich do finálneho poľa */

while(j < P_dlzka)
{
pole[k++] = P[j++];
}

/* uvoľni použitú pamäť */

free(L);
free(P);
}

void MergeSort(int pole[], int lavy, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči volanie */

if(lavy >= pravy)
{
return;
}
/* urči si prostredný index */

int stred = lavy + (pravy - lavy) / 2;

/* utrieď ľavú polovicu poľa */

MergeSort(pole, lavy, stred);

/* utrieď pravú polovicu poľa */

MergeSort(pole, stred+1, pravy);

/* zlúč obe polovice dokopy */

Merge(pole, lavy, stred, pravy);
}
</syntaxhighlight>
</tab>

<tab name="Iteračná: C" block>
<syntaxhighlight lang="C">
#include <stdio.h>
#include <stdlib.h>

void Merge(int pole[], int lavy, int stred, int pravy);
void MergeSortIt(int *pole, int lavy, int pravy);

/* hlavný program */

int main()
{
int pole[] = {12, 11, 13, 5, 6, 7, 19};
int dlzka_pola = sizeof(pole) / sizeof(pole[0]);

printf("Pôvodné pole %d: \n", dlzka_pola);

for (int i = 0; i < dlzka_pola; ++i)
{
printf("%d ", pole[i]);
}

MergeSortIt(pole, 0, dlzka_pola - 1);

printf("\nUtriedené pole: \n");

for (int i = 0; i < dlzka_pola; ++i)
{
printf("%d ", pole[i]);
}

return 0;
}

void Merge(int pole[], int lavy, int stred, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči */

if (lavy >= pravy)
{
return;
}

/* vyrátaj dĺžky oboch polovíc poľa */

int L_dlzka = stred - lavy + 1;
int P_dlzka = pravy - stred;

/* alokuj dočasné polia, kam uložíš prvky z oboch polovíc poľa */

int *L = (int*)malloc(L_dlzka * sizeof(int));
int *P = (int*)malloc(P_dlzka * sizeof(int));

/* indexy, ktorými iterujeme všetky polia: i pre L, j pre P, k pre pole */

int i, j, k;

/* skopíruj obsah oboch polovíc poľa do dočasných polí L a P */

for (i = 0; i < L_dlzka; ++i)
{
L[i] = pole[lavy + i];
}

for (j = 0; j < P_dlzka; ++j)
{
P[j] = pole[stred + 1 + j];
}

/* nastav indexy na začiatok daných polí */

i = 0; j = 0; k = lavy;

/* zlučuj dočasné polia L a P do finálneho poľa pole */

while(i < L_dlzka && j < P_dlzka)
{
if(L[i] <= P[j])
{
pole[k++] = L[i++];
}
else
{
pole[k++] = P[j++];
}
}

/* ak ostali nejaké prvky v dočasnom poli L, skopíruj ich do finálneho poľa */

while(i < L_dlzka)
{
pole[k++] = L[i++];
}

/* ak ostali nejaké prvky v dočasnom poli P, skopíruj ich do finálneho poľa */

while(j < P_dlzka)
{
pole[k++] = P[j++];
}

/* uvoľni použitú pamäť */

free(L);
free(P);
}

void MergeSortIt(int *pole, int lavy, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči volanie */

if(lavy >= pravy)
{
return;
}

int stred, koniec;

for (int dlzka_zoznamu = 1; dlzka_zoznamu <= pravy ; dlzka_zoznamu *= 2)
{
for (int zaciatok = lavy; zaciatok < pravy ; zaciatok += 2 * dlzka_zoznamu)
{
koniec = (zaciatok + 2 * dlzka_zoznamu - 1 <= pravy) ? zaciatok + 2 * dlzka_zoznamu - 1 : pravy;

stred = (zaciatok + dlzka_zoznamu - 1 <= pravy) ? zaciatok + dlzka_zoznamu - 1 : pravy;

Merge(pole, zaciatok, stred, koniec);

}
}
}

</syntaxhighlight>
</tab>

<tab name="Rekurzívna: C++" block>
<syntaxhighlight lang="C++">
#include <iostream>

using std::cout;
using std::endl;

void Merge(int pole[], int lavy, int stred, int pravy);
void MergeSort(int pole[], int lavy, int pravy);

/* hlavný program */

int main()
{
int pole[] = {12, 11, 13, 5, 6, 7};
int dlzka_pola = sizeof(pole) / sizeof(pole[0]);

printf("Pôvodné pole: \n");

for (auto i: pole)
{
cout<<i<<" ";
}

MergeSort(pole, 0, dlzka_pola - 1);

cout<<endl<<"Utriedené pole:"<<endl;

for (auto i: pole)
{
cout<<i<<" ";
}

return 0;
}

void Merge(int pole[], int lavy, int stred, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči */

if (lavy >= pravy)
{
return;
}

/* vyrátaj dĺžky oboch polovíc poľa */

int L_dlzka = stred - lavy + 1;
int P_dlzka = pravy - stred;

/* alokuj dočasné polia, kam uložíš prvky z oboch polovíc poľa */

int *L = new int[L_dlzka];
int *P = new int[P_dlzka];

/* indexy, ktorými iterujeme všetky polia: i pre L, j pre P, k pre pole */

int i, j, k;

/* skopíruj obsah oboch polovíc poľa do dočasných polí L a P */

for (i = 0; i < L_dlzka; ++i)
{
L[i] = pole[lavy + i];
}

for (j = 0; j < P_dlzka; ++j)
{
P[j] = pole[stred + 1 + j];
}

/* nastav indexy na začiatok daných polí */

i = 0; j = 0; k = lavy;

/* zlučuj dočasné polia L a P do finálneho poľa pole */

while(i < L_dlzka && j < P_dlzka)
{
if(L[i] <= P[j])
{
pole[k++] = L[i++];
}
else
{
pole[k++] = P[j++];
}
}

/* ak ostali nejaké prvky v dočasnom poli L, skopíruj ich do finálneho poľa */

while(i < L_dlzka)
{
pole[k++] = L[i++];
}

/* ak ostali nejaké prvky v dočasnom poli P, skopíruj ich do finálneho poľa */

while(j < P_dlzka)
{
pole[k++] = P[j++];
}

/* uvoľni použitú pamäť */

delete []L;
delete []P;
}

void MergeSort(int pole[], int lavy, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči volanie */

if(lavy >= pravy)
{
return;
}
/* urči si prostredný index */

int stred = lavy + (pravy - lavy) / 2;

/* utrieď ľavú polovicu poľa */

MergeSort(pole, lavy, stred);

/* utrieď pravú polovicu poľa */

MergeSort(pole, stred+1, pravy);

/* zlúč obe polovice dokopy */

Merge(pole, lavy, stred, pravy);
}

</syntaxhighlight>
</tab>

<tab name="Iteračná: C++" block>
<syntaxhighlight lang="C++">
#include <iostream>

using std::cout;
using std::endl;

void Merge(int pole[], int lavy, int stred, int pravy);
void MergeSort(int pole[], int lavy, int pravy);

/* hlavný program */

int main()
{
int pole[] = {12, 11, 13, 5, 6, 7};
int dlzka_pola = sizeof(pole) / sizeof(pole[0]);

printf("Pôvodné pole: \n");

for (auto i: pole)
{
cout<<i<<" ";
}

MergeSort(pole, 0, dlzka_pola - 1);

cout<<endl<<"Utriedené pole:"<<endl;

for (auto i: pole)
{
cout<<i<<" ";
}

return 0;
}

void Merge(int pole[], int lavy, int stred, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči */

if (lavy >= pravy)
{
return;
}

/* vyrátaj dĺžky oboch polovíc poľa */

int L_dlzka = stred - lavy + 1;
int P_dlzka = pravy - stred;

/* alokuj dočasné polia, kam uložíš prvky z oboch polovíc poľa */

int *L = new int[L_dlzka];
int *P = new int[P_dlzka];

/* indexy, ktorými iterujeme všetky polia: i pre L, j pre P, k pre pole */

int i, j, k;

/* skopíruj obsah oboch polovíc poľa do dočasných polí L a P */

for (i = 0; i < L_dlzka; ++i)
{
L[i] = pole[lavy + i];
}

for (j = 0; j < P_dlzka; ++j)
{
P[j] = pole[stred + 1 + j];
}

/* nastav indexy na začiatok daných polí */

i = 0; j = 0; k = lavy;

/* zlučuj dočasné polia L a P do finálneho poľa pole */

while(i < L_dlzka && j < P_dlzka)
{
if(L[i] <= P[j])
{
pole[k++] = L[i++];
}
else
{
pole[k++] = P[j++];
}
}

/* ak ostali nejaké prvky v dočasnom poli L, skopíruj ich do finálneho poľa */

while(i < L_dlzka)
{
pole[k++] = L[i++];
}

/* ak ostali nejaké prvky v dočasnom poli P, skopíruj ich do finálneho poľa */

while(j < P_dlzka)
{
pole[k++] = P[j++];
}

/* uvoľni použitú pamäť */

delete []L;
delete []P;
}

void MergeSort(int *pole, int lavy, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči volanie */

if(lavy >= pravy)
{
return;
}

int stred, koniec;

for (int dlzka_zoznamu = 1; dlzka_zoznamu <= pravy; dlzka_zoznamu *= 2)
{
for (int zaciatok = lavy; zaciatok < pravy; zaciatok += 2 * dlzka_zoznamu)
{
koniec = (zaciatok + 2 * dlzka_zoznamu - 1 <= pravy) ? zaciatok + 2 * dlzka_zoznamu - 1 : pravy;

stred = (zaciatok + dlzka_zoznamu - 1 <= pravy) ? zaciatok + dlzka_zoznamu - 1 : pravy;

Merge(pole, zaciatok, stred, koniec);
}
}
}
</syntaxhighlight>
</tab>

<tab name="Rekurzívna: Java" block>
<syntaxhighlight lang="Java">
class MergeSort
{

/* Funkcia zlúči 2 podpolia, ktoré sme vytvorili z pôvodného poľa.
* Každé podpole má polovičnú dĺžku pôvodného poľa.
* subpole1 [ľavý ... stred]
* subpole2 [stred + 1 ... pravý] */

void merge(int[] pole, int lavy, int stred, int pravy)
{

// Výpočet dĺžky 2 podpolí

int n1 = stred - lavy + 1;
int n2 = pravy - stred;

// Vytvorenie pomocných polí

int[] L = new int[n1];
int[] P = new int[n2];

// Načítanie dát do pomocných polí

for (int i = 0; i < n1; i++)
L[i] = pole[lavy + i];

for (int j = 0; j < n2; j++)
P[j] = pole[stred + 1 + j];

// Počiatočné indexy prvého a druhého podpoľa

int i = 0, j = 0;

// Počiatočný index zlúčeného podpoľa

int k = lavy;

// Zlúčenie dvoch podpolí

while (i < n1 && j < n2)
{
if (L[i] <= P[j])
{
pole[k] = L[i];
i++;
}
else
{
pole[k] = P[j];
j++;
}
k++;
}

/* V prípade, že sa v jednom zo podpoli nachádzajú ešte nejaké prvky, ktoré neboli zlúčené do pola,
* tak sa do pola jednoducho skopírujú */

while (i < n1)
{
pole[k] = L[i];
i++;
k++;
}

while (j < n2)
{
pole[k] = P[j];
k++;
j++;
}

}

/* Funkcia, ktorá zoradí pole použitím funkcie merge() */

void sort (int[] pole, int lavy, int pravy)
{
if (lavy < pravy)
{
// Musíme nájsť stred pola

int stred = lavy + (pravy - lavy) / 2;

// Zoradíme prvú a druhú polovicu pola samostatne

sort(pole, lavy, stred);
sort(pole, stred + 1, pravy);

// Zlúčime zoradené polovice do jedného pola

merge(pole, lavy, stred, pravy);
}
}
}

public class Main
{
/* Funkcia na výpis pola dĺžky n */

static void vypis_pole(int[] pole)
{

for (int j : pole)
{
System.out.print(j + " ");
}

System.out.println();
}

/* Hlavný program */

public static void main(String[] args)
{
int[] pole = {12, 11, 13, 5, 6, 7};

System.out.println("Zadané pole:");
vypis_pole(pole);

MergeSort ms = new MergeSort();
ms.sort(pole, 0, pole.length - 1);

System.out.println("\nZoradené pole:");
vypis_pole(pole);
}
}
</syntaxhighlight>
</tab>

<tab name="Iteračná: Java" block>
<syntaxhighlight lang="Java">
class MergeSort_iteracia {
/* Zlúči 2 subpolia, ktoré sa vytvorili z pôvodného pola.
* Každé subpole má polovičnú dĺžku pôvodného pola.
* subpole1 [ľavý..stred]
* subpole2 [stred+1..pravý] */
void merge(int[] pole, int lavy, int stred, int pravy) {
// Výpočet dĺžky 2 subpolí
int n1 = stred - lavy + 1;
int n2 = pravy - stred;

// Vytvorenie pomocných polí
int[] L = new int[n1];
int[] P = new int[n2];

// Načítanie dát do pomocných polí
for (int i = 0; i < n1; i++)
L[i] = pole[lavy + i];

for (int j = 0; j < n2; j++)
P[j] = pole[stred + 1 + j];

// Počiatočné indexy prvého a druhého subpola
int i = 0, j = 0;
// Počiatočný index zlúčeného subpola
int k = lavy;

// Zlúčenie dvoch podpolí
while (i < n1 && j < n2) {
if (L[i] <= P[j]) {
pole[k] = L[i];
i++;
}
else {
pole[k] = P[j];
j++;
}
k++;
}

/* V prípade, že v jednom zo subpolí sa nachádzajú prvky, ktoré neboli zlúčené do pola,
* tak sa do pola jednoducho skopírujú */
while (i < n1) {
pole[k] = L[i];
i++;
k++;
}

while (j < n2) {
pole[k] = P[j];
k++;
j++;
}
}

/* Funkcia, ktorá zoradí pole použitím funkcie merge() */
void sort (int[] pole, int n) {
/* Dĺžka subpolí, ktoré majú byť zlúčené, hodnoty premennej sa pohybujú v intervale <1;n-1> */
int aktual_dlzka;
/* Začiatočný index ľavého subpola, ktoré má byť zlúčené */
int zaciatok_vlavo;

/* Vzostupné usporiadanie prvkov. Najskôr sa zlúčia subpolia veľkosti 1 do subpolí veľkosti 2,
* potom subpolia veľkosti 2 do subpolí veľkosti 4 a tak ďalej */
for (aktual_dlzka = 1; aktual_dlzka <= n - 1; aktual_dlzka *= 2) {
/* Určenie začiatočného prvku rôznych subpolí aktuálnej dĺžky subpola */
for (zaciatok_vlavo = 0; zaciatok_vlavo < n - 1; zaciatok_vlavo += 2 * aktual_dlzka) {
/* Nájdenie konečného prvku ľavého subpola, stred+1 je začiatočný prvok pravého subpola */
int stred = Math.min(zaciatok_vlavo + aktual_dlzka - 1, n - 1);
int koniec_vpravo = Math.min(zaciatok_vlavo + 2 * aktual_dlzka - 1, n - 1);

/* Zlúči subpolia L[zaciatok_vlavo .. stred] & P[stred+1 .. koniec_vpravo] */
merge(pole, zaciatok_vlavo, stred, koniec_vpravo);
}
}
}
}

public class Main {
/* Funkcia na výpis pola dĺžky n */
static void vypis_pole(int[] pole) {
int n = pole.length;

for (int j : pole) {
System.out.print(j + " ");
}
System.out.println();
}

/* Hlavný program */
public static void main(String[] args) {

/* Inicializácia pola */
int[] pole = {12, 11, 13, 5, 6, 7};

System.out.println("Zadané pole:");
vypis_pole(pole);

MergeSort_iteracia ms_it = new MergeSort_iteracia();
ms_it.sort(pole, pole.length);

System.out.println("Zoradené pole:");
vypis_pole(pole);
}
}
</syntaxhighlight>
</tab>

<tab name="Rekurzívna: Python3" block>
<syntaxhighlight lang="Python3">
def MergeSort(pole):
if len(pole) > 1:
# Nájdenie stredu pola
# zápis len(pole)//2 znamená, že dĺžka pola sa vydelí 2 a výsledok je celé číslo
stred = len(pole) // 2

# Rozdelenie pola na dve časti
L = pole[:stred]
P = pole[stred:]

# Zoradenie najskôr prvej časti pola, potom druhej
MergeSort(L)
MergeSort(P)

i = j = k = 0

# Načítanie dát do pomocných polí L[] a P[]
while i < len(L) and j < len(P):
if L[i] < P[j]:
pole[k] = L[i]
i += 1
else:
pole[k] = P[j]
j += 1
k += 1

# Kontrola či všetky prvky boli zlúčené dokopy,
# ak nie, tak sa do zlúčeného pola jednoducho skopírujú
while i < len(L):
pole[k] = L[i]
i += 1
k += 1

while j < len(P):
pole[k] = P[j]
j += 1
k += 1

# Hlavný program
if __name__ == '__main__':
pole = [12, 11, 13, 5, 6, 7]

print("Zadané pole:", end="\n")
print(pole, end="\n")

MergeSort(pole)

print("Zoradené pole:", end="\n")
print(pole, end="\n")

</syntaxhighlight>
</tab>

</tabs>

==Odkazy==
# https://www.geeksforgeeks.org/merge-sort/
# https://www.geeksforgeeks.org/iterative-merge-sort/
# https://medium.com/@paulsoham/merge-sort-63d75df76388
# https://www.khanacademy.org/computing/computer-science/algorithms/merge-sort/a/overview-of-merge-sort
# https://www.tutorialspoint.com/data_structures_algorithms/merge_sort_algorithm.htm
# https://www.youtube.com/watch?v=6pV2IF0fgKY
# https://www.youtube.com/watch?v=mB5HXBb_HY8
# https://www.youtube.com/watch?v=ak-pz7tS5DE

Triedenie zlučovaním

2021-03-29T09:49:17Z

Filip Tomek: /* Implementácia algoritmov Merge a MergeSort programovacích jazykoch */

[[Kategória:Algoritmy triedenia]]
{{Draft}}
{{Skripta programovanie}}
__TOC__
==TODO: Pseudokód treba opraviť, text refaktorovať, otestovať kódy, zvýrazniť veci v texte, opraviť preklepy, opraviť popis obrázkov, pridať nové odkazy==

==Zlučovací algoritmus Merge==

Princíp zlučovania tkvie v tom, že máme dva alebo viac utriedených zoznamov, ktoré skombinuje do jedného utriedeného zoznamu (výsledný zoznam musí obsahovať všetky prvky z pôvodných zoznamov). Zoznam môže byť reprezentovaný ako dátová štruktúra pole alebo aj ako lineárny zoznam. V tomto článku sa zameriame na algoritmus pre dátovú štruktúru pole.

Algoritmus Merge tvorí kľúčovú časť triediaceho algoritmu MergeSort.

[[Súbor:Funkcia merge.png|500px|náhľad|vpravo|Vizualizácia funkcie Merge: Máme pole prvkov p = [1, 3, 5, 2, 4, 6], ktoré je už čiastočne utriedené. Použijeme algoritmus Merge, ktorý si vytvorí pomocné polia L = [1, 3, 5] a P = [2, 4, 6]. Všetky polia indexujeme od 0, pričom pre pole p používame index k, pre L index i a pre P index j. Postupnosť krokov je označená číslicami 1 až 6.
]]

===Slovný opis algoritmu===
Nech máme pole, ktoré sa skladá z dvoch už utriedených polovíc. Vytvoríme si dve pomocné polia L a P a do každého z nich skopírujeme obsah jednej polovice (L - ľavá polovica, P - pravá polovica). Potom súčasne prechádzame polia L a P od začiatku po koniec, pričom v každom cykle porovnáme prvok poľa L s prvkom v poli P. Z tejto dvojice následne vyberieme minimum, (keď triedime od najmenšieho po najväčší) ktoré vložíme na prvú voľnú pozíciu pôvodného poľa (na začiatku je to prvá pozícia poľa). Nakoniec zvýšime index pri vstupnom poli a pri pomocnom poli, z ktorého vyberáme daný prvok. Túto postupnosť krokov opakujeme, pokiaľ neprídeme na koniec jedného z polí P a L. Ak nastane situácia, že prídeme na koniec jedného z pomocných polí (a v druhom nám ostali ešte nejaké prvky), potom už iba naspäť skopírujeme zbytok druhého pomocného poľa na koniec pôvodného poľa.

===Vlastnosti algoritmu===
* vhodný pre dátové štruktúry: pole, lineárny zoznam
* časová náročnosť: vždy lineárna <math>O(n)</math>
* priestorová náročnosť: lineárna <math>O(n)</math> pre pole (alokovanie pomocných polí), <math>O(1)</math> pre lineárny zoznam (pri LZ netreba alokovať dočasné polia, stačí iba presmerovať smerníky)
* využitie: kľúčový podprogram pre triediaci algoritmus MergeSort

===Pseudokód===
Nech funkcia Merge má nasledovný prototyp: <code>Merge(pole[], lavy, stred, pravy)</code>
:1. Je <code>lavy >= pravy ? Ak áno, skonči, inak pokračuj krokom 2.</code>
:2. Nech: <code>i = 0, j = 0, k = lavy </code>
:3. Nech: <code>dlzka_L = stred - lavy + 1, dlzka_P = pravy - stred</code>
:4. Nech: <code> L = pole[lavy ... stred], P = pole[stred + 1 ... pravy] </code>
:5. Je <code>i < dlzka_L</code> a zároveň <code>j < dlzka_P</code> ? Ak áno, pokračuj krokom 5.1., inak skoč na krok 6.
:::5.1. Je <code>L[i] <= P[j]</code>?
:::: Ak áno:
:::::5.1.1. <code>pole[k] = L[i]</code>
:::::5.1.2. <code>k += 1</code>
:::::5.1.3. <code>i += 1</code>
:::::5.1.4. Skoč na krok 5.
:::: Ak nie:
:::::5.1.1. <code>pole[k] = P[j]</code>
:::::5.1.2. <code>k += 1</code>
:::::5.1.3. <code>j += 1</code>
:::::5.1.4. Skoč na krok 5.
:6. Je <code>i < dlzka_L</code> ? Ak áno, pokračuj krokom 6.1., inak skoč na krok 7.
:::6.1. <code>pole[k] = L[i]</code>
:::6.2. <code>k += 1</code>
:::6.3. <code>i += 1</code>
:::6.4. Skoč na krok 6.
:7. Je <code>j < dlzka_P</code> ? Ak áno, pokračuj krokom 7.1., inak skonči.
:::7.1. <code>pole[k] = P[j]</code>
:::7.2. <code>k += 1</code>
:::7.3. <code>j += 1</code>
:::7.4. Skoč na krok 7.

==Merge sort==
Merge Sort je triediaci algoritmus, ktorý využíva stratégiu '''"rozdeľuj a panuj"''', čo znamená, že vstupný zoznam najskôr rozdelí na dve polovice, tie zoradí a potom ich zlúči naspäť dokopy. Radí sa medzi najpoužívanejšie a najviac rešpektované triediace algoritmy.

===Vlastnosti algoritmu Merge Sort===
* vhodný pre dátové štruktúry: pole, lineárny zoznam
* časová náročnosť: vždy linearitmická <math> O(n.log(n)) </math>, vďaka ktorej dokáže efektívne triediť veľmi veľké zoznamy
* priestorová náročnosť: lineárna <math>O(n)</math> pre pole (alokovanie dočasných polí), konštantná <math>O(1)</math> pre lineárny zoznam (pri LZ stačí iba presmerovať smerníky)
* druh triedenia: triedenie zlučovaním (komparačný algoritmus)
* stabilita triedenia: stabilný
* miesto triedenia: externé triedenie (vhodný na triedenie veľkých objemov dát uložených na disku)

Z hľadiska implementácie môžeme vytvoriť dve základné verzie algoritmu, a to rekurzívnu a iteračnú.
===Opis rekurzívnej a iteračnej verzie algoritmu Merge Sort===

<tabs>
<tab name="Rekurzívna verzia" block>
[[Súbor:Merge sort.png|400px|náhľad|vpravo|Vizualizácia rekurzívnej verzie algoritmu MergeSort]]

===Princíp algoritmu===
Algoritmus MergeSort vykonáva 4 základné úlohy:
# Delenie poľa na dve polovice.
# Triedenie ľavej polovice poľa.
# Triedenie pravej polovice poľa.
# Zlúčenie oboch polovíc pomocou funkcie Merge.

===Slovný opis===
Našou úlohou je vzostupne (min - max) utriediť vstupné pole. Určíme si stred poľa (pri párnom počte prvkov je to ten menší z prostredných indexov). Následne vykonávame sériu rekurzívnych delení pre ľavú a pravú časť poľa (začiatok ... stred ; stred + 1 ... koniec) až do momentu, keď nám ostanú len jednoprvkové podpolia (tie sú už utriedené). Následne v každom volaní obe tieto podpolia zlúčime pomocou algoritmu Merge do väčších podpolí (2, 4, 8, ...), až nakoniec dostaneme jedno výsledné utriedené pole.

===Pseudokód===
Nech nech má funkcia MergeSort nasledovný prototyp: <code>MergeSort(pole[], lavy, pravy) </code>
:1. Je <code>lavy >= pravy</code> ? Ak áno, skonči volanie, inak pokračuj krokom 2.
:2. Nech: <code>stred = lavy + (pravy - lavy) / 2</code>, pričom znak ''/'' vyjadruje celočíselné delenie.
:3. Rekurzívne zavolaj funkciu <code>MergeSort(pole[], lavy , stred)</code>
:3. Rekurzívne zavolaj funkciu <code>MergeSort(pole[], stred + 1 , pravy)</code>
:4. Zavolaj funkciu <code>Merge(pole[], lavy, stred, pravy)</code>
:5. Skonči volanie.

</tab>
<tab name="Iteračná verzia" block>
[[Súbor:MergeSort It.png|400px|náhľad|vpravo|Vizualizácia iteračnej verzie algoritmu MergeSort]]

===Princíp algoritmu===
Algoritmus Merge vykonáva 3 základné úlohy:
# Vonkajší cyklus: určenie veľkosti zoznamu na zlučovanie.
# Vnútorný cyklus: prechádzanie jednotlivých zoznamov v poli.
# Zlučovanie jednotlivých zoznamov pomocou funkcie Merge.

===Slovný opis===
Vstupné pole, ktoré má ''N'' prvkov, môžeme chápať, ako ''N'' rôznych jednoprvkových (utriedených) podpolí, ktoré máme zlúčiť do jedného výsledného ''N''-prvkového utriedeného poľa. Keďže by bolo veľmi nepraktické zlučovať ''N'' podpolí naraz, zvolíme nasledovnú stratégiu: Budeme prechádzať dané pole od začiatku po koniec a v prvom cykle zlúčime každé dva prvky, takže budeme mať <math>\frac{n}{2}</math> dvojprvkových utriedených podpolí. Potom v druhom cykle zlúčime každé 4 prvky do jedného podpoľa, v treťom cykle každých 8, až do momentu, keď dostaneme jedno utriedené pole.
Aby sme to docielili, potrebujeme dva cykly, vonkajší, ktorý nastaví maximálnu veľkosť podpoľa, ktoré ideme zlučovať (1,2,4,8 ... dlzka - 1) a vnútorný, ktorý prechádza jednotlivé podpolia. Následne už iba voláme funkciu Merge, ktorá dané podpolia zlučuje.

Poznámka, ak máme pole, ktoré má nepárny počet prvkov, tak ten posledný prvok nezlúčime hneď v prvom cykle, ale až v tých ďalších. Takisto, ak n nie je mocnina čísla 2, tak musíme samozrejme ošetriť situáciu, kedy by sme sa dostali mimo rozsah poľa (Ak máme napríklad pole, čo má 7 prvkov, tak po prvej iterácii budú prvky utiredené podľa vzoru 2 + 2 + 2 + 1, po druhej 4 + 3, a po tretej 7)

===Pseudokód===
Nech nech má funkcia MergeSort nasledovný prototyp: <code>MergeSort(pole[], lavy, pravy) </code>
:1. Je <code>lavy >= pravy</code> ? Ak áno, skonči, inak pokračuj krokom 2.
:2. Nech: <code>dlzka_subzoznamu = 1 </code>
:3. Nech: <code>zaciatok = lavy</code>
:4. Je<code>dlzka_subzoznamu <= pravy</code> ? Ak áno pokračuj krokom 4.1, inak skonči.
:::4.1. Je<code>zaciatok < pravy</code> Ak áno pokračuj krokom 4.1.1, inak skoč na krok 4.2.
:::::4.1.1. Je <code>zaciatok + 2 * dlzka_zoznamu - 1 <= pravy</code> ?
:::::::Ak áno:
:::::::::4.1.1.1. Nech <code>koniec = zaciatok + 2 * dlzka_zoznamu - 1</code>
:::::::Ak nie:
:::::::::4.1.1.1. Nech <code>koniec = pravy</code>
:::::4.1.2. Je <code>zaciatok + dlzka_zoznamu - 1 <= pravy</code> ?
:::::::Ak áno:
:::::::::4.1.2.1. Nech <code>stred = zaciatok + dlzka_zoznamu - 1</code>
:::::::Ak nie:
:::::::::4.1.2.1. Nech <code>stred = pravy</code>
:::::4.1.3. <code>Merge(pole[], zaciatok, stred, koniec)</code>
:::::4.1.4. <code>zaciatok += 2 * dlzka_subzoznamu</code>
:::::4.1.5. Skoč na krok 4.1.
:::4.2. <code>dlzka_subzoznamu *= 2</code>
:::4.3 Skoč na krok 4.

</tab>
</tabs>

==Implementácia algoritmov Merge a MergeSort programovacích jazykoch==
<tabs>
<tab name="Rekurzívna: C " block>
<syntaxhighlight lang="C">
#include <stdio.h>
#include <stdlib.h>

void Merge(int pole[], int lavy, int stred, int pravy);
void MergeSort(int pole[], int lavy, int pravy);

/* hlavný program */

int main()
{
int pole[] = {12, 11, 13, 5, 6, 7};
int dlzka_pola = sizeof(pole) / sizeof(pole[0]);

printf("Pôvodné pole: \n");

for (int i = 0; i < dlzka_pola; ++i)
{
printf("%d ", pole[i]);
}

MergeSort(pole, 0, dlzka_pola - 1);

printf("\nUtriedené pole: \n");

for (int i = 0; i < dlzka_pola; ++i)
{
printf("%d ", pole[i]);
}

return 0;
}

void Merge(int pole[], int lavy, int stred, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči */

if (lavy >= pravy)
{
return;
}

/* vyrátaj dĺžky oboch polovíc poľa */

int L_dlzka = stred - lavy + 1;
int P_dlzka = pravy - stred;

/* alokuj dočasné polia, kam uložíš prvky z oboch polovíc poľa */

int *L = (int*)malloc(L_dlzka * sizeof(int));
int *P = (int*)malloc(P_dlzka * sizeof(int));

/* indexy, ktorými iterujeme všetky polia: i pre L, j pre P, k pre pole */

int i, j, k;

/* skopíruj obsah oboch polovíc poľa do dočasných polí L a P */

for (i = 0; i < L_dlzka; ++i)
{
L[i] = pole[lavy + i];
}

for (j = 0; j < P_dlzka; ++j)
{
P[j] = pole[stred + 1 + j];
}

/* nastav indexy na začiatok daných polí */

i = 0; j = 0; k = lavy;

/* zlučuj dočasné polia L a P do finálneho poľa pole */

while(i < L_dlzka && j < P_dlzka)
{
if(L[i] <= P[j])
{
pole[k++] = L[i++];
}
else
{
pole[k++] = P[j++];
}
}

/* ak ostali nejaké prvky v dočasnom poli L, skopíruj ich do finálneho poľa */

while(i < L_dlzka)
{
pole[k++] = L[i++];
}

/* ak ostali nejaké prvky v dočasnom poli P, skopíruj ich do finálneho poľa */

while(j < P_dlzka)
{
pole[k++] = P[j++];
}

/* uvoľni použitú pamäť */

free(L);
free(P);
}

void MergeSort(int pole[], int lavy, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči volanie */

if(lavy >= pravy)
{
return;
}
/* urči si prostredný index */

int stred = lavy + (pravy - lavy) / 2;

/* utrieď ľavú polovicu poľa */

MergeSort(pole, lavy, stred);

/* utrieď pravú polovicu poľa */

MergeSort(pole, stred+1, pravy);

/* zlúč obe polovice dokopy */

Merge(pole, lavy, stred, pravy);
}
</syntaxhighlight>
</tab>

<tab name="Iteračná: C" block>
<syntaxhighlight lang="C">
#include <stdio.h>
#include <stdlib.h>

void Merge(int pole[], int lavy, int stred, int pravy);
void MergeSortIt(int *pole, int lavy, int pravy);

/* hlavný program */

int main()
{
int pole[] = {12, 11, 13, 5, 6, 7, 19};
int dlzka_pola = sizeof(pole) / sizeof(pole[0]);

printf("Pôvodné pole %d: \n", dlzka_pola);

for (int i = 0; i < dlzka_pola; ++i)
{
printf("%d ", pole[i]);
}

MergeSortIt(pole, 0, dlzka_pola - 1);

printf("\nUtriedené pole: \n");

for (int i = 0; i < dlzka_pola; ++i)
{
printf("%d ", pole[i]);
}

return 0;
}

void Merge(int pole[], int lavy, int stred, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči */

if (lavy >= pravy)
{
return;
}

/* vyrátaj dĺžky oboch polovíc poľa */

int L_dlzka = stred - lavy + 1;
int P_dlzka = pravy - stred;

/* alokuj dočasné polia, kam uložíš prvky z oboch polovíc poľa */

int *L = (int*)malloc(L_dlzka * sizeof(int));
int *P = (int*)malloc(P_dlzka * sizeof(int));

/* indexy, ktorými iterujeme všetky polia: i pre L, j pre P, k pre pole */

int i, j, k;

/* skopíruj obsah oboch polovíc poľa do dočasných polí L a P */

for (i = 0; i < L_dlzka; ++i)
{
L[i] = pole[lavy + i];
}

for (j = 0; j < P_dlzka; ++j)
{
P[j] = pole[stred + 1 + j];
}

/* nastav indexy na začiatok daných polí */

i = 0; j = 0; k = lavy;

/* zlučuj dočasné polia L a P do finálneho poľa pole */

while(i < L_dlzka && j < P_dlzka)
{
if(L[i] <= P[j])
{
pole[k++] = L[i++];
}
else
{
pole[k++] = P[j++];
}
}

/* ak ostali nejaké prvky v dočasnom poli L, skopíruj ich do finálneho poľa */

while(i < L_dlzka)
{
pole[k++] = L[i++];
}

/* ak ostali nejaké prvky v dočasnom poli P, skopíruj ich do finálneho poľa */

while(j < P_dlzka)
{
pole[k++] = P[j++];
}

/* uvoľni použitú pamäť */

free(L);
free(P);
}

void MergeSortIt(int *pole, int lavy, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči volanie */

if(lavy >= pravy)
{
return;
}

int stred, koniec;

for (int dlzka_zoznamu = 1; dlzka_zoznamu <= pravy ; dlzka_zoznamu *= 2)
{
for (int zaciatok = lavy; zaciatok < pravy ; zaciatok += 2 * dlzka_zoznamu)
{
koniec = (zaciatok + 2 * dlzka_zoznamu - 1 <= pravy) ? zaciatok + 2 * dlzka_zoznamu - 1 : pravy;

stred = (zaciatok + dlzka_zoznamu - 1 <= pravy) ? zaciatok + dlzka_zoznamu - 1 : pravy;

Merge(pole, zaciatok, stred, koniec);

}
}
}

</syntaxhighlight>
</tab>

<tab name="Rekurzívna: C++" block>
<syntaxhighlight lang="C++">
#include <iostream>

using std::cout;
using std::endl;

void Merge(int pole[], int lavy, int stred, int pravy);
void MergeSort(int pole[], int lavy, int pravy);

/* hlavný program */

int main()
{
int pole[] = {12, 11, 13, 5, 6, 7};
int dlzka_pola = sizeof(pole) / sizeof(pole[0]);

printf("Pôvodné pole: \n");

for (auto i: pole)
{
cout<<i<<" ";
}

MergeSort(pole, 0, dlzka_pola - 1);

cout<<endl<<"Utriedené pole:"<<endl;

for (auto i: pole)
{
cout<<i<<" ";
}

return 0;
}

void Merge(int pole[], int lavy, int stred, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči */

if (lavy >= pravy)
{
return;
}

/* vyrátaj dĺžky oboch polovíc poľa */

int L_dlzka = stred - lavy + 1;
int P_dlzka = pravy - stred;

/* alokuj dočasné polia, kam uložíš prvky z oboch polovíc poľa */

int *L = new int[L_dlzka];
int *P = new int[P_dlzka];

/* indexy, ktorými iterujeme všetky polia: i pre L, j pre P, k pre pole */

int i, j, k;

/* skopíruj obsah oboch polovíc poľa do dočasných polí L a P */

for (i = 0; i < L_dlzka; ++i)
{
L[i] = pole[lavy + i];
}

for (j = 0; j < P_dlzka; ++j)
{
P[j] = pole[stred + 1 + j];
}

/* nastav indexy na začiatok daných polí */

i = 0; j = 0; k = lavy;

/* zlučuj dočasné polia L a P do finálneho poľa pole */

while(i < L_dlzka && j < P_dlzka)
{
if(L[i] <= P[j])
{
pole[k++] = L[i++];
}
else
{
pole[k++] = P[j++];
}
}

/* ak ostali nejaké prvky v dočasnom poli L, skopíruj ich do finálneho poľa */

while(i < L_dlzka)
{
pole[k++] = L[i++];
}

/* ak ostali nejaké prvky v dočasnom poli P, skopíruj ich do finálneho poľa */

while(j < P_dlzka)
{
pole[k++] = P[j++];
}

/* uvoľni použitú pamäť */

delete []L;
delete []P;
}

void MergeSort(int pole[], int lavy, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči volanie */

if(lavy >= pravy)
{
return;
}
/* urči si prostredný index */

int stred = lavy + (pravy - lavy) / 2;

/* utrieď ľavú polovicu poľa */

MergeSort(pole, lavy, stred);

/* utrieď pravú polovicu poľa */

MergeSort(pole, stred+1, pravy);

/* zlúč obe polovice dokopy */

Merge(pole, lavy, stred, pravy);
}

</syntaxhighlight>
</tab>

<tab name="Iteračná: C++" block>
<syntaxhighlight lang="C++">
#include <iostream>

using std::cout;
using std::endl;

void Merge(int pole[], int lavy, int stred, int pravy);
void MergeSort(int pole[], int lavy, int pravy);

/* hlavný program */

int main()
{
int pole[] = {12, 11, 13, 5, 6, 7};
int dlzka_pola = sizeof(pole) / sizeof(pole[0]);

printf("Pôvodné pole: \n");

for (auto i: pole)
{
cout<<i<<" ";
}

MergeSort(pole, 0, dlzka_pola - 1);

cout<<endl<<"Utriedené pole:"<<endl;

for (auto i: pole)
{
cout<<i<<" ";
}

return 0;
}

void Merge(int pole[], int lavy, int stred, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči */

if (lavy >= pravy)
{
return;
}

/* vyrátaj dĺžky oboch polovíc poľa */

int L_dlzka = stred - lavy + 1;
int P_dlzka = pravy - stred;

/* alokuj dočasné polia, kam uložíš prvky z oboch polovíc poľa */

int *L = new int[L_dlzka];
int *P = new int[P_dlzka];

/* indexy, ktorými iterujeme všetky polia: i pre L, j pre P, k pre pole */

int i, j, k;

/* skopíruj obsah oboch polovíc poľa do dočasných polí L a P */

for (i = 0; i < L_dlzka; ++i)
{
L[i] = pole[lavy + i];
}

for (j = 0; j < P_dlzka; ++j)
{
P[j] = pole[stred + 1 + j];
}

/* nastav indexy na začiatok daných polí */

i = 0; j = 0; k = lavy;

/* zlučuj dočasné polia L a P do finálneho poľa pole */

while(i < L_dlzka && j < P_dlzka)
{
if(L[i] <= P[j])
{
pole[k++] = L[i++];
}
else
{
pole[k++] = P[j++];
}
}

/* ak ostali nejaké prvky v dočasnom poli L, skopíruj ich do finálneho poľa */

while(i < L_dlzka)
{
pole[k++] = L[i++];
}

/* ak ostali nejaké prvky v dočasnom poli P, skopíruj ich do finálneho poľa */

while(j < P_dlzka)
{
pole[k++] = P[j++];
}

/* uvoľni použitú pamäť */

delete []L;
delete []P;
}

void MergeSort(int *pole, int lavy, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči volanie */

if(lavy >= pravy)
{
return;
}

int stred, koniec;

for (int dlzka_zoznamu = 1; dlzka_zoznamu <= pravy; dlzka_zoznamu *= 2)
{
for (int zaciatok = lavy; zaciatok < pravy; zaciatok += 2 * dlzka_zoznamu)
{
koniec = (zaciatok + 2 * dlzka_zoznamu - 1 <= pravy) ? zaciatok + 2 * dlzka_zoznamu - 1 : pravy;

stred = (zaciatok + dlzka_zoznamu - 1 <= pravy) ? zaciatok + dlzka_zoznamu - 1 : pravy;

Merge(pole, zaciatok, stred, koniec);
}
}
}
</syntaxhighlight>
</tab>

<tab name="Rekurzívna: Java" block>
<syntaxhighlight lang="Java">
class MergeSort
{

/* Funkcia zlúči 2 podpolia, ktoré sme vytvorili z pôvodného poľa.
* Každé podpole má polovičnú dĺžku pôvodného poľa.
* subpole1 [ľavý ... stred]
* subpole2 [stred + 1 ... pravý] */

void merge(int[] pole, int lavy, int stred, int pravy)
{

// Výpočet dĺžky 2 podpolí

int n1 = stred - lavy + 1;
int n2 = pravy - stred;

// Vytvorenie pomocných polí

int[] L = new int[n1];
int[] P = new int[n2];

// Načítanie dát do pomocných polí

for (int i = 0; i < n1; i++)
L[i] = pole[lavy + i];

for (int j = 0; j < n2; j++)
P[j] = pole[stred + 1 + j];

// Počiatočné indexy prvého a druhého podpoľa

int i = 0, j = 0;

// Počiatočný index zlúčeného podpoľa

int k = lavy;

// Zlúčenie dvoch podpolí

while (i < n1 && j < n2)
{
if (L[i] <= P[j])
{
pole[k] = L[i];
i++;
}
else
{
pole[k] = P[j];
j++;
}
k++;
}

/* V prípade, že sa v jednom zo podpoli nachádzajú ešte nejaké prvky, ktoré neboli zlúčené do pola,
* tak sa do pola jednoducho skopírujú */

while (i < n1)
{
pole[k] = L[i];
i++;
k++;
}

while (j < n2)
{
pole[k] = P[j];
k++;
j++;
}

}

/* Funkcia, ktorá zoradí pole použitím funkcie merge() */

void sort (int[] pole, int lavy, int pravy)
{
if (lavy < pravy)
{
// Musíme nájsť stred pola

int stred = lavy + (pravy - lavy) / 2;

// Zoradíme prvú a druhú polovicu pola samostatne

sort(pole, lavy, stred);
sort(pole, stred + 1, pravy);

// Zlúčime zoradené polovice do jedného pola

merge(pole, lavy, stred, pravy);
}
}
}

public class Main
{
/* Funkcia na výpis pola dĺžky n */

static void vypis_pole(int[] pole)
{

for (int j : pole)
{
System.out.print(j + " ");
}

System.out.println();
}

/* Hlavný program */

public static void main(String[] args)
{
int[] pole = {12, 11, 13, 5, 6, 7};

System.out.println("Zadané pole:");
vypis_pole(pole);

MergeSort ms = new MergeSort();
ms.sort(pole, 0, pole.length - 1);

System.out.println("\nZoradené pole:");
vypis_pole(pole);
}
}
</syntaxhighlight>
</tab>

<tab name="Iteračná: Java" block>
<syntaxhighlight lang="Java">
class MergeSort_iteracia {
/* Zlúči 2 subpolia, ktoré sa vytvorili z pôvodného pola.
* Každé subpole má polovičnú dĺžku pôvodného pola.
* subpole1 [ľavý..stred]
* subpole2 [stred+1..pravý] */
void merge(int[] pole, int lavy, int stred, int pravy) {
// Výpočet dĺžky 2 subpolí
int n1 = stred - lavy + 1;
int n2 = pravy - stred;

// Vytvorenie pomocných polí
int[] L = new int[n1];
int[] P = new int[n2];

// Načítanie dát do pomocných polí
for (int i = 0; i < n1; i++)
L[i] = pole[lavy + i];

for (int j = 0; j < n2; j++)
P[j] = pole[stred + 1 + j];

// Počiatočné indexy prvého a druhého subpola
int i = 0, j = 0;
// Počiatočný index zlúčeného subpola
int k = lavy;

// Zlúčenie dvoch podpolí
while (i < n1 && j < n2) {
if (L[i] <= P[j]) {
pole[k] = L[i];
i++;
}
else {
pole[k] = P[j];
j++;
}
k++;
}

/* V prípade, že v jednom zo subpolí sa nachádzajú prvky, ktoré neboli zlúčené do pola,
* tak sa do pola jednoducho skopírujú */
while (i < n1) {
pole[k] = L[i];
i++;
k++;
}

while (j < n2) {
pole[k] = P[j];
k++;
j++;
}
}

/* Funkcia, ktorá zoradí pole použitím funkcie merge() */
void sort (int[] pole, int n) {
/* Dĺžka subpolí, ktoré majú byť zlúčené, hodnoty premennej sa pohybujú v intervale <1;n-1> */
int aktual_dlzka;
/* Začiatočný index ľavého subpola, ktoré má byť zlúčené */
int zaciatok_vlavo;

/* Vzostupné usporiadanie prvkov. Najskôr sa zlúčia subpolia veľkosti 1 do subpolí veľkosti 2,
* potom subpolia veľkosti 2 do subpolí veľkosti 4 a tak ďalej */
for (aktual_dlzka = 1; aktual_dlzka <= n - 1; aktual_dlzka *= 2) {
/* Určenie začiatočného prvku rôznych subpolí aktuálnej dĺžky subpola */
for (zaciatok_vlavo = 0; zaciatok_vlavo < n - 1; zaciatok_vlavo += 2 * aktual_dlzka) {
/* Nájdenie konečného prvku ľavého subpola, stred+1 je začiatočný prvok pravého subpola */
int stred = Math.min(zaciatok_vlavo + aktual_dlzka - 1, n - 1);
int koniec_vpravo = Math.min(zaciatok_vlavo + 2 * aktual_dlzka - 1, n - 1);

/* Zlúči subpolia L[zaciatok_vlavo .. stred] & P[stred+1 .. koniec_vpravo] */
merge(pole, zaciatok_vlavo, stred, koniec_vpravo);
}
}
}
}

public class Main {
/* Funkcia na výpis pola dĺžky n */
static void vypis_pole(int[] pole) {
int n = pole.length;

for (int j : pole) {
System.out.print(j + " ");
}
System.out.println();
}

/* Hlavný program */
public static void main(String[] args) {

/* Inicializácia pola */
int[] pole = {12, 11, 13, 5, 6, 7};

System.out.println("Zadané pole:");
vypis_pole(pole);

MergeSort_iteracia ms_it = new MergeSort_iteracia();
ms_it.sort(pole, pole.length);

System.out.println("Zoradené pole:");
vypis_pole(pole);
}
}
</syntaxhighlight>
</tab>

<tab name="Rekurzívna: Python3" block>
<syntaxhighlight lang="Python3">
def MergeSort(pole):
if len(pole) > 1:
# Nájdenie stredu pola
# zápis len(pole)//2 znamená, že dĺžka pola sa vydelí 2 a výsledok je celé číslo
stred = len(pole) // 2

# Rozdelenie pola na dve časti
L = pole[:stred]
P = pole[stred:]

# Zoradenie najskôr prvej časti pola, potom druhej
MergeSort(L)
MergeSort(P)

i = j = k = 0

# Načítanie dát do pomocných polí L[] a P[]
while i < len(L) and j < len(P):
if L[i] < P[j]:
pole[k] = L[i]
i += 1
else:
pole[k] = P[j]
j += 1
k += 1

# Kontrola či všetky prvky boli zlúčené dokopy,
# ak nie, tak sa do zlúčeného pola jednoducho skopírujú
while i < len(L):
pole[k] = L[i]
i += 1
k += 1

while j < len(P):
pole[k] = P[j]
j += 1
k += 1

# Hlavný program
if __name__ == '__main__':
pole = [12, 11, 13, 5, 6, 7]
print("Zadané pole:", end="\n")
print(pole, end="\n")
MergeSort(pole)
print("Zoradené pole:", end="\n")
print(pole, end="\n")
</syntaxhighlight>
</tab>

</tabs>

==Odkazy==
# https://www.geeksforgeeks.org/merge-sort/
# https://www.geeksforgeeks.org/iterative-merge-sort/
# https://medium.com/@paulsoham/merge-sort-63d75df76388
# https://www.khanacademy.org/computing/computer-science/algorithms/merge-sort/a/overview-of-merge-sort
# https://www.tutorialspoint.com/data_structures_algorithms/merge_sort_algorithm.htm
# https://www.youtube.com/watch?v=6pV2IF0fgKY
# https://www.youtube.com/watch?v=mB5HXBb_HY8
# https://www.youtube.com/watch?v=ak-pz7tS5DE

Triedenie zlučovaním

2021-03-28T16:41:41Z

Filip Tomek: /* Iteračná verzia algoritmov */

[[Kategória:Algoritmy triedenia]]
{{Draft}}
{{Skripta programovanie}}
__TOC__
==TODO: Pseudokód treba opraviť, text refaktorovať, otestovať kódy, zvýrazniť veci v texte, opraviť preklepy, opraviť popis obrázkov, pridať nové odkazy==

==Zlučovací algoritmus Merge==

Princíp zlučovania tkvie v tom, že máme dva alebo viac utriedených zoznamov, ktoré skombinuje do jedného utriedeného zoznamu (výsledný zoznam musí obsahovať všetky prvky z pôvodných zoznamov). Zoznam môže byť reprezentovaný ako dátová štruktúra pole alebo aj ako lineárny zoznam. V tomto článku sa zameriame na algoritmus pre dátovú štruktúru pole.

Algoritmus Merge tvorí kľúčovú časť triediaceho algoritmu MergeSort.

[[Súbor:Funkcia merge.png|500px|náhľad|vpravo|Vizualizácia funkcie Merge: Máme pole prvkov p = [1, 3, 5, 2, 4, 6], ktoré je už čiastočne utriedené. Použijeme algoritmus Merge, ktorý si vytvorí pomocné polia L = [1, 3, 5] a P = [2, 4, 6]. Všetky polia indexujeme od 0, pričom pre pole p používame index k, pre L index i a pre P index j. Postupnosť krokov je označená číslicami 1 až 6.
]]

===Slovný opis algoritmu===
Nech máme pole, ktoré sa skladá z dvoch už utriedených polovíc. Vytvoríme si dve pomocné polia L a P a do každého z nich skopírujeme obsah jednej polovice (L - ľavá polovica, P - pravá polovica). Potom súčasne prechádzame polia L a P od začiatku po koniec, pričom v každom cykle porovnáme prvok poľa L s prvkom v poli P. Z tejto dvojice následne vyberieme minimum, (keď triedime od najmenšieho po najväčší) ktoré vložíme na prvú voľnú pozíciu pôvodného poľa (na začiatku je to prvá pozícia poľa). Nakoniec zvýšime index pri vstupnom poli a pri pomocnom poli, z ktorého vyberáme daný prvok. Túto postupnosť krokov opakujeme, pokiaľ neprídeme na koniec jedného z polí P a L. Ak nastane situácia, že prídeme na koniec jedného z pomocných polí (a v druhom nám ostali ešte nejaké prvky), potom už iba naspäť skopírujeme zbytok druhého pomocného poľa na koniec pôvodného poľa.

===Vlastnosti algoritmu===
* vhodný pre dátové štruktúry: pole, lineárny zoznam
* časová náročnosť: vždy lineárna <math>O(n)</math>
* priestorová náročnosť: lineárna <math>O(n)</math> pre pole (alokovanie pomocných polí), <math>O(1)</math> pre lineárny zoznam (pri LZ netreba alokovať dočasné polia, stačí iba presmerovať smerníky)
* využitie: kľúčový podprogram pre triediaci algoritmus MergeSort

===Pseudokód===
Nech funkcia Merge má nasledovný prototyp: <code>Merge(pole[], lavy, stred, pravy)</code>
:1. Je <code>lavy >= pravy ? Ak áno, skonči, inak pokračuj krokom 2.</code>
:2. Nech: <code>i = 0, j = 0, k = lavy </code>
:3. Nech: <code>dlzka_L = stred - lavy + 1, dlzka_P = pravy - stred</code>
:4. Nech: <code> L = pole[lavy ... stred], P = pole[stred + 1 ... pravy] </code>
:5. Je <code>i < dlzka_L</code> a zároveň <code>j < dlzka_P</code> ? Ak áno, pokračuj krokom 5.1., inak skoč na krok 6.
:::5.1. Je <code>L[i] <= P[j]</code>?
:::: Ak áno:
:::::5.1.1. <code>pole[k] = L[i]</code>
:::::5.1.2. <code>k += 1</code>
:::::5.1.3. <code>i += 1</code>
:::::5.1.4. Skoč na krok 5.
:::: Ak nie:
:::::5.1.1. <code>pole[k] = P[j]</code>
:::::5.1.2. <code>k += 1</code>
:::::5.1.3. <code>j += 1</code>
:::::5.1.4. Skoč na krok 5.
:6. Je <code>i < dlzka_L</code> ? Ak áno, pokračuj krokom 6.1., inak skoč na krok 7.
:::6.1. <code>pole[k] = L[i]</code>
:::6.2. <code>k += 1</code>
:::6.3. <code>i += 1</code>
:::6.4. Skoč na krok 6.
:7. Je <code>j < dlzka_P</code> ? Ak áno, pokračuj krokom 7.1., inak skonči.
:::7.1. <code>pole[k] = P[j]</code>
:::7.2. <code>k += 1</code>
:::7.3. <code>j += 1</code>
:::7.4. Skoč na krok 7.

==Merge sort==
Merge Sort je triediaci algoritmus, ktorý využíva stratégiu '''"rozdeľuj a panuj"''', čo znamená, že vstupný zoznam najskôr rozdelí na dve polovice, tie zoradí a potom ich zlúči naspäť dokopy. Radí sa medzi najpoužívanejšie a najviac rešpektované triediace algoritmy.

Z hľadiska implementácie môžeme vytvoriť dve základné verzie algoritmu, a to rekurzívnu a iteračnú.

===Vlastnosti algoritmu Merge Sort===
* vhodný pre dátové štruktúry: pole, lineárny zoznam
* časová náročnosť: vždy linearitmická <math> O(n.log(n)) </math>, vďaka ktorej dokáže efektívne triediť veľmi veľké zoznamy
* priestorová náročnosť: lineárna <math>O(n)</math> pre pole (alokovanie dočasných polí), konštantná <math>O(1)</math> pre lineárny zoznam (pri LZ stačí iba presmerovať smerníky)
* druh triedenia: triedenie zlučovaním (komparačný algoritmus)
* stabilita triedenia: stabilný
* miesto triedenia: externé triedenie (vhodný na triedenie veľkých objemov dát uložených na disku)

<tabs>
<tab name="Rekurzívna verzia" block>
[[Súbor:Merge sort.png|400px|náhľad|vpravo|Vizualizácia rekurzívnej verzie algoritmu MergeSort]]

===Princíp algoritmu===
Algoritmus MergeSort vykonáva 4 základné úlohy:
# Delenie poľa na dve polovice.
# Triedenie ľavej polovice poľa.
# Triedenie pravej polovice poľa.
# Zlúčenie oboch polovíc pomocou funkcie Merge.

===Slovný opis===
Našou úlohou je vzostupne (min - max) utriediť vstupné pole. Určíme si stred poľa (pri párnom počte prvkov je to ten menší z prostredných indexov). Následne vykonávame sériu rekurzívnych delení pre ľavú a pravú časť poľa (začiatok ... stred ; stred + 1 ... koniec) až do momentu, keď nám ostanú len jednoprvkové podpolia (tie sú už utriedené). Následne v každom volaní obe tieto podpolia zlúčime pomocou algoritmu Merge do väčších podpolí (2, 4, 8, ...), až nakoniec dostaneme jedno výsledné utriedené pole.

===Pseudokód===
Nech nech má funkcia MergeSort nasledovný prototyp: <code>MergeSort(pole[], lavy, pravy) </code>
:1. Je <code>lavy >= pravy</code> ? Ak áno, skonči volanie, inak pokračuj krokom 2.
:2. Nech: <code>stred = lavy + (pravy - lavy) / 2</code>, pričom znak ''/'' vyjadruje celočíselné delenie.
:3. Rekurzívne zavolaj funkciu <code>MergeSort(pole[], lavy , stred)</code>
:3. Rekurzívne zavolaj funkciu <code>MergeSort(pole[], stred + 1 , pravy)</code>
:4. Zavolaj funkciu <code>Merge(pole[], lavy, stred, pravy)</code>
:5. Skonči volanie.

</tab>
<tab name="Iteračná verzia" block>
[[Súbor:MergeSort It.png|400px|náhľad|vpravo|Vizualizácia iteračnej verzie algoritmu MergeSort]]

===Princíp algoritmu===
Algoritmus Merge vykonáva 3 základné úlohy:
# Vonkajší cyklus: určenie veľkosti zoznamu na zlučovanie.
# Vnútorný cyklus: prechádzanie jednotlivých zoznamov v poli.
# Zlučovanie jednotlivých zoznamov pomocou funkcie Merge.

===Slovný opis===
Vstupné pole, ktoré má ''N'' prvkov, môžeme chápať, ako ''N'' rôznych jednoprvkových (utriedených) podpolí, ktoré máme zlúčiť do jedného výsledného ''N''-prvkového utriedeného poľa. Keďže by bolo veľmi nepraktické zlučovať ''N'' podpolí naraz, zvolíme nasledovnú stratégiu: Budeme prechádzať dané pole od začiatku po koniec a v prvom cykle zlúčime každé dva prvky, takže budeme mať <math>\frac{n}{2}</math> dvojprvkových utriedených podpolí. Potom v druhom cykle zlúčime každé 4 prvky do jedného podpoľa, v treťom cykle každých 8, až do momentu, keď dostaneme jedno utriedené pole.
Aby sme to docielili, potrebujeme dva cykly, vonkajší, ktorý nastaví maximálnu veľkosť podpoľa, ktoré ideme zlučovať (1,2,4,8 ... dlzka - 1) a vnútorný, ktorý prechádza jednotlivé podpolia. Následne už iba voláme funkciu Merge, ktorá dané podpolia zlučuje.

Poznámka, ak máme pole, ktoré má nepárny počet prvkov, tak ten posledný prvok nezlúčime hneď v prvom cykle, ale až v tých ďalších. Takisto, ak n nie je mocnina čísla 2, tak musíme samozrejme ošetriť situáciu, kedy by sme sa dostali mimo rozsah poľa (Ak máme napríklad pole, čo má 7 prvkov, tak po prvej iterácii budú prvky utiredené podľa vzoru 2 + 2 + 2 + 1, po druhej 4 + 3, a po tretej 7)

===Pseudokód===
Nech nech má funkcia MergeSort nasledovný prototyp: <code>MergeSort(pole[], lavy, pravy) </code>
:1. Je <code>lavy >= pravy</code> ? Ak áno, skonči, inak pokračuj krokom 2.
:2. Nech: <code>dlzka_subzoznamu = 1 </code>
:3. Nech: <code>zaciatok = lavy</code>
:4. Je<code>dlzka_subzoznamu <= pravy</code> ? Ak áno pokračuj krokom 4.1, inak skonči.
:::4.1. Je<code>zaciatok < pravy</code> Ak áno pokračuj krokom 4.1.1, inak skoč na krok 4.2.
:::::4.1.1. Je <code>zaciatok + 2 * dlzka_zoznamu - 1 <= pravy</code> ?
:::::::Ak áno:
:::::::::4.1.1.1. Nech <code>koniec = zaciatok + 2 * dlzka_zoznamu - 1</code>
:::::::Ak nie:
:::::::::4.1.1.1. Nech <code>koniec = pravy</code>
:::::4.1.2. Je <code>zaciatok + dlzka_zoznamu - 1 <= pravy</code> ?
:::::::Ak áno:
:::::::::4.1.2.1. Nech <code>stred = zaciatok + dlzka_zoznamu - 1</code>
:::::::Ak nie:
:::::::::4.1.2.1. Nech <code>stred = pravy</code>
:::::4.1.3. <code>Merge(pole[], zaciatok, stred, koniec)</code>
:::::4.1.4. <code>zaciatok += 2 * dlzka_subzoznamu</code>
:::::4.1.5. Skoč na krok 4.1.
:::4.2. <code>dlzka_subzoznamu *= 2</code>
:::4.3 Skoč na krok 4.

</tab>
</tabs>

==Implementácia algoritmov Merge a MergeSort==
===Rekurzívna verzia algoritmov===

<tabs>
<tab name="C" block>
<syntaxhighlight lang="C">
#include <stdio.h>
#include <stdlib.h>

void Merge(int pole[], int lavy, int stred, int pravy);
void MergeSort(int pole[], int lavy, int pravy);

/* hlavný program */

int main()
{
int pole[] = {12, 11, 13, 5, 6, 7};
int dlzka_pola = sizeof(pole) / sizeof(pole[0]);

printf("Pôvodné pole: \n");

for (int i = 0; i < dlzka_pola; ++i)
{
printf("%d ", pole[i]);
}

MergeSort(pole, 0, dlzka_pola - 1);

printf("\nUtriedené pole: \n");

for (int i = 0; i < dlzka_pola; ++i)
{
printf("%d ", pole[i]);
}

return 0;
}

void Merge(int pole[], int lavy, int stred, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči */

if (lavy >= pravy)
{
return;
}

/* vyrátaj dĺžky oboch polovíc poľa */

int L_dlzka = stred - lavy + 1;
int P_dlzka = pravy - stred;

/* alokuj dočasné polia, kam uložíš prvky z oboch polovíc poľa */

int *L = (int*)malloc(L_dlzka * sizeof(int));
int *P = (int*)malloc(P_dlzka * sizeof(int));

/* indexy, ktorými iterujeme všetky polia: i pre L, j pre P, k pre pole */

int i, j, k;

/* skopíruj obsah oboch polovíc poľa do dočasných polí L a P */

for (i = 0; i < L_dlzka; ++i)
{
L[i] = pole[lavy + i];
}

for (j = 0; j < P_dlzka; ++j)
{
P[j] = pole[stred + 1 + j];
}

/* nastav indexy na začiatok daných polí */

i = 0; j = 0; k = lavy;

/* zlučuj dočasné polia L a P do finálneho poľa pole */

while(i < L_dlzka && j < P_dlzka)
{
if(L[i] <= P[j])
{
pole[k++] = L[i++];
}
else
{
pole[k++] = P[j++];
}
}

/* ak ostali nejaké prvky v dočasnom poli L, skopíruj ich do finálneho poľa */

while(i < L_dlzka)
{
pole[k++] = L[i++];
}

/* ak ostali nejaké prvky v dočasnom poli P, skopíruj ich do finálneho poľa */

while(j < P_dlzka)
{
pole[k++] = P[j++];
}

/* uvoľni použitú pamäť */

free(L);
free(P);
}

void MergeSort(int pole[], int lavy, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči volanie */

if(lavy >= pravy)
{
return;
}
/* urči si prostredný index */

int stred = lavy + (pravy - lavy) / 2;

/* utrieď ľavú polovicu poľa */

MergeSort(pole, lavy, stred);

/* utrieď pravú polovicu poľa */

MergeSort(pole, stred+1, pravy);

/* zlúč obe polovice dokopy */

Merge(pole, lavy, stred, pravy);
}
</syntaxhighlight>
</tab>

<tab name="C++" block>
<syntaxhighlight lang="C++">
#include <iostream>

using std::cout;
using std::endl;

void Merge(int pole[], int lavy, int stred, int pravy);
void MergeSort(int pole[], int lavy, int pravy);

/* hlavný program */

int main()
{
int pole[] = {12, 11, 13, 5, 6, 7};
int dlzka_pola = sizeof(pole) / sizeof(pole[0]);

printf("Pôvodné pole: \n");

for (auto i: pole)
{
cout<<i<<" ";
}

MergeSort(pole, 0, dlzka_pola - 1);

cout<<endl<<"Utriedené pole:"<<endl;

for (auto i: pole)
{
cout<<i<<" ";
}

return 0;
}

void Merge(int pole[], int lavy, int stred, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči */

if (lavy >= pravy)
{
return;
}

/* vyrátaj dĺžky oboch polovíc poľa */

int L_dlzka = stred - lavy + 1;
int P_dlzka = pravy - stred;

/* alokuj dočasné polia, kam uložíš prvky z oboch polovíc poľa */

int *L = new int[L_dlzka];
int *P = new int[P_dlzka];

/* indexy, ktorými iterujeme všetky polia: i pre L, j pre P, k pre pole */

int i, j, k;

/* skopíruj obsah oboch polovíc poľa do dočasných polí L a P */

for (i = 0; i < L_dlzka; ++i)
{
L[i] = pole[lavy + i];
}

for (j = 0; j < P_dlzka; ++j)
{
P[j] = pole[stred + 1 + j];
}

/* nastav indexy na začiatok daných polí */

i = 0; j = 0; k = lavy;

/* zlučuj dočasné polia L a P do finálneho poľa pole */

while(i < L_dlzka && j < P_dlzka)
{
if(L[i] <= P[j])
{
pole[k++] = L[i++];
}
else
{
pole[k++] = P[j++];
}
}

/* ak ostali nejaké prvky v dočasnom poli L, skopíruj ich do finálneho poľa */

while(i < L_dlzka)
{
pole[k++] = L[i++];
}

/* ak ostali nejaké prvky v dočasnom poli P, skopíruj ich do finálneho poľa */

while(j < P_dlzka)
{
pole[k++] = P[j++];
}

/* uvoľni použitú pamäť */

delete []L;
delete []P;
}

void MergeSort(int pole[], int lavy, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči volanie */

if(lavy >= pravy)
{
return;
}
/* urči si prostredný index */

int stred = lavy + (pravy - lavy) / 2;

/* utrieď ľavú polovicu poľa */

MergeSort(pole, lavy, stred);

/* utrieď pravú polovicu poľa */

MergeSort(pole, stred+1, pravy);

/* zlúč obe polovice dokopy */

Merge(pole, lavy, stred, pravy);
}

</syntaxhighlight>
</tab>

<tab name="Java" block>
<syntaxhighlight lang="Java">
class MergeSort {
/* Zlúči 2 subpolia, ktoré sa vytvorili z pôvodného pola.
* Každé subpole má polovičnú dĺžku pôvodného pola.
* subpole1 [ľavý..stred]
* subpole2 [stred+1..pravý] */
void merge(int[] pole, int lavy, int stred, int pravy) {
// Výpočet dĺžky 2 subpolí
int n1 = stred - lavy + 1;
int n2 = pravy - stred;

// Vytvorenie pomocných polí
int[] L = new int[n1];
int[] P = new int[n2];

// Načítanie dát do pomocných polí
for (int i = 0; i < n1; i++)
L[i] = pole[lavy + i];

for (int j = 0; j < n2; j++)
P[j] = pole[stred + 1 + j];

// Počiatočné indexy prvého a druhého subpola
int i = 0, j = 0;
// Počiatočný index zlúčeného subpola
int k = lavy;

// Zlúčenie dvoch podpolí
while (i < n1 && j < n2) {
if (L[i] <= P[j]) {
pole[k] = L[i];
i++;
}
else {
pole[k] = P[j];
j++;
}
k++;
}

/* V prípade, že v jednom zo subpolí sa nachádzajú prvky, ktoré neboli zlúčené do pola,
* tak sa do pola jednoducho skopírujú */
while (i < n1) {
pole[k] = L[i];
i++;
k++;
}

while (j < n2) {
pole[k] = P[j];
k++;
j++;
}
}

/* Funkcia, ktorá zoradí pole použitím funkcie merge() */
void sort (int[] pole, int lavy, int pravy) {
if (lavy < pravy) {
//Musíme nájsť stred pola
int stred = lavy + (pravy - lavy) / 2;

// Zoradíme prvú a druhú polovicu pola samostatne
sort(pole, lavy, stred);
sort(pole, stred + 1, pravy);

// Zlúčime zoradené polovice do jedného pola
merge(pole, lavy, stred, pravy);
}
}
}

public class Main {
/* Funkcia na výpis pola dĺžky n */
static void vypis_pole(int[] pole) {
int n = pole.length;

for (int i = 0; i < n; i++) {
System.out.print(pole[i] + " ");
}
System.out.println();
}

/* Hlavný program */
public static void main(String[] args) {
int[] pole = {12, 11, 13, 5, 6, 7};

System.out.println("Zadané pole:");
vypis_pole(pole);

MergeSort ms = new MergeSort();
ms.sort(pole, 0, pole.length - 1);

System.out.println("\nZoradené pole:");
vypis_pole(pole);
}
}
</syntaxhighlight>
</tab>

<tab name="Python3" block>
<syntaxhighlight lang="Python3">
def MergeSort(pole):
if len(pole) > 1:
# Nájdenie stredu pola
# zápis len(pole)//2 znamená, že dĺžka pola sa vydelí 2 a výsledok je celé číslo
stred = len(pole) // 2

# Rozdelenie pola na dve časti
L = pole[:stred]
P = pole[stred:]

# Zoradenie najskôr prvej časti pola, potom druhej
MergeSort(L)
MergeSort(P)

i = j = k = 0

# Načítanie dát do pomocných polí L[] a P[]
while i < len(L) and j < len(P):
if L[i] < P[j]:
pole[k] = L[i]
i += 1
else:
pole[k] = P[j]
j += 1
k += 1

# Kontrola či všetky prvky boli zlúčené dokopy,
# ak nie, tak sa do zlúčeného pola jednoducho skopírujú
while i < len(L):
pole[k] = L[i]
i += 1
k += 1

while j < len(P):
pole[k] = P[j]
j += 1
k += 1

# Kód na výpis pola
def vypis_pole(pole):
for i in range(len(pole)):
print(pole[i], end=" ")
print()

# Hlavný program
if __name__ == '__main__':
pole = [12, 11, 13, 5, 6, 7]
print("Zadané pole:", end="\n")
vypis_pole(pole)
MergeSort(pole)
print("Zoradené pole:", end="\n")
vypis_pole(pole)
</syntaxhighlight>
</tab>
</tabs>

===Iteračná verzia algoritmov===

<tabs>
<tab name="C" block>
<syntaxhighlight lang="C">
#include <stdio.h>
#include <stdlib.h>

void Merge(int pole[], int lavy, int stred, int pravy);
void MergeSortIt(int *pole, int lavy, int pravy);

/* hlavný program */

int main()
{
int pole[] = {12, 11, 13, 5, 6, 7, 19};
int dlzka_pola = sizeof(pole) / sizeof(pole[0]);

printf("Pôvodné pole %d: \n", dlzka_pola);

for (int i = 0; i < dlzka_pola; ++i)
{
printf("%d ", pole[i]);
}

MergeSortIt(pole, 0, dlzka_pola - 1);

printf("\nUtriedené pole: \n");

for (int i = 0; i < dlzka_pola; ++i)
{
printf("%d ", pole[i]);
}

return 0;
}

void Merge(int pole[], int lavy, int stred, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči */

if (lavy >= pravy)
{
return;
}

/* vyrátaj dĺžky oboch polovíc poľa */

int L_dlzka = stred - lavy + 1;
int P_dlzka = pravy - stred;

/* alokuj dočasné polia, kam uložíš prvky z oboch polovíc poľa */

int *L = (int*)malloc(L_dlzka * sizeof(int));
int *P = (int*)malloc(P_dlzka * sizeof(int));

/* indexy, ktorými iterujeme všetky polia: i pre L, j pre P, k pre pole */

int i, j, k;

/* skopíruj obsah oboch polovíc poľa do dočasných polí L a P */

for (i = 0; i < L_dlzka; ++i)
{
L[i] = pole[lavy + i];
}

for (j = 0; j < P_dlzka; ++j)
{
P[j] = pole[stred + 1 + j];
}

/* nastav indexy na začiatok daných polí */

i = 0; j = 0; k = lavy;

/* zlučuj dočasné polia L a P do finálneho poľa pole */

while(i < L_dlzka && j < P_dlzka)
{
if(L[i] <= P[j])
{
pole[k++] = L[i++];
}
else
{
pole[k++] = P[j++];
}
}

/* ak ostali nejaké prvky v dočasnom poli L, skopíruj ich do finálneho poľa */

while(i < L_dlzka)
{
pole[k++] = L[i++];
}

/* ak ostali nejaké prvky v dočasnom poli P, skopíruj ich do finálneho poľa */

while(j < P_dlzka)
{
pole[k++] = P[j++];
}

/* uvoľni použitú pamäť */

free(L);
free(P);
}

void MergeSortIt(int *pole, int lavy, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči volanie */

if(lavy >= pravy)
{
return;
}

int stred, koniec;

for (int dlzka_zoznamu = 1; dlzka_zoznamu <= pravy ; dlzka_zoznamu *= 2)
{
for (int zaciatok = lavy; zaciatok < pravy ; zaciatok += 2 * dlzka_zoznamu)
{
koniec = (zaciatok + 2 * dlzka_zoznamu - 1 <= pravy) ? zaciatok + 2 * dlzka_zoznamu - 1 : pravy;

stred = (zaciatok + dlzka_zoznamu - 1 <= pravy) ? zaciatok + dlzka_zoznamu - 1 : pravy;

Merge(pole, zaciatok, stred, koniec);

}
}
}

</syntaxhighlight>
</tab>

<tab name="C++" block>
<syntaxhighlight lang="C++">
#include <iostream>

using std::cout;
using std::endl;

void Merge(int pole[], int lavy, int stred, int pravy);
void MergeSort(int pole[], int lavy, int pravy);

/* hlavný program */

int main()
{
int pole[] = {12, 11, 13, 5, 6, 7};
int dlzka_pola = sizeof(pole) / sizeof(pole[0]);

printf("Pôvodné pole: \n");

for (auto i: pole)
{
cout<<i<<" ";
}

MergeSort(pole, 0, dlzka_pola - 1);

cout<<endl<<"Utriedené pole:"<<endl;

for (auto i: pole)
{
cout<<i<<" ";
}

return 0;
}

void Merge(int pole[], int lavy, int stred, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči */

if (lavy >= pravy)
{
return;
}

/* vyrátaj dĺžky oboch polovíc poľa */

int L_dlzka = stred - lavy + 1;
int P_dlzka = pravy - stred;

/* alokuj dočasné polia, kam uložíš prvky z oboch polovíc poľa */

int *L = new int[L_dlzka];
int *P = new int[P_dlzka];

/* indexy, ktorými iterujeme všetky polia: i pre L, j pre P, k pre pole */

int i, j, k;

/* skopíruj obsah oboch polovíc poľa do dočasných polí L a P */

for (i = 0; i < L_dlzka; ++i)
{
L[i] = pole[lavy + i];
}

for (j = 0; j < P_dlzka; ++j)
{
P[j] = pole[stred + 1 + j];
}

/* nastav indexy na začiatok daných polí */

i = 0; j = 0; k = lavy;

/* zlučuj dočasné polia L a P do finálneho poľa pole */

while(i < L_dlzka && j < P_dlzka)
{
if(L[i] <= P[j])
{
pole[k++] = L[i++];
}
else
{
pole[k++] = P[j++];
}
}

/* ak ostali nejaké prvky v dočasnom poli L, skopíruj ich do finálneho poľa */

while(i < L_dlzka)
{
pole[k++] = L[i++];
}

/* ak ostali nejaké prvky v dočasnom poli P, skopíruj ich do finálneho poľa */

while(j < P_dlzka)
{
pole[k++] = P[j++];
}

/* uvoľni použitú pamäť */

delete []L;
delete []P;
}

void MergeSort(int *pole, int lavy, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči volanie */

if(lavy >= pravy)
{
return;
}

int stred, koniec;

for (int dlzka_zoznamu = 1; dlzka_zoznamu <= pravy; dlzka_zoznamu *= 2)
{
for (int zaciatok = lavy; zaciatok < pravy; zaciatok += 2 * dlzka_zoznamu)
{
koniec = (zaciatok + 2 * dlzka_zoznamu - 1 <= pravy) ? zaciatok + 2 * dlzka_zoznamu - 1 : pravy;

stred = (zaciatok + dlzka_zoznamu - 1 <= pravy) ? zaciatok + dlzka_zoznamu - 1 : pravy;

Merge(pole, zaciatok, stred, koniec);
}
}
}
</syntaxhighlight>
</tab>

<tab name="Java" block>
<syntaxhighlight lang="Java">
class MergeSort_iteracia {
/* Zlúči 2 subpolia, ktoré sa vytvorili z pôvodného pola.
* Každé subpole má polovičnú dĺžku pôvodného pola.
* subpole1 [ľavý..stred]
* subpole2 [stred+1..pravý] */
void merge(int[] pole, int lavy, int stred, int pravy) {
// Výpočet dĺžky 2 subpolí
int n1 = stred - lavy + 1;
int n2 = pravy - stred;

// Vytvorenie pomocných polí
int[] L = new int[n1];
int[] P = new int[n2];

// Načítanie dát do pomocných polí
for (int i = 0; i < n1; i++)
L[i] = pole[lavy + i];

for (int j = 0; j < n2; j++)
P[j] = pole[stred + 1 + j];

// Počiatočné indexy prvého a druhého subpola
int i = 0, j = 0;
// Počiatočný index zlúčeného subpola
int k = lavy;

// Zlúčenie dvoch podpolí
while (i < n1 && j < n2) {
if (L[i] <= P[j]) {
pole[k] = L[i];
i++;
}
else {
pole[k] = P[j];
j++;
}
k++;
}

/* V prípade, že v jednom zo subpolí sa nachádzajú prvky, ktoré neboli zlúčené do pola,
* tak sa do pola jednoducho skopírujú */
while (i < n1) {
pole[k] = L[i];
i++;
k++;
}

while (j < n2) {
pole[k] = P[j];
k++;
j++;
}
}

/* Funkcia, ktorá zoradí pole použitím funkcie merge() */
void sort (int[] pole, int n) {
/* Dĺžka subpolí, ktoré majú byť zlúčené, hodnoty premennej sa pohybujú v intervale <1;n-1> */
int aktual_dlzka;
/* Začiatočný index ľavého subpola, ktoré má byť zlúčené */
int zaciatok_vlavo;

/* Vzostupné usporiadanie prvkov. Najskôr sa zlúčia subpolia veľkosti 1 do subpolí veľkosti 2,
* potom subpolia veľkosti 2 do subpolí veľkosti 4 a tak ďalej */
for (aktual_dlzka = 1; aktual_dlzka <= n - 1; aktual_dlzka *= 2) {
/* Určenie začiatočného prvku rôznych subpolí aktuálnej dĺžky subpola */
for (zaciatok_vlavo = 0; zaciatok_vlavo < n - 1; zaciatok_vlavo += 2 * aktual_dlzka) {
/* Nájdenie konečného prvku ľavého subpola, stred+1 je začiatočný prvok pravého subpola */
int stred = Math.min(zaciatok_vlavo + aktual_dlzka - 1, n - 1);
int koniec_vpravo = Math.min(zaciatok_vlavo + 2 * aktual_dlzka - 1, n - 1);

/* Zlúči subpolia L[zaciatok_vlavo .. stred] & P[stred+1 .. koniec_vpravo] */
merge(pole, zaciatok_vlavo, stred, koniec_vpravo);
}
}
}
}

public class Main {
/* Funkcia na výpis pola dĺžky n */
static void vypis_pole(int[] pole) {
int n = pole.length;

for (int j : pole) {
System.out.print(j + " ");
}
System.out.println();
}

/* Hlavný program */
public static void main(String[] args) {

/* Inicializácia pola */
int[] pole = {12, 11, 13, 5, 6, 7};

System.out.println("Zadané pole:");
vypis_pole(pole);

MergeSort_iteracia ms_it = new MergeSort_iteracia();
ms_it.sort(pole, pole.length);

System.out.println("Zoradené pole:");
vypis_pole(pole);
}
}
</syntaxhighlight>
</tab>
</tabs>

==Odkazy==
# https://www.geeksforgeeks.org/merge-sort/
# https://www.geeksforgeeks.org/iterative-merge-sort/
# https://medium.com/@paulsoham/merge-sort-63d75df76388
# https://www.khanacademy.org/computing/computer-science/algorithms/merge-sort/a/overview-of-merge-sort
# https://www.tutorialspoint.com/data_structures_algorithms/merge_sort_algorithm.htm
# https://www.youtube.com/watch?v=6pV2IF0fgKY
# https://www.youtube.com/watch?v=mB5HXBb_HY8
# https://www.youtube.com/watch?v=ak-pz7tS5DE

Triedenie zlučovaním

2021-03-28T16:34:48Z

Filip Tomek: /* Iteračná verzia algoritmov */

[[Kategória:Algoritmy triedenia]]
{{Draft}}
{{Skripta programovanie}}
__TOC__
==TODO: Pseudokód treba opraviť, text refaktorovať, otestovať kódy, zvýrazniť veci v texte, opraviť preklepy, opraviť popis obrázkov, pridať nové odkazy==

==Zlučovací algoritmus Merge==

Princíp zlučovania tkvie v tom, že máme dva alebo viac utriedených zoznamov, ktoré skombinuje do jedného utriedeného zoznamu (výsledný zoznam musí obsahovať všetky prvky z pôvodných zoznamov). Zoznam môže byť reprezentovaný ako dátová štruktúra pole alebo aj ako lineárny zoznam. V tomto článku sa zameriame na algoritmus pre dátovú štruktúru pole.

Algoritmus Merge tvorí kľúčovú časť triediaceho algoritmu MergeSort.

[[Súbor:Funkcia merge.png|500px|náhľad|vpravo|Vizualizácia funkcie Merge: Máme pole prvkov p = [1, 3, 5, 2, 4, 6], ktoré je už čiastočne utriedené. Použijeme algoritmus Merge, ktorý si vytvorí pomocné polia L = [1, 3, 5] a P = [2, 4, 6]. Všetky polia indexujeme od 0, pričom pre pole p používame index k, pre L index i a pre P index j. Postupnosť krokov je označená číslicami 1 až 6.
]]

===Slovný opis algoritmu===
Nech máme pole, ktoré sa skladá z dvoch už utriedených polovíc. Vytvoríme si dve pomocné polia L a P a do každého z nich skopírujeme obsah jednej polovice (L - ľavá polovica, P - pravá polovica). Potom súčasne prechádzame polia L a P od začiatku po koniec, pričom v každom cykle porovnáme prvok poľa L s prvkom v poli P. Z tejto dvojice následne vyberieme minimum, (keď triedime od najmenšieho po najväčší) ktoré vložíme na prvú voľnú pozíciu pôvodného poľa (na začiatku je to prvá pozícia poľa). Nakoniec zvýšime index pri vstupnom poli a pri pomocnom poli, z ktorého vyberáme daný prvok. Túto postupnosť krokov opakujeme, pokiaľ neprídeme na koniec jedného z polí P a L. Ak nastane situácia, že prídeme na koniec jedného z pomocných polí (a v druhom nám ostali ešte nejaké prvky), potom už iba naspäť skopírujeme zbytok druhého pomocného poľa na koniec pôvodného poľa.

===Vlastnosti algoritmu===
* vhodný pre dátové štruktúry: pole, lineárny zoznam
* časová náročnosť: vždy lineárna <math>O(n)</math>
* priestorová náročnosť: lineárna <math>O(n)</math> pre pole (alokovanie pomocných polí), <math>O(1)</math> pre lineárny zoznam (pri LZ netreba alokovať dočasné polia, stačí iba presmerovať smerníky)
* využitie: kľúčový podprogram pre triediaci algoritmus MergeSort

===Pseudokód===
Nech funkcia Merge má nasledovný prototyp: <code>Merge(pole[], lavy, stred, pravy)</code>
:1. Je <code>lavy >= pravy ? Ak áno, skonči, inak pokračuj krokom 2.</code>
:2. Nech: <code>i = 0, j = 0, k = lavy </code>
:3. Nech: <code>dlzka_L = stred - lavy + 1, dlzka_P = pravy - stred</code>
:4. Nech: <code> L = pole[lavy ... stred], P = pole[stred + 1 ... pravy] </code>
:5. Je <code>i < dlzka_L</code> a zároveň <code>j < dlzka_P</code> ? Ak áno, pokračuj krokom 5.1., inak skoč na krok 6.
:::5.1. Je <code>L[i] <= P[j]</code>?
:::: Ak áno:
:::::5.1.1. <code>pole[k] = L[i]</code>
:::::5.1.2. <code>k += 1</code>
:::::5.1.3. <code>i += 1</code>
:::::5.1.4. Skoč na krok 5.
:::: Ak nie:
:::::5.1.1. <code>pole[k] = P[j]</code>
:::::5.1.2. <code>k += 1</code>
:::::5.1.3. <code>j += 1</code>
:::::5.1.4. Skoč na krok 5.
:6. Je <code>i < dlzka_L</code> ? Ak áno, pokračuj krokom 6.1., inak skoč na krok 7.
:::6.1. <code>pole[k] = L[i]</code>
:::6.2. <code>k += 1</code>
:::6.3. <code>i += 1</code>
:::6.4. Skoč na krok 6.
:7. Je <code>j < dlzka_P</code> ? Ak áno, pokračuj krokom 7.1., inak skonči.
:::7.1. <code>pole[k] = P[j]</code>
:::7.2. <code>k += 1</code>
:::7.3. <code>j += 1</code>
:::7.4. Skoč na krok 7.

==Merge sort==
Merge Sort je triediaci algoritmus, ktorý využíva stratégiu '''"rozdeľuj a panuj"''', čo znamená, že vstupný zoznam najskôr rozdelí na dve polovice, tie zoradí a potom ich zlúči naspäť dokopy. Radí sa medzi najpoužívanejšie a najviac rešpektované triediace algoritmy.

Z hľadiska implementácie môžeme vytvoriť dve základné verzie algoritmu, a to rekurzívnu a iteračnú.

===Vlastnosti algoritmu Merge Sort===
* vhodný pre dátové štruktúry: pole, lineárny zoznam
* časová náročnosť: vždy linearitmická <math> O(n.log(n)) </math>, vďaka ktorej dokáže efektívne triediť veľmi veľké zoznamy
* priestorová náročnosť: lineárna <math>O(n)</math> pre pole (alokovanie dočasných polí), konštantná <math>O(1)</math> pre lineárny zoznam (pri LZ stačí iba presmerovať smerníky)
* druh triedenia: triedenie zlučovaním (komparačný algoritmus)
* stabilita triedenia: stabilný
* miesto triedenia: externé triedenie (vhodný na triedenie veľkých objemov dát uložených na disku)

<tabs>
<tab name="Rekurzívna verzia" block>
[[Súbor:Merge sort.png|400px|náhľad|vpravo|Vizualizácia rekurzívnej verzie algoritmu MergeSort]]

===Princíp algoritmu===
Algoritmus MergeSort vykonáva 4 základné úlohy:
# Delenie poľa na dve polovice.
# Triedenie ľavej polovice poľa.
# Triedenie pravej polovice poľa.
# Zlúčenie oboch polovíc pomocou funkcie Merge.

===Slovný opis===
Našou úlohou je vzostupne (min - max) utriediť vstupné pole. Určíme si stred poľa (pri párnom počte prvkov je to ten menší z prostredných indexov). Následne vykonávame sériu rekurzívnych delení pre ľavú a pravú časť poľa (začiatok ... stred ; stred + 1 ... koniec) až do momentu, keď nám ostanú len jednoprvkové podpolia (tie sú už utriedené). Následne v každom volaní obe tieto podpolia zlúčime pomocou algoritmu Merge do väčších podpolí (2, 4, 8, ...), až nakoniec dostaneme jedno výsledné utriedené pole.

===Pseudokód===
Nech nech má funkcia MergeSort nasledovný prototyp: <code>MergeSort(pole[], lavy, pravy) </code>
:1. Je <code>lavy >= pravy</code> ? Ak áno, skonči volanie, inak pokračuj krokom 2.
:2. Nech: <code>stred = lavy + (pravy - lavy) / 2</code>, pričom znak ''/'' vyjadruje celočíselné delenie.
:3. Rekurzívne zavolaj funkciu <code>MergeSort(pole[], lavy , stred)</code>
:3. Rekurzívne zavolaj funkciu <code>MergeSort(pole[], stred + 1 , pravy)</code>
:4. Zavolaj funkciu <code>Merge(pole[], lavy, stred, pravy)</code>
:5. Skonči volanie.

</tab>
<tab name="Iteračná verzia" block>
[[Súbor:MergeSort It.png|400px|náhľad|vpravo|Vizualizácia iteračnej verzie algoritmu MergeSort]]

===Princíp algoritmu===
Algoritmus Merge vykonáva 3 základné úlohy:
# Vonkajší cyklus: určenie veľkosti zoznamu na zlučovanie.
# Vnútorný cyklus: prechádzanie jednotlivých zoznamov v poli.
# Zlučovanie jednotlivých zoznamov pomocou funkcie Merge.

===Slovný opis===
Vstupné pole, ktoré má ''N'' prvkov, môžeme chápať, ako ''N'' rôznych jednoprvkových (utriedených) podpolí, ktoré máme zlúčiť do jedného výsledného ''N''-prvkového utriedeného poľa. Keďže by bolo veľmi nepraktické zlučovať ''N'' podpolí naraz, zvolíme nasledovnú stratégiu: Budeme prechádzať dané pole od začiatku po koniec a v prvom cykle zlúčime každé dva prvky, takže budeme mať <math>\frac{n}{2}</math> dvojprvkových utriedených podpolí. Potom v druhom cykle zlúčime každé 4 prvky do jedného podpoľa, v treťom cykle každých 8, až do momentu, keď dostaneme jedno utriedené pole.
Aby sme to docielili, potrebujeme dva cykly, vonkajší, ktorý nastaví maximálnu veľkosť podpoľa, ktoré ideme zlučovať (1,2,4,8 ... dlzka - 1) a vnútorný, ktorý prechádza jednotlivé podpolia. Následne už iba voláme funkciu Merge, ktorá dané podpolia zlučuje.

Poznámka, ak máme pole, ktoré má nepárny počet prvkov, tak ten posledný prvok nezlúčime hneď v prvom cykle, ale až v tých ďalších. Takisto, ak n nie je mocnina čísla 2, tak musíme samozrejme ošetriť situáciu, kedy by sme sa dostali mimo rozsah poľa (Ak máme napríklad pole, čo má 7 prvkov, tak po prvej iterácii budú prvky utiredené podľa vzoru 2 + 2 + 2 + 1, po druhej 4 + 3, a po tretej 7)

===Pseudokód===
Nech nech má funkcia MergeSort nasledovný prototyp: <code>MergeSort(pole[], lavy, pravy) </code>
:1. Je <code>lavy >= pravy</code> ? Ak áno, skonči, inak pokračuj krokom 2.
:2. Nech: <code>dlzka_subzoznamu = 1 </code>
:3. Nech: <code>zaciatok = lavy</code>
:4. Je<code>dlzka_subzoznamu <= pravy</code> ? Ak áno pokračuj krokom 4.1, inak skonči.
:::4.1. Je<code>zaciatok < pravy</code> Ak áno pokračuj krokom 4.1.1, inak skoč na krok 4.2.
:::::4.1.1. Je <code>zaciatok + 2 * dlzka_zoznamu - 1 <= pravy</code> ?
:::::::Ak áno:
:::::::::4.1.1.1. Nech <code>koniec = zaciatok + 2 * dlzka_zoznamu - 1</code>
:::::::Ak nie:
:::::::::4.1.1.1. Nech <code>koniec = pravy</code>
:::::4.1.2. Je <code>zaciatok + dlzka_zoznamu - 1 <= pravy</code> ?
:::::::Ak áno:
:::::::::4.1.2.1. Nech <code>stred = zaciatok + dlzka_zoznamu - 1</code>
:::::::Ak nie:
:::::::::4.1.2.1. Nech <code>stred = pravy</code>
:::::4.1.3. <code>Merge(pole[], zaciatok, stred, koniec)</code>
:::::4.1.4. <code>zaciatok += 2 * dlzka_subzoznamu</code>
:::::4.1.5. Skoč na krok 4.1.
:::4.2. <code>dlzka_subzoznamu *= 2</code>
:::4.3 Skoč na krok 4.

</tab>
</tabs>

==Implementácia algoritmov Merge a MergeSort==
===Rekurzívna verzia algoritmov===

<tabs>
<tab name="C" block>
<syntaxhighlight lang="C">
#include <stdio.h>
#include <stdlib.h>

void Merge(int pole[], int lavy, int stred, int pravy);
void MergeSort(int pole[], int lavy, int pravy);

/* hlavný program */

int main()
{
int pole[] = {12, 11, 13, 5, 6, 7};
int dlzka_pola = sizeof(pole) / sizeof(pole[0]);

printf("Pôvodné pole: \n");

for (int i = 0; i < dlzka_pola; ++i)
{
printf("%d ", pole[i]);
}

MergeSort(pole, 0, dlzka_pola - 1);

printf("\nUtriedené pole: \n");

for (int i = 0; i < dlzka_pola; ++i)
{
printf("%d ", pole[i]);
}

return 0;
}

void Merge(int pole[], int lavy, int stred, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči */

if (lavy >= pravy)
{
return;
}

/* vyrátaj dĺžky oboch polovíc poľa */

int L_dlzka = stred - lavy + 1;
int P_dlzka = pravy - stred;

/* alokuj dočasné polia, kam uložíš prvky z oboch polovíc poľa */

int *L = (int*)malloc(L_dlzka * sizeof(int));
int *P = (int*)malloc(P_dlzka * sizeof(int));

/* indexy, ktorými iterujeme všetky polia: i pre L, j pre P, k pre pole */

int i, j, k;

/* skopíruj obsah oboch polovíc poľa do dočasných polí L a P */

for (i = 0; i < L_dlzka; ++i)
{
L[i] = pole[lavy + i];
}

for (j = 0; j < P_dlzka; ++j)
{
P[j] = pole[stred + 1 + j];
}

/* nastav indexy na začiatok daných polí */

i = 0; j = 0; k = lavy;

/* zlučuj dočasné polia L a P do finálneho poľa pole */

while(i < L_dlzka && j < P_dlzka)
{
if(L[i] <= P[j])
{
pole[k++] = L[i++];
}
else
{
pole[k++] = P[j++];
}
}

/* ak ostali nejaké prvky v dočasnom poli L, skopíruj ich do finálneho poľa */

while(i < L_dlzka)
{
pole[k++] = L[i++];
}

/* ak ostali nejaké prvky v dočasnom poli P, skopíruj ich do finálneho poľa */

while(j < P_dlzka)
{
pole[k++] = P[j++];
}

/* uvoľni použitú pamäť */

free(L);
free(P);
}

void MergeSort(int pole[], int lavy, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči volanie */

if(lavy >= pravy)
{
return;
}
/* urči si prostredný index */

int stred = lavy + (pravy - lavy) / 2;

/* utrieď ľavú polovicu poľa */

MergeSort(pole, lavy, stred);

/* utrieď pravú polovicu poľa */

MergeSort(pole, stred+1, pravy);

/* zlúč obe polovice dokopy */

Merge(pole, lavy, stred, pravy);
}
</syntaxhighlight>
</tab>

<tab name="C++" block>
<syntaxhighlight lang="C++">
#include <iostream>

using std::cout;
using std::endl;

void Merge(int pole[], int lavy, int stred, int pravy);
void MergeSort(int pole[], int lavy, int pravy);

/* hlavný program */

int main()
{
int pole[] = {12, 11, 13, 5, 6, 7};
int dlzka_pola = sizeof(pole) / sizeof(pole[0]);

printf("Pôvodné pole: \n");

for (auto i: pole)
{
cout<<i<<" ";
}

MergeSort(pole, 0, dlzka_pola - 1);

cout<<endl<<"Utriedené pole:"<<endl;

for (auto i: pole)
{
cout<<i<<" ";
}

return 0;
}

void Merge(int pole[], int lavy, int stred, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči */

if (lavy >= pravy)
{
return;
}

/* vyrátaj dĺžky oboch polovíc poľa */

int L_dlzka = stred - lavy + 1;
int P_dlzka = pravy - stred;

/* alokuj dočasné polia, kam uložíš prvky z oboch polovíc poľa */

int *L = new int[L_dlzka];
int *P = new int[P_dlzka];

/* indexy, ktorými iterujeme všetky polia: i pre L, j pre P, k pre pole */

int i, j, k;

/* skopíruj obsah oboch polovíc poľa do dočasných polí L a P */

for (i = 0; i < L_dlzka; ++i)
{
L[i] = pole[lavy + i];
}

for (j = 0; j < P_dlzka; ++j)
{
P[j] = pole[stred + 1 + j];
}

/* nastav indexy na začiatok daných polí */

i = 0; j = 0; k = lavy;

/* zlučuj dočasné polia L a P do finálneho poľa pole */

while(i < L_dlzka && j < P_dlzka)
{
if(L[i] <= P[j])
{
pole[k++] = L[i++];
}
else
{
pole[k++] = P[j++];
}
}

/* ak ostali nejaké prvky v dočasnom poli L, skopíruj ich do finálneho poľa */

while(i < L_dlzka)
{
pole[k++] = L[i++];
}

/* ak ostali nejaké prvky v dočasnom poli P, skopíruj ich do finálneho poľa */

while(j < P_dlzka)
{
pole[k++] = P[j++];
}

/* uvoľni použitú pamäť */

delete []L;
delete []P;
}

void MergeSort(int pole[], int lavy, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči volanie */

if(lavy >= pravy)
{
return;
}
/* urči si prostredný index */

int stred = lavy + (pravy - lavy) / 2;

/* utrieď ľavú polovicu poľa */

MergeSort(pole, lavy, stred);

/* utrieď pravú polovicu poľa */

MergeSort(pole, stred+1, pravy);

/* zlúč obe polovice dokopy */

Merge(pole, lavy, stred, pravy);
}

</syntaxhighlight>
</tab>

<tab name="Java" block>
<syntaxhighlight lang="Java">
class MergeSort {
/* Zlúči 2 subpolia, ktoré sa vytvorili z pôvodného pola.
* Každé subpole má polovičnú dĺžku pôvodného pola.
* subpole1 [ľavý..stred]
* subpole2 [stred+1..pravý] */
void merge(int[] pole, int lavy, int stred, int pravy) {
// Výpočet dĺžky 2 subpolí
int n1 = stred - lavy + 1;
int n2 = pravy - stred;

// Vytvorenie pomocných polí
int[] L = new int[n1];
int[] P = new int[n2];

// Načítanie dát do pomocných polí
for (int i = 0; i < n1; i++)
L[i] = pole[lavy + i];

for (int j = 0; j < n2; j++)
P[j] = pole[stred + 1 + j];

// Počiatočné indexy prvého a druhého subpola
int i = 0, j = 0;
// Počiatočný index zlúčeného subpola
int k = lavy;

// Zlúčenie dvoch podpolí
while (i < n1 && j < n2) {
if (L[i] <= P[j]) {
pole[k] = L[i];
i++;
}
else {
pole[k] = P[j];
j++;
}
k++;
}

/* V prípade, že v jednom zo subpolí sa nachádzajú prvky, ktoré neboli zlúčené do pola,
* tak sa do pola jednoducho skopírujú */
while (i < n1) {
pole[k] = L[i];
i++;
k++;
}

while (j < n2) {
pole[k] = P[j];
k++;
j++;
}
}

/* Funkcia, ktorá zoradí pole použitím funkcie merge() */
void sort (int[] pole, int lavy, int pravy) {
if (lavy < pravy) {
//Musíme nájsť stred pola
int stred = lavy + (pravy - lavy) / 2;

// Zoradíme prvú a druhú polovicu pola samostatne
sort(pole, lavy, stred);
sort(pole, stred + 1, pravy);

// Zlúčime zoradené polovice do jedného pola
merge(pole, lavy, stred, pravy);
}
}
}

public class Main {
/* Funkcia na výpis pola dĺžky n */
static void vypis_pole(int[] pole) {
int n = pole.length;

for (int i = 0; i < n; i++) {
System.out.print(pole[i] + " ");
}
System.out.println();
}

/* Hlavný program */
public static void main(String[] args) {
int[] pole = {12, 11, 13, 5, 6, 7};

System.out.println("Zadané pole:");
vypis_pole(pole);

MergeSort ms = new MergeSort();
ms.sort(pole, 0, pole.length - 1);

System.out.println("\nZoradené pole:");
vypis_pole(pole);
}
}
</syntaxhighlight>
</tab>

<tab name="Python3" block>
<syntaxhighlight lang="Python3">
def MergeSort(pole):
if len(pole) > 1:
# Nájdenie stredu pola
# zápis len(pole)//2 znamená, že dĺžka pola sa vydelí 2 a výsledok je celé číslo
stred = len(pole) // 2

# Rozdelenie pola na dve časti
L = pole[:stred]
P = pole[stred:]

# Zoradenie najskôr prvej časti pola, potom druhej
MergeSort(L)
MergeSort(P)

i = j = k = 0

# Načítanie dát do pomocných polí L[] a P[]
while i < len(L) and j < len(P):
if L[i] < P[j]:
pole[k] = L[i]
i += 1
else:
pole[k] = P[j]
j += 1
k += 1

# Kontrola či všetky prvky boli zlúčené dokopy,
# ak nie, tak sa do zlúčeného pola jednoducho skopírujú
while i < len(L):
pole[k] = L[i]
i += 1
k += 1

while j < len(P):
pole[k] = P[j]
j += 1
k += 1

# Kód na výpis pola
def vypis_pole(pole):
for i in range(len(pole)):
print(pole[i], end=" ")
print()

# Hlavný program
if __name__ == '__main__':
pole = [12, 11, 13, 5, 6, 7]
print("Zadané pole:", end="\n")
vypis_pole(pole)
MergeSort(pole)
print("Zoradené pole:", end="\n")
vypis_pole(pole)
</syntaxhighlight>
</tab>
</tabs>

===Iteračná verzia algoritmov===

<tabs>
<tab name="C" block>
<syntaxhighlight lang="C">
#include <stdio.h>
#include <stdlib.h>

void Merge(int pole[], int lavy, int stred, int pravy);
void MergeSortIt(int *pole, int lavy, int pravy);

/* hlavný program */

int main()
{
int pole[] = {12, 11, 13, 5, 6, 7, 19};
int dlzka_pola = sizeof(pole) / sizeof(pole[0]);

printf("Pôvodné pole %d: \n", dlzka_pola);

for (int i = 0; i < dlzka_pola; ++i)
{
printf("%d ", pole[i]);
}

MergeSortIt(pole, 0, dlzka_pola - 1);

printf("\nUtriedené pole: \n");

for (int i = 0; i < dlzka_pola; ++i)
{
printf("%d ", pole[i]);
}

return 0;
}

void Merge(int pole[], int lavy, int stred, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči */

if (lavy >= pravy)
{
return;
}

/* vyrátaj dĺžky oboch polovíc poľa */

int L_dlzka = stred - lavy + 1;
int P_dlzka = pravy - stred;

/* alokuj dočasné polia, kam uložíš prvky z oboch polovíc poľa */

int *L = (int*)malloc(L_dlzka * sizeof(int));
int *P = (int*)malloc(P_dlzka * sizeof(int));

/* indexy, ktorými iterujeme všetky polia: i pre L, j pre P, k pre pole */

int i, j, k;

/* skopíruj obsah oboch polovíc poľa do dočasných polí L a P */

for (i = 0; i < L_dlzka; ++i)
{
L[i] = pole[lavy + i];
}

for (j = 0; j < P_dlzka; ++j)
{
P[j] = pole[stred + 1 + j];
}

/* nastav indexy na začiatok daných polí */

i = 0; j = 0; k = lavy;

/* zlučuj dočasné polia L a P do finálneho poľa pole */

while(i < L_dlzka && j < P_dlzka)
{
if(L[i] <= P[j])
{
pole[k++] = L[i++];
}
else
{
pole[k++] = P[j++];
}
}

/* ak ostali nejaké prvky v dočasnom poli L, skopíruj ich do finálneho poľa */

while(i < L_dlzka)
{
pole[k++] = L[i++];
}

/* ak ostali nejaké prvky v dočasnom poli P, skopíruj ich do finálneho poľa */

while(j < P_dlzka)
{
pole[k++] = P[j++];
}

/* uvoľni použitú pamäť */

free(L);
free(P);
}

void MergeSortIt(int *pole, int lavy, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči volanie */

if(lavy >= pravy)
{
return;
}

int stred, koniec;

for (int dlzka_zoznamu = 1; dlzka_zoznamu <= pravy ; dlzka_zoznamu *= 2)
{
for (int zaciatok = lavy; zaciatok < pravy ; zaciatok += 2 * dlzka_zoznamu)
{
koniec = (zaciatok + 2 * dlzka_zoznamu - 1 <= pravy) ? zaciatok + 2 * dlzka_zoznamu - 1 : pravy;

stred = (zaciatok + dlzka_zoznamu - 1 <= pravy) ? zaciatok + dlzka_zoznamu - 1 : pravy;

Merge(pole, zaciatok, stred, koniec);

}
}
}

</syntaxhighlight>
</tab>

<tab name="C++" block>
<syntaxhighlight lang="C++">
#include <iostream>

using std::cout;
using std::endl;

void Merge(int pole[], int lavy, int stred, int pravy);
void MergeSort(int pole[], int lavy, int pravy);

/* hlavný program */

int main()
{
int pole[] = {12, 11, 13, 5, 6, 7};
int dlzka_pola = sizeof(pole) / sizeof(pole[0]);

printf("Pôvodné pole: \n");

for (auto i: pole)
{
cout<<i<<" ";
}

MergeSort(pole, 0, dlzka_pola - 1);

cout<<endl<<"Utriedené pole:"<<endl;

for (auto i: pole)
{
cout<<i<<" ";
}

return 0;
}

void Merge(int pole[], int lavy, int stred, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči */

if (lavy >= pravy)
{
return;
}

/* vyrátaj dĺžky oboch polovíc poľa */

int L_dlzka = stred - lavy + 1;
int P_dlzka = pravy - stred;

/* alokuj dočasné polia, kam uložíš prvky z oboch polovíc poľa */

int *L = new int[L_dlzka];
int *P = new int[P_dlzka];

/* indexy, ktorými iterujeme všetky polia: i pre L, j pre P, k pre pole */

int i, j, k;

/* skopíruj obsah oboch polovíc poľa do dočasných polí L a P */

for (i = 0; i < L_dlzka; ++i)
{
L[i] = pole[lavy + i];
}

for (j = 0; j < P_dlzka; ++j)
{
P[j] = pole[stred + 1 + j];
}

/* nastav indexy na začiatok daných polí */

i = 0; j = 0; k = lavy;

/* zlučuj dočasné polia L a P do finálneho poľa pole */

while(i < L_dlzka && j < P_dlzka)
{
if(L[i] <= P[j])
{
pole[k++] = L[i++];
}
else
{
pole[k++] = P[j++];
}
}

/* ak ostali nejaké prvky v dočasnom poli L, skopíruj ich do finálneho poľa */

while(i < L_dlzka)
{
pole[k++] = L[i++];
}

/* ak ostali nejaké prvky v dočasnom poli P, skopíruj ich do finálneho poľa */

while(j < P_dlzka)
{
pole[k++] = P[j++];
}

/* uvoľni použitú pamäť */

delete []L;
delete []P;
}

void MergeSort(int *pole, int lavy, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči volanie */

if(lavy >= pravy)
{
return;
}

int stred, koniec;

for (int dlzka_zoznamu = 1; dlzka_zoznamu <= pravy; dlzka_zoznamu *= 2)
{
for (int zaciatok = lavy; zaciatok < pravy; zaciatok += 2 * dlzka_zoznamu)
{
koniec = (zaciatok + 2 * dlzka_zoznamu - 1 <= pravy) ? zaciatok + 2 * dlzka_zoznamu - 1 : pravy;

stred = (zaciatok + dlzka_zoznamu - 1 <= pravy) ? zaciatok + dlzka_zoznamu - 1 : pravy;

Merge(pole, zaciatok, stred, koniec);
}
}
}
</syntaxhighlight>
</tab>

<tab name="Java" block>
<syntaxhighlight lang="Java">
class MergeSort_iteracia {
/* Zlúči 2 subpolia, ktoré sa vytvorili z pôvodného pola.
* Každé subpole má polovičnú dĺžku pôvodného pola.
* subpole1 [ľavý..stred]
* subpole2 [stred+1..pravý] */
void merge(int[] pole, int lavy, int stred, int pravy) {
// Výpočet dĺžky 2 subpolí
int n1 = stred - lavy + 1;
int n2 = pravy - stred;

// Vytvorenie pomocných polí
int[] L = new int[n1];
int[] P = new int[n2];

// Načítanie dát do pomocných polí
for (int i = 0; i < n1; i++)
L[i] = pole[lavy + i];

for (int j = 0; j < n2; j++)
P[j] = pole[stred + 1 + j];

// Počiatočné indexy prvého a druhého subpola
int i = 0, j = 0;
// Počiatočný index zlúčeného subpola
int k = lavy;

// Zlúčenie dvoch podpolí
while (i < n1 && j < n2) {
if (L[i] <= P[j]) {
pole[k] = L[i];
i++;
}
else {
pole[k] = P[j];
j++;
}
k++;
}

/* V prípade, že v jednom zo subpolí sa nachádzajú prvky, ktoré neboli zlúčené do pola,
* tak sa do pola jednoducho skopírujú */
while (i < n1) {
pole[k] = L[i];
i++;
k++;
}

while (j < n2) {
pole[k] = P[j];
k++;
j++;
}
}

/* Funkcia, ktorá zoradí pole použitím funkcie merge() */
void sort (int[] pole, int n) {
/* Dĺžka subpolí, ktoré majú byť zlúčené, hodnoty premennej sa pohybujú v intervale <1;n-1> */
int aktual_dlzka;
/* Začiatočný index ľavého subpola, ktoré má byť zlúčené */
int zaciatok_vlavo;

/* Vzostupné usporiadanie prvkov. Najskôr sa zlúčia subpolia veľkosti 1 do subpolí veľkosti 2,
* potom subpolia veľkosti 2 do subpolí veľkosti 4 a tak ďalej */
for (aktual_dlzka = 1; aktual_dlzka <= n - 1; aktual_dlzka *= 2) {
/* Určenie začiatočného prvku rôznych subpolí aktuálnej dĺžky subpola */
for (zaciatok_vlavo = 0; zaciatok_vlavo < n - 1; zaciatok_vlavo += 2 * aktual_dlzka) {
/* Nájdenie konečného prvku ľavého subpola, stred+1 je začiatočný prvok pravého subpola */
int stred = Math.min(zaciatok_vlavo + aktual_dlzka - 1, n - 1);
int koniec_vpravo = Math.min(zaciatok_vlavo + 2 * aktual_dlzka - 1, n - 1);

/* Zlúči subpolia L[zaciatok_vlavo .. stred] & P[stred+1 .. koniec_vpravo] */
merge(pole, zaciatok_vlavo, stred, koniec_vpravo);
}
}
}
}

public class Main {
/* Funkcia na načítanie pola dĺžky n */
static void nacitaj_pole(int[] pole) {
Random rand = new Random();

int min = -100000;
int max = 100000;

/* Naplnenie pola náhodnými číslami */
for (int i = 0; i < pole.length; i++) {
//pole[i] = rand.nextInt(pole.length);
pole[i] = (int)(Math.random() * (max - min + 1) + min);
}
}

/* Funkcia na výpis pola dĺžky n */
static void vypis_pole(int[] pole) {
int n = pole.length;

for (int j : pole) {
System.out.print(j + " ");
}
System.out.println();
}

static boolean kontrola(int[] pole) {
/* Premenná, pomocou ktorej zistíme či je pole zoradené */
boolean sorted = false;

for (int i = 0; i < Math.pow(10, 6) - 1; i++) {
if (pole[i] <= pole[i + 1])
sorted = true;

else {
sorted = false;
break;
}
}

return sorted;
}

/* Hlavný program */
public static void main(String[] args) {

/* Inicializácia pola */
int[] pole_parne = new int[1000000];
int[] pole_neparne = new int[1000001];

nacitaj_pole(pole_parne);
nacitaj_pole(pole_neparne);

/*System.out.println("Zadané polia:");
vypis_pole(pole_parne);
System.out.println();
vypis_pole(pole_neparne);
System.out.println();*/

/*MergeSort_rekurzia ms_re = new MergeSort_rekurzia();
ms_re.sort(pole_parne, 0, pole_parne.length - 1);
ms_re.sort(pole_neparne, 0, pole_neparne.length - 1);*/

/*System.out.println("Zoradené polia:");
vypis_pole(pole_parne);
System.out.println();
vypis_pole(pole_neparne);
System.out.println();*/

MergeSort_iteracia ms_it = new MergeSort_iteracia();
ms_it.sort(pole_parne, pole_parne.length);
ms_it.sort(pole_neparne, pole_neparne.length);

System.out.println("Je pole_parne zoradene? " + kontrola(pole_parne));
System.out.println("Je pole_neparne zoradene? " + kontrola(pole_neparne));
}
}class MergeSort_iteracia {
/* Zlúči 2 subpolia, ktoré sa vytvorili z pôvodného pola.
* Každé subpole má polovičnú dĺžku pôvodného pola.
* subpole1 [ľavý..stred]
* subpole2 [stred+1..pravý] */
void merge(int[] pole, int lavy, int stred, int pravy) {
// Výpočet dĺžky 2 subpolí
int n1 = stred - lavy + 1;
int n2 = pravy - stred;

// Vytvorenie pomocných polí
int[] L = new int[n1];
int[] P = new int[n2];

// Načítanie dát do pomocných polí
for (int i = 0; i < n1; i++)
L[i] = pole[lavy + i];

for (int j = 0; j < n2; j++)
P[j] = pole[stred + 1 + j];

// Počiatočné indexy prvého a druhého subpola
int i = 0, j = 0;
// Počiatočný index zlúčeného subpola
int k = lavy;

// Zlúčenie dvoch podpolí
while (i < n1 && j < n2) {
if (L[i] <= P[j]) {
pole[k] = L[i];
i++;
}
else {
pole[k] = P[j];
j++;
}
k++;
}

/* V prípade, že v jednom zo subpolí sa nachádzajú prvky, ktoré neboli zlúčené do pola,
* tak sa do pola jednoducho skopírujú */
while (i < n1) {
pole[k] = L[i];
i++;
k++;
}

while (j < n2) {
pole[k] = P[j];
k++;
j++;
}
}

/* Funkcia, ktorá zoradí pole použitím funkcie merge() */
void sort (int[] pole, int n) {
/* Dĺžka subpolí, ktoré majú byť zlúčené, hodnoty premennej sa pohybujú v intervale <1;n-1> */
int aktual_dlzka;
/* Začiatočný index ľavého subpola, ktoré má byť zlúčené */
int zaciatok_vlavo;

/* Vzostupné usporiadanie prvkov. Najskôr sa zlúčia subpolia veľkosti 1 do subpolí veľkosti 2,
* potom subpolia veľkosti 2 do subpolí veľkosti 4 a tak ďalej */
for (aktual_dlzka = 1; aktual_dlzka <= n - 1; aktual_dlzka *= 2) {
/* Určenie začiatočného prvku rôznych subpolí aktuálnej dĺžky subpola */
for (zaciatok_vlavo = 0; zaciatok_vlavo < n - 1; zaciatok_vlavo += 2 * aktual_dlzka) {
/* Nájdenie konečného prvku ľavého subpola, stred+1 je začiatočný prvok pravého subpola */
int stred = Math.min(zaciatok_vlavo + aktual_dlzka - 1, n - 1);
int koniec_vpravo = Math.min(zaciatok_vlavo + 2 * aktual_dlzka - 1, n - 1);

/* Zlúči subpolia L[zaciatok_vlavo .. stred] & P[stred+1 .. koniec_vpravo] */
merge(pole, zaciatok_vlavo, stred, koniec_vpravo);
}
}
}
}

public class Main {
/* Funkcia na načítanie pola dĺžky n */
static void nacitaj_pole(int[] pole) {
Random rand = new Random();

int min = -100000;
int max = 100000;

/* Naplnenie pola náhodnými číslami */
for (int i = 0; i < pole.length; i++) {
//pole[i] = rand.nextInt(pole.length);
pole[i] = (int)(Math.random() * (max - min + 1) + min);
}
}

/* Funkcia na výpis pola dĺžky n */
static void vypis_pole(int[] pole) {
int n = pole.length;

for (int j : pole) {
System.out.print(j + " ");
}
System.out.println();
}

static boolean kontrola(int[] pole) {
/* Premenná, pomocou ktorej zistíme či je pole zoradené */
boolean sorted = false;

for (int i = 0; i < Math.pow(10, 6) - 1; i++) {
if (pole[i] <= pole[i + 1])
sorted = true;

else {
sorted = false;
break;
}
}

return sorted;
}

/* Hlavný program */
public static void main(String[] args) {

/* Inicializácia pola */
int[] pole_parne = new int[1000000];
int[] pole_neparne = new int[1000001];

nacitaj_pole(pole_parne);
nacitaj_pole(pole_neparne);

/*System.out.println("Zadané polia:");
vypis_pole(pole_parne);
System.out.println();
vypis_pole(pole_neparne);
System.out.println();*/

/*MergeSort_rekurzia ms_re = new MergeSort_rekurzia();
ms_re.sort(pole_parne, 0, pole_parne.length - 1);
ms_re.sort(pole_neparne, 0, pole_neparne.length - 1);*/

/*System.out.println("Zoradené polia:");
vypis_pole(pole_parne);
System.out.println();
vypis_pole(pole_neparne);
System.out.println();*/

MergeSort_iteracia ms_it = new MergeSort_iteracia();
ms_it.sort(pole_parne, pole_parne.length);
ms_it.sort(pole_neparne, pole_neparne.length);

System.out.println("Je pole_parne zoradene? " + kontrola(pole_parne));
System.out.println("Je pole_neparne zoradene? " + kontrola(pole_neparne));
}
}
</syntaxhighlight>
</tab>
</tabs>

==Odkazy==
# https://www.geeksforgeeks.org/merge-sort/
# https://www.geeksforgeeks.org/iterative-merge-sort/
# https://medium.com/@paulsoham/merge-sort-63d75df76388
# https://www.khanacademy.org/computing/computer-science/algorithms/merge-sort/a/overview-of-merge-sort
# https://www.tutorialspoint.com/data_structures_algorithms/merge_sort_algorithm.htm
# https://www.youtube.com/watch?v=6pV2IF0fgKY
# https://www.youtube.com/watch?v=mB5HXBb_HY8
# https://www.youtube.com/watch?v=ak-pz7tS5DE

Triedenie zlučovaním

2021-03-28T16:15:00Z

Filip Tomek: /* Merge sort */

[[Kategória:Algoritmy triedenia]]
{{Draft}}
{{Skripta programovanie}}
__TOC__
==TODO: Pseudokód treba opraviť, text refaktorovať, otestovať kódy, zvýrazniť veci v texte, opraviť preklepy, opraviť popis obrázkov, pridať nové odkazy==

==Zlučovací algoritmus Merge==

Princíp zlučovania tkvie v tom, že máme dva alebo viac utriedených zoznamov, ktoré skombinuje do jedného utriedeného zoznamu (výsledný zoznam musí obsahovať všetky prvky z pôvodných zoznamov). Zoznam môže byť reprezentovaný ako dátová štruktúra pole alebo aj ako lineárny zoznam. V tomto článku sa zameriame na algoritmus pre dátovú štruktúru pole.

Algoritmus Merge tvorí kľúčovú časť triediaceho algoritmu MergeSort.

[[Súbor:Funkcia merge.png|500px|náhľad|vpravo|Vizualizácia funkcie Merge: Máme pole prvkov p = [1, 3, 5, 2, 4, 6], ktoré je už čiastočne utriedené. Použijeme algoritmus Merge, ktorý si vytvorí pomocné polia L = [1, 3, 5] a P = [2, 4, 6]. Všetky polia indexujeme od 0, pričom pre pole p používame index k, pre L index i a pre P index j. Postupnosť krokov je označená číslicami 1 až 6.
]]

===Slovný opis algoritmu===
Nech máme pole, ktoré sa skladá z dvoch už utriedených polovíc. Vytvoríme si dve pomocné polia L a P a do každého z nich skopírujeme obsah jednej polovice (L - ľavá polovica, P - pravá polovica). Potom súčasne prechádzame polia L a P od začiatku po koniec, pričom v každom cykle porovnáme prvok poľa L s prvkom v poli P. Z tejto dvojice následne vyberieme minimum, (keď triedime od najmenšieho po najväčší) ktoré vložíme na prvú voľnú pozíciu pôvodného poľa (na začiatku je to prvá pozícia poľa). Nakoniec zvýšime index pri vstupnom poli a pri pomocnom poli, z ktorého vyberáme daný prvok. Túto postupnosť krokov opakujeme, pokiaľ neprídeme na koniec jedného z polí P a L. Ak nastane situácia, že prídeme na koniec jedného z pomocných polí (a v druhom nám ostali ešte nejaké prvky), potom už iba naspäť skopírujeme zbytok druhého pomocného poľa na koniec pôvodného poľa.

===Vlastnosti algoritmu===
* vhodný pre dátové štruktúry: pole, lineárny zoznam
* časová náročnosť: vždy lineárna <math>O(n)</math>
* priestorová náročnosť: lineárna <math>O(n)</math> pre pole (alokovanie pomocných polí), <math>O(1)</math> pre lineárny zoznam (pri LZ netreba alokovať dočasné polia, stačí iba presmerovať smerníky)
* využitie: kľúčový podprogram pre triediaci algoritmus MergeSort

===Pseudokód===
Nech funkcia Merge má nasledovný prototyp: <code>Merge(pole[], lavy, stred, pravy)</code>
:1. Je <code>lavy >= pravy ? Ak áno, skonči, inak pokračuj krokom 2.</code>
:2. Nech: <code>i = 0, j = 0, k = lavy </code>
:3. Nech: <code>dlzka_L = stred - lavy + 1, dlzka_P = pravy - stred</code>
:4. Nech: <code> L = pole[lavy ... stred], P = pole[stred + 1 ... pravy] </code>
:5. Je <code>i < dlzka_L</code> a zároveň <code>j < dlzka_P</code> ? Ak áno, pokračuj krokom 5.1., inak skoč na krok 6.
:::5.1. Je <code>L[i] <= P[j]</code>?
:::: Ak áno:
:::::5.1.1. <code>pole[k] = L[i]</code>
:::::5.1.2. <code>k += 1</code>
:::::5.1.3. <code>i += 1</code>
:::::5.1.4. Skoč na krok 5.
:::: Ak nie:
:::::5.1.1. <code>pole[k] = P[j]</code>
:::::5.1.2. <code>k += 1</code>
:::::5.1.3. <code>j += 1</code>
:::::5.1.4. Skoč na krok 5.
:6. Je <code>i < dlzka_L</code> ? Ak áno, pokračuj krokom 6.1., inak skoč na krok 7.
:::6.1. <code>pole[k] = L[i]</code>
:::6.2. <code>k += 1</code>
:::6.3. <code>i += 1</code>
:::6.4. Skoč na krok 6.
:7. Je <code>j < dlzka_P</code> ? Ak áno, pokračuj krokom 7.1., inak skonči.
:::7.1. <code>pole[k] = P[j]</code>
:::7.2. <code>k += 1</code>
:::7.3. <code>j += 1</code>
:::7.4. Skoč na krok 7.

==Merge sort==
Merge Sort je triediaci algoritmus, ktorý využíva stratégiu '''"rozdeľuj a panuj"''', čo znamená, že vstupný zoznam najskôr rozdelí na dve polovice, tie zoradí a potom ich zlúči naspäť dokopy. Radí sa medzi najpoužívanejšie a najviac rešpektované triediace algoritmy.

Z hľadiska implementácie môžeme vytvoriť dve základné verzie algoritmu, a to rekurzívnu a iteračnú.

===Vlastnosti algoritmu Merge Sort===
* vhodný pre dátové štruktúry: pole, lineárny zoznam
* časová náročnosť: vždy linearitmická <math> O(n.log(n)) </math>, vďaka ktorej dokáže efektívne triediť veľmi veľké zoznamy
* priestorová náročnosť: lineárna <math>O(n)</math> pre pole (alokovanie dočasných polí), konštantná <math>O(1)</math> pre lineárny zoznam (pri LZ stačí iba presmerovať smerníky)
* druh triedenia: triedenie zlučovaním (komparačný algoritmus)
* stabilita triedenia: stabilný
* miesto triedenia: externé triedenie (vhodný na triedenie veľkých objemov dát uložených na disku)

===Princíp algoritmu===
<tabs>
<tab name="Rekurzívna verzia" block>
Algoritmus MergeSort vykonáva 4 základné úlohy:
# Delenie poľa na dve polovice.
# Triedenie ľavej polovice poľa.
# Triedenie pravej polovice poľa.
# Zlúčenie oboch polovíc pomocou funkcie Merge.
</tab>

<tab name="Iteračná verzia" block>
Algoritmus Merge vykonáva 3 základné úlohy:
# Vonkajší cyklus: určenie veľkosti zoznamu na zlučovanie
# Vnútorný cyklus: prechádzanie jednotlivých zoznamov v poli
# Zlučovanie jednotlivých zoznamov pomocou funkcie Merge
</tab>
</tabs>

===Slovný opis===
<tabs>
<tab name="Rekurzívna verzia">
Našou úlohou je vzostupne (min - max) utriediť vstupné pole. Určíme si stred poľa (pri párnom počte prvkov je to ten menší z prostredných indexov). Následne vykonávame sériu rekurzívnych delení pre ľavú a pravú časť poľa (začiatok ... stred ; stred + 1 ... koniec) až do momentu, keď nám ostanú len jednoprvkové podpolia (tie sú už utriedené). Následne v každom volaní obe tieto podpolia zlúčime pomocou algoritmu Merge do väčších podpolí (2, 4, 8, ...), až nakoniec dostaneme jedno výsledné utriedené pole.
[[Súbor:Merge sort.png|400px|náhľad|center|Vizualizácia rekurzívnej verzie algoritmu MergeSort]]
</tab>

<tab name="Iteračná verzia">
[[Súbor:MergeSort It.png|400px|náhľad|vpravo|Vizualizácia iteračnej verzie algoritmu MergeSort]]
Vstupné pole, ktoré má ''N'' prvkov, môžeme chápať, ako ''N'' rôznych jednoprvkových (utriedených) podpolí, ktoré máme zlúčiť do jedného výsledného ''N''-prvkového utriedeného poľa. Keďže by bolo veľmi nepraktické zlučovať ''N'' podpolí naraz, zvolíme nasledovnú stratégiu: Budeme prechádzať dané pole od začiatku po koniec a v prvom cykle zlúčime každé dva prvky, takže budeme mať <math>\frac{n}{2}</math> dvojprvkových utriedených podpolí. Potom v druhom cykle zlúčime každé 4 prvky do jedného podpoľa, v treťom cykle každých 8, až do momentu, keď dostaneme jedno utriedené pole.
Aby sme to docielili, potrebujeme dva cykly, vonkajší, ktorý nastaví maximálnu veľkosť podpoľa, ktoré ideme zlučovať (1,2,4,8 ... dlzka - 1) a vnútorný, ktorý prechádza jednotlivé podpolia. Následne už iba voláme funkciu Merge, ktorá dané podpolia zlučuje.

Poznámka, ak máme pole, ktoré má nepárny počet prvkov, tak ten posledný prvok nezlúčime hneď v prvom cykle, ale až v tých ďalších. Takisto, ak n nie je mocnina čísla 2, tak musíme samozrejme ošetriť situáciu, kedy by sme sa dostali mimo rozsah poľa (Ak máme napríklad pole, čo má 7 prvkov, tak po prvej iterácii budú prvky utiredené podľa vzoru 2 + 2 + 2 + 1, po druhej 4 + 3, a po tretej 7)
</tab>
</tabs>

===Pseudokód===
<tabs>
<tab name="Rekurzívna verzia" block>
Nech nech má funkcia MergeSort nasledovný prototyp: <code>MergeSort(pole[], lavy, pravy) </code>
:1. Je <code>lavy >= pravy</code> ? Ak áno, skonči volanie, inak pokračuj krokom 2.
:2. Nech: <code>stred = lavy + (pravy - lavy) / 2</code>, pričom znak ''/'' vyjadruje celočíselné delenie.
:3. Rekurzívne zavolaj funkciu <code>MergeSort(pole[], lavy , stred)</code>
:3. Rekurzívne zavolaj funkciu <code>MergeSort(pole[], stred + 1 , pravy)</code>
:4. Zavolaj funkciu <code>Merge(pole[], lavy, stred, pravy)</code>
:5. Skonči volanie.
</tab>

<tab name="Iteračná verzia" block>
Nech nech má funkcia MergeSort nasledovný prototyp: <code>MergeSort(pole[], lavy, pravy) </code>
:1. Je <code>lavy >= pravy</code> ? Ak áno, skonči, inak pokračuj krokom 2.
:2. Nech: <code>dlzka_subzoznamu = 1 </code>
:3. Nech: <code>zaciatok = lavy</code>
:4. Je<code>dlzka_subzoznamu <= pravy</code> ? Ak áno pokračuj krokom 4.1, inak skonči.
:::4.1. Je<code>zaciatok < pravy</code> Ak áno pokračuj krokom 4.1.1, inak skoč na krok 4.2.
:::::4.1.1. Je <code>zaciatok + 2 * dlzka_zoznamu - 1 <= pravy</code> ?
:::::::Ak áno:
:::::::::4.1.1.1. Nech <code>koniec = zaciatok + 2 * dlzka_zoznamu - 1</code>
:::::::Ak nie:
:::::::::4.1.1.1. Nech <code>koniec = pravy</code>
:::::4.1.2. Je <code>zaciatok + dlzka_zoznamu - 1 <= pravy</code> ?
:::::::Ak áno:
:::::::::4.1.2.1. Nech <code>stred = zaciatok + dlzka_zoznamu - 1</code>
:::::::Ak nie:
:::::::::4.1.2.1. Nech <code>stred = pravy</code>
:::::4.1.3. <code>Merge(pole[], zaciatok, stred, koniec)</code>
:::::4.1.4. <code>zaciatok += 2 * dlzka_subzoznamu</code>
:::::4.1.5. Skoč na krok 4.1.
:::4.2. <code>dlzka_subzoznamu *= 2</code>
:::4.3 Skoč na krok 4.
</tab>
</tabs>

==Implementácia algoritmov Merge a MergeSort==
===Rekurzívna verzia algoritmov===

<tabs>
<tab name="C" block>
<syntaxhighlight lang="C">
#include <stdio.h>
#include <stdlib.h>

void Merge(int pole[], int lavy, int stred, int pravy);
void MergeSort(int pole[], int lavy, int pravy);

/* hlavný program */

int main()
{
int pole[] = {12, 11, 13, 5, 6, 7};
int dlzka_pola = sizeof(pole) / sizeof(pole[0]);

printf("Pôvodné pole: \n");

for (int i = 0; i < dlzka_pola; ++i)
{
printf("%d ", pole[i]);
}

MergeSort(pole, 0, dlzka_pola - 1);

printf("\nUtriedené pole: \n");

for (int i = 0; i < dlzka_pola; ++i)
{
printf("%d ", pole[i]);
}

return 0;
}

void Merge(int pole[], int lavy, int stred, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči */

if (lavy >= pravy)
{
return;
}

/* vyrátaj dĺžky oboch polovíc poľa */

int L_dlzka = stred - lavy + 1;
int P_dlzka = pravy - stred;

/* alokuj dočasné polia, kam uložíš prvky z oboch polovíc poľa */

int *L = (int*)malloc(L_dlzka * sizeof(int));
int *P = (int*)malloc(P_dlzka * sizeof(int));

/* indexy, ktorými iterujeme všetky polia: i pre L, j pre P, k pre pole */

int i, j, k;

/* skopíruj obsah oboch polovíc poľa do dočasných polí L a P */

for (i = 0; i < L_dlzka; ++i)
{
L[i] = pole[lavy + i];
}

for (j = 0; j < P_dlzka; ++j)
{
P[j] = pole[stred + 1 + j];
}

/* nastav indexy na začiatok daných polí */

i = 0; j = 0; k = lavy;

/* zlučuj dočasné polia L a P do finálneho poľa pole */

while(i < L_dlzka && j < P_dlzka)
{
if(L[i] <= P[j])
{
pole[k++] = L[i++];
}
else
{
pole[k++] = P[j++];
}
}

/* ak ostali nejaké prvky v dočasnom poli L, skopíruj ich do finálneho poľa */

while(i < L_dlzka)
{
pole[k++] = L[i++];
}

/* ak ostali nejaké prvky v dočasnom poli P, skopíruj ich do finálneho poľa */

while(j < P_dlzka)
{
pole[k++] = P[j++];
}

/* uvoľni použitú pamäť */

free(L);
free(P);
}

void MergeSort(int pole[], int lavy, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči volanie */

if(lavy >= pravy)
{
return;
}
/* urči si prostredný index */

int stred = lavy + (pravy - lavy) / 2;

/* utrieď ľavú polovicu poľa */

MergeSort(pole, lavy, stred);

/* utrieď pravú polovicu poľa */

MergeSort(pole, stred+1, pravy);

/* zlúč obe polovice dokopy */

Merge(pole, lavy, stred, pravy);
}
</syntaxhighlight>
</tab>

<tab name="C++" block>
<syntaxhighlight lang="C++">
#include <iostream>

using std::cout;
using std::endl;

void Merge(int pole[], int lavy, int stred, int pravy);
void MergeSort(int pole[], int lavy, int pravy);

/* hlavný program */

int main()
{
int pole[] = {12, 11, 13, 5, 6, 7};
int dlzka_pola = sizeof(pole) / sizeof(pole[0]);

printf("Pôvodné pole: \n");

for (auto i: pole)
{
cout<<i<<" ";
}

MergeSort(pole, 0, dlzka_pola - 1);

cout<<endl<<"Utriedené pole:"<<endl;

for (auto i: pole)
{
cout<<i<<" ";
}

return 0;
}

void Merge(int pole[], int lavy, int stred, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči */

if (lavy >= pravy)
{
return;
}

/* vyrátaj dĺžky oboch polovíc poľa */

int L_dlzka = stred - lavy + 1;
int P_dlzka = pravy - stred;

/* alokuj dočasné polia, kam uložíš prvky z oboch polovíc poľa */

int *L = new int[L_dlzka];
int *P = new int[P_dlzka];

/* indexy, ktorými iterujeme všetky polia: i pre L, j pre P, k pre pole */

int i, j, k;

/* skopíruj obsah oboch polovíc poľa do dočasných polí L a P */

for (i = 0; i < L_dlzka; ++i)
{
L[i] = pole[lavy + i];
}

for (j = 0; j < P_dlzka; ++j)
{
P[j] = pole[stred + 1 + j];
}

/* nastav indexy na začiatok daných polí */

i = 0; j = 0; k = lavy;

/* zlučuj dočasné polia L a P do finálneho poľa pole */

while(i < L_dlzka && j < P_dlzka)
{
if(L[i] <= P[j])
{
pole[k++] = L[i++];
}
else
{
pole[k++] = P[j++];
}
}

/* ak ostali nejaké prvky v dočasnom poli L, skopíruj ich do finálneho poľa */

while(i < L_dlzka)
{
pole[k++] = L[i++];
}

/* ak ostali nejaké prvky v dočasnom poli P, skopíruj ich do finálneho poľa */

while(j < P_dlzka)
{
pole[k++] = P[j++];
}

/* uvoľni použitú pamäť */

delete []L;
delete []P;
}

void MergeSort(int pole[], int lavy, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči volanie */

if(lavy >= pravy)
{
return;
}
/* urči si prostredný index */

int stred = lavy + (pravy - lavy) / 2;

/* utrieď ľavú polovicu poľa */

MergeSort(pole, lavy, stred);

/* utrieď pravú polovicu poľa */

MergeSort(pole, stred+1, pravy);

/* zlúč obe polovice dokopy */

Merge(pole, lavy, stred, pravy);
}

</syntaxhighlight>
</tab>

<tab name="Java" block>
<syntaxhighlight lang="Java">
class MergeSort {
/* Zlúči 2 subpolia, ktoré sa vytvorili z pôvodného pola.
* Každé subpole má polovičnú dĺžku pôvodného pola.
* subpole1 [ľavý..stred]
* subpole2 [stred+1..pravý] */
void merge(int[] pole, int lavy, int stred, int pravy) {
// Výpočet dĺžky 2 subpolí
int n1 = stred - lavy + 1;
int n2 = pravy - stred;

// Vytvorenie pomocných polí
int[] L = new int[n1];
int[] P = new int[n2];

// Načítanie dát do pomocných polí
for (int i = 0; i < n1; i++)
L[i] = pole[lavy + i];

for (int j = 0; j < n2; j++)
P[j] = pole[stred + 1 + j];

// Počiatočné indexy prvého a druhého subpola
int i = 0, j = 0;
// Počiatočný index zlúčeného subpola
int k = lavy;

// Zlúčenie dvoch podpolí
while (i < n1 && j < n2) {
if (L[i] <= P[j]) {
pole[k] = L[i];
i++;
}
else {
pole[k] = P[j];
j++;
}
k++;
}

/* V prípade, že v jednom zo subpolí sa nachádzajú prvky, ktoré neboli zlúčené do pola,
* tak sa do pola jednoducho skopírujú */
while (i < n1) {
pole[k] = L[i];
i++;
k++;
}

while (j < n2) {
pole[k] = P[j];
k++;
j++;
}
}

/* Funkcia, ktorá zoradí pole použitím funkcie merge() */
void sort (int[] pole, int lavy, int pravy) {
if (lavy < pravy) {
//Musíme nájsť stred pola
int stred = lavy + (pravy - lavy) / 2;

// Zoradíme prvú a druhú polovicu pola samostatne
sort(pole, lavy, stred);
sort(pole, stred + 1, pravy);

// Zlúčime zoradené polovice do jedného pola
merge(pole, lavy, stred, pravy);
}
}
}

public class Main {
/* Funkcia na výpis pola dĺžky n */
static void vypis_pole(int[] pole) {
int n = pole.length;

for (int i = 0; i < n; i++) {
System.out.print(pole[i] + " ");
}
System.out.println();
}

/* Hlavný program */
public static void main(String[] args) {
int[] pole = {12, 11, 13, 5, 6, 7};

System.out.println("Zadané pole:");
vypis_pole(pole);

MergeSort ms = new MergeSort();
ms.sort(pole, 0, pole.length - 1);

System.out.println("\nZoradené pole:");
vypis_pole(pole);
}
}
</syntaxhighlight>
</tab>

<tab name="Python3" block>
<syntaxhighlight lang="Python3">
def MergeSort(pole):
if len(pole) > 1:
# Nájdenie stredu pola
# zápis len(pole)//2 znamená, že dĺžka pola sa vydelí 2 a výsledok je celé číslo
stred = len(pole) // 2

# Rozdelenie pola na dve časti
L = pole[:stred]
P = pole[stred:]

# Zoradenie najskôr prvej časti pola, potom druhej
MergeSort(L)
MergeSort(P)

i = j = k = 0

# Načítanie dát do pomocných polí L[] a P[]
while i < len(L) and j < len(P):
if L[i] < P[j]:
pole[k] = L[i]
i += 1
else:
pole[k] = P[j]
j += 1
k += 1

# Kontrola či všetky prvky boli zlúčené dokopy,
# ak nie, tak sa do zlúčeného pola jednoducho skopírujú
while i < len(L):
pole[k] = L[i]
i += 1
k += 1

while j < len(P):
pole[k] = P[j]
j += 1
k += 1

# Kód na výpis pola
def vypis_pole(pole):
for i in range(len(pole)):
print(pole[i], end=" ")
print()

# Hlavný program
if __name__ == '__main__':
pole = [12, 11, 13, 5, 6, 7]
print("Zadané pole:", end="\n")
vypis_pole(pole)
MergeSort(pole)
print("Zoradené pole:", end="\n")
vypis_pole(pole)
</syntaxhighlight>
</tab>
</tabs>

===Iteračná verzia algoritmov===

<tabs>
<tab name="C" block>
<syntaxhighlight lang="C">
#include <stdio.h>
#include <stdlib.h>

void Merge(int pole[], int lavy, int stred, int pravy);
void MergeSortIt(int *pole, int lavy, int pravy);

/* hlavný program */

int main()
{
int pole[] = {12, 11, 13, 5, 6, 7, 19};
int dlzka_pola = sizeof(pole) / sizeof(pole[0]);

printf("Pôvodné pole %d: \n", dlzka_pola);

for (int i = 0; i < dlzka_pola; ++i)
{
printf("%d ", pole[i]);
}

MergeSortIt(pole, 0, dlzka_pola - 1);

printf("\nUtriedené pole: \n");

for (int i = 0; i < dlzka_pola; ++i)
{
printf("%d ", pole[i]);
}

return 0;
}

void Merge(int pole[], int lavy, int stred, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči */

if (lavy >= pravy)
{
return;
}

/* vyrátaj dĺžky oboch polovíc poľa */

int L_dlzka = stred - lavy + 1;
int P_dlzka = pravy - stred;

/* alokuj dočasné polia, kam uložíš prvky z oboch polovíc poľa */

int *L = (int*)malloc(L_dlzka * sizeof(int));
int *P = (int*)malloc(P_dlzka * sizeof(int));

/* indexy, ktorými iterujeme všetky polia: i pre L, j pre P, k pre pole */

int i, j, k;

/* skopíruj obsah oboch polovíc poľa do dočasných polí L a P */

for (i = 0; i < L_dlzka; ++i)
{
L[i] = pole[lavy + i];
}

for (j = 0; j < P_dlzka; ++j)
{
P[j] = pole[stred + 1 + j];
}

/* nastav indexy na začiatok daných polí */

i = 0; j = 0; k = lavy;

/* zlučuj dočasné polia L a P do finálneho poľa pole */

while(i < L_dlzka && j < P_dlzka)
{
if(L[i] <= P[j])
{
pole[k++] = L[i++];
}
else
{
pole[k++] = P[j++];
}
}

/* ak ostali nejaké prvky v dočasnom poli L, skopíruj ich do finálneho poľa */

while(i < L_dlzka)
{
pole[k++] = L[i++];
}

/* ak ostali nejaké prvky v dočasnom poli P, skopíruj ich do finálneho poľa */

while(j < P_dlzka)
{
pole[k++] = P[j++];
}

/* uvoľni použitú pamäť */

free(L);
free(P);
}

void MergeSortIt(int *pole, int lavy, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči volanie */

if(lavy >= pravy)
{
return;
}

int stred, koniec;

for (int dlzka_zoznamu = 1; dlzka_zoznamu <= pravy ; dlzka_zoznamu *= 2)
{
for (int zaciatok = lavy; zaciatok < pravy ; zaciatok += 2 * dlzka_zoznamu)
{
koniec = (zaciatok + 2 * dlzka_zoznamu - 1 <= pravy) ? zaciatok + 2 * dlzka_zoznamu - 1 : pravy;

stred = (zaciatok + dlzka_zoznamu - 1 <= pravy) ? zaciatok + dlzka_zoznamu - 1 : pravy;

Merge(pole, zaciatok, stred, koniec);

}
}
}

</syntaxhighlight>
</tab>

<tab name="C++" block>
<syntaxhighlight lang="C++">
#include <iostream>

using std::cout;
using std::endl;

void Merge(int pole[], int lavy, int stred, int pravy);
void MergeSort(int pole[], int lavy, int pravy);

/* hlavný program */

int main()
{
int pole[] = {12, 11, 13, 5, 6, 7};
int dlzka_pola = sizeof(pole) / sizeof(pole[0]);

printf("Pôvodné pole: \n");

for (auto i: pole)
{
cout<<i<<" ";
}

MergeSort(pole, 0, dlzka_pola - 1);

cout<<endl<<"Utriedené pole:"<<endl;

for (auto i: pole)
{
cout<<i<<" ";
}

return 0;
}

void Merge(int pole[], int lavy, int stred, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči */

if (lavy >= pravy)
{
return;
}

/* vyrátaj dĺžky oboch polovíc poľa */

int L_dlzka = stred - lavy + 1;
int P_dlzka = pravy - stred;

/* alokuj dočasné polia, kam uložíš prvky z oboch polovíc poľa */

int *L = new int[L_dlzka];
int *P = new int[P_dlzka];

/* indexy, ktorými iterujeme všetky polia: i pre L, j pre P, k pre pole */

int i, j, k;

/* skopíruj obsah oboch polovíc poľa do dočasných polí L a P */

for (i = 0; i < L_dlzka; ++i)
{
L[i] = pole[lavy + i];
}

for (j = 0; j < P_dlzka; ++j)
{
P[j] = pole[stred + 1 + j];
}

/* nastav indexy na začiatok daných polí */

i = 0; j = 0; k = lavy;

/* zlučuj dočasné polia L a P do finálneho poľa pole */

while(i < L_dlzka && j < P_dlzka)
{
if(L[i] <= P[j])
{
pole[k++] = L[i++];
}
else
{
pole[k++] = P[j++];
}
}

/* ak ostali nejaké prvky v dočasnom poli L, skopíruj ich do finálneho poľa */

while(i < L_dlzka)
{
pole[k++] = L[i++];
}

/* ak ostali nejaké prvky v dočasnom poli P, skopíruj ich do finálneho poľa */

while(j < P_dlzka)
{
pole[k++] = P[j++];
}

/* uvoľni použitú pamäť */

delete []L;
delete []P;
}

void MergeSort(int *pole, int lavy, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči volanie */

if(lavy >= pravy)
{
return;
}

int stred, koniec;

for (int dlzka_zoznamu = 1; dlzka_zoznamu <= pravy; dlzka_zoznamu *= 2)
{
for (int zaciatok = lavy; zaciatok < pravy; zaciatok += 2 * dlzka_zoznamu)
{
koniec = (zaciatok + 2 * dlzka_zoznamu - 1 <= pravy) ? zaciatok + 2 * dlzka_zoznamu - 1 : pravy;

stred = (zaciatok + dlzka_zoznamu - 1 <= pravy) ? zaciatok + dlzka_zoznamu - 1 : pravy;

Merge(pole, zaciatok, stred, koniec);
}
}
}
</syntaxhighlight>
</tab>
</tabs>

==Odkazy==
# https://www.geeksforgeeks.org/merge-sort/
# https://www.geeksforgeeks.org/iterative-merge-sort/
# https://medium.com/@paulsoham/merge-sort-63d75df76388
# https://www.khanacademy.org/computing/computer-science/algorithms/merge-sort/a/overview-of-merge-sort
# https://www.tutorialspoint.com/data_structures_algorithms/merge_sort_algorithm.htm
# https://www.youtube.com/watch?v=6pV2IF0fgKY
# https://www.youtube.com/watch?v=mB5HXBb_HY8
# https://www.youtube.com/watch?v=ak-pz7tS5DE

Triedenie zlučovaním

2021-03-28T15:56:34Z

Filip Tomek: /* Merge sort */

[[Kategória:Algoritmy triedenia]]
{{Draft}}
{{Skripta programovanie}}
__TOC__
==TODO: Pseudokód treba opraviť, text refaktorovať, otestovať kódy, zvýrazniť veci v texte, opraviť preklepy, opraviť popis obrázkov, pridať nové odkazy==

==Zlučovací algoritmus Merge==

Princíp zlučovania tkvie v tom, že máme dva alebo viac utriedených zoznamov, ktoré skombinuje do jedného utriedeného zoznamu (výsledný zoznam musí obsahovať všetky prvky z pôvodných zoznamov). Zoznam môže byť reprezentovaný ako dátová štruktúra pole alebo aj ako lineárny zoznam. V tomto článku sa zameriame na algoritmus pre dátovú štruktúru pole.

Algoritmus Merge tvorí kľúčovú časť triediaceho algoritmu MergeSort.

[[Súbor:Funkcia merge.png|500px|náhľad|vpravo|Vizualizácia funkcie Merge: Máme pole prvkov p = [1, 3, 5, 2, 4, 6], ktoré je už čiastočne utriedené. Použijeme algoritmus Merge, ktorý si vytvorí pomocné polia L = [1, 3, 5] a P = [2, 4, 6]. Všetky polia indexujeme od 0, pričom pre pole p používame index k, pre L index i a pre P index j. Postupnosť krokov je označená číslicami 1 až 6.
]]

===Slovný opis algoritmu===
Nech máme pole, ktoré sa skladá z dvoch už utriedených polovíc. Vytvoríme si dve pomocné polia L a P a do každého z nich skopírujeme obsah jednej polovice (L - ľavá polovica, P - pravá polovica). Potom súčasne prechádzame polia L a P od začiatku po koniec, pričom v každom cykle porovnáme prvok poľa L s prvkom v poli P. Z tejto dvojice následne vyberieme minimum, (keď triedime od najmenšieho po najväčší) ktoré vložíme na prvú voľnú pozíciu pôvodného poľa (na začiatku je to prvá pozícia poľa). Nakoniec zvýšime index pri vstupnom poli a pri pomocnom poli, z ktorého vyberáme daný prvok. Túto postupnosť krokov opakujeme, pokiaľ neprídeme na koniec jedného z polí P a L. Ak nastane situácia, že prídeme na koniec jedného z pomocných polí (a v druhom nám ostali ešte nejaké prvky), potom už iba naspäť skopírujeme zbytok druhého pomocného poľa na koniec pôvodného poľa.

===Vlastnosti algoritmu===
* vhodný pre dátové štruktúry: pole, lineárny zoznam
* časová náročnosť: vždy lineárna <math>O(n)</math>
* priestorová náročnosť: lineárna <math>O(n)</math> pre pole (alokovanie pomocných polí), <math>O(1)</math> pre lineárny zoznam (pri LZ netreba alokovať dočasné polia, stačí iba presmerovať smerníky)
* využitie: kľúčový podprogram pre triediaci algoritmus MergeSort

===Pseudokód===
Nech funkcia Merge má nasledovný prototyp: <code>Merge(pole[], lavy, stred, pravy)</code>
:1. Je <code>lavy >= pravy ? Ak áno, skonči, inak pokračuj krokom 2.</code>
:2. Nech: <code>i = 0, j = 0, k = lavy </code>
:3. Nech: <code>dlzka_L = stred - lavy + 1, dlzka_P = pravy - stred</code>
:4. Nech: <code> L = pole[lavy ... stred], P = pole[stred + 1 ... pravy] </code>
:5. Je <code>i < dlzka_L</code> a zároveň <code>j < dlzka_P</code> ? Ak áno, pokračuj krokom 5.1., inak skoč na krok 6.
:::5.1. Je <code>L[i] <= P[j]</code>?
:::: Ak áno:
:::::5.1.1. <code>pole[k] = L[i]</code>
:::::5.1.2. <code>k += 1</code>
:::::5.1.3. <code>i += 1</code>
:::::5.1.4. Skoč na krok 5.
:::: Ak nie:
:::::5.1.1. <code>pole[k] = P[j]</code>
:::::5.1.2. <code>k += 1</code>
:::::5.1.3. <code>j += 1</code>
:::::5.1.4. Skoč na krok 5.
:6. Je <code>i < dlzka_L</code> ? Ak áno, pokračuj krokom 6.1., inak skoč na krok 7.
:::6.1. <code>pole[k] = L[i]</code>
:::6.2. <code>k += 1</code>
:::6.3. <code>i += 1</code>
:::6.4. Skoč na krok 6.
:7. Je <code>j < dlzka_P</code> ? Ak áno, pokračuj krokom 7.1., inak skonči.
:::7.1. <code>pole[k] = P[j]</code>
:::7.2. <code>k += 1</code>
:::7.3. <code>j += 1</code>
:::7.4. Skoč na krok 7.

==Merge sort==
[[Súbor:Merge sort.png|400px|náhľad|vpravo|Vizualizácia rekurzívnej verzie algoritmu MergeSort]]
Merge Sort je triediaci algoritmus, ktorý využíva stratégiu '''"rozdeľuj a panuj"''', čo znamená, že vstupný zoznam najskôr rozdelí na dve polovice, tie zoradí a potom ich zlúči naspäť dokopy. Radí sa medzi najpoužívanejšie a najviac rešpektované triediace algoritmy.

Z hľadiska implementácie môžeme vytvoriť dve základné verzie algoritmu, a to rekurzívnu a iteračnú.

===Vlastnosti algoritmu Merge Sort===
* vhodný pre dátové štruktúry: pole, lineárny zoznam
* časová náročnosť: vždy linearitmická <math> O(n.log(n)) </math>, vďaka ktorej dokáže efektívne triediť veľmi veľké zoznamy
* priestorová náročnosť: lineárna <math>O(n)</math> pre pole (alokovanie dočasných polí), konštantná <math>O(1)</math> pre lineárny zoznam (pri LZ stačí iba presmerovať smerníky)
* druh triedenia: triedenie zlučovaním (komparačný algoritmus)
* stabilita triedenia: stabilný
* miesto triedenia: externé triedenie (vhodný na triedenie veľkých objemov dát uložených na disku)

===Princíp algoritmu===
====Rekurzívna verzia====
Algoritmus MergeSort vykonáva 4 základné úlohy:
# Delenie poľa na dve polovice.
# Triedenie ľavej polovice poľa.
# Triedenie pravej polovice poľa.
# Zlúčenie oboch polovíc pomocou funkcie Merge.

====Iteračná verzia====
Algoritmus Merge vykonáva 3 základné úlohy:
# Vonkajší cyklus: určenie veľkosti zoznamu na zlučovanie
# Vnútorný cyklus: prechádzanie jednotlivých zoznamov v poli
# Zlučovanie jednotlivých zoznamov pomocou funkcie Merge

===Slovný opis===
====Rekurzívna verzia====
Našou úlohou je vzostupne (min - max) utriediť vstupné pole. Určíme si stred poľa (pri párnom počte prvkov je to ten menší z prostredných indexov). Následne vykonávame sériu rekurzívnych delení pre ľavú a pravú časť poľa (začiatok ... stred ; stred + 1 ... koniec) až do momentu, keď nám ostanú len jednoprvkové podpolia (tie sú už utriedené). Následne v každom volaní obe tieto podpolia zlúčime pomocou algoritmu Merge do väčších podpolí (2, 4, 8, ...), až nakoniec dostaneme jedno výsledné utriedené pole.
[[Súbor:MergeSort It.png|400px|náhľad|vpravo|Vizualizácia iteračnej verzie algoritmu MergeSort]]

====Iteračná verzia====
Vstupné pole, ktoré má ''N'' prvkov, môžeme chápať, ako ''N'' rôznych jednoprvkových (utriedených) podpolí, ktoré máme zlúčiť do jedného výsledného ''N''-prvkového utriedeného poľa. Keďže by bolo veľmi nepraktické zlučovať ''N'' podpolí naraz, zvolíme nasledovnú stratégiu: Budeme prechádzať dané pole od začiatku po koniec a v prvom cykle zlúčime každé dva prvky, takže budeme mať <math>\frac{n}{2}</math> dvojprvkových utriedených podpolí. Potom v druhom cykle zlúčime každé 4 prvky do jedného podpoľa, v treťom cykle každých 8, až do momentu, keď dostaneme jedno utriedené pole.
Aby sme to docielili, potrebujeme dva cykly, vonkajší, ktorý nastaví maximálnu veľkosť podpoľa, ktoré ideme zlučovať (1,2,4,8 ... dlzka - 1) a vnútorný, ktorý prechádza jednotlivé podpolia. Následne už iba voláme funkciu Merge, ktorá dané podpolia zlučuje.

Poznámka, ak máme pole, ktoré má nepárny počet prvkov, tak ten posledný prvok nezlúčime hneď v prvom cykle, ale až v tých ďalších. Takisto, ak n nie je mocnina čísla 2, tak musíme samozrejme ošetriť situáciu, kedy by sme sa dostali mimo rozsah poľa (Ak máme napríklad pole, čo má 7 prvkov, tak po prvej iterácii budú prvky utiredené podľa vzoru 2 + 2 + 2 + 1, po druhej 4 + 3, a po tretej 7)

===Pseudokód===
====Rekurzívna verzia====
Nech nech má funkcia MergeSort nasledovný prototyp: <code>MergeSort(pole[], lavy, pravy) </code>
:1. Je <code>lavy >= pravy</code> ? Ak áno, skonči volanie, inak pokračuj krokom 2.
:2. Nech: <code>stred = lavy + (pravy - lavy) / 2</code>, pričom znak ''/'' vyjadruje celočíselné delenie.
:3. Rekurzívne zavolaj funkciu <code>MergeSort(pole[], lavy , stred)</code>
:3. Rekurzívne zavolaj funkciu <code>MergeSort(pole[], stred + 1 , pravy)</code>
:4. Zavolaj funkciu <code>Merge(pole[], lavy, stred, pravy)</code>
:5. Skonči volanie.

====Iteračná verzia====
Nech nech má funkcia MergeSort nasledovný prototyp: <code>MergeSort(pole[], lavy, pravy) </code>
:1. Je <code>lavy >= pravy</code> ? Ak áno, skonči, inak pokračuj krokom 2.
:2. Nech: <code>dlzka_subzoznamu = 1 </code>
:3. Nech: <code>zaciatok = lavy</code>
:4. Je<code>dlzka_subzoznamu <= pravy</code> ? Ak áno pokračuj krokom 4.1, inak skonči.
:::4.1. Je<code>zaciatok < pravy</code> Ak áno pokračuj krokom 4.1.1, inak skoč na krok 4.2.
:::::4.1.1. Je <code>zaciatok + 2 * dlzka_zoznamu - 1 <= pravy</code> ?
:::::::Ak áno:
:::::::::4.1.1.1. Nech <code>koniec = zaciatok + 2 * dlzka_zoznamu - 1</code>
:::::::Ak nie:
:::::::::4.1.1.1. Nech <code>koniec = pravy</code>
:::::4.1.2. Je <code>zaciatok + dlzka_zoznamu - 1 <= pravy</code> ?
:::::::Ak áno:
:::::::::4.1.2.1. Nech <code>stred = zaciatok + dlzka_zoznamu - 1</code>
:::::::Ak nie:
:::::::::4.1.2.1. Nech <code>stred = pravy</code>
:::::4.1.3. <code>Merge(pole[], zaciatok, stred, koniec)</code>
:::::4.1.4. <code>zaciatok += 2 * dlzka_subzoznamu</code>
:::::4.1.5. Skoč na krok 4.1.
:::4.2. <code>dlzka_subzoznamu *= 2</code>
:::4.3 Skoč na krok 4.

==Implementácia algoritmov Merge a MergeSort==
===Rekurzívna verzia algoritmov===

<tabs>
<tab name="C" block>
<syntaxhighlight lang="C">
#include <stdio.h>
#include <stdlib.h>

void Merge(int pole[], int lavy, int stred, int pravy);
void MergeSort(int pole[], int lavy, int pravy);

/* hlavný program */

int main()
{
int pole[] = {12, 11, 13, 5, 6, 7};
int dlzka_pola = sizeof(pole) / sizeof(pole[0]);

printf("Pôvodné pole: \n");

for (int i = 0; i < dlzka_pola; ++i)
{
printf("%d ", pole[i]);
}

MergeSort(pole, 0, dlzka_pola - 1);

printf("\nUtriedené pole: \n");

for (int i = 0; i < dlzka_pola; ++i)
{
printf("%d ", pole[i]);
}

return 0;
}

void Merge(int pole[], int lavy, int stred, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči */

if (lavy >= pravy)
{
return;
}

/* vyrátaj dĺžky oboch polovíc poľa */

int L_dlzka = stred - lavy + 1;
int P_dlzka = pravy - stred;

/* alokuj dočasné polia, kam uložíš prvky z oboch polovíc poľa */

int *L = (int*)malloc(L_dlzka * sizeof(int));
int *P = (int*)malloc(P_dlzka * sizeof(int));

/* indexy, ktorými iterujeme všetky polia: i pre L, j pre P, k pre pole */

int i, j, k;

/* skopíruj obsah oboch polovíc poľa do dočasných polí L a P */

for (i = 0; i < L_dlzka; ++i)
{
L[i] = pole[lavy + i];
}

for (j = 0; j < P_dlzka; ++j)
{
P[j] = pole[stred + 1 + j];
}

/* nastav indexy na začiatok daných polí */

i = 0; j = 0; k = lavy;

/* zlučuj dočasné polia L a P do finálneho poľa pole */

while(i < L_dlzka && j < P_dlzka)
{
if(L[i] <= P[j])
{
pole[k++] = L[i++];
}
else
{
pole[k++] = P[j++];
}
}

/* ak ostali nejaké prvky v dočasnom poli L, skopíruj ich do finálneho poľa */

while(i < L_dlzka)
{
pole[k++] = L[i++];
}

/* ak ostali nejaké prvky v dočasnom poli P, skopíruj ich do finálneho poľa */

while(j < P_dlzka)
{
pole[k++] = P[j++];
}

/* uvoľni použitú pamäť */

free(L);
free(P);
}

void MergeSort(int pole[], int lavy, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči volanie */

if(lavy >= pravy)
{
return;
}
/* urči si prostredný index */

int stred = lavy + (pravy - lavy) / 2;

/* utrieď ľavú polovicu poľa */

MergeSort(pole, lavy, stred);

/* utrieď pravú polovicu poľa */

MergeSort(pole, stred+1, pravy);

/* zlúč obe polovice dokopy */

Merge(pole, lavy, stred, pravy);
}
</syntaxhighlight>
</tab>

<tab name="C++" block>
<syntaxhighlight lang="C++">
#include <iostream>

using std::cout;
using std::endl;

void Merge(int pole[], int lavy, int stred, int pravy);
void MergeSort(int pole[], int lavy, int pravy);

/* hlavný program */

int main()
{
int pole[] = {12, 11, 13, 5, 6, 7};
int dlzka_pola = sizeof(pole) / sizeof(pole[0]);

printf("Pôvodné pole: \n");

for (auto i: pole)
{
cout<<i<<" ";
}

MergeSort(pole, 0, dlzka_pola - 1);

cout<<endl<<"Utriedené pole:"<<endl;

for (auto i: pole)
{
cout<<i<<" ";
}

return 0;
}

void Merge(int pole[], int lavy, int stred, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči */

if (lavy >= pravy)
{
return;
}

/* vyrátaj dĺžky oboch polovíc poľa */

int L_dlzka = stred - lavy + 1;
int P_dlzka = pravy - stred;

/* alokuj dočasné polia, kam uložíš prvky z oboch polovíc poľa */

int *L = new int[L_dlzka];
int *P = new int[P_dlzka];

/* indexy, ktorými iterujeme všetky polia: i pre L, j pre P, k pre pole */

int i, j, k;

/* skopíruj obsah oboch polovíc poľa do dočasných polí L a P */

for (i = 0; i < L_dlzka; ++i)
{
L[i] = pole[lavy + i];
}

for (j = 0; j < P_dlzka; ++j)
{
P[j] = pole[stred + 1 + j];
}

/* nastav indexy na začiatok daných polí */

i = 0; j = 0; k = lavy;

/* zlučuj dočasné polia L a P do finálneho poľa pole */

while(i < L_dlzka && j < P_dlzka)
{
if(L[i] <= P[j])
{
pole[k++] = L[i++];
}
else
{
pole[k++] = P[j++];
}
}

/* ak ostali nejaké prvky v dočasnom poli L, skopíruj ich do finálneho poľa */

while(i < L_dlzka)
{
pole[k++] = L[i++];
}

/* ak ostali nejaké prvky v dočasnom poli P, skopíruj ich do finálneho poľa */

while(j < P_dlzka)
{
pole[k++] = P[j++];
}

/* uvoľni použitú pamäť */

delete []L;
delete []P;
}

void MergeSort(int pole[], int lavy, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči volanie */

if(lavy >= pravy)
{
return;
}
/* urči si prostredný index */

int stred = lavy + (pravy - lavy) / 2;

/* utrieď ľavú polovicu poľa */

MergeSort(pole, lavy, stred);

/* utrieď pravú polovicu poľa */

MergeSort(pole, stred+1, pravy);

/* zlúč obe polovice dokopy */

Merge(pole, lavy, stred, pravy);
}

</syntaxhighlight>
</tab>

<tab name="Java" block>
<syntaxhighlight lang="Java">
class MergeSort {
/* Zlúči 2 subpolia, ktoré sa vytvorili z pôvodného pola.
* Každé subpole má polovičnú dĺžku pôvodného pola.
* subpole1 [ľavý..stred]
* subpole2 [stred+1..pravý] */
void merge(int[] pole, int lavy, int stred, int pravy) {
// Výpočet dĺžky 2 subpolí
int n1 = stred - lavy + 1;
int n2 = pravy - stred;

// Vytvorenie pomocných polí
int[] L = new int[n1];
int[] P = new int[n2];

// Načítanie dát do pomocných polí
for (int i = 0; i < n1; i++)
L[i] = pole[lavy + i];

for (int j = 0; j < n2; j++)
P[j] = pole[stred + 1 + j];

// Počiatočné indexy prvého a druhého subpola
int i = 0, j = 0;
// Počiatočný index zlúčeného subpola
int k = lavy;

// Zlúčenie dvoch podpolí
while (i < n1 && j < n2) {
if (L[i] <= P[j]) {
pole[k] = L[i];
i++;
}
else {
pole[k] = P[j];
j++;
}
k++;
}

/* V prípade, že v jednom zo subpolí sa nachádzajú prvky, ktoré neboli zlúčené do pola,
* tak sa do pola jednoducho skopírujú */
while (i < n1) {
pole[k] = L[i];
i++;
k++;
}

while (j < n2) {
pole[k] = P[j];
k++;
j++;
}
}

/* Funkcia, ktorá zoradí pole použitím funkcie merge() */
void sort (int[] pole, int lavy, int pravy) {
if (lavy < pravy) {
//Musíme nájsť stred pola
int stred = lavy + (pravy - lavy) / 2;

// Zoradíme prvú a druhú polovicu pola samostatne
sort(pole, lavy, stred);
sort(pole, stred + 1, pravy);

// Zlúčime zoradené polovice do jedného pola
merge(pole, lavy, stred, pravy);
}
}
}

public class Main {
/* Funkcia na výpis pola dĺžky n */
static void vypis_pole(int[] pole) {
int n = pole.length;

for (int i = 0; i < n; i++) {
System.out.print(pole[i] + " ");
}
System.out.println();
}

/* Hlavný program */
public static void main(String[] args) {
int[] pole = {12, 11, 13, 5, 6, 7};

System.out.println("Zadané pole:");
vypis_pole(pole);

MergeSort ms = new MergeSort();
ms.sort(pole, 0, pole.length - 1);

System.out.println("\nZoradené pole:");
vypis_pole(pole);
}
}
</syntaxhighlight>
</tab>

<tab name="Python3" block>
<syntaxhighlight lang="Python3">
def MergeSort(pole):
if len(pole) > 1:
# Nájdenie stredu pola
# zápis len(pole)//2 znamená, že dĺžka pola sa vydelí 2 a výsledok je celé číslo
stred = len(pole) // 2

# Rozdelenie pola na dve časti
L = pole[:stred]
P = pole[stred:]

# Zoradenie najskôr prvej časti pola, potom druhej
MergeSort(L)
MergeSort(P)

i = j = k = 0

# Načítanie dát do pomocných polí L[] a P[]
while i < len(L) and j < len(P):
if L[i] < P[j]:
pole[k] = L[i]
i += 1
else:
pole[k] = P[j]
j += 1
k += 1

# Kontrola či všetky prvky boli zlúčené dokopy,
# ak nie, tak sa do zlúčeného pola jednoducho skopírujú
while i < len(L):
pole[k] = L[i]
i += 1
k += 1

while j < len(P):
pole[k] = P[j]
j += 1
k += 1

# Kód na výpis pola
def vypis_pole(pole):
for i in range(len(pole)):
print(pole[i], end=" ")
print()

# Hlavný program
if __name__ == '__main__':
pole = [12, 11, 13, 5, 6, 7]
print("Zadané pole:", end="\n")
vypis_pole(pole)
MergeSort(pole)
print("Zoradené pole:", end="\n")
vypis_pole(pole)
</syntaxhighlight>
</tab>
</tabs>

===Iteračná verzia algoritmov===

<tabs>
<tab name="C" block>
<syntaxhighlight lang="C">
#include <stdio.h>
#include <stdlib.h>

void Merge(int pole[], int lavy, int stred, int pravy);
void MergeSortIt(int *pole, int lavy, int pravy);

/* hlavný program */

int main()
{
int pole[] = {12, 11, 13, 5, 6, 7, 19};
int dlzka_pola = sizeof(pole) / sizeof(pole[0]);

printf("Pôvodné pole %d: \n", dlzka_pola);

for (int i = 0; i < dlzka_pola; ++i)
{
printf("%d ", pole[i]);
}

MergeSortIt(pole, 0, dlzka_pola - 1);

printf("\nUtriedené pole: \n");

for (int i = 0; i < dlzka_pola; ++i)
{
printf("%d ", pole[i]);
}

return 0;
}

void Merge(int pole[], int lavy, int stred, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči */

if (lavy >= pravy)
{
return;
}

/* vyrátaj dĺžky oboch polovíc poľa */

int L_dlzka = stred - lavy + 1;
int P_dlzka = pravy - stred;

/* alokuj dočasné polia, kam uložíš prvky z oboch polovíc poľa */

int *L = (int*)malloc(L_dlzka * sizeof(int));
int *P = (int*)malloc(P_dlzka * sizeof(int));

/* indexy, ktorými iterujeme všetky polia: i pre L, j pre P, k pre pole */

int i, j, k;

/* skopíruj obsah oboch polovíc poľa do dočasných polí L a P */

for (i = 0; i < L_dlzka; ++i)
{
L[i] = pole[lavy + i];
}

for (j = 0; j < P_dlzka; ++j)
{
P[j] = pole[stred + 1 + j];
}

/* nastav indexy na začiatok daných polí */

i = 0; j = 0; k = lavy;

/* zlučuj dočasné polia L a P do finálneho poľa pole */

while(i < L_dlzka && j < P_dlzka)
{
if(L[i] <= P[j])
{
pole[k++] = L[i++];
}
else
{
pole[k++] = P[j++];
}
}

/* ak ostali nejaké prvky v dočasnom poli L, skopíruj ich do finálneho poľa */

while(i < L_dlzka)
{
pole[k++] = L[i++];
}

/* ak ostali nejaké prvky v dočasnom poli P, skopíruj ich do finálneho poľa */

while(j < P_dlzka)
{
pole[k++] = P[j++];
}

/* uvoľni použitú pamäť */

free(L);
free(P);
}

void MergeSortIt(int *pole, int lavy, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči volanie */

if(lavy >= pravy)
{
return;
}

int stred, koniec;

for (int dlzka_zoznamu = 1; dlzka_zoznamu <= pravy ; dlzka_zoznamu *= 2)
{
for (int zaciatok = lavy; zaciatok < pravy ; zaciatok += 2 * dlzka_zoznamu)
{
koniec = (zaciatok + 2 * dlzka_zoznamu - 1 <= pravy) ? zaciatok + 2 * dlzka_zoznamu - 1 : pravy;

stred = (zaciatok + dlzka_zoznamu - 1 <= pravy) ? zaciatok + dlzka_zoznamu - 1 : pravy;

Merge(pole, zaciatok, stred, koniec);

}
}
}

</syntaxhighlight>
</tab>

<tab name="C++" block>
<syntaxhighlight lang="C++">
#include <iostream>

using std::cout;
using std::endl;

void Merge(int pole[], int lavy, int stred, int pravy);
void MergeSort(int pole[], int lavy, int pravy);

/* hlavný program */

int main()
{
int pole[] = {12, 11, 13, 5, 6, 7};
int dlzka_pola = sizeof(pole) / sizeof(pole[0]);

printf("Pôvodné pole: \n");

for (auto i: pole)
{
cout<<i<<" ";
}

MergeSort(pole, 0, dlzka_pola - 1);

cout<<endl<<"Utriedené pole:"<<endl;

for (auto i: pole)
{
cout<<i<<" ";
}

return 0;
}

void Merge(int pole[], int lavy, int stred, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči */

if (lavy >= pravy)
{
return;
}

/* vyrátaj dĺžky oboch polovíc poľa */

int L_dlzka = stred - lavy + 1;
int P_dlzka = pravy - stred;

/* alokuj dočasné polia, kam uložíš prvky z oboch polovíc poľa */

int *L = new int[L_dlzka];
int *P = new int[P_dlzka];

/* indexy, ktorými iterujeme všetky polia: i pre L, j pre P, k pre pole */

int i, j, k;

/* skopíruj obsah oboch polovíc poľa do dočasných polí L a P */

for (i = 0; i < L_dlzka; ++i)
{
L[i] = pole[lavy + i];
}

for (j = 0; j < P_dlzka; ++j)
{
P[j] = pole[stred + 1 + j];
}

/* nastav indexy na začiatok daných polí */

i = 0; j = 0; k = lavy;

/* zlučuj dočasné polia L a P do finálneho poľa pole */

while(i < L_dlzka && j < P_dlzka)
{
if(L[i] <= P[j])
{
pole[k++] = L[i++];
}
else
{
pole[k++] = P[j++];
}
}

/* ak ostali nejaké prvky v dočasnom poli L, skopíruj ich do finálneho poľa */

while(i < L_dlzka)
{
pole[k++] = L[i++];
}

/* ak ostali nejaké prvky v dočasnom poli P, skopíruj ich do finálneho poľa */

while(j < P_dlzka)
{
pole[k++] = P[j++];
}

/* uvoľni použitú pamäť */

delete []L;
delete []P;
}

void MergeSort(int *pole, int lavy, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči volanie */

if(lavy >= pravy)
{
return;
}

int stred, koniec;

for (int dlzka_zoznamu = 1; dlzka_zoznamu <= pravy; dlzka_zoznamu *= 2)
{
for (int zaciatok = lavy; zaciatok < pravy; zaciatok += 2 * dlzka_zoznamu)
{
koniec = (zaciatok + 2 * dlzka_zoznamu - 1 <= pravy) ? zaciatok + 2 * dlzka_zoznamu - 1 : pravy;

stred = (zaciatok + dlzka_zoznamu - 1 <= pravy) ? zaciatok + dlzka_zoznamu - 1 : pravy;

Merge(pole, zaciatok, stred, koniec);
}
}
}
</syntaxhighlight>
</tab>
</tabs>

==Odkazy==
# https://www.geeksforgeeks.org/merge-sort/
# https://www.geeksforgeeks.org/iterative-merge-sort/
# https://medium.com/@paulsoham/merge-sort-63d75df76388
# https://www.khanacademy.org/computing/computer-science/algorithms/merge-sort/a/overview-of-merge-sort
# https://www.tutorialspoint.com/data_structures_algorithms/merge_sort_algorithm.htm
# https://www.youtube.com/watch?v=6pV2IF0fgKY
# https://www.youtube.com/watch?v=mB5HXBb_HY8
# https://www.youtube.com/watch?v=ak-pz7tS5DE

Triedenie zlučovaním

2021-03-28T15:56:04Z

Filip Tomek: /* Merge sort */

[[Kategória:Algoritmy triedenia]]
{{Draft}}
{{Skripta programovanie}}
__TOC__
==TODO: Pseudokód treba opraviť, text refaktorovať, otestovať kódy, zvýrazniť veci v texte, opraviť preklepy, opraviť popis obrázkov, pridať nové odkazy==

==Zlučovací algoritmus Merge==

Princíp zlučovania tkvie v tom, že máme dva alebo viac utriedených zoznamov, ktoré skombinuje do jedného utriedeného zoznamu (výsledný zoznam musí obsahovať všetky prvky z pôvodných zoznamov). Zoznam môže byť reprezentovaný ako dátová štruktúra pole alebo aj ako lineárny zoznam. V tomto článku sa zameriame na algoritmus pre dátovú štruktúru pole.

Algoritmus Merge tvorí kľúčovú časť triediaceho algoritmu MergeSort.

[[Súbor:Funkcia merge.png|500px|náhľad|vpravo|Vizualizácia funkcie Merge: Máme pole prvkov p = [1, 3, 5, 2, 4, 6], ktoré je už čiastočne utriedené. Použijeme algoritmus Merge, ktorý si vytvorí pomocné polia L = [1, 3, 5] a P = [2, 4, 6]. Všetky polia indexujeme od 0, pričom pre pole p používame index k, pre L index i a pre P index j. Postupnosť krokov je označená číslicami 1 až 6.
]]

===Slovný opis algoritmu===
Nech máme pole, ktoré sa skladá z dvoch už utriedených polovíc. Vytvoríme si dve pomocné polia L a P a do každého z nich skopírujeme obsah jednej polovice (L - ľavá polovica, P - pravá polovica). Potom súčasne prechádzame polia L a P od začiatku po koniec, pričom v každom cykle porovnáme prvok poľa L s prvkom v poli P. Z tejto dvojice následne vyberieme minimum, (keď triedime od najmenšieho po najväčší) ktoré vložíme na prvú voľnú pozíciu pôvodného poľa (na začiatku je to prvá pozícia poľa). Nakoniec zvýšime index pri vstupnom poli a pri pomocnom poli, z ktorého vyberáme daný prvok. Túto postupnosť krokov opakujeme, pokiaľ neprídeme na koniec jedného z polí P a L. Ak nastane situácia, že prídeme na koniec jedného z pomocných polí (a v druhom nám ostali ešte nejaké prvky), potom už iba naspäť skopírujeme zbytok druhého pomocného poľa na koniec pôvodného poľa.

===Vlastnosti algoritmu===
* vhodný pre dátové štruktúry: pole, lineárny zoznam
* časová náročnosť: vždy lineárna <math>O(n)</math>
* priestorová náročnosť: lineárna <math>O(n)</math> pre pole (alokovanie pomocných polí), <math>O(1)</math> pre lineárny zoznam (pri LZ netreba alokovať dočasné polia, stačí iba presmerovať smerníky)
* využitie: kľúčový podprogram pre triediaci algoritmus MergeSort

===Pseudokód===
Nech funkcia Merge má nasledovný prototyp: <code>Merge(pole[], lavy, stred, pravy)</code>
:1. Je <code>lavy >= pravy ? Ak áno, skonči, inak pokračuj krokom 2.</code>
:2. Nech: <code>i = 0, j = 0, k = lavy </code>
:3. Nech: <code>dlzka_L = stred - lavy + 1, dlzka_P = pravy - stred</code>
:4. Nech: <code> L = pole[lavy ... stred], P = pole[stred + 1 ... pravy] </code>
:5. Je <code>i < dlzka_L</code> a zároveň <code>j < dlzka_P</code> ? Ak áno, pokračuj krokom 5.1., inak skoč na krok 6.
:::5.1. Je <code>L[i] <= P[j]</code>?
:::: Ak áno:
:::::5.1.1. <code>pole[k] = L[i]</code>
:::::5.1.2. <code>k += 1</code>
:::::5.1.3. <code>i += 1</code>
:::::5.1.4. Skoč na krok 5.
:::: Ak nie:
:::::5.1.1. <code>pole[k] = P[j]</code>
:::::5.1.2. <code>k += 1</code>
:::::5.1.3. <code>j += 1</code>
:::::5.1.4. Skoč na krok 5.
:6. Je <code>i < dlzka_L</code> ? Ak áno, pokračuj krokom 6.1., inak skoč na krok 7.
:::6.1. <code>pole[k] = L[i]</code>
:::6.2. <code>k += 1</code>
:::6.3. <code>i += 1</code>
:::6.4. Skoč na krok 6.
:7. Je <code>j < dlzka_P</code> ? Ak áno, pokračuj krokom 7.1., inak skonči.
:::7.1. <code>pole[k] = P[j]</code>
:::7.2. <code>k += 1</code>
:::7.3. <code>j += 1</code>
:::7.4. Skoč na krok 7.

==Merge sort==
Merge Sort je triediaci algoritmus, ktorý využíva stratégiu '''"rozdeľuj a panuj"''', čo znamená, že vstupný zoznam najskôr rozdelí na dve polovice, tie zoradí a potom ich zlúči naspäť dokopy. Radí sa medzi najpoužívanejšie a najviac rešpektované triediace algoritmy.

Z hľadiska implementácie môžeme vytvoriť dve základné verzie algoritmu, a to rekurzívnu a iteračnú.

===Vlastnosti algoritmu Merge Sort===
* vhodný pre dátové štruktúry: pole, lineárny zoznam
* časová náročnosť: vždy linearitmická <math> O(n.log(n)) </math>, vďaka ktorej dokáže efektívne triediť veľmi veľké zoznamy
* priestorová náročnosť: lineárna <math>O(n)</math> pre pole (alokovanie dočasných polí), konštantná <math>O(1)</math> pre lineárny zoznam (pri LZ stačí iba presmerovať smerníky)
* druh triedenia: triedenie zlučovaním (komparačný algoritmus)
* stabilita triedenia: stabilný
* miesto triedenia: externé triedenie (vhodný na triedenie veľkých objemov dát uložených na disku)

===Princíp algoritmu===
====Rekurzívna verzia====
Algoritmus MergeSort vykonáva 4 základné úlohy:
# Delenie poľa na dve polovice.
# Triedenie ľavej polovice poľa.
# Triedenie pravej polovice poľa.
# Zlúčenie oboch polovíc pomocou funkcie Merge.

====Iteračná verzia====
Algoritmus Merge vykonáva 3 základné úlohy:
# Vonkajší cyklus: určenie veľkosti zoznamu na zlučovanie
# Vnútorný cyklus: prechádzanie jednotlivých zoznamov v poli
# Zlučovanie jednotlivých zoznamov pomocou funkcie Merge

===Slovný opis===
====Rekurzívna verzia====
[[Súbor:Merge sort.png|400px|náhľad|vpravo|Vizualizácia rekurzívnej verzie algoritmu MergeSort]]
Našou úlohou je vzostupne (min - max) utriediť vstupné pole. Určíme si stred poľa (pri párnom počte prvkov je to ten menší z prostredných indexov). Následne vykonávame sériu rekurzívnych delení pre ľavú a pravú časť poľa (začiatok ... stred ; stred + 1 ... koniec) až do momentu, keď nám ostanú len jednoprvkové podpolia (tie sú už utriedené). Následne v každom volaní obe tieto podpolia zlúčime pomocou algoritmu Merge do väčších podpolí (2, 4, 8, ...), až nakoniec dostaneme jedno výsledné utriedené pole.

====Iteračná verzia====
[[Súbor:MergeSort It.png|400px|náhľad|vpravo|Vizualizácia iteračnej verzie algoritmu MergeSort]]
Vstupné pole, ktoré má ''N'' prvkov, môžeme chápať, ako ''N'' rôznych jednoprvkových (utriedených) podpolí, ktoré máme zlúčiť do jedného výsledného ''N''-prvkového utriedeného poľa. Keďže by bolo veľmi nepraktické zlučovať ''N'' podpolí naraz, zvolíme nasledovnú stratégiu: Budeme prechádzať dané pole od začiatku po koniec a v prvom cykle zlúčime každé dva prvky, takže budeme mať <math>\frac{n}{2}</math> dvojprvkových utriedených podpolí. Potom v druhom cykle zlúčime každé 4 prvky do jedného podpoľa, v treťom cykle každých 8, až do momentu, keď dostaneme jedno utriedené pole.
Aby sme to docielili, potrebujeme dva cykly, vonkajší, ktorý nastaví maximálnu veľkosť podpoľa, ktoré ideme zlučovať (1,2,4,8 ... dlzka - 1) a vnútorný, ktorý prechádza jednotlivé podpolia. Následne už iba voláme funkciu Merge, ktorá dané podpolia zlučuje.

Poznámka, ak máme pole, ktoré má nepárny počet prvkov, tak ten posledný prvok nezlúčime hneď v prvom cykle, ale až v tých ďalších. Takisto, ak n nie je mocnina čísla 2, tak musíme samozrejme ošetriť situáciu, kedy by sme sa dostali mimo rozsah poľa (Ak máme napríklad pole, čo má 7 prvkov, tak po prvej iterácii budú prvky utiredené podľa vzoru 2 + 2 + 2 + 1, po druhej 4 + 3, a po tretej 7)

===Pseudokód===
====Rekurzívna verzia====
Nech nech má funkcia MergeSort nasledovný prototyp: <code>MergeSort(pole[], lavy, pravy) </code>
:1. Je <code>lavy >= pravy</code> ? Ak áno, skonči volanie, inak pokračuj krokom 2.
:2. Nech: <code>stred = lavy + (pravy - lavy) / 2</code>, pričom znak ''/'' vyjadruje celočíselné delenie.
:3. Rekurzívne zavolaj funkciu <code>MergeSort(pole[], lavy , stred)</code>
:3. Rekurzívne zavolaj funkciu <code>MergeSort(pole[], stred + 1 , pravy)</code>
:4. Zavolaj funkciu <code>Merge(pole[], lavy, stred, pravy)</code>
:5. Skonči volanie.

====Iteračná verzia====
Nech nech má funkcia MergeSort nasledovný prototyp: <code>MergeSort(pole[], lavy, pravy) </code>
:1. Je <code>lavy >= pravy</code> ? Ak áno, skonči, inak pokračuj krokom 2.
:2. Nech: <code>dlzka_subzoznamu = 1 </code>
:3. Nech: <code>zaciatok = lavy</code>
:4. Je<code>dlzka_subzoznamu <= pravy</code> ? Ak áno pokračuj krokom 4.1, inak skonči.
:::4.1. Je<code>zaciatok < pravy</code> Ak áno pokračuj krokom 4.1.1, inak skoč na krok 4.2.
:::::4.1.1. Je <code>zaciatok + 2 * dlzka_zoznamu - 1 <= pravy</code> ?
:::::::Ak áno:
:::::::::4.1.1.1. Nech <code>koniec = zaciatok + 2 * dlzka_zoznamu - 1</code>
:::::::Ak nie:
:::::::::4.1.1.1. Nech <code>koniec = pravy</code>
:::::4.1.2. Je <code>zaciatok + dlzka_zoznamu - 1 <= pravy</code> ?
:::::::Ak áno:
:::::::::4.1.2.1. Nech <code>stred = zaciatok + dlzka_zoznamu - 1</code>
:::::::Ak nie:
:::::::::4.1.2.1. Nech <code>stred = pravy</code>
:::::4.1.3. <code>Merge(pole[], zaciatok, stred, koniec)</code>
:::::4.1.4. <code>zaciatok += 2 * dlzka_subzoznamu</code>
:::::4.1.5. Skoč na krok 4.1.
:::4.2. <code>dlzka_subzoznamu *= 2</code>
:::4.3 Skoč na krok 4.

==Implementácia algoritmov Merge a MergeSort==
===Rekurzívna verzia algoritmov===

<tabs>
<tab name="C" block>
<syntaxhighlight lang="C">
#include <stdio.h>
#include <stdlib.h>

void Merge(int pole[], int lavy, int stred, int pravy);
void MergeSort(int pole[], int lavy, int pravy);

/* hlavný program */

int main()
{
int pole[] = {12, 11, 13, 5, 6, 7};
int dlzka_pola = sizeof(pole) / sizeof(pole[0]);

printf("Pôvodné pole: \n");

for (int i = 0; i < dlzka_pola; ++i)
{
printf("%d ", pole[i]);
}

MergeSort(pole, 0, dlzka_pola - 1);

printf("\nUtriedené pole: \n");

for (int i = 0; i < dlzka_pola; ++i)
{
printf("%d ", pole[i]);
}

return 0;
}

void Merge(int pole[], int lavy, int stred, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči */

if (lavy >= pravy)
{
return;
}

/* vyrátaj dĺžky oboch polovíc poľa */

int L_dlzka = stred - lavy + 1;
int P_dlzka = pravy - stred;

/* alokuj dočasné polia, kam uložíš prvky z oboch polovíc poľa */

int *L = (int*)malloc(L_dlzka * sizeof(int));
int *P = (int*)malloc(P_dlzka * sizeof(int));

/* indexy, ktorými iterujeme všetky polia: i pre L, j pre P, k pre pole */

int i, j, k;

/* skopíruj obsah oboch polovíc poľa do dočasných polí L a P */

for (i = 0; i < L_dlzka; ++i)
{
L[i] = pole[lavy + i];
}

for (j = 0; j < P_dlzka; ++j)
{
P[j] = pole[stred + 1 + j];
}

/* nastav indexy na začiatok daných polí */

i = 0; j = 0; k = lavy;

/* zlučuj dočasné polia L a P do finálneho poľa pole */

while(i < L_dlzka && j < P_dlzka)
{
if(L[i] <= P[j])
{
pole[k++] = L[i++];
}
else
{
pole[k++] = P[j++];
}
}

/* ak ostali nejaké prvky v dočasnom poli L, skopíruj ich do finálneho poľa */

while(i < L_dlzka)
{
pole[k++] = L[i++];
}

/* ak ostali nejaké prvky v dočasnom poli P, skopíruj ich do finálneho poľa */

while(j < P_dlzka)
{
pole[k++] = P[j++];
}

/* uvoľni použitú pamäť */

free(L);
free(P);
}

void MergeSort(int pole[], int lavy, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči volanie */

if(lavy >= pravy)
{
return;
}
/* urči si prostredný index */

int stred = lavy + (pravy - lavy) / 2;

/* utrieď ľavú polovicu poľa */

MergeSort(pole, lavy, stred);

/* utrieď pravú polovicu poľa */

MergeSort(pole, stred+1, pravy);

/* zlúč obe polovice dokopy */

Merge(pole, lavy, stred, pravy);
}
</syntaxhighlight>
</tab>

<tab name="C++" block>
<syntaxhighlight lang="C++">
#include <iostream>

using std::cout;
using std::endl;

void Merge(int pole[], int lavy, int stred, int pravy);
void MergeSort(int pole[], int lavy, int pravy);

/* hlavný program */

int main()
{
int pole[] = {12, 11, 13, 5, 6, 7};
int dlzka_pola = sizeof(pole) / sizeof(pole[0]);

printf("Pôvodné pole: \n");

for (auto i: pole)
{
cout<<i<<" ";
}

MergeSort(pole, 0, dlzka_pola - 1);

cout<<endl<<"Utriedené pole:"<<endl;

for (auto i: pole)
{
cout<<i<<" ";
}

return 0;
}

void Merge(int pole[], int lavy, int stred, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči */

if (lavy >= pravy)
{
return;
}

/* vyrátaj dĺžky oboch polovíc poľa */

int L_dlzka = stred - lavy + 1;
int P_dlzka = pravy - stred;

/* alokuj dočasné polia, kam uložíš prvky z oboch polovíc poľa */

int *L = new int[L_dlzka];
int *P = new int[P_dlzka];

/* indexy, ktorými iterujeme všetky polia: i pre L, j pre P, k pre pole */

int i, j, k;

/* skopíruj obsah oboch polovíc poľa do dočasných polí L a P */

for (i = 0; i < L_dlzka; ++i)
{
L[i] = pole[lavy + i];
}

for (j = 0; j < P_dlzka; ++j)
{
P[j] = pole[stred + 1 + j];
}

/* nastav indexy na začiatok daných polí */

i = 0; j = 0; k = lavy;

/* zlučuj dočasné polia L a P do finálneho poľa pole */

while(i < L_dlzka && j < P_dlzka)
{
if(L[i] <= P[j])
{
pole[k++] = L[i++];
}
else
{
pole[k++] = P[j++];
}
}

/* ak ostali nejaké prvky v dočasnom poli L, skopíruj ich do finálneho poľa */

while(i < L_dlzka)
{
pole[k++] = L[i++];
}

/* ak ostali nejaké prvky v dočasnom poli P, skopíruj ich do finálneho poľa */

while(j < P_dlzka)
{
pole[k++] = P[j++];
}

/* uvoľni použitú pamäť */

delete []L;
delete []P;
}

void MergeSort(int pole[], int lavy, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči volanie */

if(lavy >= pravy)
{
return;
}
/* urči si prostredný index */

int stred = lavy + (pravy - lavy) / 2;

/* utrieď ľavú polovicu poľa */

MergeSort(pole, lavy, stred);

/* utrieď pravú polovicu poľa */

MergeSort(pole, stred+1, pravy);

/* zlúč obe polovice dokopy */

Merge(pole, lavy, stred, pravy);
}

</syntaxhighlight>
</tab>

<tab name="Java" block>
<syntaxhighlight lang="Java">
class MergeSort {
/* Zlúči 2 subpolia, ktoré sa vytvorili z pôvodného pola.
* Každé subpole má polovičnú dĺžku pôvodného pola.
* subpole1 [ľavý..stred]
* subpole2 [stred+1..pravý] */
void merge(int[] pole, int lavy, int stred, int pravy) {
// Výpočet dĺžky 2 subpolí
int n1 = stred - lavy + 1;
int n2 = pravy - stred;

// Vytvorenie pomocných polí
int[] L = new int[n1];
int[] P = new int[n2];

// Načítanie dát do pomocných polí
for (int i = 0; i < n1; i++)
L[i] = pole[lavy + i];

for (int j = 0; j < n2; j++)
P[j] = pole[stred + 1 + j];

// Počiatočné indexy prvého a druhého subpola
int i = 0, j = 0;
// Počiatočný index zlúčeného subpola
int k = lavy;

// Zlúčenie dvoch podpolí
while (i < n1 && j < n2) {
if (L[i] <= P[j]) {
pole[k] = L[i];
i++;
}
else {
pole[k] = P[j];
j++;
}
k++;
}

/* V prípade, že v jednom zo subpolí sa nachádzajú prvky, ktoré neboli zlúčené do pola,
* tak sa do pola jednoducho skopírujú */
while (i < n1) {
pole[k] = L[i];
i++;
k++;
}

while (j < n2) {
pole[k] = P[j];
k++;
j++;
}
}

/* Funkcia, ktorá zoradí pole použitím funkcie merge() */
void sort (int[] pole, int lavy, int pravy) {
if (lavy < pravy) {
//Musíme nájsť stred pola
int stred = lavy + (pravy - lavy) / 2;

// Zoradíme prvú a druhú polovicu pola samostatne
sort(pole, lavy, stred);
sort(pole, stred + 1, pravy);

// Zlúčime zoradené polovice do jedného pola
merge(pole, lavy, stred, pravy);
}
}
}

public class Main {
/* Funkcia na výpis pola dĺžky n */
static void vypis_pole(int[] pole) {
int n = pole.length;

for (int i = 0; i < n; i++) {
System.out.print(pole[i] + " ");
}
System.out.println();
}

/* Hlavný program */
public static void main(String[] args) {
int[] pole = {12, 11, 13, 5, 6, 7};

System.out.println("Zadané pole:");
vypis_pole(pole);

MergeSort ms = new MergeSort();
ms.sort(pole, 0, pole.length - 1);

System.out.println("\nZoradené pole:");
vypis_pole(pole);
}
}
</syntaxhighlight>
</tab>

<tab name="Python3" block>
<syntaxhighlight lang="Python3">
def MergeSort(pole):
if len(pole) > 1:
# Nájdenie stredu pola
# zápis len(pole)//2 znamená, že dĺžka pola sa vydelí 2 a výsledok je celé číslo
stred = len(pole) // 2

# Rozdelenie pola na dve časti
L = pole[:stred]
P = pole[stred:]

# Zoradenie najskôr prvej časti pola, potom druhej
MergeSort(L)
MergeSort(P)

i = j = k = 0

# Načítanie dát do pomocných polí L[] a P[]
while i < len(L) and j < len(P):
if L[i] < P[j]:
pole[k] = L[i]
i += 1
else:
pole[k] = P[j]
j += 1
k += 1

# Kontrola či všetky prvky boli zlúčené dokopy,
# ak nie, tak sa do zlúčeného pola jednoducho skopírujú
while i < len(L):
pole[k] = L[i]
i += 1
k += 1

while j < len(P):
pole[k] = P[j]
j += 1
k += 1

# Kód na výpis pola
def vypis_pole(pole):
for i in range(len(pole)):
print(pole[i], end=" ")
print()

# Hlavný program
if __name__ == '__main__':
pole = [12, 11, 13, 5, 6, 7]
print("Zadané pole:", end="\n")
vypis_pole(pole)
MergeSort(pole)
print("Zoradené pole:", end="\n")
vypis_pole(pole)
</syntaxhighlight>
</tab>
</tabs>

===Iteračná verzia algoritmov===

<tabs>
<tab name="C" block>
<syntaxhighlight lang="C">
#include <stdio.h>
#include <stdlib.h>

void Merge(int pole[], int lavy, int stred, int pravy);
void MergeSortIt(int *pole, int lavy, int pravy);

/* hlavný program */

int main()
{
int pole[] = {12, 11, 13, 5, 6, 7, 19};
int dlzka_pola = sizeof(pole) / sizeof(pole[0]);

printf("Pôvodné pole %d: \n", dlzka_pola);

for (int i = 0; i < dlzka_pola; ++i)
{
printf("%d ", pole[i]);
}

MergeSortIt(pole, 0, dlzka_pola - 1);

printf("\nUtriedené pole: \n");

for (int i = 0; i < dlzka_pola; ++i)
{
printf("%d ", pole[i]);
}

return 0;
}

void Merge(int pole[], int lavy, int stred, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči */

if (lavy >= pravy)
{
return;
}

/* vyrátaj dĺžky oboch polovíc poľa */

int L_dlzka = stred - lavy + 1;
int P_dlzka = pravy - stred;

/* alokuj dočasné polia, kam uložíš prvky z oboch polovíc poľa */

int *L = (int*)malloc(L_dlzka * sizeof(int));
int *P = (int*)malloc(P_dlzka * sizeof(int));

/* indexy, ktorými iterujeme všetky polia: i pre L, j pre P, k pre pole */

int i, j, k;

/* skopíruj obsah oboch polovíc poľa do dočasných polí L a P */

for (i = 0; i < L_dlzka; ++i)
{
L[i] = pole[lavy + i];
}

for (j = 0; j < P_dlzka; ++j)
{
P[j] = pole[stred + 1 + j];
}

/* nastav indexy na začiatok daných polí */

i = 0; j = 0; k = lavy;

/* zlučuj dočasné polia L a P do finálneho poľa pole */

while(i < L_dlzka && j < P_dlzka)
{
if(L[i] <= P[j])
{
pole[k++] = L[i++];
}
else
{
pole[k++] = P[j++];
}
}

/* ak ostali nejaké prvky v dočasnom poli L, skopíruj ich do finálneho poľa */

while(i < L_dlzka)
{
pole[k++] = L[i++];
}

/* ak ostali nejaké prvky v dočasnom poli P, skopíruj ich do finálneho poľa */

while(j < P_dlzka)
{
pole[k++] = P[j++];
}

/* uvoľni použitú pamäť */

free(L);
free(P);
}

void MergeSortIt(int *pole, int lavy, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči volanie */

if(lavy >= pravy)
{
return;
}

int stred, koniec;

for (int dlzka_zoznamu = 1; dlzka_zoznamu <= pravy ; dlzka_zoznamu *= 2)
{
for (int zaciatok = lavy; zaciatok < pravy ; zaciatok += 2 * dlzka_zoznamu)
{
koniec = (zaciatok + 2 * dlzka_zoznamu - 1 <= pravy) ? zaciatok + 2 * dlzka_zoznamu - 1 : pravy;

stred = (zaciatok + dlzka_zoznamu - 1 <= pravy) ? zaciatok + dlzka_zoznamu - 1 : pravy;

Merge(pole, zaciatok, stred, koniec);

}
}
}

</syntaxhighlight>
</tab>

<tab name="C++" block>
<syntaxhighlight lang="C++">
#include <iostream>

using std::cout;
using std::endl;

void Merge(int pole[], int lavy, int stred, int pravy);
void MergeSort(int pole[], int lavy, int pravy);

/* hlavný program */

int main()
{
int pole[] = {12, 11, 13, 5, 6, 7};
int dlzka_pola = sizeof(pole) / sizeof(pole[0]);

printf("Pôvodné pole: \n");

for (auto i: pole)
{
cout<<i<<" ";
}

MergeSort(pole, 0, dlzka_pola - 1);

cout<<endl<<"Utriedené pole:"<<endl;

for (auto i: pole)
{
cout<<i<<" ";
}

return 0;
}

void Merge(int pole[], int lavy, int stred, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči */

if (lavy >= pravy)
{
return;
}

/* vyrátaj dĺžky oboch polovíc poľa */

int L_dlzka = stred - lavy + 1;
int P_dlzka = pravy - stred;

/* alokuj dočasné polia, kam uložíš prvky z oboch polovíc poľa */

int *L = new int[L_dlzka];
int *P = new int[P_dlzka];

/* indexy, ktorými iterujeme všetky polia: i pre L, j pre P, k pre pole */

int i, j, k;

/* skopíruj obsah oboch polovíc poľa do dočasných polí L a P */

for (i = 0; i < L_dlzka; ++i)
{
L[i] = pole[lavy + i];
}

for (j = 0; j < P_dlzka; ++j)
{
P[j] = pole[stred + 1 + j];
}

/* nastav indexy na začiatok daných polí */

i = 0; j = 0; k = lavy;

/* zlučuj dočasné polia L a P do finálneho poľa pole */

while(i < L_dlzka && j < P_dlzka)
{
if(L[i] <= P[j])
{
pole[k++] = L[i++];
}
else
{
pole[k++] = P[j++];
}
}

/* ak ostali nejaké prvky v dočasnom poli L, skopíruj ich do finálneho poľa */

while(i < L_dlzka)
{
pole[k++] = L[i++];
}

/* ak ostali nejaké prvky v dočasnom poli P, skopíruj ich do finálneho poľa */

while(j < P_dlzka)
{
pole[k++] = P[j++];
}

/* uvoľni použitú pamäť */

delete []L;
delete []P;
}

void MergeSort(int *pole, int lavy, int pravy)
{
/* ak má pole menej ako 2 prvky, skonči volanie */

if(lavy >= pravy)
{
return;
}

int stred, koniec;

for (int dlzka_zoznamu = 1; dlzka_zoznamu <= pravy; dlzka_zoznamu *= 2)
{
for (int zaciatok = lavy; zaciatok < pravy; zaciatok += 2 * dlzka_zoznamu)
{
koniec = (zaciatok + 2 * dlzka_zoznamu - 1 <= pravy) ? zaciatok + 2 * dlzka_zoznamu - 1 : pravy;

stred = (zaciatok + dlzka_zoznamu - 1 <= pravy) ? zaciatok + dlzka_zoznamu - 1 : pravy;

Merge(pole, zaciatok, stred, koniec);
}
}
}
</syntaxhighlight>
</tab>
</tabs>

==Odkazy==
# https://www.geeksforgeeks.org/merge-sort/
# https://www.geeksforgeeks.org/iterative-merge-sort/
# https://medium.com/@paulsoham/merge-sort-63d75df76388
# https://www.khanacademy.org/computing/computer-science/algorithms/merge-sort/a/overview-of-merge-sort
# https://www.tutorialspoint.com/data_structures_algorithms/merge_sort_algorithm.htm
# https://www.youtube.com/watch?v=6pV2IF0fgKY
# https://www.youtube.com/watch?v=mB5HXBb_HY8
# https://www.youtube.com/watch?v=ak-pz7tS5DE

Triedenie zlučovaním

2021-03-28T15:50:26Z

Filip Tomek: /* Merge sort */

Triedenie zlučovaním

2021-03-28T15:49:42Z

Filip Tomek: /* Merge sort */

Triedenie zlučovaním

2021-03-28T15:48:48Z

Filip Tomek: /* Merge sort */

Triedenie zlučovaním

2021-03-28T15:48:38Z

Filip Tomek: /* Merge sort */

Triedenie zlučovaním

2021-03-28T15:47:57Z

Filip Tomek: /* Merge sort */