Question

我必须编写一个C代码，使用递归查找数组中的最小值。我已经使用for循环完成了它，但递归比较棘手。有人能帮助我吗？

Answer 1

单个项目数组的最小值是单个项目（基本情况或终止条件）。
数组的最小值是[第一项，最小值（不包括第一项）的最小值]

Answer 2

#include <stdio.h>

int minimum(int *a_s, int *a_e, int candidate){
    if(a_s == a_e)
        return candidate;
    return  minimum(a_s+1, a_e, *a_s < candidate ? *a_s : candidate);
}

int main(void){
    int array[] = { 1,3,-2,0,-1};

    printf("%d ", minimum(array+1, &array[sizeof(array)/sizeof(*array)], *array));

    return 0;
}

Answer 3

以下是使用递归查找最小值的简单代码，

int rec(int a[],int n)
{
    int min;

    if(n==1)
        return a[0];

    else {
        min=rec(a,n-1);

        if(min<a[n-1])
            return min;
        else
            return a[n-1];
    }

} 

void main()
{
    int i,j,n,a[20];
    printf("enter n :");
    scanf("%d",&n);
    printf("enter values : ");

    for(i=0;i<n;i++)
    {
        scanf("%d",&a[i]);  
    }

    printf("\n%d",rec(a,n));

    getch();
}

Answer 4

接受回答后。

下面是一个不会咀嚼堆栈的递归解决方案。估计最大堆栈深度为O（ln2（n））。其他解决方案看起来最大堆栈深度为O（n）。

int ArrayMin(const int a[], size_t n) {
  if (n <= 1) {
    if (n < 0) return 0;  // Handle degenerate ArrayMin( ,0)
    return a[0];
  }
  size_t nhalf = n / 2;
  int left = ArrayMin(a, nhalf);
  int right = ArrayMin(&a[nhalf], n - nhalf);
  return left < right ? left : right;
}

9小时后回答，我们可以假设作业截止日期已过去。

Answer 5

考虑数组的第一个元素是最小的。
通过传递数组的基址和元素数来调用函数。
检查是否有任何其他数字小于最小值，如果是则将该值指定为最小值。
对于每次迭代，增加数组地址并减少元素的数量！

试试这段代码 -

#include<stdio.h>
int min;
int arrfun(int *arr,int n)
{
        if(n){
                if(*arr < min) // check any no is less than minimum.
                        min = *arr; // if yes assign it
        }
        else
                return min; // when n becomes 0 it returns the minimum element
        arrfun(++arr,--n); // recursive call
}

int main()
{
        int arr[]={7,3,9,2,1,6};
        min = arr[0]; // Taking first element is minimum
        printf("minimum is: %d\n",arrfun(arr,6)); // call the function by passing address and no of elements in array
        return 0;
}

如何使用递归在数组中找到最小值？

5 个答案: