// METODE DE SORTARE A VECTORILOR

#include <iostream.h>
#include <stdlib.h>
#include <time.h>
#include <process.h>
#define N 10
int v[N],t0,t1,t;

////////////////////////////////////
// COUNT SORT
// Sortarea prin numarare
void countSort(int v[], int len)
{int i,j,a[N],b[N];
for(i=0;i<len;i++) a[i]=0;
for(i=0;i<len-1;i++)
for(j=i+1;j<len;j++)
if(v[i]<v[j])
a[j]++;
else
a[i]++;
for(i=0;i<len;i++) b[a[i]]=v[i];
memcpy(v,b,len*sizeof(int));
return;
}

////////////////////////////////////
// BUBBLE SORT
// Metoda "Bulelor"-performanta
void bubbleSort(int v[], int len)
{int i,aux,schimb,index=len-1;
do
{schimb=0;
for (i=0; i<=index-1; i++)
if (v[i] > v[i+1])
{
aux=v[i];v[i]=v[i+1];v[i+1]=aux;
schimb=1;
}
index--;
}while(schimb);
}

////////////////////////////////////
// MERGE SORT
// Sortarea prin interclasare
void merge(int v[], int lo, int m, int hi)
{int i, j, k,temp[N];
i=0; j=lo;
while (j<=m)
temp[i++]=v[j++];
i=0; k=lo;
while (k<j && j<=hi)
if (temp[i]<=v[j])
v[k++]=temp[i++];
else
v[k++]=v[j++];
while (k<j)
v[k++]=temp[i++];
}

void mergeSort(int v[], int lo, int hi)

{if (lo<hi)
{int m=(lo+hi)/2;
mergeSort(v, lo, m);
mergeSort(v, m+1, hi);
merge(v, lo, m, hi);
}
}

////////////////////////////////////
// SELECTION SORT
// Sortarea prin selectie-performanta
void selectionSort(int v[], int len)
{int i, j,index,aux;
for (i = 0; i < len-1; i++)
{ index=i;
for (j = i+1; j < len; j++)
if (v[j] < v[index])
index=j; //poz.elem.min
aux = v[i];
//schimbare
v[i] = v[index];
v[index] = aux;
}
}

////////////////////////////////////
// INSERTION SORT
// Sortarea prin insertie
void insertionSort(int v[], int len)
{int i, k, index;
for(i=1;i<len;i++)
{ index=v[i];
k=i;
while((k>0)&&(v[k-1]>index))
{ v[k] = v[k-1];
k=k- 1;
}
v[k]=index;
}
}

////////////////////////////////////
// QUICK SORT
// Sortarea rapida (prin partitionare)
void quickSort (int v[], int lo, int hi)
{int i=lo, j=hi, aux, x=v[(lo+hi)/2];
do
{
while (v[i]<x) i++;
while (v[j]>x) j--;
if (i<=j)
{ aux=v[i]; v[i]=v[j]; v[j]=aux;
i++; j--;
}
}while (i<=j);
if (lo<j) quickSort(v, lo, j);
if (i<hi) quickSort(v, i, hi);
}

////////////////////////////////////
// SHELL SORT
// Insertie cu diminuarea incrementului
void shellSort(int v[], int len)
{int inc,i,j,aux;
for(inc=len/2;inc>0;inc/=2)
for(i=inc;i<len;i++)
for(j=i-inc;j>=0&&v[j]>v[j+inc];j-=inc)
{
aux=v[j];v[j]=v[j+inc];v[j+inc]=aux;
}
}

////////////////////////////////////
// SHAKER SORT
// Sortare prin amestecare
void shakerSort(int v[], int len)
{int j,k,left,right,aux;
left=1;right=len-1;
k=len-1;
do
{for(j=right;j>=left;j--)
if(v[j-1] > v[j])
{
aux=v[j-1];v[j-1]=v[j];v[j]=aux;
k=j;
}
left=k+1;
for(j=left;j<=right;j++)
if (v[j-1] > v[j])
{
aux=v[j-1];v[j-1]=v[j];v[j]=aux;
k=j;
}
right=k-1;
}while(left < right);
}

////////////////////////////////////
// HEAP SORT
// Sortarea prin metoda ansamblelor
void siftDown(int v[], int root, int bottom)
{ int done, maxChild, aux;
done = 0;
while ((root*2 <= bottom) && (!done))
{ if (root*2 == bottom)
maxChild = root * 2;
else
if (v[root * 2] > v[root * 2 + 1])
maxChild = root * 2;
else
maxChild = root * 2 + 1;
if (v[root] < v[maxChild])
{ aux = v[root];
v[root] = v[maxChild];
v[maxChild] = aux;
root = maxChild;
}
else
done = 1;
}
}
void heapSort(int v[], int len)
{ int i, aux;
for (i = (len / 2)-1; i >= 0; i--)
siftDown(v, i, len);
for (i = len-1; i >= 1; i--)
{ aux = v[0];
v[0] = v[i];
v[i] = aux;
siftDown(v, 0, i-1);
}
}

////////////////////////////////////
// Functia principala
int main(void)
{ int i;
// init. generator de nr.aleatoare
srand(getpid());
//umplere vector cu nr.int.aleatoare
for (i = 0; i < N; i++)
v[i] = rand();
//cout<<"Vectorul generat aleator ... \n";
//for (i = 0; i < N; i++)
//cout<<"v["<<i<<"]="<<v[i]<<" ";
t0=clock();
//countSort(v, N);
//bubbleSort(v, N);
//shakerSort(v, N);
//selectionSort(v, N);
//insertionSort(v, N);
//shellSort(v, N);
//heapSort(v, N);
mergeSort(v, 0, N-1);
//quickSort(v, 0, N-1);
t1=clock(); t=t1-t0;
for (i = 0; i < N; i++)
cout<<v[i]<<" ";
cout<<"\n t= "<<t<<"; timp= "
<<t/CLK_TCK<<endl;
return 0;
}