Найти минимальное положительное и максимальное отрицательное числа, не входящие в вектор

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
typedef enum
{
  no_error,
  error_invalid_arguments,
  error_mem_alloc,
  error_pos_no_exist,
  error_neg_no_exist
} TErrorCodes;
 
int compareAsc(const void* a, const void* b)
{
  return (*(int*)a - *(int*)b);
}
 
int compareDesc(const void* a, const void* b)
{
  return (*(int*)b - *(int*)a);
}
 
int FindValues(int* const arr, const int N, int* const minPositivePtr, int* const maxNegativePtr)
{
  int errorCode = no_error;
  int positivesCount = 0;
  int negativesCount = 0;
  int minPositive = 0;
  int maxNegative = 0;
  int i = 0;
 
  int* positives = NULL;
  int* negatives = NULL;
 
 
  if ((arr == NULL) || (minPositivePtr == NULL) || (maxNegativePtr == NULL) || (N <= 0))
  {
    errorCode = error_invalid_arguments;
  }
  else
  {
    positives = malloc(N * sizeof(*positives));
 
    if (positives != NULL)
    {
 
      negatives = malloc(N * sizeof(*negatives));
 
      if (negatives != NULL)
      {
        memset(positives, 0, N * sizeof(*positives));
        memset(negatives, 0, N * sizeof(*negatives));
 
        positivesCount = 0;
        negativesCount = 0;
 
        for(i = 0; i < N; i++)
        {
          if (arr[i] > 0)
          {
            positives[positivesCount] = arr[i];
            positivesCount++;
          }
          
          if (arr[i] < 0)
          {
            negatives[negativesCount] = arr[i];
            negativesCount++;
          }
        }
 
        if (positivesCount == 0)
        {
          errorCode = error_pos_no_exist;
        }
        else
        {
          qsort(positives, positivesCount, sizeof(*positives), compareAsc);
 
          minPositive = positives[0];
 
          while (bsearch(&minPositive, positives, positivesCount, sizeof(*positives), compareAsc) != NULL)
          {
            minPositive++;
          }
 
          (*minPositivePtr) = minPositive;
        }
 
        if (negativesCount == 0)
        {
          errorCode = error_neg_no_exist;
        }
        else
        {
          qsort(negatives, negativesCount, sizeof(*negatives), compareDesc);
 
          maxNegative = negatives[0];
 
          while (bsearch(&maxNegative, negatives, negativesCount, sizeof(*negatives), compareDesc) != NULL)
          {
            maxNegative++;
          }
 
          (*maxNegativePtr) = maxNegative;
        }
 
        free(positives);
        free(negatives);
      }
      else
      {
        free(positives);
        errorCode = error_mem_alloc;
      }
    }
    else
    {
      errorCode = error_mem_alloc;
    }
  }
 
  return errorCode;
}
 
int main(void)
{
  int a[] = {7, 3, 1, -5, -2, 5, 2, 0, 8, 1};
 
  int minPositive = 0;
  int maxNegative = 0;
  int errorCode = 0;
 
  errorCode = FindValues(&a[0], 10, &minPositive, &maxNegative);
 
  switch (errorCode)
  {
  case no_error:
    {
      printf("Minimal positive not present: %d\n"
          "Maximal negative not present: %d\n",
          minPositive,
          maxNegative);
      break;
    }
  case error_invalid_arguments:
    {
      printf("Error: invalid arguments!\n");
      break;
    }
  case error_mem_alloc:
    {
      printf("Error: failed to allocate memory!\n");
      break;
    }
  case error_neg_no_exist:
    {
      printf("Warning: negatives not present.\n"
          "Minimal positive not present: %d\n",
          minPositive);
      break;
    }
  case error_pos_no_exist:
    {
      printf("Warning: positives not present.\n"
          "Maximal nagative not present: %d\n",
          maxNegative);
      break;
    }
  default:
    {
      abort();
    }
  }
  return 0;
}

#include <stdio.h>
 
int * find(const int * array, const size_t count, const int value) {
    return ( ! count ) ? NULL : ( *array == value ) ? (int*)array : find(array + 1, count - 1, value);
}
 
void dump(const int * array, size_t count) {
    while ( count-- )
        printf("%3d%c", *array++, ( count ) ? ' ' : '\n');
}
 
#define ROWS 3
#define COLUMNS 5
 
int main(void) {
    int tests[ROWS][COLUMNS] = {
        { 3, 1, -2, 4, -5 },
        { 5, 6, 7, 8, 9 },
        { -3, -8, -1, -9, -5 }
    };
    int i, n;
    
    for ( i = 0; i < ROWS; ++i ) {
        printf("Test #%d\nArray:\n", i + 1);
        dump(tests[i], COLUMNS);
        for ( n = 1; find(tests[i], COLUMNS, n); ++n )
            ;
        printf("Min positive number not in array: %d\n", n);
        for ( n = -1; find(tests[i], COLUMNS, n); --n )
            ;
        printf("Max negative number not in array: %d\n\n", n);
    }
    
    return 0;
}