Recursive minimum function

• You don't initialize min correctly, it needs to be set to the smallest possible number it can have, for example the constant INT_MIN found in limits.h. Instead of doing this, you overwrite min in each recursive call with the line min = a[ i ];.
• You access the array out-of-bounds, in the last function call when i is 6, you run the code [ i + 1 ] which invokes undefined behavior. Unfortunately your program didn't crash, but instead outputs some garbage value.
• There is absolutely no reason to use recursion for this algorithm you are writing.

Show this code (I add integer variable static int initialize_min for initialization min as a[0] in first function call):

#include<stdio.h>
#define SIZE 7

int recursiveMinimum( int a[], int size );

int main(void) {
    int a[ SIZE ] = { 5, 7, 4, 3, 5, 1, 3 }; // Number 2 is not initialized.

    printf( "The smallest number is %d", recursiveMinimum( a, SIZE ) );

    return 0;
}

int recursiveMinimum( int a[], int size ) {
    static int min;
    static int initialize_min = 1;
    static int i = 0;


    if(initialize_min )
    {
        min = a[0];
        initialize_min = 0;
    }



    if( a[ i ] < min ) {
        min = a[ i ];
    }

    i++;

    if( i == size  ) {
        return min;
    } else {
       return recursiveMinimum( a, size  );
    }
}

I think this example is what is intended for a recursive minimum function:

#include <stdio.h>
#define SIZE 7

#define min(a, b)  (((a) < (b)) ? (a) : (b))

/*      assumes size != 0 */
int recursiveMinimum(int a[], size_t size){
int *beg;               /* ptr to beginning */
int *mid;               /* ptr to middle */
int *end;               /* ptr to end */
    if(size < 2)        /* if size == 1 */
        return a[0];
    beg = &a[0];        /* else split array */
    mid = &a[size/2];   /*  and recurse */
    end = &a[size];
    return min(recursiveMinimum(beg, mid-beg),
               recursiveMinimum(mid, end-mid));
}

int main(void)
{
    int a[SIZE] = {5, 7, 4, 3, 5, 1, 3 };
    printf( "The smallest number is %d", recursiveMinimum( a, SIZE ) );
    return 0;
}

You could try this method:

double smaller(double a, double b){
  return (a<b)?a:b;
}

double min(double *p_array, int idx_low, int idx_high){
  if(idx_low==idx_high)
     return p_array[idx_low];
  int idx_mid=idx_low+(idx_high-idx_low)/2;
  return smaller(min(p_array,idx_low,idx_mid), min(p_array,idx_mid+1, idx_high));
}

An analysis of the algorithm should give you an O(n*log(n)) running time - take it with a pinch of salt, though.

To use INT_MIN, we should include limits.h. Also it must be unsafe, because we may want use unsigned, long, long long, __int8 etc.