使用递归查找数组的最小和最大元素的程序答案

【问题标题】：program to find minimum and maximum element of array using recursion使用递归查找数组的最小和最大元素的程序
【发布时间】：2015-11-19 14:04:04
【问题描述】：

我想使用递归找到数组的最大值和最小值。这是我编写的程序，我已经完成了逻辑，它似乎很完美。但是当我编译程序时，程序在输入后卡住了。

这是我的程序：

#include<stdio.h>
#include<conio.h>

int max(int a[], int n);
int min(int a[], int n);

void main(){
    int a[100],n,i,maxi,mini;
    clrscr();
    printf("Enter the number of elements ");
    scanf("%d",&n);
    printf("Enter the elements of array ");
    for(i=0;i<n;i++)
    {
        scanf("%d \n",&a[i]);
    }
    maxi = max(a,n);
    mini = min(a,n);
    printf("\nMaximum element : %d",maxi);
    printf("\nMinimum element : %d",mini);
    getch();
}

int max(int a[],int n){
    int maxo=0,i=0;
    if(i<n){
        if(maxo < a[i]){
           maxo=a[i];
        }
        i++;
        max(a,n);
    }
    return maxo;
}

int min(int a[],int n){
    int mino=999,i=0;
    if(i<n){
        if(mino > a[i]){
            mino=a[i];
        }
        i++;
        min(a,n);
    }
    return mino;
}

【问题讨论】：

这是一个相当奇怪的循环/recusrion 混合体。如果你想递归，你应该递归大小不断减小的数组，并有一个数组只有一个元素的基本情况。否则你将永远递归。
未成年人：建议#include <limits.h>maxo=INT_MIN和int mino=INT_MAX
程序是在编译阶段还是在执行阶段“卡住”了？这个问题在这个细节上似乎有点含糊。
头文件：conio.h 不可移植（在 Visual Studio/Windows 之外不可用）强烈建议不要使用该头文件。标准 C 库中提供了更好的系统函数
@user3629249 OP 发布“但是当我编译程序时，程序在输入后卡住了。”对我来说听起来像是一个运行时问题。

标签： c arrays recursion conio

【解决方案1】：

您的函数 max 和 min 导致无限递归。这会导致堆栈溢出。

你有：

int max(int a[],int n){
   int maxo=0,i=0;
   if(i<n){
      if(maxo < a[i]){
         maxo=a[i];
      }
      i++;
      max(a,n);
   }
   return maxo;
}

使用递归方法的问题在于，i 在每个递归调用中都被初始化为0。您使用i++ 的事实不会影响下一次递归调用中i 的值。同样，maxo 的值在每个递归调用中都设置为0。

要使递归函数工作，您需要在递归函数调用中传递i 和maxo。比如：

int max(int a[],int n, int i, int maxo){
   if(i<n){
      if(maxo < a[i]){
         maxo=a[i];
      }
      return max(a, n, i+1, maxo);
   }
   return maxo;
}

然后调用函数：

maxi = max(a, n, 0, a[0]);

对min 的定义和对min 的调用进行类似的更改。

【讨论】：

【解决方案2】：

代码无限递归

对 OP 的代码进行了 2 处更改

#include <limits.h>

int max(int a[],int n){
    //int maxo=0,i=0;
    int maxo=INT_MIN,i=0;  // Initialize maxo to the minimum int
    if(i<n){
        if(maxo < a[i]){
           maxo=a[i];
        }
        i++;
        // max(a,n);  
        // go to next element in the array, decrement array size. 
        // Without eventually reducing the array size, code recurses indefinitely.
        // So here max() works on a 1 smaller array.
        int m = max(a+1,n-1);  
        // save the greater one
        if (m > maxo) maxo = m;
    }
    return maxo;
}

在循环更好的情况下使用递归会给递归带来不好的名字。考虑以下将每次调用的数组大小减半的情况。最后还是有大约n调用max()，但是递归深度只有log2(n)而不是n。

int find_max(const int *a, size_t n) {
  if (n <= 1) {
    return (n == 0) ? INT_MIN : a[0];
  }
  int left = find_max(a, n/2);
  int right = find_max(&a[n/2], n - n/2);
  return left > right ? left : right;
}

【讨论】：