我正在尝试使用递归树来查找斐波那契数列的复杂性，并得出结论height of tree = O(n)最坏情况cost of each level = cn，因此complexity = n*n=n^2
怎么会是O(2^n)？
【问题讨论】：
标签： algorithm recursion big-o fibonacci
朴素递归斐波那契的复杂度确实是 2ⁿ。
T(n) = T(n-1) + T(n-2) = T(n-2) + T(n-3) + T(n-3) + T(n-4) =
= T(n-3) + T(n-4) + T(n-4) + T(n-5) + T(n-4) + T(n-5) + T(n-5) + T(n-6) = ...
在每个步骤中，您两次调用T，因此将提供最终的渐近障碍：T(n) = 2⋅2⋅...⋅2 = 2ⁿ
奖励：斐波那契的最佳理论实现实际上是close formula，使用golden ratio：
Fib(n) = (φⁿ – (–φ)⁻ⁿ)/sqrt(5) [where φ is the golden ratio]
（但是，由于浮点运算，它在现实生活中会出现精度误差，不精确）
【讨论】：
T(n) = T(n/2) + T(n/2) = T(n/4) + T(n/4) + T(n/4) + T(n/4) = ... = T(n/2^logn) + ... + T(n/2^logn) [2^logn times] = 2^logn = n
这样看。假设通过递归计算F(k)，kth 斐波那契数的复杂度最多为2^k，对于k <= n。这是我们的归纳假设。那么递归计算F(n + 1)的复杂度为
F(n + 1) = F(n) + F(n - 1)
具有复杂性2^n + 2^(n - 1)。请注意
2^n + 2^(n - 1) = 2 * 2^n / 2 + 2^n / 2 = 3 * 2^n / 2 <= 2 * 2^n = 2^(n + 1).
我们已经通过归纳证明，通过递归计算F(k) 最多为2^k 的说法是正确的。
【讨论】：
你是正确的，树的深度是 O(n)，但你没有在每个级别上做 O(n) 的工作。在每一层，每个递归调用都做 O(1) 的工作，但是每个递归调用会贡献两个新的递归调用，一个在它的下一层，一个在它下面的第二层。这意味着，随着您在递归树中越走越远，每个级别的调用次数呈指数级增长。
有趣的是，您实际上可以将计算 F(n) 所需的准确调用次数确定为 2F(n + 1) - 1，其中 F(n) 是第 n 个斐波那契数。我们可以归纳地证明这一点。作为基本情况，要计算 F(0) 或 F(1)，我们需要对函数进行一次调用，该函数在不进行任何新调用的情况下终止。假设 L(n) 是计算 F(n) 所需的调用次数。然后我们就有了
L(0) = 1 = 2*1 - 1 = 2F(1) - 1 = 2F(0 + 1) - 1
L(1) = 1 = 2*1 - 1 = 2F(2) - 1 = 2F(1 + 1) - 1
现在，对于归纳步骤，假设对于所有 n'
1 + L(n - 1) + L(n - 2)
= 1 + 2F((n - 1) + 1) - 1 + 2F((n - 2) + 1) - 1
= 2F(n) + 2F(n - 1) - 1
= 2(F(n) + F(n - 1)) - 1
= 2(F(n + 1)) - 1
= 2F(n + 1) - 1
这完成了归纳。
此时，您可以使用Binet's formula 来表明
L(n) = 2(1/√5)(((1 + √5) / 2)n - ((1 - √5) / 2)n) - 1
因此 L(n) = O(((1 + √5) / 2)n)。如果我们使用约定
φ = (1 + √5) / 2 & 约; 1.6
我们有这个
L(n) = Θ(φn)
并且由于 φ n)（使用 little-o 表示法）。
有趣的是，我为这个系列选择了名称 L(n)，因为这个系列被称为 Leonardo numbers。除了这里的使用，它还出现在smoothsort算法的分析中。
希望这会有所帮助！
【讨论】：
T(k) 的复杂度对于k <= n - 1 至多为k，那么T(n) 的复杂度至多为T(n) = T(n / 2) + T(n / 2) <= 2 * n / 2 = n。
double phi = 1.6180339887; return Math.round((Math.pow(phi, n) / Math.sqrt(5)));
斐波那契数列的复杂度为 O(F(k))，其中 F(k) 是第 k 个斐波那契数。这可以通过归纳来证明。对于基础案例来说这是微不足道的。并假设对于所有k
【讨论】：
T(k) = C*F(k) + o(F(k)) for k <= n 毫无意义）。
t(n)=t(n-1)+t(n-2) 可以通过tree方法解决：
t(n-1) + t(n-2) 2^1=2
| |
t(n-2)+t(n-3) t(n-3)+t(n-4) 2^2=4
. . 2^3=8
. . .
. . .
最后一层也是如此。 . 2^n
它会使总时间复杂度=>2+4+8+.....2^n
解决上述 gp 后，我们将得到时间复杂度为 O(2^n)
【讨论】：
fib(n) 的递归树类似于：
n
/ \
n-1 n-2 --------- maximum 2^1 additions
/ \ / \
n-2 n-3 n-3 n-4 -------- maximum 2^2 additions
/ \
n-3 n-4 -------- maximum 2^3 additions
........
-------- maximum 2^(n-1) additions
【讨论】：
斐波那契数计算的 O(2^n) 复杂度仅适用于递归方法。使用一些额外的空间，您可以使用 O(n) 获得更好的性能。
public static int fibonacci(int n) throws Exception {
if (n < 0)
throws new Exception("Can't be a negative integer")
if (n <= 1)
return n;
int s = 0, s1 = 0, s2 = 1;
for(int i= 2; i<=n; i++) {
s = s1 + s2;
s1 = s2;
s2 = s;
}
return s;
}
【讨论】：
递归斐波那契数列的复杂度为 2^n:
这将是递归斐波那契的递归关系
T(n)=T(n-1)+T(n-2) No of elements 2
现在使用替换方法解决这个关系（替换 T(n-1) 和 T(n-2) 的值）
T(n)=T(n-2)+2*T(n-3)+T(n-4) No of elements 4=2^2
再次代入上述项的值，我们将得到
T(n)=T(n-3)+3*T(n-4)+3*T(n-5)+T(n-6) No of elements 8=2^3
完全解决后，我们得到
T(n)={T(n-k)+---------+---------}----------------------------->2^k eq(3)
这意味着任何级别的最大递归调用次数最多为 2^n。
对于等式 3 中的所有递归调用是 ϴ(1)，因此时间复杂度将为 2^n* ϴ(1)=2^n
【讨论】：
我无法抗拒将 Fib 的线性时间迭代算法连接到指数时间递归算法的诱惑：如果有人阅读 Jon Bentley 关于“编写高效算法”的精彩小书，我相信这是一个简单的“缓存”案例：每当计算 Fib(k) 时，将其存储在数组 FibCached[k] 中。每当调用 Fib(j) 时，首先检查它是否缓存在 FibCached[j] 中；如果是，则返回值；如果不使用递归。 （现在看看调用树...）
【讨论】：