#include <stdio.

h>
#include <stdlib.h>
#include <conio.h>
void max_heapify(int *a, int i, int n)
{// ok deci ce facem aici
int j, temp;
temp = a[i];// in primul rand salvam valoarea la pozitia i ca urmeaa cel mai
probabil sa o pierdem sortand
j = 2*i;// si ne ducem la opzitia lui times 2. de ce? pentru ca asa zice in
teorie, don't question it.
// daca te uiti la un vecotor "heapified" it will make sense
while (j<=n)
{// cat timp n-am ajuns la sfarsitul vecoturlui...
if (j<n && a[j+1]>a[j])// daca again avem nuemere la dreapta lui j, si
numarul ala e mai mare ne mutam la ala
j = j+1;
if (temp>a[j])// daca numarul de pe pozitia i e mai mare decat ala de ep
pozitia j ne-am terminat treaba
break;// adica radacina are in dreapta ei numar mai mic.
else if (temp<=a[j])// daca nu, interschimbam cu pozitia initiala al lui i
{
a[j/2] = a[j];// daia l-am salvat in temp
j = 2*j;// si revenim inapoi in while
// if-ul asta nu se intampla mai mult de 2 ori, hence the value is
safe.
}
}
a[j/2] = temp;// bineinteles ca dupa procedeu punem valoarea inapoi ca altfel o
pierdem
}

void heapsort(int *a, int n)

{// ok you might be wondering, wtf is this? are deabia 10 randuri sortarea
// well yeah. la fel ca la interclasare, sortarea sta in prepararea de dinainte
int i, temp;// what w ebasically do is luam cel mai mic numar si il ducem pe
radacina ca sa il sortam, if tha makes any sense
for(i=n;i>=2;i--)
{
temp=a[i];
a[i]=a[1];
a[1]=temp;
max_heapify(a,1,i-1);// dupa care trebuie sa reparam arborele notru acolo
unde l-am stricat.
// i suggest you watch a visual aid on youtube ca sa vezi exact ce se
intampla. e greu sa explici fara desene
}
}

void build_maxheap(int *a,int n)

{//ok. the idea is we start from half. daca ai vazut un arbore binar, ai vazut ca
are jumate in stanga numere mici
//si jumate in dreapta numere mari.
int i;
for(i=n/2; i>=1; i--)//deci incepem de la jumatate
{
max_heapify(a,i,n);
// oricum retinem n ca sa stim full length-ul. idea e sa menajam vecotrul
ca sa putem sa-l citim in heapsort
 // ca arbore. go to max_heapify, dupa revi aici
}

//acum ca am facut pentru o pozitie heapify, trebuie sa aplicam regula pentru

toate elementele
// back to main

int main()
{
/*
Ok gabi. scurt walkthrough la heapsort.
Stim ca heapsort sorteaza un vector.
el face asta cu un heap, sau gramada sau cum vreai sa-i spui.
adica nu putem cu vectorul nostru sa aplicam heapsort direct.
deci trebuie sa transformam vectorul nostru in heap.
doua metode: max heap si min heap
noi aici facem max heap.
max heap. adica un nod tata e mai mare decat ambii copii ai lui in arbore.
iti sugerez sa stergi mesajele astea dupa ce ai invata programul
*/
int n, x, i;
printf("Numarul de elemente: ");
scanf("%d",&n);
int a[20];
for(i=1;i<=n;i++)
{
printf("Introduceti elementul %d: ", i);
scanf("%d", &a[i]);
}// pana acum am umplut un vector. pretty self explanatory
build_maxheap(a,n);// ne ducem la fuctia build_maxheap sa vedem ce se intampla
acolo

// acum ca am menajat vectorul sa arate a "arbore" facem in sfarsit heapsort

/*
for(i=1;i<=n;i++)
{
printf("%d ", a[i]);
}
pune asta in cod sa vezi cum arata vectorul dupa heapify daca vrei
*/

heapsort(a,n);// ok. to heapsort

printf("Max Heap\n");
for(i=1;i<=n;i++)
// now the spoils of war. afisam vectorul sortat, ne scarpinam in cap ca de ce
merge, and we fuck off
{
printf("%d ", a[i]);
}
//Remember to delete the comments
}