数据结构和算法笔记--复杂度分析（上）

1.大O的定义

int cal(int n) {
    int sum = 0;
    int i = 1;
    for (; i <= n; ++i){
        sum = sum + i;
    }
    return sum;
}

第2、3行代码，每行执行一个unit_time时间，第4、5行都运行了n遍，所以需要 2* n * unit_time的执行时间 T(n) = (2n+2)*unit_time时间

int cal(int n) {
    int sum = 0;
    int i = 1;
    int j = 1;
    for (;i <= n; i++){
        j = 1;
        for (; j <= n; j++) {
            sum = sum + i * j;
        }
    }
}

第2、3、4行代码，每行执行一个unit_time时间 3unit_time，第5、6行执行了n次，需要2nunit_time时间，第7、8行执行了 nn所以需要2nnunit_time的时间，所以T(n) = (2n * n+ 2n + 3) * unit_time

由上面的两段代码可以看出，所有代码的执行时间和每行代码的执行次数n成正比

所以 T(n) = O(f(n))
注：f(n)为每行代码执行次数总和

当n很大时，第一段代码执行时间T(n) = O(n)， 第二段代码T(n) = O(n*n)

2.分析时间复杂度方法

• 只关注循环次数最多的一段代码
• 加法法则：总复杂度等于量级最大的那段代码的复杂度
• 乘法法则：嵌套代码的复杂度等于嵌套内外代码复杂度的乘积

3.常见的时间复杂度

• O(1)

  int i = 8;
  int j = 6;
  int sum = i + j;
  

  代码的时间不随n的增长而增加，都记作O(1)

• O(logn)、O(nlogn)

  i = 1;
  while (i <= n) {
      i = i * 2;
  }
  

  第三行代码的执行次数最多，每执行一次i * 2, 所以，我们需要求2^x = n中x的具体值。x = log2 n (以二为底n的对数)，所以该代码的时间复杂度为 O(log2n),忽略对数的底即为O(logn)

• O(m+n)、O(m*n)

int cal(int m, int n) {
  int sum_1 = 0;
  int i = 1;
  for (; i < m; ++i) {
    sum_1 = sum_1 + i;
  }

  int sum_2 = 0;
  int j = 1;
  for (; j < n; ++j) {
    sum_2 = sum_2 + j;
  }

  return sum_1 + sum_2;
}

该代码片段存在两个数据规模m,n。我们并不能判断m,n的大小，所以时间复杂度为O(m+n)

• 非多项级时间复杂度 O(2^n)与 O(n!)
  当n越来越大时，非多项级的时间复杂度会急剧增加，求解问题的执行时间会无限增长，所以非多项式的时间复杂度算法是非常低效的算法。

空间复杂度

void print(int n) {
    int i = 0;
    int[]a = new int[n];
    for(i; i < n; ++i) {
        a[i] = i * i; 
    }
    
    for (i = n-1; i >=0; --i) {
        print out a[i];
    }
}

整段代码只有第3行代码申请了一个大小为n的int类型的数组，所以空间复杂度为O(n)

相对于时间复杂度来说，空间复杂度要简单，常见的空间复杂度有O(1), O(n), O(n^2),像O(logn)和O(nlogn)这样的对数复杂度，一般用不到

T(n)与n的关系曲线图