void mergesort( int p, int r, int v[])
{
if ( p < r - 1 ) {
int q = ( p + r )/2;
mergesort(p ,q ,v);
mergesort(q ,r ,v);
intercala(p, q, r, v);
printf("Mergesort: \n Numero de trocas:%d Numero de comparacoes:%d \n", trocas, comp );
}
void intercala( int p, int q, int r, int v[] )
{
int i, j, k, *w;
w = malloc ((r - p) * sizeof (int));
i = p, j = q, k = 0;
while ( i < q && j < r ) {
if ( v[i] <= v[j]) w[k++] = v[i++];
else w[k++] = v[j++];
}
while ( i < q ) w[k++] = v[i++];
while ( j < r ) w[k++] = v[j++];
for ( i = p; i < r; i++ ) v[i] = w[i-p];
free(w);
}
void mergesort (int p, int r, int v[]) {
if (p < r) {
int q = (p + r)/2;
mergesort (p, q, v);
mergesort (q + 1, r, v);
intercala (p, q + 1, r, v);
}
}
static void
mergesort (int p, int r, int v[])
{
if (p < r-1) {
int q = (p + r)/2;
mergesort (p, q, v);
mergesort (q, r, v);
intercala (p, q, r, v);
}
}
void mergeSort (int vet[], int esq, int dir,int aux[]){
int meio;
if(esq < dir){
meio = (esq+dir)/2;
mergeSort(vet,esq,meio,aux);
mergeSort(vet,meio+1,dir,aux);
intercala(vet,esq,meio,dir,aux);
}
}
void
mergeSort(Item *v, int p, int r)
{
if (p < r-1) {
int q = (p + r)/2;
mergeSort(v, p, q);
mergeSort(v, q, r);
intercala( p, q, r, v);
}
}
void mergesort (int p, int r, int v[])
{
if (p < r-1) // 1
{
int q = (p + r)/2; // 2
mergesort (p, q, v); // 3
mergesort (q, r, v); // 4
intercala (p, q, r, v); // 5
}
}
void mergesort(int v[],int inicio,int fim)
{
int meio;
if (inicio < fim)
{
meio = (inicio+fim)/2;
mergesort(v,inicio,meio);
mergesort(v,meio+1,fim);
intercala(v, inicio, meio, fim);
}
return ;
}
count merge_sort(int v[], int p, int u){
count c; count aux;
c.compa=0; c.troca=0;
if (p == u) return c;
int m = (p + u)/2;
merge_sort( v, p, m);
merge_sort( v, m+1, u);
aux = intercala( v, p, m, u);
c.compa += aux.compa;
c.troca += aux.troca;
return c;
}
void mergesort (int p, int r, int v[]) {
if (p < r) {
int q = (p + r)/2;
#pragma omp task if(q-p > 1000000)
{
mergesort (p, q, v);
}
#pragma omp task
{
mergesort (q+1, r, v);
}
#pragma omp taskwait
{
intercala (p, q+1, r, v);
}
}
}
int* mergeSort (int* vetor, int r, int q) {
int meio;
int* esq, *dir, *ordenado;
ordenado = (int*) malloc ((q-r+1) * sizeof(int));
if (r == q)
ordenado[0] = vetor[r];
else if (r < q) {
meio = r + (q-r) / 2;
esq = mergeSort (vetor, r, meio);
dir = mergeSort (vetor, meio+1, q);
ordenado = intercala (esq, dir, meio-r+1, q-meio);
}
return ordenado;
}