Algorithm 以下伪代码的big-O复杂性是多少？_Algorithm_Complexity Theory

Algorithm 以下伪代码的big-O复杂性是多少？

algorithm

Algorithm 以下伪代码的big-O复杂性是多少？,algorithm,complexity-theory,Algorithm,Complexity Theory,以下伪代码的计算复杂度是多少 integer recursive (integer n) { if (n == 1) return (1); else return (recursive (n-1) + recursive (n-1)); } 在现实世界中，调用将得到优化并产生线性复杂度，但在计算大Oh的RAM模型中，复杂度是多少2^n？该算法的当前形式的复杂性实际上是O（2n），因为在每一级调用上，调用数将增加两倍 integer recursive (i

以下伪代码的计算复杂度是多少

integer recursive (integer n) {
   if (n == 1)
      return (1);
   else
      return (recursive (n-1) + recursive (n-1));
}

在现实世界中，调用将得到优化并产生线性复杂度，但在计算大Oh的RAM模型中，复杂度是多少2^n？

该算法的当前形式的复杂性实际上是O（2n），因为在每一级调用上，调用数将增加两倍

integer recursive (integer n) {
   if (n == 1)
      return (1);
   else
      return (recursive (n-1) + recursive (n-1));
}

第一个调用（递归（n））构成一个调用

下一级（递归（n-1））由2个调用组成

在基本情况下（递归（1）），它构成2n-1个调用

所以函数调用的总数是1+2+…+2n-1=2n-1

所以复杂性为O（2n）

其他要点：

正如您所说，通过记忆或动态编程，可以很容易地得到O（n）（或者对于这种特殊情况，使用快速求幂法得到O（logn）。

此算法的当前形式的复杂性实际上是O（2n），因为在每一级调用上，调用数都会增加一倍

第一个调用（递归（n））构成一个调用

下一级（递归（n-1））由2个调用组成

在基本情况下（递归（1）），它构成2n-1个调用

所以函数调用的总数是1+2+…+2n-1=2n-1

所以复杂性为O（2n）

其他要点：

正如您所说，通过记忆或动态编程，可以很容易地实现O（n）（或者对于这种特殊情况，可以使用快速求幂法实现O（logn）。

您的复杂性将是

为什么会这样？简单证明：

N=1：特殊情况，步数=1
N=2，很明显，=2，所以它是正确的
让它对
```
N=K
```
正确，即对
```
N=K
```
正确
假设
```
N=K+1
```
。函数
```
recursive
```
将递归调用自己两次
```
N=K
```
：
```
recursive（K+1）=recursive（K）+recursive（K）
```
，如下代码所示。即：。因此，对于
```
N=K+1
```
我们得到了步骤

因此，我们已经证明了

的复杂性在一般情况下（根据数学归纳法的定义）。

您的复杂性将是

为什么会这样？简单证明：

N=1：特殊情况，步数=1
N=2，很明显，=2，所以它是正确的
让它对
```
N=K
```
正确，即对
```
N=K
```
正确
假设
```
N=K+1
```
。函数
```
recursive
```
将递归调用自己两次
```
N=K
```
：
```
recursive（K+1）=recursive（K）+recursive（K）
```
，如下代码所示。即：。因此，对于
```
N=K+1
```
我们得到了步骤

因此，我们已经证明了

的复杂度在一般情况下（根据数学归纳法的定义）。

这样的复杂度似乎是2^N，但可以减少到N。是的，这似乎是

2^N

。在每一个递归上，递归树都以2的因子分支。因此，在递归结束时，您有一个深度为

的完整二叉树，因此顺序为

Θ（2^n）

。这样的复杂性似乎是2^n，但可以将其减少到n。是的，这似乎是

2^n

。在每个递归上，您的递归树都以因子2分支。因此，在递归结束时，您有一个深度为

的完整二叉树，因此顺序为

Θ（2^n）

。