递归算法到迭代

Question

如何将下面的递归算法变成迭代算法？

count(integer: n)
  for i = 1...n
    return count(n-i) + count(n-i)
  return 1

该算法基本上计算以下内容：

count(n-1) + count(n-2) + ... + count(1)

Answer 1

这不是尾递归，因此将其转换为迭代并非易事。

但是，可以很容易地使用堆栈和循环来模拟递归，方法是压入堆栈而不是递归。

stack = Stack()
stack.push(n)
count = 0
while (stack.empty() == false):
  current = stack.pop()
  count++
  for i from current-1 to 1 inclusive (and descending):
     stack.push(i)
return count

---

另一个解决方案是使用Dynamic Programming，因为您不需要多次计算同一件事：

DP = new int[n+1]
DP[0] = 1
for i from 1 to n:
  DP[i] = 0
  for j from 0 to i-1:
    DP[i] += DP[j]
return DP[n]

请注意，您甚至可以通过记住“到目前为止的总和”来优化它以在 O(n) 而不是 O(n^2) 中运行：

sum = 1
current = 1
for i from 1 to n:
  current = sum
  sum = sum + current
return current

---

最后，这实际上总结为您可以轻松预先计算的内容：count(n) = 2^(n-1), count(0) = 1（您可以通过查看我们拥有的最后一个迭代解决方案来怀疑它......）

base: count(0) 自动产生 1，因为没有到达循环体。
假设：T(k) = 2^(k-1) 代表所有 k < n

证明：

T(n) = T(n-1) + T(n-2) + ... + T(1) + T(0) = (induction hypothesis)
     = 2^(n-2) + 2^(n-3) + ... + 2^0 + 1 = 
     = sum { 2^i | i=0,...,n-2 } + 1 = (sum of geometric series)
     = (1-2^(n-1)/(1-2)) + 1 =  (2^(n-1) - 1) + 1 = 2^(n-1)

Answer 2

如果您以以下递归方式定义您的问题：

count(integer : n)
    if n==0 return 1 
    return count(n-1)+count(n-1)

转换为迭代算法是反向归纳的典型应用，您应该保留所有先前的结果：

count(integer : n):
  result[0] = 1

  for i = 1..n
     result[i] = result[i-1] + result[i-1]

  return result[n]

Ir 很清楚，这比应有的复杂得多，因为重点是举例说明反向归纳。我可以累积到一个地方，但我想提供一个更一般的概念，可以扩展到其他情况。在我看来，这样的想法更清晰。

核心思想明确后，可以改进伪代码。事实上，有两个非常简单的改进只适用于这种特定情况：

• 不需要保留所有以前的值，只需要最后一个值
• 不需要两个相同的调用，因为没有预期的副作用

超越，可以根据函数的定义来计算，count(n)= 2^n

Answer 3

语句return count(n-i) + count(n-i) 似乎等同于return 2 * count(n-i)。在这种情况下：

count(integer: n)
  result = 1
  for i = 1...n
    result = 2 * result
  return result

我在这里错过了什么？