Recursion 两个递归调用将N分成两半的函数的时间复杂度 int函数8（int N）{ 整数和=0； 对于（int i=0；i1） 返回和+函数8（N/2）+函数8（N/2）； 其他的 返回0； }

上述算法的时间复杂度是多少

参考斐波那契递归理论，将其视为n* 2 ^ n，因为<<代码> < /代码>循环为O（n），递归部分为2 ^ n/p> 递归部分是2^N

不，递归部分是O（log（N）），因为每次递归调用都会将N切成两半。该算法基本上简化为O（n log（n）），因为我们对每个堆栈帧执行O（n）个工作，并且创建了log（n）个堆栈帧

斐波那契在这里是不相关的，因为这是一个动态规划问题，涉及到使用前面的两个解N-1和N-2来构建N，正如你所说的，它给出了一个简单的指数算法。这与我们在这里看到的代码中的复杂度不同。如果递归调用是

function8（N-2）+function8（N-1），那么你就对了

递归部分是2^N

不，递归部分是O（log（N）），因为每次递归调用都会将N切成两半。该算法基本上简化为O（n log（n）），因为我们对每个堆栈帧执行O（n）个工作，并且创建了log（n）个堆栈帧

斐波那契在这里是不相关的，因为这是一个动态规划问题，涉及到使用前面的两个解N-1和N-2来构建N，正如你所说的，它给出了一个简单的指数算法。这与我们在这里看到的代码中的复杂度不同。如果递归调用是
function8（N-2）+function8（N-1），那么您就对了。
实现的时间复杂度是
O（N log N）
，因为递归关系是
T（N）=O（N）+2*T（N/2）
（
O（N）
用于计算
sum
，其余用于两个递归调用）

但是您可以编写
2*function8（N/2）
而不是
function8（N/2）+function8（N/2）
。这将给出递归关系
T（N）=O（N）+T（N/2）
（只有一个递归调用），
因此，将复杂性降低到
O（N）
实现的时间复杂性是
O（N log N）
，因为递归关系是
T（N）=O（N）+2*T（N/2）
（
O（N）
用于计算
sum
，其余用于两个递归调用）

但是您可以编写
2*function8（N/2）
而不是
function8（N/2）+function8（N/2）
。这将给出递归关系
T（N）=O（N）+T（N/2）
（只有一个递归调用），
从而将复杂性降低到
O（N）

int function8(int N) {
  int sum = 0;

  for (int i = 0; i < N; i++) sum += 1;
  
  if (N > 1)
    return sum + function8(N / 2) + function8(N / 2);
  else
    return 0;
}