Question

我进行了一项实验来计算递归与迭代的斐波那契序列。有没有更好的方法来提高我的递归方法的性能？

require 'benchmark'

def fibonacci_iterative(n)
  fib_numbers = [0, 1]
  iterate = n-1
  iterate.times do
    number = fib_numbers[-2] + fib_numbers[-1]
    fib_numbers << number
  end
  p fib_numbers[-1]
end

def fibonacci_recursive(n)
  fib_number = 0
  if n == 0 || n == 1
    n
  else
    fib_number = fibonacci_recursive(n - 1) + fibonacci_recursive(n - 2)
  end
end

puts Benchmark.measure {fibonacci_iterative(5)}
puts Benchmark.measure {fibonacci_recursive(5)}

5
  0.000000   0.000000   0.000000 (  0.000037)
  0.000000   0.000000   0.000000 (  0.000005)

puts Benchmark.measure {fibonacci_iterative(45)}
puts Benchmark.measure {fibonacci_recursive(45)}

1134903170
  0.000000   0.000000   0.000000 (  0.000039)
378.990000   0.330000 379.320000 (379.577337)

这是递归的固有特征吗？

Answer 1

长运行时不是递归的固有功能，但是当您进行冗余递归计算时，通常会出现这种情况。使用称为“memoization”的技术可以避免这种情况，在这种技术中，您只需计算一次值并将其表格以备将来使用。

这是斐波那契数字的备忘递归实现，猴子修补到Fixnum ......

class Fixnum
  @@fib_value = [0,1]

  def fib
    raise "fib not defined for negative numbers" if self < 0
    @@fib_value[self] ||= (self-1).fib + (self-2).fib
  end
end

0.fib     # => 0
1.fib     # => 1
2.fib     # => 1
5.fib     # => 5
100.fib   # => 354224848179261915075

如果你真的想变大，请使用Fibonacci算法的matrix multiplication version，即O（log n）：

class Fixnum
  def fib
    raise "fib not defined for negative numbers" if self < 0
    self.zero? ? self : matrix_fib(self)[1]
  end

  private

  def matrix_fib(n)
    if n == 1
      [0,1]
    else
      f = matrix_fib(n/2)
      c = f[0] * f[0] + f[1] * f[1]
      d = f[1] * (f[1] + 2 * f[0])
      n.even? ? [c,d] : [d,c+d]
    end
  end
end

45.fib  # => 1134903170 confirms correctness

你几乎可以即时计算1000000.fib并且不会破坏递归堆栈，尽管输出超过2600个80列线。

Answer 2

您在Ruby中的Fibonacci实现是正确的。您可以通过以下方式重写它

def fib(n)
  if n < 2
    n
  else
    fib(n-1) + fib(n-2)
  end
end

唯一的优点是它更简洁一点，你不使用任何额外的变量，事实上，它并不是必需的。

但除此之外，与算法相比，时间方面没有成本变化。有一个few possible improvements。众所周知，递归算法比非递归版本慢。

Fibonacci递归序列的时间复杂度为O(n^2)（我将跳过计算的细节，有大量论文和SO answers可用于该主题。有several variations。

一个快速改进是添加缓存。这将减少序列中相同子编号的计算。

这是一个使用数组作为存储的非常快速和肮脏的例子。

$cache = []

def fib(n)
  $cache[n] ||= if n < 2
    n
  else
    fib(n-1) + fib(n-2)
  end
end

只是为了好玩，这里有一个更紧凑，更独立的替代方案

def fib(n)
  $fibcache    ||= []
  $fibcache[n] ||= (n < 2 ? n : fib(n-1) + fib(n-2))
end

PS。我仅使用全局变量作为示例来演示memoization模式。你应该使用一个更好的系统，全局变量几乎被认为是Ruby中的代码味道。

Answer 3

您可以在计算递归斐波那契时尝试保存结果：

def fibonacci_recursive(n):
    def fib_rec(n, a, b):
        if n == 1:
            return a
        return fib_rec(n - 1, a + b, a)
    return fib_rec(n, 1, 0)

您的递归代码具有指数行为：O（phi ^ n）其中phi =（1 + sqrt（5））/ 2.

编辑：这是在Python中（没有看到Ruby标签）。应该简单地翻译。

优化递归搜索

3 个答案: