时间复杂度分析(上)

为什么会有时间复杂度分析？

数据结构和算法解决的就是‘快’和‘省’的问题，即如何让代码跑的更快，更省存储空间。

大 O 复杂度表示法

算法的执行效率，粗略地讲，就是算法代码执行的时间

• 只关注循环执行次数最多的一段代码
  大 O 这种复杂度表示方法只是表示一种变化趋势，我们通常会忽略掉公式中的常量、低阶、系数，只需要记录一个最大阶的量级就可以了。所以在分析一个算法、一段代码的时间复杂度的时候，也只关注循环执行次数最多的那一段代码就可以了

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

时间复杂度为O(n), n表示的是执行次数， 代码的执行时间为T(n)

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

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;
 }

第一段：循环100次，因为循环次数100是常量，无论这个常量多大，照样也是常量级的执行时间，都与n的规模无关，就可以忽略，因为对n的增长趋势没有影响，时间复杂度为O(1)。

第二段：循环n次，时间复杂度是O(n)

第三段：循环n²次，时间复杂度为O(n²)

综合这三段代码的时间复杂度，我们取其中最大的量级，即时间复杂度为：O(n²)

公式：

如果T1(n)=O(f(n))，T2(n)=O(g(n))；
那么 T(n)=T1(n)+T2(n)=max(O(f(n)), O(g(n))) =O(max(f(n), g(n))).

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

我们可以把乘法法则看成是嵌套循环

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;
 }

单独看：
第一段：循环n次，时间复杂度是O(n)
第二段：循环n次，时间复杂度是O(n)

整体：第一段中嵌套了f(i), 所以时间复杂度为O(n) * O(n)

公式：

如果 T1(n)=O(f(n))，T2(n)=O(g(n))；
那么 T(n)=T1(n)*T2(n)=O(f(n))*O(g(n))=O(f(n)*g(n)).

常见的复杂度量级

对于以上罗列的复杂度量级，我们可以粗略地分为两类，多项式量级和非多项式量级。其中，非多项式量级只有两个：O(2n) 和 O(n!)。

我们把时间复杂度为非多项式量级的算法问题叫作 NP（Non-Deterministic Polynomial，非确定多项式）问题。

数据规模 n 越来越大时，非多项式量级算法的执行时间会急剧增加，求解问题的执行时间会无限增长。所以，非多项式时间复杂度的算法其实是非常低效的算法。

时间复杂度分析

时间复杂度的全称是渐进时间复杂度，表示算法的执行时间与数据规模之间的增长关系。

O(1)

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

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

O(logn)、O(nlogn)

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

这是一个等比数列, 循环x遍就是对应的时间复杂度
则 2^x = n 求解即得：x = log₂n，所以这个代码的时间复杂度为：O(log₂n)

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

时间复杂度为：O(log~3~n)
不管是以2为底还是以3为底或10为底，我们可以把所有对数阶的时间复杂度都记为 O(logn)。

如果对以上的程序执行n遍，那么时间复杂度为O(nlogn)

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)。

针对这种情况，原来的加法法则就不正确了，我们需要将加法规则改为：T1(m) + T2(n) = O(f(m) + g(n))。但是乘法法则继续有效：T1(m)*T2(n) = O(f(m) * f(n))。

空间复杂度分析

空间复杂度全称是渐进空间复杂度（asymptotic space complexity），表示算法的存储空间与数据规模之间的增长关系

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]
  }
}

int[] a = new int[n];申请了一个大小为n的数组，其他都不占用大小，则空间复杂度为O(n)

常见的空间复杂度

O(1)、O(n)、O(n2)
O(logn)、O(nlogn) 这样的对数阶复杂度平时都用不到

总结

什么是复杂度分析？

• 数据结构和算法解决是“如何让计算机更快时间、更省空间的解决问题”。
• 因此需从执行时间和占用空间两个维度来评估数据结构和算法的性能。
• 分别用时间复杂度和空间复杂度两个概念来描述性能问题，二者统称为复杂度。
• 复杂度描述的是算法执行时间（或占用空间）与数据规模的增长关系。

为什么要进行复杂度分析？

• 和性能测试相比，复杂度分析有不依赖执行环境、成本低、效率高、易操作、指导性强的特点。
• 掌握复杂度分析，将能编写出性能更优的代码，有利于降低系统开发和维护成本。

如何进行复杂度分析？

大O表示法

• 来源
  算法的执行时间与每行代码的执行次数成正比，用T(n) = O(f(n))表示，其中T(n)表示算法执行总时间，f(n)表示每行代码执行总次数，而n往往表示数据的规模。
• 特点
  以时间复杂度为例，由于时间复杂度描述的是算法执行时间与数据规模的增长变化趋势，所以常量阶、低阶以及系数实际上对这种增长趋势不产决定性影响，所以在做时间复杂度分析时忽略这些项。

复杂度分析法则

• 单段代码看高频：比如循环。
• 多段代码取最大：比如一段代码中有单循环和多重循环，那么取多重循环的复杂度。
• 嵌套代码求乘积：比如递归、多重循环等
• 多个规模求加法：比如方法有两个参数控制两个循环的次数，那么这时就取二者复杂度相加。

常用的复杂度级别？

• 多项式阶：随着数据规模的增长，算法的执行时间和空间占用，按照多项式的比例增长。包括：O(1)（常数阶）、O(logn)（对数阶）、O(n)（线性阶）、O(nlogn)（线性对数阶）、O(n^{2)（平方阶）、O(n}3)（立方阶）
• 非多项式阶：随着数据规模的增长，算法的执行时间和空间占用暴增，这类算法性能极差。包括：O(2^n)（指数阶）、O(n!)（阶乘阶）
  五、如何掌握好复杂度分析方法？
  复杂度分析关键在于多练，所谓孰能生巧。

时间复杂度分析是否多此一举？

我不认为是多此一举，渐进时间，空间复杂度分析为我们提供了一个很好的理论分析的方向，并且它是宿主平台无关的，能够让我们对我们的程序或算法有一个大致的认识，让我们知道，比如在最坏的情况下程序的执行效率如何，同时也为我们交流提供了一个不错的桥梁，我们可以说，算法1的时间复杂度是O(n)，算法2的时间复杂度是O(logN)，这样我们立刻就对不同的算法有了一个“效率”上的感性认识。

当然，渐进式时间，空间复杂度分析只是一个理论模型，只能提供给粗略的估计分析，我们不能直接断定就觉得O(logN)的算法一定优于O(n), 针对不同的宿主环境，不同的数据集，不同的数据量的大小，在实际应用上面可能真正的性能会不同，个人觉得，针对不同的实际情况，进而进行一定的性能基准测试是很有必要的，比如在统一一批手机上(同样的硬件，系统等等)进行横向基准测试，进而选择适合特定应用场景下的最有算法。

综上所述，渐进式时间，空间复杂度分析与性能基准测试并不冲突，而是相辅相成的，但是一个低阶的时间复杂度程序有极大的可能性会优于一个高阶的时间复杂度程序，所以在实际编程中，时刻关心理论时间，空间度模型是有助于产出效率高的程序的，同时，因为渐进式时间，空间复杂度分析只是提供一个粗略的分析模型，因此也不会浪费太多时间，重点在于在编程时，要具有这种复杂度分析的思维。