如何在C中使用结构和递归查找数组中的最大值和最小值

Question

我具有以下在矩阵中查找最大值和最小值的函数，如何添加具有min和max的结构以仅执行查找最小值和最大值的函数？

int maximum(int array[], int index, int len) 
{
    int max;

    if(index >= len-2)
    {
        if(array[index] > array[index + 1])
            return array[index];
        else
            return array[index + 1];
    }




    max = maximum(array, index + 1, len);

    if(array[index] > max)
        return array[index];
    else
        return max;
}

int minimum(int array[], int index, int len)
{
    int min;

    if(index >= len-2)
    {
        if(array[index] < array[index + 1])
            return array[index];
        else
            return array[index + 1];
    }

    min = minimum(array, index + 1, len);

    if(array[index] < min)
        return array[index];
    else
        return min;
}

Answer 1

#include <assert.h>
#include <stddef.h>
#include <stdio.h>

typedef struct minmax_tag {
    int min;
    int max;
} minmax_t;

minmax_t get_minmax(int const *data, size_t length)
{
    assert(length);

    minmax_t minmax = { data[0], data[0] };

    for (size_t i = 1; i < length; ++i) {
        if (data[i] < minmax.min)
            minmax.min = data[i];
        if (data[i] > minmax.max)
            minmax.max = data[i];
    }

    return minmax;
}

int main(void)
{
    int foo[] = { 12, 484, 487, 1, 500 };
    minmax_t result = get_minmax(foo, sizeof(foo) / sizeof(*foo));
    printf("Min: %d\tMax: %d\n\n", result.min, result.max);
}

Sowwy，递归：

#include <assert.h>
#include <stddef.h>
#include <stdio.h>

typedef struct minmax_tag {
    int min;
    int max;
} minmax_t;

minmax_t get_minmax_impl(int const *data, size_t pos, size_t length, minmax_t previous)
{
    if (pos == length)
        return previous;

    if (data[pos] < previous.min)
        previous.min = data[pos];
    if (data[pos] > previous.max)
        previous.max = data[pos];

    return get_minmax_impl(data, pos + 1, length, previous);
}

minmax_t get_minmax(int const *data, size_t length)
{
    assert(length);

    minmax_t previous = { data[0], data[0] };
    return get_minmax_impl(data, 1, length, previous);
}

int main(void)
{
    int foo[] = { 12, 484, 487, 1, 500 };
    minmax_t result = get_minmax(foo, sizeof(foo) / sizeof(*foo));
    printf("Min: %d\tMax: %d\n\n", result.min, result.max);
}

Answer 2

如Danny-ds的评论中所述，如果您确实需要使用递归（出于教学目的）执行此操作，至少应使用分而治之的技术将堆栈消耗限制为O（ln（n））。

在下面的代码中，我将创建一个函数，该函数接受一个范围，该范围定义为first指向数组（或子数组）的第一个元素的指针， last指向过去同一数组（或子数组）的最后一个元素的指针的范围。 请注意，可以安全地比较这两个指针，但不应取消引用last 。

此函数返回一个结构，该结构聚集两个指向最小值和最大值的指针。 如果传递的数组为空（当first == last ， first == last此约定），则将这些指针设置为last并且在使用该结构之前应检查此条件。

#include <stdio.h>

typedef struct {
    int *min;
    int *max;
} min_max_t;

min_max_t min_max_element(int *first, int *last)
{
    // First check if the range is at least two elements wide, to stop the recursion.
    if ( first == last  ||  first + 1 == last )
        return (min_max_t){first, first};

    // Then apply the algorithm to two sub-range
    int *middle = first + (last - first)/2;
    min_max_t left = min_max_element(first, middle);
    min_max_t right = min_max_element(middle, last);

    // No need to compare 'right.min' with 'left.max' or 'right.max' with 'left.min'
    if ( *(right.min) < *(left.min) )
        left.min = right.min;

    if ( *(right.max) > *(left.max) )
        left.max = right.max;

    return left;
}

// Helper function to print the result. The only part which is really necessary is
// the check before accessing the resulting struct.
void print_min_max(size_t n, int *arr)
{ 
    int *arr_end = arr + n;
    min_max_t result = min_max_element(arr, arr_end);
    if (result.min != arr_end)
        printf("Min: %d\tMax: %d\n", *(result.min), *(result.max));
    else
        puts("Error: invalid array.");
}

int main(void)
{
    int a1[] = { 1, 2, 3, 4, -5 };
    print_min_max(5, a1);               // -> Min: -5   Max: 4

    int a2[] = { 4, 2, 1, 4, -2, 0 };    
    print_min_max(6, a2);               // -> Min: -2   Max: 4

    int *a3 = NULL;    
    print_min_max(0, a3);               // -> Error: invalid array.

    int a4[] = { 1 };    
    print_min_max(1, a4);               // -> Min: 1    Max: 1

    int a5[] = { 2, 2, 2, 2 };    
    print_min_max(4, a5);               // -> Min: 2    Max: 2
}