复杂度分析

Posted 2020-11-26 tczw

复杂度分析

衡量一个算法的执行效率需要使用复杂度分析

 

---

 

为什么需要复杂度分析？

1. 单纯靠测试的方法来衡量算法的执行效率是不可靠的。因为在不同的机器环境下执行同样一段代码，结果可能会不同。测试数据也会影响测试结果，比如排序算法，运行不同量级的数据时，表现会不一样，比如对于小规模的数据排序，插入排序可能反倒会比快速排序要快！
2. 所以，我们需要一个不用具体数据来测试的方法，来估算算法的执行效率。也就是时间、空间复杂度分析。

 

---

 

大 O 复杂度表示法

如何直接用肉眼观察出一段代码的执行时间。

 1  int cal(int n) {
 2    int sum = 0;
 3    int i = 1;
 4    int j = 1;
 5    for (; i <= n; ++i) {
 6      j = 1;
 7      for (; j <= n; ++j) {
 8        sum = sum +  i * j;
 9      }
10    }
11  }

 

假设每段代码对应的执行时间都是一样的，为unit_time。

总执行时间为:(2n²+2n+3)*unit_time

可以看出总执行时间T(n)与每行代码的执行次数n成正比，于是得到下面公式：

T(n) = O(f(n))，

其中T(n)代表代码的执行总时间，n表示数据规模的大小,f(n)表示每行代码执行次数总和。O表示T(n)与f(n)表达式成正比。

这就叫做大O时间复杂度表示法，表示代码执行时间随数据规模增长的变化趋势，也叫做渐进时间复杂度,简称时间复杂度。

当n很大时，可以把它想象成无穷大，而公式中的低阶、常量、系数三部分因为不左右增长趋势可以都忽略。我们只需要记录一个最大量级就可以了。

例如上面例子，可以记为:T(n) = O(n²)

 

---

 

时间复杂度分析

如何分析一段代码的时间复杂度？

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

几种常见时间复杂度量级，可以粗略地分为两类，多项式量级和非多项式量级。

多项式量级：常量阶O(1),对数阶O(logn),线性阶O(n),线性对数阶O(nlogn),K次方阶O(n^k)

非多项式量级:指数阶O(2ⁿ),阶乘阶O(n!)

非多项式量级复杂度的算法是非常低效的算法。我们一般使用的算法的复杂度大多都是多项式量级的。

 

---

 

 常见多项式时间复杂度

1.O(1)

O(1)只是常量级时间复杂度的一种表示方法，并不是指只执行了一行代码。一般情况下，只要算法中不存在循环语句。递归语句，即使有成千上万的代码，时间复杂度都是O(1)。

2.O(logn)、O(nlogn)

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

 

 

 从代码中可以看出，变量 i 的值从 1 开始取，每循环一次就乘以 2。当大于 n 时，循环结束。通过 2^x=n 求解 x。

x=log2n，所以，这段代码的时间复杂度就是 O(log2n)。

实际上，不管是以 2 为底、以 3 为底，还是以 10 为底，我们可以把所有对数阶的时间复杂度都记为 O(logn)。为什么呢？

我们知道，对数之间是可以互相转换的，log3n 就等于 log32 * log2n，所以 O(log3n) = O(C *  log2n)，其中 C=log32 是一个常量。基于我们前面的一个理论：在采用大 O 标记复杂度的时候，可以忽略系数，即 O(Cf(n)) = O(f(n))。所以，O(log2n) 就等于 O(log3n)。因此，在对数阶时间复杂度的表示方法里，我们忽略对数的“底”，统一表示为 O(logn)。

如果你理解了我前面讲的 O(logn)，那 O(nlogn) 就很容易理解了。还记得我们刚讲的乘法法则吗？如果一段代码的时间复杂度是 O(logn)，我们循环执行 n 遍，时间复杂度就是 O(nlogn) 了。而且，O(nlogn) 也是一种非常常见的算法时间复杂度。比如，归并排序、快速排序的时间复杂度都是 O(nlogn)。

3.O(m+n)、O(m*n)

 1 int cal(int m, int n) {
 2   int sum_1 = 0;
 3   int i = 1;
 4   for (; i < m; ++i) {
 5     sum_1 = sum_1 + i;
 6   }
 7 
 8   int sum_2 = 0;
 9   int j = 1;
10   for (; j < n; ++j) {
11     sum_2 = sum_2 + j;
12   }
13 
14   return sum_1 + sum_2;
15 }

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

 

---

 

空间复杂度分析

时间复杂度的全称是渐进时间复杂度，表示算法的执行时间与数据规模之间的增长关系。类比一下，空间复杂度全称就是渐进空间复杂度，表示算法的存储空间与数据规模之间的增长关系。

int[] a = new int[n]

这里的空间复杂度就为O(n),我们常见的空间复杂度就是 O(1)、O(n)、O(n2)，像 O(logn)、O(nlogn) 这样的对数阶复杂度平时都用不到。

 

---

总结

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

 

参考：极客时间数据结构与算法之美