这个递归函数可以优化吗

Question

有没有办法优化所附代码中第一个定义的函数？

我想知道我所做的练习是否可以针对可读性和性能进行优化。该练习是关于确定存储整数值的数组是递增式良好排序(每个数字都大于前一个数字[即1,2,3,4,5](，还是递增式排序(数字通常是递增式排序的，但一行中可能很少有相同值的数字[即1,3,3,5](或根本不递增式排序[即4,2,1]。

必须以最优化的方式使用递归方法来完成此练习。以下是我的解决方案主张：

// 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 sortedn");
else if (result == 1 && precision == 0)
printf("This array is sortedn");
else
printf("This array isn't sortedn");
}
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 %dn", 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;
}

如果有人能找到更优化的解决方案，我将不胜感激，谢谢。

Answer 1

此变体既不针对可读性也不针对性能进行优化，而是针对可用性和一致性进行优化，因为它不需要调用方使用默认假设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;
}