数组中最大的双精度

Question

我正在尝试使用递归返回数组中最大的双精度数。

sz 是数组中元素的数量。

start 是开始当前调用的数组的索引。

这是我目前所拥有的。为什么函数在到达'return max'行时没有终止！？

double arrayMax (double arr[], int sz, int start) {
double max;

if (start == sz) {
    return max;
} else {
    if (arr[start] > max) {
        max = arr[start];
    }
    arrayMax(arr, sz, start+1);
}
return max;

}

Answer 1

首先，您在第二行中没有分配任何最大值。这会导致问题。因为如果大小和起始整数值相同，您会尝试返回它 - 我相信当数组中只有一个元素时会发生这种情况。

所以你的意思是，如果我的数组只有一个元素，则返回一个名为 max 的值，但没有人知道它里面是什么，这个值。 （未定义行为）

但是，这也是错误的。因为正如你所看到的，我们给 max 变量赋值，但是由于我们在所有调用中定义和声明它，这导致我们使用巨大的内存。所以更好的方法是你需要给你的 max 变量和它在你的函数中的值作为参数，这是更好的方法。

其次，最好返回递归函数。因为您的递归调用没有返回值。您需要在这两个地方都这样做。

首先，您需要在所有函数结束时返回最大值，其次，您需要返回函数以在上述阶段进行另一个递归调用，而不是函数结束。

这个代码和ghostman一样，所以我和他在这个。

double arrayMax (double maxValue, double myArray[], int arraySize, int startPoint) 
{
    if (startPoint < arraySize) 
    {
        if (myArray[startPoint] > maxValue)
            maxValue = myArray[startPoint];

        return arrayMax(maxValue, myArray, arraySize, startPoint + 1);
    }
    return maxValue;
}

Answer 2

发布代码的问题：

1. 递归逻辑有缺陷。你的函数的实现方式，每次调用函数都会创建一个新的局部变量max。最大值不会在递归调用中传播。

2. max 在未初始化的情况下被使用。这会导致未定义的行为。

3. 递归调用中没有return。

我建议在辅助函数中实现核心逻辑。

double arrayMaxHelper(double arr[], int sz, int start, int currentMax)
{
   if (start == sz)
   {
      return currentMax;
   }

   if (arr[start] > currentMax)
   {
      currentMax = arr[start];
   }

   return arrayMaxHelper(arr, sz, start+1, currentMax);
}

double arrayMax (double arr[], int sz, int start)
{
   // Call the helper function.
   // The fact that arrayMax is implemented using a recursive
   // helper function is a detail. Callers of the arrayMax()
   // shouldn't have to worry about it.
   return arrayMaxHelper(arr, sz, start, std::numeric_limits<double>::min):
}

Answer 3

这个呢：

double arrayMax (double arr[], int sz, int start)
{
    double max;
    if(start >= sz - 1)
    {
        max = arr[sz - 1];
    }
    else
    {
        max = arrayMax (arr, sz, start + 1);
        if(arr[start] > max)
        {
            max = arr[start];
        }
    }
    return max;
}

没有附加参数，没有辅助函数...

Answer 4

double arrayMax (double max, double arr[], int sz, int start) {

if (start < sz) {

    if (arr[start] > max) {
        max = arr[start];
    }

    return arrayMax(max, arr, sz, start+1);
}

return max;

}

如果数组长度未确定或非常大，那么这是一个非常不好的方法。命令式语言更适合迭代算法。

Answer 5

在递归调用中，您递增 start，但不会递减 sz。因此，算法的待办事项列表永远不会变短。