相关疑难解决方法(0)

问题

如何找到算法的时间复杂度？

在SO上发布问题之前我做了什么？

我走过了这个,这和许多其他链接

但是,我没有能够找到关于如何计算时间复杂度的明确而直接的解释.

我知道什么 ？

假设代码如下所示:

char h = 'y'; // This will be executed 1 time
int abc = 0; // This will be executed 1 time

说一个像下面这样的循环:

for (int i = 0; i < N; i++) {        
    Console.Write('Hello World !');
}

int i = 0; 这只会执行一次.实际计算时间i=0而不是声明.

我<N; 这将执行N + 1次

i ++; 这将被执行N次

所以这个循环所需的操作数量是

{1+(N + 1)+ N} = 2N + 2

注意:这仍然可能是错误的,因为我对计算时间复杂度的理解没有信心

我想知道什么？ …

什么是假多项式时间？它与多项式时间有何不同？在伪多项式时间运行的一些算法具有运行时间,如O(nW)(对于0/1背包问题)或O(√n)(对于试验除法); 为什么不算作多项式时间？

今天在课堂上我的老师在黑板上写下了这个递归因子算法:

int factorial(int n) {
   if (n == 1) 
       return 1;
   else 
       return n * factorial(n-1);
}

她说它有成本T(n-1) + 1.

然后用迭代法她说T(n-1) = T(n-2) + 2 = T(n-3) + 3 ... T(n-j) + j,所以算法停止的时候n - j = 1,所以j = n - 1.

之后,她取代j的T(n-j) + j,并获得了T(1) + n-1.

她直接说那个n-1 = 2 ^{(log ₂ n-1)},所以算法的成本是指数的.

我真的失去了最后两步.可以请有人向我解释一下吗？

这段代码的大O是什么？我知道所有的行都是O(1),除了递归部分.我不确定递归的大O是什么,我感觉它仍然是O(1),因为我们没有比O(1)差的行,但通常递归是O(n).

码:

public int getSum(int a, int b) {

        if (b == 0){
            return a;
        }

        if (a == 0){
            return b;
        }

        int add = a ^ b;
        int carry = (a&b) << 1;

        return getSum(add, carry);
    }

编辑:顺便说一下,这不是作业,而是为面试做好准备.

计算以下递归函数的时间和空间复杂度(Big O表示法)的最直观方法是什么？

function count(str) {
  if (str.length <= 1) {
    return 1;
  }

  var firstTwoDigits = parseInt(str.slice(0, 2), 10);

  if (firstTwoDigits <= 26) {
    return count(str.slice(1)) +
           count(str.slice(2));
  }

  return count(str.slice(1));
}

我有一个使用递归打印斐波纳契数列的程序.有更好的方法,但我被要求使用递归,所以我必须这样做.

这是程序:

#include <stdio.h>
#define TERMS 10

long fibo(int);

int main(void){
   for(int i = 1; i <= TERMS; i++) {
       printf("%ld", fibo(i));
   }
   return 0;
}

long fibo(int n){
    if (n < 3) {
        return 1;
    }
    else {
        return fibo(n - 1) + fibo(n - 2);
    }
}

我知道这对于Fibonacci系列来说真的是一个糟糕的方法,从上面可以清楚地看到,因为TERMS超过35,该程序需要花费大量时间才能完成.

我已经完成了这个答案,无法理解他们是如何解决的,但它看起来像

fibo(int n)的时间复杂度为O(2 ^ n)

我可能也完全错了,但我想要的只是:

这个完整程序的时间复杂度是什么,简要解释一下你如何计算它？

如果你有一个更好的方法来计算使用递归计算Fibonacci,也欢迎.

对于迭代版本，它是线性的：

// O(n)
function factorial (n) {
  let ret = 1;
  for(let i = 2; i <= n; i++) {
    ret = ret * i;
  }
  return ret;
}

对于递归版本，它似乎也是线性的：

function factorialR (n) {
  if( n === 0 || n === 1 ) {
    return 1;
  } else {
    return n * factorialR(n - 1);
  }
}

递归版本也是线性的吗？它只是一个额外的函数调用，而不是每个附加值的循环。

我很困惑解决这个时间复杂性问题.

T(n) = T(n-1)

我知道快速排序最糟糕的情况 T(n) = T(n-1) + T(1) + n

评估为(n-1) + (n-2) + (n-3) + ... + 1&此几何序列等于O(n^2)

然而.我看到stackoverflow上的答案T(n) = T(n-1) + c = O(n).

当这也等于时(n-1) + (n-2) + (n-3) + ... + 1,这怎么可能呢？O(n^2)

有人可以解释一下.

我不知道从哪里开始计算这个函数的时间复杂度。这个函数的 O（时间复杂度）是多少？我了解到答案是 3^n。

int f3(int n) {
    if (n < 100)
        return 1;
    return n* f3(n-1) * f3(n-2) * f3(n-3)
}