Can this recursive function be optimized? - arrays

Question

Is there a way to optimize the first defined function in attached code?
I wonder if the exercise I've done can be optimized for readability and performance. The exercise was about determining if the array, which stores the integer values is incrementally well sorted (every digit is greater than the previous [i.e. 1,2,3,4,5]), just incrementally sorted (the numbers are generally incrementally sorted, but there can be few with the same values in a row [i.e. 1,3,3,5]), or not sorted at all incrementally [i.e. 4,2,1].
The exercise has to be done by using recursive approach in the most optimized way. Below is my solution proposition:
// find if the array is well sorted incrementally, sorted incrementally or not sorted at all
// the function should return 1 if array is well sorted or just sorted and return 0 otherwise
// the function should pass by refference 1 if the array is well sorted or 0 otherwise
// the result will be thus determined based on those two parameters in separate function
// recursive approach
#include <stdio.h>
#define SIZE1 5 // constants for ready arrays tests
#define SIZE2 4 // ...
#define SIZE3 3 // ...
int findIfArrayIsSorted(int array[], int size, int *precision);
void printResult(int result, int precision);
void specifyInputArraySize(int *size);
void inputArrayElements(int array[], int size);
void printArrayElements(int array[], int size);
int findIfArrayIsSorted(int array[], int size, int *precision)
{
if (size > 1)
{
if (array[size-1] < array[size-2])
{
*precision = 0;
return 0;
}
else if (array[size-1] == array[size-2])
{
*precision = 0;
return findIfArrayIsSorted(array, size - 1, precision);
}
else if (array[size-1] > array[size-2])
return findIfArrayIsSorted(array, size - 1, precision);
}
return 1;
}
void printResult(int result, int precision)
{
if (result == 1 && precision == 1)
printf("This array is well sorted\n");
else if (result == 1 && precision == 0)
printf("This array is sorted\n");
else
printf("This array isn't sorted\n");
}
void specifyInputArraySize(int *size)
{
printf("Please enter the size: ");
scanf("%d", size);
}
void inputArrayElements(int array[], int size)
{
int i;
printf("Please input array elements (one by one):\n");
for (i = 0; i < size; i++)
scanf("%d", &array[i]);
}
void printArrayElements(int array[], int size)
{
int i;
printf("The elements stored in an array are:\n");
for (i = 0; i < size; i++)
printf("Element[%d] is %d\n", i, array[i]);
}
int main(void)
{
int result;
int precision;
// tests for ready arrays
int numArrayW[SIZE1] = {1, 2, 3, 4, 5};
int numArrayS[SIZE2] = {1, 3, 3, 5};
int numArrayU[SIZE3] = {4, 2, 1};
precision = 1; // default assumption
printArrayElements(numArrayW, SIZE1);
result = findIfArrayIsSorted(numArrayW, SIZE1, &precision);
printResult(result, precision);
precision = 1; // default assumption
printArrayElements(numArrayS, SIZE2);
result = findIfArrayIsSorted(numArrayS, SIZE2, &precision);
printResult(result, precision);
precision = 1; // default assumption
printArrayElements(numArrayU, SIZE3);
result = findIfArrayIsSorted(numArrayU, SIZE3, &precision);
printResult(result, precision);
// test for inputted array
int size;
precision = 1; // default assumption
specifyInputArraySize(&size);
int numInputtedArray[size];
inputArrayElements(numInputtedArray, size);
printArrayElements(numInputtedArray, size);
result = findIfArrayIsSorted(numInputtedArray, size, &precision);
printResult(result, precision);
return 0;
}
I would really appreciate if someone will find more optimized solution, thanks.

Answer 1

This variant optimizes for neither readability nor performance, but rather for usability and conformance, because it doesn't require the caller to preset the reference argument with the default assumption 1.
int findIfArrayIsSorted(int array[], int size, int *precision)
{
if (size <= 1) return *precision = 1;
if (array[size-1] < array[size-2]) return *precision = 0;
int sorted = findIfArrayIsSorted(array, size-1, precision);
*precision &= array[size-1] > array[size-2];
return sorted;
}