I am parallelizing odd-even Merge Sort. But I only get worst results with the parallel approach than the sequential one.

void oddEvenMergeSort(int *arr, int n) {
    if (n > 1) {
        int m = n / 2;

        #pragma omp task shared(arr) // Crea una tarea para la primera mitad
        oddEvenMergeSort(arr, m);

        #pragma omp task shared(arr) // Crea una tarea para la segunda mitad
        oddEvenMergeSort(arr + m, n - m);

        // #pragma omp taskwait // Espera a que ambas tareas anteriores completen
        oddEvenMerge(arr, n);
    }
}

this is the way I use to parallelize the global function, and the result is the same than the sequential.

void oddEvenMerge(int *arr, int n) {
    if (n == 1) return;
    if (n == 2) {
        compare(arr, 0, 1);
        return;
    }
    else {
        int *odd = (int *)malloc(sizeof(int) * (n / 2));
        int *even = (int *)malloc(sizeof(int) * (n / 2));
        oddEvenSplit(arr, odd, even, n);
        
        // #pragma omp task shared(odd, even)
        oddEvenMerge(odd, n / 2);

        // #pragma omp task shared(odd, even)
        oddEvenMerge(even, n / 2);

        oddEvenJoin(arr, odd, even, n);

        for (int i = 1; i < n / 2; i++) {
            compare(arr, 2 * i - 1, 2 * i);
        }

        free(odd);
        free(even);
    }
}

here, if I use this omp task, it is even worse than the sequential.

void oddEvenSplit(int *arr, int *odd, int *even, int n) {
    // #pragma omp parallel for
    for (int i = 0; i < n/2; i++) {
        odd[i] = arr[2 * i + 1];
        even[i] = arr[2 * i];
    }
}

void oddEvenJoin(int *arr, int *odd, int *even, int n) {
    // #pragma omp parallel for
    for (int i = 0; i < n/2; i++) {
        arr[2 * i + 1] = odd[i];
        arr[2 * i] = even[i];
    }
}

finally, in this 2 functions i get as well worst results, but I suppose it is because they are a very simple loop so it is not worth it to parallelize it.