复杂度分析上-时间复杂度（important）

1、时间复杂度：

        大 O 时间复杂度表示法。大 O 时间复杂度实际上并不具体表示代码真正的执行时间，而是表示代码执行时间随数据规模增长的变化趋势，所以，也叫作渐进时间复杂度（asymptotic time complexity），简称时间复杂度，如T(n) = O(2n+2)， T(n) = O(2n*n+2n+3)。

1.1、时间复杂度分析实用方法：

1.1.1、 只关注循环执行次数最多的一段代码：

        我们通常会忽略掉公式中的常量、低阶、系数，只需要记录一个最大阶的量级就可以了。所以，我们在分析一个算法、一段代码的时间复杂度的时候，也只关注循环执行次数最多的那一段代码就可以了。举例：

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

循环执行次数最多的是for循环代码，这两行代码被执行了 n 次，所以总的时间复杂度就是 O(n)。

1.1.2、加法法则：总复杂度等于量级最大的那段代码的复杂度：

int cal(int n) {
   int sum_1 = 0;
   int p = 1;
   for (; p < 100; ++p) {
     sum_1 = sum_1 + p;
   }

   int sum_2 = 0;
   int q = 1;
   for (; q < n; ++q) {
     sum_2 = sum_2 + q;
   }
 
   int sum_3 = 0;
   int i = 1;
   int j = 1;
   for (; i <= n; ++i) {
     j = 1; 
     for (; j <= n; ++j) {
       sum_3 = sum_3 +  i * j;
     }
   }
 
   return sum_1 + sum_2 + sum_3;
 }

综合这三段代码的时间复杂度，我们取其中最大的量级。所以，整段代码的时间复杂度就为 O(n2)->n2标识n的平方也就是说：总的时间复杂度就等于量级最大的那段代码的时间复杂度。

1.1.3、 乘法法则：嵌套代码的复杂度等于嵌套内外代码复杂度的乘积：

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

整个 cal() 函数的时间复杂度就是，T(n) = T1(n) * T2(n) = O(n*n) = O(n2)。

1.2、常见的时间复杂度表示方式：

1.2.1、O(1)：

O(1) 只是常量级时间复杂度的一种表示方法，并不是指只执行了一行代码。比如这段代码，即便有 3 行，它的时间复杂度也是 O(1），而不是 O(3)。

只要代码的执行时间不随 n 的增大而增长，这样代码的时间复杂度我们都记作 O(1)。或者说，一般情况下，只要算法中不存在循环语句、递归语句，即使有成千上万行的代码，其时间复杂度也是Ο(1)。

1.2.2、 O(logn)、O(nlogn)：

对数阶时间复杂度非常常见，同时也是最难分析的一种时间复杂度。我通过一个例子来说明一下。

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

变量 i 的值从 1 开始取，每循环一次就乘以 2。当大于 n 时，循环结束，通过 2x次方=n 求解 x 这个值,x=log2n，这段代码的时间复杂度就是 O(log2n)。在对数阶时间复杂度的表示方法里，我们忽略对数的“底”，统一表示为 O(logn)。

1.3.3、3. 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)。

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

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

  return sum_1 + sum_2;
}

乘法法则有效：T1(m)*T2(n) = O(f(m) * f(n)),这种情况的时间复杂度：O(m*n)。

1.3、总结：

复杂度也叫渐进复杂度，包括时间复杂度和空间复杂度，用来分析算法执行效率与数据规模之间的增长关系，可以粗略地表示，越高阶复杂度的算法，执行效率越低，从低阶到高阶有：O(1)、O(logn)、O(n)、O(nlogn)、O(n2 )->n的平方。