C - 递归指针

Question

我想写一个递归函数，它将一个数组作为参数并返回MIN和MAX值。到目前为止，我只能得到MAX。我试图添加一个指针来发回最小值，但由于某种原因，它总是崩溃并显示大量警告。

请帮我弄清楚我的代码有什么问题。

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); 
} 

，所以我试过，但返回的是最小的百达在一个索引0 如何使它工作？

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

这样

#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

呼叫

MinMaxArray(arr, (size - 1), &min) 

指定的第三个参数具有相对于参数声明类型错误。

参数的类型为int **，而参数的类型为int *。

此外，不计算最小元素。

在C++中有一个名为minmax_element的标准算法，它返回一对指向数组最小元素的指针。

你可以使用C语言编写的

另一种方法的功能类似的声明以返回一对最小和最大元素的索引。

为此，您需要声明两个数据成员的结构。

下面示出如何返回一对指数能够以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; 
} 

它的输出可能看起来像

14 6 7 9 6 7 15 12 0 10 
The minimum is 0 
The maximum is 15 

考虑到用户可以通过函数是一个“空”数组，即与数组大小相对应的参数等于0时的数组。在这种情况下，您自己的函数实现具有未定义的行为。

如果不可以使用结构，那么该函数可以声明如下

void minmax_element(const int a[], size_t n, size_t *min, size_t *max); 

或者

void minmax_element(const int a[], size_t n, int **min, int **max); 

这不会是很难根据这些声明的上面显示的递归函数改变。

例如

#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; 
}