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

Súbor:MCU I2C 3 casovyDiagram.png

2023-03-21T20:28:02Z

Matúš Nečas:

Súbor:Mcu i2c 1 pripojenie.png

2023-03-21T20:24:19Z

Matúš Nečas: Matúš Nečas nahral novú verziu Súbor:Mcu i2c 1 pripojenie.png

Súbor:Mcu i2c 1 pripojenie.png

2023-03-21T20:21:17Z

Matúš Nečas:

Triedenie výberom

2021-04-19T16:50:39Z

Matúš Nečas: /* Pseudokód */

[[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[max]</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[max]</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};
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[max])
{
max = lavy;
}

if(pravy < dlzka && pole[pravy] > pole[max])
{
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="Iteračná 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="Rekurzívna 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 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[max])
{
max = lavy;
}

if(pravy < dlzka && pole[pravy] > pole[max])
{
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áčná 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="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>

<tab name="Iteračná 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="Rekurzívna 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-19T16:49:38Z

Matúš Nečas: /* Pseudokód */

[[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[max] > 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[max] > 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};
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[max])
{
max = lavy;
}

if(pravy < dlzka && pole[pravy] > pole[max])
{
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="Iteračná 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="Rekurzívna 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 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[max])
{
max = lavy;
}

if(pravy < dlzka && pole[pravy] > pole[max])
{
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áčná 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="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>

<tab name="Iteračná 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="Rekurzívna 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-19T16:49:03Z

Matúš Nečas: /* Implementácia algoritmov Heapify a HeapSort v rôznych programovacích jazykoch */

[[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};
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[max])
{
max = lavy;
}

if(pravy < dlzka && pole[pravy] > pole[max])
{
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="Iteračná 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="Rekurzívna 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 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[max])
{
max = lavy;
}

if(pravy < dlzka && pole[pravy] > pole[max])
{
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áčná 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="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>

<tab name="Iteračná 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="Rekurzívna 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-19T16:10:57Z

Matúš Nečas: /* Implementácia algoritmov Heapify a HeapSort v rôznych programovacích jazykoch */

[[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};
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[max])
{
max = lavy;
}

if(pravy < dlzka && pole[pravy] > pole[max])
{
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="Rekurzívna 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 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[max])
{
max = lavy;
}

if(pravy < dlzka && pole[pravy] > pole[max])
{
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-19T16:08:50Z

Matúš Nečas: /* Implementácia algoritmov Heapify a HeapSort v rôznych programovacích jazykoch */

[[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};
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[max])
{
max = lavy;
}

if(pravy < dlzka && pole[pravy] > pole[max])
{
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:55:04Z

Matúš Nečas: /* Implementácia algoritmov Heapify a HeapSort v rôznych programovacích jazykoch */

[[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:54:02Z

Matúš Nečas: /* Implementácia algoritmov Heapify a HeapSort v rôznych programovacích jazykoch */

[[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 lang="C++">
</tab>

<tab name="Iterácia C++" block>
<syntaxhighlight>
#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:43:19Z

Matúš Nečas: /* Pseudokód */

[[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:42:25Z

Matúš Nečas: /* Pseudokód */

[[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 - 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:27Z

Matúš Nečas: /* Pseudokód */

[[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-19T15:39:36Z

Matúš Nečas: /* Pseudokód */

[[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. 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==
[[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:37:18Z

Matúš Nečas: /* Zmazanie hromady */

[[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. 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==
[[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:35:42Z

Matúš Nečas: /* Zmazanie hromady */

[[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, závisí len to, ako implementujeme algoritmus 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. 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==
[[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:35:15Z

Matúš Nečas: /* Zmazanie hromady */

[[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, závisí len to, ako implementujeme algoritmus 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. 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==
[[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:33:35Z

Matúš Nečas: /* Zmazanie hromady */

[[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 \rangle : \ \ \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, závisí len to, ako implementujeme algoritmus 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. 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==
[[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 zlučovaním

2021-04-19T15:30:06Z

Matúš Nečas: /* Opis rekurzívnej a iteračnej verzie algoritmu Merge Sort */

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

==Merge Sort==

===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 výberom

2021-04-19T15:29:19Z

Matúš Nečas: /* 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 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 \rangle : \ \ \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, závisí len to, ako implementujeme algoritmus 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. 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==
[[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:21:57Z

Matúš Nečas: /* 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ť 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 s maximálnou hodnotou i-teho prvku.
# 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 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 \rangle : \ \ \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, závisí len to, ako implementujeme algoritmus 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. 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==
[[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:20:29Z

Matúš Nečas: /* 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ť 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 s maximálnou hodnotou i-teho prvku.
# 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. 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 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 \rangle : \ \ \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, závisí len to, ako implementujeme algoritmus 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. 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==
[[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:19:15Z

Matúš Nečas: /* 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: ľ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ť 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 s maximálnou hodnotou i-teho prvku.
# 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. 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 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 \rangle : \ \ \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, závisí len to, ako implementujeme algoritmus 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. 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==
[[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:16:44Z

Matúš Nečas: /* 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: ľ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ť 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 s maximálnou hodnotou i-teho prvku.
# 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 ľ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. 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 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 \rangle : \ \ \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, závisí len to, ako implementujeme algoritmus 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. 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==
[[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:15:18Z

Matúš Nečas: /* 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: ľ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ť 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 s maximálnou hodnotou i-teho prvku.
# 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: Priebeh algoritmu je vyobrazený pomocou poľa, ktoré triedime a binárnej hromady, ktorú dané pole reprezentuje. 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 člena a prvky zafarbené na zeleno vyjadrujú ľavú pohromadu i-teho člena. 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 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 \rangle : \ \ \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, závisí len to, ako implementujeme algoritmus 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. 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==
[[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:12:14Z

Matúš Nečas: /* 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: ľ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ť 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 s maximálnou hodnotou i-teho prvku.
# 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: Priebeh algoritmu je vyobrazený pomocou poľa a binárnej hromady. 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, prvky vyfarené na zeleno vyjadrujú pravú pohromadu. 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 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 \rangle : \ \ \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, závisí len to, ako implementujeme algoritmus 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. 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==
[[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:07:52Z

Matúš Nečas: /* Základné časti algoritmu */

[[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|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 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 s maximálnou hodnotou i-teho prvku.
# 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: Priebeh algoritmu je vyobrazený pomocou poľa a binárnej hromady. 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, prvky vyfarené na zeleno vyjadrujú pravú pohromadu. 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 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 \rangle : \ \ \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, závisí len to, ako implementujeme algoritmus 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. 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==
[[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-19T13:25:36Z

Matúš Nečas: /* ZČ */

[[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|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 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 s maximálnou hodnotou i-teho prvku.
# 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: Priebeh algoritmu je vyobrazený pomocou poľa a binárnej hromady. 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, prvky vyfarené na zeleno vyjadrujú pravú pohromadu. 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 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 \rangle : \ \ \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, závisí len to, ako implementujeme algoritmus 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. 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==
[[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===
# Nájdenie minima v nezoradenej časti.
# Umiestnenie minima na koniec zoradenej časti. (výmenou minima a i-teho prvku)

===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-19T13:22:42Z

Matúš Nečas: /* 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|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 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 s maximálnou hodnotou i-teho prvku.
# 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: Priebeh algoritmu je vyobrazený pomocou poľa a binárnej hromady. 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, prvky vyfarené na zeleno vyjadrujú pravú pohromadu. 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 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 \rangle : \ \ \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, závisí len to, ako implementujeme algoritmus 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. 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==
[[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Č===
ejshfjskfskfhdjksfjhdsfjdshfkanoôadkmslJDHKMSALMjbdv ,ksalmncv asd
das
sadas
dsa
dsa
dsa
dasdkljasdklsajdsajdsa
dsadsadjsakldjsakldsa
dasd
sad
asd
sakdsalôdsaôkdsa
dsa
d
sadsadkljsadkljsa
===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-19T13:11:06Z

Matúš Nečas: /* Slovný opis */

[[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|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 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 s maximálnou hodnotou i-teho prvku.
# 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|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 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 \rangle : \ \ \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, závisí len to, ako implementujeme algoritmus 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. 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==
[[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Č===
ejshfjskfskfhdjksfjhdsfjdshfkanoôadkmslJDHKMSALMjbdv ,ksalmncv asd
das
sadas
dsa
dsa
dsa
dasdkljasdklsajdsajdsa
dsadsadjsakldjsakldsa
dasd
sad
asd
sakdsalôdsaôkdsa
dsa
d
sadsadkljsadkljsa
===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-19T13:08:24Z

Matúš Nečas: /* Zmazanie hromady */

[[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|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 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 s maximálnou hodnotou i-teho prvku.
# 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|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 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 \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==
[[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Č===
ejshfjskfskfhdjksfjhdsfjdshfkanoôadkmslJDHKMSALMjbdv ,ksalmncv asd
das
sadas
dsa
dsa
dsa
dasdkljasdklsajdsajdsa
dsadsadjsakldjsakldsa
dasd
sad
asd
sakdsalôdsaôkdsa
dsa
d
sadsadkljsadkljsa
===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-19T13:00:03Z

Matúš Nečas: /* Vytvorenie hromady */

[[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|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 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 s maximálnou hodnotou i-teho prvku.
# 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|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 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==
[[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Č===
ejshfjskfskfhdjksfjhdsfjdshfkanoôadkmslJDHKMSALMjbdv ,ksalmncv asd
das
sadas
dsa
dsa
dsa
dasdkljasdklsajdsajdsa
dsadsadjsakldjsakldsa
dasd
sad
asd
sakdsalôdsaôkdsa
dsa
d
sadsadkljsadkljsa
===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-19T12:58:48Z

Matúš Nečas: /* Vytvorenie hromady */

[[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|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 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 s maximálnou hodnotou i-teho prvku.
# 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|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 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==
[[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Č===
ejshfjskfskfhdjksfjhdsfjdshfkanoôadkmslJDHKMSALMjbdv ,ksalmncv asd
das
sadas
dsa
dsa
dsa
dasdkljasdklsajdsajdsa
dsadsadjsakldjsakldsa
dasd
sad
asd
sakdsalôdsaôkdsa
dsa
d
sadsadkljsadkljsa
===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-19T12:57:33Z

Matúš Nečas: /* Vytvorenie hromady */

[[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|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 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 s maximálnou hodnotou i-teho prvku.
# 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|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{rodič posledného potomka:} \ \ 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 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==
[[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Č===
ejshfjskfskfhdjksfjhdsfjdshfkanoôadkmslJDHKMSALMjbdv ,ksalmncv asd
das
sadas
dsa
dsa
dsa
dasdkljasdklsajdsajdsa
dsadsadjsakldjsakldsa
dasd
sad
asd
sakdsalôdsaôkdsa
dsa
d
sadsadkljsadkljsa
===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-19T09:34:43Z

Matúš Nečas: /* Vytvorenie hromady */

[[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|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 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 s maximálnou hodnotou i-teho prvku.
# 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|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 prvok, ktorý je najspodnejší, najviac vpravo a zároveň má aspoň jedného potomka. Tento prvok určíme tak, že zoberieme posledný prvok v poli a pomocou rovnice 3, z časti prehľad, ktorú si jemne upravíme, nájdeme jeho 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==
[[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Č===
ejshfjskfskfhdjksfjhdsfjdshfkanoôadkmslJDHKMSALMjbdv ,ksalmncv asd
das
sadas
dsa
dsa
dsa
dasdkljasdklsajdsajdsa
dsadsadjsakldjsakldsa
dasd
sad
asd
sakdsalôdsaôkdsa
dsa
d
sadsadkljsadkljsa
===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-19T09:07:48Z

Matúš Nečas: /* Vytvorenie hromady */

[[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|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 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 s maximálnou hodnotou i-teho prvku.
# 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|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 prvok ktorý je najspodnejší, 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==
[[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Č===
ejshfjskfskfhdjksfjhdsfjdshfkanoôadkmslJDHKMSALMjbdv ,ksalmncv asd
das
sadas
dsa
dsa
dsa
dasdkljasdklsajdsajdsa
dsadsadjsakldjsakldsa
dasd
sad
asd
sakdsalôdsaôkdsa
dsa
d
sadsadkljsadkljsa
===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-19T09:06:36Z

Matúš Nečas: /* Základné časti algoritmu */

[[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|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 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 s maximálnou hodnotou i-teho prvku.
# 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|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 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==
[[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Č===
ejshfjskfskfhdjksfjhdsfjdshfkanoôadkmslJDHKMSALMjbdv ,ksalmncv asd
das
sadas
dsa
dsa
dsa
dasdkljasdklsajdsajdsa
dsadsadjsakldjsakldsa
dasd
sad
asd
sakdsalôdsaôkdsa
dsa
d
sadsadkljsadkljsa
===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-19T09:05:08Z

Matúš Nečas: /* 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|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 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 s maximálnou hodnotou i-teho prvku.
# 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|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==
[[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Č===
ejshfjskfskfhdjksfjhdsfjdshfkanoôadkmslJDHKMSALMjbdv ,ksalmncv asd
das
sadas
dsa
dsa
dsa
dasdkljasdklsajdsajdsa
dsadsadjsakldjsakldsa
dasd
sad
asd
sakdsalôdsaôkdsa
dsa
d
sadsadkljsadkljsa
===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-19T09:04:20Z

Matúš Nečas: /* Pseudokód */

[[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|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 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 s maximálnou hodnotou i-teho prvku.
# 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 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==
[[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Č===
ejshfjskfskfhdjksfjhdsfjdshfkanoôadkmslJDHKMSALMjbdv ,ksalmncv asd
das
sadas
dsa
dsa
dsa
dasdkljasdklsajdsajdsa
dsadsadjsakldjsakldsa
dasd
sad
asd
sakdsalôdsaôkdsa
dsa
d
sadsadkljsadkljsa
===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-19T08:50:28Z

Matúš Nečas: /* Pseudokód */

[[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|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 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 s maximálnou hodnotou i-teho prvku.
# 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. Je <code>lavy < dlzka</code> a zároveň <code>pole[lavy] > pole[i]</code> ?
::: Ak áno:
:::::3.1. Nech: <code>max = lavy</code>
::: Ak nie:
:::::3.1. Pokračuj krokom 4.
:4. Je <code>pravy < dlzka</code> a zároveň <code>pole[pravy] > pole[i]</code> ?
::: Ak áno:
:::::4.1. Nech: <code>max = pravy</code>
::: Ak nie:
:::::4.1. Pokračuj krokom 5.
:5. Je <code>pole[max] > pole[i]</code> ?
::: Ak áno:
::::: 5.1. Vymeň: <code>pole[i] a pole[max]</code>
::::: 5.2. Rekurzívne zavolaj: <code>Heapify(pole[], dlzka, max)</code>
::: Ak nie:
::::: 5.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==
[[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Č===
ejshfjskfskfhdjksfjhdsfjdshfkanoôadkmslJDHKMSALMjbdv ,ksalmncv asd
das
sadas
dsa
dsa
dsa
dasdkljasdklsajdsajdsa
dsadsadjsakldjsakldsa
dasd
sad
asd
sakdsalôdsaôkdsa
dsa
d
sadsadkljsadkljsa
===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-19T08:26:17Z

Matúš Nečas: /* 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|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 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 s maximálnou hodnotou i-teho prvku.
# 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. 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==
[[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Č===
ejshfjskfskfhdjksfjhdsfjdshfkanoôadkmslJDHKMSALMjbdv ,ksalmncv asd
das
sadas
dsa
dsa
dsa
dasdkljasdklsajdsajdsa
dsadsadjsakldjsakldsa
dasd
sad
asd
sakdsalôdsaôkdsa
dsa
d
sadsadkljsadkljsa
===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-19T08:01:00Z

Matúš Nečas: /* 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|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==
[[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Č===
ejshfjskfskfhdjksfjhdsfjdshfkanoôadkmslJDHKMSALMjbdv ,ksalmncv asd
das
sadas
dsa
dsa
dsa
dasdkljasdklsajdsajdsa
dsadsadjsakldjsakldsa
dasd
sad
asd
sakdsalôdsaôkdsa
dsa
d
sadsadkljsadkljsa
===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-19T07:59:01Z

Matúš Nečas: /* 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 (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==
[[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Č===
ejshfjskfskfhdjksfjhdsfjdshfkanoôadkmslJDHKMSALMjbdv ,ksalmncv asd
das
sadas
dsa
dsa
dsa
dasdkljasdklsajdsajdsa
dsadsadjsakldjsakldsa
dasd
sad
asd
sakdsalôdsaôkdsa
dsa
d
sadsadkljsadkljsa
===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-18T19:29:23Z

Matúš Nečas: /* Slovný opis algoritmu */

[[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==
[[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Č===
ejshfjskfskfhdjksfjhdsfjdshfkanoôadkmslJDHKMSALMjbdv ,ksalmncv asd
das
sadas
dsa
dsa
dsa
dasdkljasdklsajdsajdsa
dsadsadjsakldjsakldsa
dasd
sad
asd
sakdsalôdsaôkdsa
dsa
d
sadsadkljsadkljsa
===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-18T19:29:01Z

Matúš Nečas: /* Selection 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 (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==
[[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Č===
ejshfjskfskfhdjksfjhdsfjdshfkanoôadkmslJDHKMSALMjbdv ,ksalmncv asd
das
sadas
dsa
dsa
dsa
dasdkljasdklsajdsajdsa
dsadsadjsakldjsakldsa
dasd
sad
asd
sakdsalôdsaôkdsa
dsa
d
sadsadkljsadkljsa
==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-18T19:28:11Z

Matúš Nečas: /* Selection 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 (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==
[[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Č===

===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

Súbor:SelectionSort.png

2021-04-18T19:26:39Z

Matúš Nečas:

Vizualizácia algoritmu Selection Sort

Triedenie výberom

2021-04-15T18:42:29Z

Matúš Nečas: /* Selection 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 (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==
===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Č===

===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-15T18:16:48Z

Matúš Nečas: /* Selection 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 (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==
===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

==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-15T18:00:00Z

Matúš Nečas: /* 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 (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==
===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===

==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