我知道大o符号，但我不知道如何计算它的许多函数。特别是，我一直在试图弄清楚朴素版斐波那契数列的计算复杂度:
int Fibonacci(int n)
{
if (n <= 1)
return n;
else
return Fibonacci(n - 1) + Fibonacci(n - 2);
}
斐波那契数列的计算复杂度是多少?它是如何计算的?
当前回答
将计算Fib(n)的时间函数建模为计算Fib(n-1)的时间加上计算Fib(n-2)的时间加上将它们相加的时间(O(1))的总和。这是假设重复计算相同的Fib(n)需要相同的时间-即不使用记忆。
T(n<=1) = O(1)
T(n) = T(n-1) + T(n-2) + O(1)
你解决这个递归关系(例如使用生成函数)，你就会得到答案。
或者，你可以画出递归树，它的深度是n，直观地看出这个函数是渐近的O(2n)。然后你可以用归纳法证明你的猜想。
基数:n = 1是显而易见的
因此，假设T(n-1) = O(2n-1)
T(n) = T(n-1) + T(n-2) + O(1)等于
T(n) = O(2n-1) + O(2n-2) + O(1) = O(2n)
然而，正如评论中提到的，这不是严格的界限。关于这个函数的一个有趣的事实是T(n)与Fib(n)的值渐近相同，因为两者都被定义为
f(n) = f(n-1) + f(n-2)。
递归树的叶结点总是返回1。Fib(n)的值是递归树中所有叶子返回值的和，等于叶子的计数。由于每个叶需要O(1)来计算，T(n)等于Fib(n) x O(1)。因此，这个函数的紧界是斐波那契数列本身(~θ(1.6n))。你可以使用我上面提到的生成函数来找到这个紧边界。
其他回答
证明答案很好，但我总是不得不手工做一些迭代来真正说服自己。所以我在白板上画了一个小的调用树，并开始计算节点。我将计数分为总节点、叶节点和内部节点。以下是我得到的答案:
IN | OUT | TOT | LEAF | INT
1 | 1 | 1 | 1 | 0
2 | 1 | 1 | 1 | 0
3 | 2 | 3 | 2 | 1
4 | 3 | 5 | 3 | 2
5 | 5 | 9 | 5 | 4
6 | 8 | 15 | 8 | 7
7 | 13 | 25 | 13 | 12
8 | 21 | 41 | 21 | 20
9 | 34 | 67 | 34 | 33
10 | 55 | 109 | 55 | 54
显而易见的是，叶节点的数量是fib(n)经过几次迭代才发现，内部节点的数量是fib(n) - 1。因此节点总数为2 * fib(n) - 1。
由于在对计算复杂度进行分类时去掉了系数，最终答案是θ(fib(n))。
通过绘制函数调用图来计算很简单。简单地为n的每个值添加函数调用，看看这个数字是如何增长的。
大O是O(Z^n)， Z是黄金比例，约为1.62。
当我们增加n时，列奥纳多数和斐波那契数都接近这个比率。
与其他大O问题不同，输入中没有可变性，算法和算法的实现都是明确定义的。
不需要一堆复杂的数学。简单地画出下面的函数调用，并将函数与数字匹配。
如果你熟悉黄金比例你就能认出来。
这个答案比公认的f(n) = 2^n的答案更正确。永远不会。它会趋于f(n) = golden_ratio^n。
2 (2 -> 1, 0)
4 (3 -> 2, 1) (2 -> 1, 0)
8 (4 -> 3, 2) (3 -> 2, 1) (2 -> 1, 0)
(2 -> 1, 0)
14 (5 -> 4, 3) (4 -> 3, 2) (3 -> 2, 1) (2 -> 1, 0)
(2 -> 1, 0)
(3 -> 2, 1) (2 -> 1, 0)
22 (6 -> 5, 4)
(5 -> 4, 3) (4 -> 3, 2) (3 -> 2, 1) (2 -> 1, 0)
(2 -> 1, 0)
(3 -> 2, 1) (2 -> 1, 0)
(4 -> 3, 2) (3 -> 2, 1) (2 -> 1, 0)
(2 -> 1, 0)
好吧，根据我的说法，它是O(2^n)，因为在这个函数中，只有递归花费了相当多的时间(分治)。我们看到，上面的函数将在树中继续存在，直到叶子趋近于F(n-(n-1))级，即F(1)。因此，当我们在这里记下树的每个深度处遇到的时间复杂度时，求和级数为:
1+2+4+.......(n-1)
= 1((2^n)-1)/(2-1)
=2^n -1
它是2^n的O(2^n)阶。
将计算Fib(n)的时间函数建模为计算Fib(n-1)的时间加上计算Fib(n-2)的时间加上将它们相加的时间(O(1))的总和。这是假设重复计算相同的Fib(n)需要相同的时间-即不使用记忆。
T(n<=1) = O(1)
T(n) = T(n-1) + T(n-2) + O(1)
你解决这个递归关系(例如使用生成函数)，你就会得到答案。
或者，你可以画出递归树，它的深度是n，直观地看出这个函数是渐近的O(2n)。然后你可以用归纳法证明你的猜想。
基数:n = 1是显而易见的
因此，假设T(n-1) = O(2n-1)
T(n) = T(n-1) + T(n-2) + O(1)等于
T(n) = O(2n-1) + O(2n-2) + O(1) = O(2n)
然而，正如评论中提到的，这不是严格的界限。关于这个函数的一个有趣的事实是T(n)与Fib(n)的值渐近相同，因为两者都被定义为
f(n) = f(n-1) + f(n-2)。
递归树的叶结点总是返回1。Fib(n)的值是递归树中所有叶子返回值的和，等于叶子的计数。由于每个叶需要O(1)来计算，T(n)等于Fib(n) x O(1)。因此，这个函数的紧界是斐波那契数列本身(~θ(1.6n))。你可以使用我上面提到的生成函数来找到这个紧边界。
由于计算的重复，朴素递归版本的斐波那契是指数型的:
在根上，你正在计算:
F(n)取决于F(n-1)和F(n-2)
F(n-1)又取决于F(n-2)和F(n-3)
F(n-2)又取决于F(n-3)和F(n-4)
然后你在每一个二级递归调用中都浪费了大量的数据，时间函数看起来像这样:
T（n） = T（n-1） + T（n-2） + C，C 常数
T（n-1） = T（n-2） + T（n-3） > T（n-2） 则
T（n） > 2*T（n-2）
...
T(n) > 2^(n/2) * T(1) = O(2^(n/2))
这只是一个下界，对于你的分析来说应该足够了，但实时函数是一个常数的因子，根据相同的斐波那契公式，封闭形式是已知的黄金比例的指数。
此外，你可以使用动态规划找到优化版的斐波那契函数，如下所示:
static int fib(int n)
{
/* memory */
int f[] = new int[n+1];
int i;
/* Init */
f[0] = 0;
f[1] = 1;
/* Fill */
for (i = 2; i <= n; i++)
{
f[i] = f[i-1] + f[i-2];
}
return f[n];
}
这是优化的，只做n步，但也是指数级的。
Cost functions are defined from Input size to the number of steps to solve the problem. When you see the dynamic version of Fibonacci (n steps to compute the table) or the easiest algorithm to know if a number is prime (sqrt(n) to analyze the valid divisors of the number). you may think that these algorithms are O(n) or O(sqrt(n)) but this is simply not true for the following reason: The input to your algorithm is a number: n, using the binary notation the input size for an integer n is log2(n) then doing a variable change of
m = log2(n) // your real input size
让我们找出作为输入大小的函数的步数
m = log2(n)
2^m = 2^log2(n) = n
那么你的算法的代价作为输入大小的函数是:
T(m) = n steps = 2^m steps
这就是为什么成本是指数级的。
