Odd-Even Transposition Sort for a fixed number of threads in OpenMP

I am trying to create a program that parallelizes odd-even transposition sort algorithm by means of openmp, in the case when there is not a 1:1 ratio between the numbers in an array and the number of processors/threads. I first divide the array into blocks, sort these arrays inside a pragma block using the localSort function. After these local arrays have been sorted, I do the odd-even transposition sort by comparing elements in successive blocks and merging them. The problem is that it doesn't seem to sort the numbers. Could anyone please help me identify the problem? Thank you!

The code I have is follows:

//Odd Even Transposition for P processors

#include <stdio.h>
#include <stdlib.h>
#include "omp.h"

int *arr;

int compare (const void * a, const void * b)
{
  return ( *(int*)a - *(int*)b );
}

void localSort (int* arr, int f, int locSize)
{
  int k, i;
  int* locArr = malloc(locSize *sizeof(int)); 
  for (i = 0; i < locSize; i++) {
   locArr[i] = arr [i + f];
  }

  qsort(locArr, locSize, sizeof(int), compare);

  for (k = 0; k < locSize; k++) {

    arr[f + k]  = locArr [k];
  }

  free (locArr);

}

void localCompareAndMerge (int id, int localSize) {

    int k, temp;

      for (k = id * localSize; k < localSize; k++) {

        if (arr[k] > arr[k+localSize]) {

          temp = arr[k];
          arr[k] = arr[k+localSize];
          arr[k+localSize] = temp;

        }

      }

}

void main() {

  int phase;



  int n;
  int i, tmp, m;
  int P;

  printf("Enter array size:");
  scanf("%d", &n);

  arr = malloc(n *sizeof(int));  

  printf("\n Please enter array numbers: ");

  int number;

  int o;

  for ( o = 0; o < n; o++)
    {
      scanf("%d", &number);
      arr[o] = number;
    }

 printf("Enter number of processors: ");
  scanf("%d",&P);
  omp_set_dynamic(0);

  int evenNumThreads = n/2;
  int oddNumThreads = n - (n/2);
  int localSize = n/P;
  int l;

  //sorting locally by parallelization

     #pragma omp parallel for shared(arr, n, localSize, P)

       for (l = 0; l < n; l+= (n/P)) {

            localSort(arr, l, n/P);

       }

  for (phase = 0; phase < n; phase++) {

    if (phase % 2 == 0)
    #pragma omp parallel for num_threads(evenNumThreads) default(none) shared(arr, n, phase, localSize, P) private (i, tmp)

      for (i = 0; i < P; i+=2){
        printf("I am thread %d inside phase %d\n", omp_get_thread_num(), phase);
            localCompareAndMerge (i, localSize);

      }

    else 

#pragma omp parallel for num_threads(oddNumThreads) default(none) shared(arr, n, phase, localSize) private(i, tmp)

      for (i = 1; i < n-1; i+=2) {
      printf("I am thread %d inside phase %d\n", omp_get_thread_num(), phase);
          localCompareAndMerge (i, localSize);
      }


  }

  printf ("\n Printing out sorted array: \n");
  for (m = 0; m < n; m++)
    printf ("\n arr[%d] = %d\n", m+1, arr[m]);


  free(arr);
}