Question

C中的代码，使用分而治之的方法查找数组的最大值，但它一直在抛出 “堆栈溢出异常”。帮助将不胜感激！

int a[10];
int find(int l,int h)
{
    int x;

    if(h==0)
    {
        x=0;
        return x;
    }
    else
    {
        if(h==1)
        {
            if(a[0]>a[1])
            {
                x=0;
                return x;
            }
            else
            {
                x=1;
                return x;
            }
        }
        else
        { 
            int mid,z,y;
            mid=(l+h)/2;
            y=find(0,mid);
            z=find(mid+1,h);
            if(a[y]<a[z])
            {
                x=z;
            }
            else
            {
                x=y;
            }
            return x;
        }
    }
}

只有有限的变量，我没有看到函数可以进入无限递归的位置。

int main()
{
    int i,n,max,min,ans;
    scanf("%d",&n);
    for(i=0;i<n;i++)
    {
        scanf("%d",&a[i]);
    }
    ans=find(0,n-1);

    printf("the maximum element is- %d\n",ans);

    getch();
    return 0;
}

Answer 1

考虑您拨打find(0, 2)的情况。自h > 1起，您输入第二个else子句，mid为1。然后在第二次递归调用中，它是find(2, 2)。在此递归调用中，您再次输入第二个else，因为h仍为2.但mid也是2。现在，第一个递归调用转到find(0, 2)，进入无限循环。

find(0, 2)
   h not 0
       h not 1
           mid = 1
           find(0, 1)
           find(2, 2)
               h not 0
                   h not 1
                       mid = 2
                       find (0, 2) <-- loop

if上的h检查似乎是为了防止mid计算与l相同。如果是这样，那么您可以计算函数顶部的mid变量，并将其用作停止条件。

看起来这是尝试使用分而治之来定位数组a中最大元素的位置。如果是这样，那么您的第一次递归调用应将自己限制在[l..mid]的范围内，而不是返回0。

全部放在一起：

int find(int l,int h)
{
    int mid = (l+h)/2;

    if (mid == l)
    {
        return (a[l] > a[h]) ? l : h;
    }
    else
    {
        int y = find(l, mid);
        int z = find(mid+1, h);
        return (a[y] > a[z]) ? y : z;
    }
}

Answer 2

以下是您修改的代码，该代码已成功运行.. 问题是您没有检查l和h之间的差异，而只检查h ...

的值

#include <iostream>
using namespace std;
int a[10];


int find(int l,int h)
{
int x;



if(h-l==0)
{

    return h;
}
else
{


    if(h-l==1)
    {
        if(a[l]>a[l+1])
        {

            return l;
        }
        else
            {

                return l+1;
            }
    }
    else
    { 
        int mid,z,y;
        mid=(l+h)/2;
        y=find(0,mid);
        z=find(mid+1,h);



        if(a[y]<a[z])
        {
            x=z;
        }
        else
        {
            x=y;
        }

        return x;
    }}}
int main()
{
a[0]=3;
a[1]=7;
a[2]=5;
cout<<find(0,2)<<endl;
return 0;
}

Answer 3

你使用的是错误的条件，请尝试：

first if: if(h==l)

second if: if(h-l==1)

third if:  
      if(a[h]>a[l])  {
         return h;
      } else {
         return l;
      }

C-修复递归中的堆栈溢出

3 个答案: