C ++ | 需要帮助从For循环功能->递归功能过渡

Question

因此，对于我的一项家庭作业，我们被要求创建一个冰雹序列，而我完全陷入困境。 我很难弄清楚如何分解包含循环的函数的各个部分，然后尝试从本质上将其转换为递归函数。 任何帮助将不胜感激。 下面，我拥有原始的for循环功能，然后是（尝试）递归功能。

// startingValue function with For-Loop
// Takes in an int value n and returns the
// start value k from 1 to n, that has the longest length.

int startingValue (int n) {
    int length = 0;
    int k;

    for ( int i = 1; i <= n; i++ ) {
        int currentLength = largestHailstoneLength(i);

        if (currentLength > length) {
            length = currentLength;
            k = i;
        }
    }       

    return k;
}

这是我对上述函数的递归版本的尝试：

int startingValue (int n) {
    int length = 0;
    int n = 0;
    int currentLength = largestHailstoneLength(i);

    if (currentLength < length) {
        return 0;
    } else {
        length = currentLength;
        n = i;
    }

    return (startingValue(i));
}

Answer 1

这是一些简单但可能效率不高的方法，应该可以帮助您入门：

int startingValue(int n) {

    if (n == 1) {
        return n;
    }

    int m = startingValue(n - 1);

    return largestHailstoneLength(n) > largestHailstoneLength(m) ? n : m;
}

Answer 2

我不会做家庭作业，但将向您展示Ruby（一种与伪代码一样可读的语言）中的解决方案。 #之后的所有内容均为注释。

# Ruby equivalent to your C++ loop version
def start(n)
  biggest = 0
  k = -1
  (1..n).each do |i|  # loop from 1 to n, inclusive...
    # don't have access to your largestHailstoneLength(i) function,
    # so I'm using a random number on the range [0,1000)
    current = rand(1000)
    biggest, k = current, i if current > biggest
  end
  return k
end

# Using default argument values.  Alternatively, you can build
# a single-argument front end function and a recursive back end
# with these args the state info.
def start_recursive(n, i = 1, biggest = 0, k = -1)
  current = rand(1000)  # same as above
  biggest, k = current, i if current > biggest
  return i < n ? start_recursive(n, i + 1, biggest, k) : k
end

srand 12345  # explicit seed to RNG for reproducibility of sequence
p start(1000)  # => 301
srand 12345  # reseed RNG sequence to show recursive version yields same result
p start_recursive(1000)  # => 301

---

附录

在考虑了一下并扩大了范围之后，我想到了以下变种，该变种不太可能遭受堆栈溢出的困扰，它使用分而治之的策略来划分候选范围。 我还用调用您的largestHailstoneLength(i)代替了随机数评估：

def start_recursive(upper_index, lower_index = 1)
  return lower_index if lower_index >= upper_index
  mid = (lower_index + upper_index) / 2
  lower_max = start_recursive(mid, lower_index)
  upper_max = start_recursive(upper_index, mid + 1)
  if largestHailstoneLength(lower_max) < largestHailstoneLength(upper_max)
    return upper_max
  else
    return lower_max
  end
end

Answer 3

您的代码中有一些问题

1. 您没有在递归函数中定义i
2. 您似乎对递归的工作方式一无所知，我给您一个线索：
   • 每次调用函数时，都会保存一个状态。
   • 您需要声明递归函数停止的位置，否则它将继续调用自身，直到由于堆栈溢出而崩溃为止。
   • 您需要知道您是否要使用该函数返回的内容，还是要使用传递给它的内容（或两者都使用）

如果我做对， startingValue()应该返回一个值，其中largestHailstoneLength()是最大可能值。

因此，我们遵循的是归纳原理：

• 我有n值
• 如果n为1 ，我不必进行任何比较，只需返回n 。

除此以外

• 如果n最大，则它应大于1和n - 1之间的最大值。
• 现在我们需要看到1到n - 1之间的最大值。
• 如果n - 1最大，则它应大于1和n - 2之间的最大值
• ...

好吧，首先要做的是检查n

// Stop here, no need to go compare
if (n == 1) return n;

递归内需要做的是比较当前 n与1到n - 1的最大值。 那是：

// If current n is greater then the best case for n - 1
int k = startingValue(n - 1);
if (largestHailstoneLength(n) > largestHailstoneLength(k))
{
    // n is greater
}
else // startingValue(n - 1) is greater

知道哪个更大，我们简单地将其返回。

为了更好地理解事物，请多读一些。 您可以从这里开始。