这个c函数的复杂性是什么

以下c函数的复杂性是什么

double foo (int n) {
    int i;
    double sum;
    if (n==0) return 1.0;
    else {
        sum = 0.0;
        for (i =0; i<n; i++)
        sum +=foo(i);
        return sum;
    }
}

double foo（int n）{
int i；
双和；
如果（n==0）返回1.0；
否则{
总和=0.0；
对于（i=0；i对于一个，它的编码很差：）

double foo（int n）{//foo返回一个double，并接受一个整数参数
int i；//声明一个整数变量i，该变量用作下面的计数器
double sum；//这是返回的值
如果（n==0）返回1.0；//如果有人调用foo（0），此函数返回1.0
else{//如果n！=0
sum=0.0；//将sum设置为0
对于（i=0；i函数由多个部分组成

复杂性的第一位是if（n==0）返回1.0；
，因为它只生成一次运行。这就是
O（1）

下一部分是（i=0；i它是Θ（2^n）（假设f是我们的算法的运行时间）：

实际上，如果我们忽略常数运算，精确的运行时间是2n

同样，在你写的这是一个考试的情况下，O（n！）和O（n^n）都是正确的，并且最接近于Θ（2^n）的答案，其中是O（n！），但如果我是学生，我会将它们都打分数：）


关于O（n！）的解释：

对于所有n>=1:n！=n（n-1）.*2*1>=2*2*2*…*2=2^（n-1）=>
2*n！>=2^n=>2^n在O（n！）中，
而且n！=1所以n！在O（n^n）中
所以你们问题中的O（n！）是最接近θ（2^n）的可接受界
你本可以说得更清楚一点……咕哝咕哝

因此，可以简化为：

double foo(int n)
{
    return((double)pow(2, n));
}

“为什么foo返回双精度？”因为，它是双精度的。（重言式FTW！）将sum强制转换为int将是完全相同的值。使用int而不是double可以占用4字节而不是8字节的内存。i增加1，与n相比，i增加1，因此该函数总是以整数作为参数递归调用。它永远不需要返回double，除非执行超负或正操作数字。当然，负数有一个例外。它不会递归调用，因为我总是大于n。这是一个考试中提出的客观问题，提供的选项是1.O（1）2.O（n）3.O（n！）4.O（n^n）@Bunny Rabbit，可能是你的老师不熟悉O符号。3.O（n！）4.O（n^n）是真的，也是O（2^n）事实上，Teta（2^n）我想重点是选择最紧的边界嗯，你没有对O（n！）给出任何解释：（@Bunny Rabbit，查看我的更新。很好，但非常离题。@Juan，OP不够清楚……至少，当我第一次看这个问题时。我看到的大部分是代码和“你能解释一下吗？”事实上，wolfram alpha告诉我它正好是2^n，但是，嘿，细节：看看我的答案，看看执行的次数。
int foo(int n)
{
    if(n==0) return 1;
    else{
        int sum = 0;
        for(int i = 0; i < n; ++i)
        sum += foo(i);
        return sum;
    }
}

f(n) = f(n-1) + f(n-2) + ... + 1
f(n-1) = f(n-2) + f(n-3) + ...
==> f(n) = 2*f(n-1), f(0) = 1
==> f(n) is in O(2^n)

for all n >= 1: n! = n(n-1)...*2*1 >= 2*2*2*...*2 = 2^(n-1) ==>
2 * n! >= 2^n ==> 2^n is in O(n!),
Also n! <= n^n for all n >= 1 so n! is in O(n^n)

So O(n!) in your question is nearest acceptable bound to Theta(2^n)

<n = ?> : <return value> : <number of times called>
n = 0 : 1 : 1
n = 1 : 1 : 2
n = 2 : 2 : 4
n = 3 : 4 : 8
n = 4 : 8 : 16
n = 5 : 16 : 32
n = 6 : 32 : 64
n = 7 : 64 : 128
n = 8 : 128 : 256
n = 9 : 256 : 512
n = 10 : 512 : 1024

#include <iostream>

double foo (int n) {
    int i;
    double sum;
    if (n==0) return 1.0;
    else {
        sum = 0.0;
        for (i =0; i<n; i++)
        sum +=foo(i);
        return sum;
    }
}


int main(int argc, char* argv[])
{
    for(int n = 0; 1; n++)
    {
       std::cout << "n = " << n << " : " << foo(n);
       std::cin.ignore();
 }

    return(0);
}

n = 0 : 1
n = 1 : 1
n = 2 : 2
n = 3 : 4
n = 4 : 8
n = 5 : 16
n = 6 : 32
n = 7 : 64
n = 8 : 128
n = 9 : 256
n = 10 : 512

double foo(int n)
{
    return((double)pow(2, n));
}