C - Recursion with pointers - c

Question

I am trying to write a recursion function that takes an array as an argument and returns the MIN and MAX values. So far i can only get MAX. I tried to add a pointer to send back the minimum value but for some reason, it always crashes and shows lots of warnings.
Please help me figure out what is wrong in my code.
int MinMaxArray(int arr[], int size, int* min)
{
if (size == 1)
return arr[0];
if (arr[size - 1] > MinMaxArray(arr, (size - 1), &min))
return arr[size - 1];
else
return MinMaxArray(arr, (size - 1), &min);
}
so i tried this but the min that return is allways the one in index 0
how to make it works?
int MinMaxArray(int arr[], int size, int* min)
{
if (size == 1)
{
*min = arr[0];
return arr[0];
}
if (arr[size - 1] < MinMaxArray(arr, (size - 1), min))
*min = arr[size - 1];
else
*min = MinMaxArray(arr, (size - 1), min);
if (arr[size - 1] > MinMaxArray(arr, (size - 1), min))
return arr[size - 1];
else
return MinMaxArray(arr, (size - 1), min);
}

Answer 1

like this
#include <stdio.h>
#include <assert.h>
int MinMaxArray(int arr[], int size, int *min){
assert(arr != NULL && size > 0);
if (size == 1){
*min = arr[0];
return arr[0];
}
int max = MinMaxArray(arr, size - 1, min);
if (arr[size - 1] < *min)
*min = arr[size - 1];
return (arr[size - 1] > max) ? arr[size - 1] : max;
}
int main(void) {
int arr[] = { 1,5,9,2,6,-4,8,3,7 };
int min, max = MinMaxArray(arr, sizeof(arr)/sizeof(*arr), &min);
printf("max:%d, min:%d\n", max, min);
return 0;
}

Answer 2

The third argument specified for the call
MinMaxArray(arr, (size - 1), &min)
has wrong type relative to the parameter declaration.
The argument has type int ** while the parameter has type int *.
Also the minimum element is not calculated.
In C++ there is standard algorithm named minmax_element that returns a pair of pointers that point to the maximum an minimum elements of an array.
You could use a similar declaration of the function written in C.
Another approach is to return a pair of indices of the minimum and maximum elements.
To do so you need to declare a structure of two data members.
Below there is shown how the function that returns a pair of indices can be implemented in C.
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
struct MinMax
{
size_t min;
size_t max;
};
struct MinMax minmax_element( const int a[], size_t n )
{
struct MinMax minmax = { 0, 0 };
if ( n > 1 )
{
struct MinMax current = minmax_element( a + 1, n - 1 );
++current.min; ++current.max;
if ( a[current.min] < a[minmax.min] ) minmax.min = current.min;
if ( a[minmax.max] < a[current.max] ) minmax.max = current.max;
}
return minmax;
}
#define N 10
int main(void)
{
int a[N];
srand( ( unsigned int )time(NULL ) );
for ( size_t i = 0; i < N; i++ ) a[i]= rand() % ( 2 * N );
for ( size_t i = 0; i < N; i++ ) printf( "%d ", a[i] );
putchar( '\n' );
struct MinMax minmax = minmax_element( a, N );
printf( "The minimum is %d\n", a[minmax.min] );
printf( "The maximum is %d\n", a[minmax.max] );
return 0;
}
Its output might look like
14 6 7 9 6 7 15 12 0 10
The minimum is 0
The maximum is 15
Take into account that the user can pass to the function an "empty" array that is when the argument that corresponds to the size of the array is equal to 0. In this case your own function implementation has undefined behavior.
If you may not use a structure then the function can be declared like
void minmax_element( const int a[], size_t n, size_t *min, size_t *max );
Or
void minmax_element( const int a[], size_t n, int **min, int **max );
It will not be difficult to change the shown above recursive function according to these declarations.
For example
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
void minmax_element( const int a[], size_t n, size_t *min, size_t *max )
{
*min = 0;
*max = 0;
if ( n > 1 )
{
size_t cur_min, cur_max;
minmax_element( a + 1, n - 1, &cur_min, &cur_max );
++cur_min; ++cur_max;
if ( a[cur_min] < a[*min] ) *min = cur_min;
if ( a[*max] < a[cur_max] ) *max = cur_max;
}
}
#define N 10
int main(void)
{
int a[N];
srand( ( unsigned int )time(NULL ) );
for ( size_t i = 0; i < N; i++ ) a[i]= rand() % ( 2 * N );
for ( size_t i = 0; i < N; i++ ) printf( "%d ", a[i] );
putchar( '\n' );
size_t min;
size_t max;
minmax_element( a, N, &min, &max );
printf( "The minimum is %d\n", a[min] );
printf( "The maximum is %d\n", a[max] );
return 0;
}