复杂度分析：时间复杂度和空间复杂度
本文转载自：数据结构和算法之美html
当咱们设计了一个算法之后，每每会从时间和空间这两个维度来评判这个算法的优劣。执行时间越短，占用内存空间越小的算法，咱们认为是更优的算法。java
这篇文章的主题：复杂度分析就是用来分析算法时间和空间复杂度的。算法
为何须要复杂度分析
你可能会有些疑惑，我把代码跑一遍，经过统计、监控，就能获得算法执行的时间和占用的内存大小。为何还要作时间、空间复杂度分析呢？这种分析方法能比我实实在在跑一遍获得的数据更准确吗？数组
首先，我能够确定地说，你这种评估算法执行效率的方法是正确的。不少数据结构和算法书籍还给这种方法起了一个名字，叫过后统计法。可是，这种统计方法有很是大的局限性。数据结构
1. 测试的结果依赖测试的环境数据结构和算法
测试环境中硬件的不一样会对测试结果有很大的影响。好比，咱们拿一样一段代码，分别用 Intel Core i9 处理器和 Intel Core i3 处理器来运行，不用说，i9 处理器要比 i3 处理器执行的速度快不少。还有，好比本来在这台机器上 a 代码执行的速度比 b 代码要快，等咱们换到另外一台机器上时，可能会有截然相反的结果。函数
2. 测试结果受数据规模的影响很大性能
若是测试数据规模过小，测试结果可能没法真实地反映算法的性能。好比，对于小规模的数据排序，插入排序可能反倒会比快速排序要快！测试
因此，咱们须要一个不用具体的测试数据来测试，就能够粗略地估计算法的执行效率的方法。这就是咱们今天要讲的时间、空间复杂度分析方法。spa
大 O 复杂度表示法
算法的执行效率，粗略地讲，就是算法代码执行的时间。可是，如何在不运行代码的状况下，用“肉眼”获得一段代码的执行时间呢？
这里有段很是简单的代码，求 1,2,3…n 的累加和。如今，我就带你一块来估算一下这段代码的执行时间。
int cal(int n)
{
int sum = 0;
int i = 1;
for (; i <= n; ++i)
{
sum = sum + i;
}
return sum;
}
从 CPU 的角度来看，这段代码的每一行都执行着相似的操做：读数据-运算-写数据。尽管每行代码对应的 CPU 执行的个数、执行的时间都不同，可是，咱们这里只是粗略估计，因此能够假设每行代码执行的时间都同样，为 unit_time。在这个假设的基础之上，这段代码的总执行时间是多少呢？
第 二、3 行代码分别须要 1 个 unit_time 的执行时间，第 四、5 行都运行了 n 遍，因此须要 2nunit_time 的执行时间，因此这段代码总的执行时间就是 (2n+2)unit_time。能够看出来，全部代码的执行时间 T(n) 与每行代码的执行次数成正比。
按照这个分析思路，咱们再来看这段代码。
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;
}
}
}
咱们依旧假设每一个语句的执行时间是 unit_time。那这段代码的总执行时间 T(n) 是多少呢？
第 二、三、4 行代码，每行都须要 1 个 unit_time 的执行时间，第 五、6 行代码循环执行了 n 遍，须要 2n * unit_time 的执行时间，第 七、8 行代码循环执行了 n2遍，因此须要 2n2 * unit_time 的执行时间。因此，整段代码总的执行时间 T(n) = (2n2+2n+3)*unit_time。
尽管咱们不知道 unit_time 的具体值，可是经过这两段代码执行时间的推导过程，咱们能够获得一个很是重要的规律，那就是，全部代码的执行时间 T(n) 与每行代码的执行次数 n 成比例。
咱们能够把这个规律总结成一个公式。注意，大 O 就要登场了！
我来具体解释一下这个公式。其中，T(n) 咱们已经讲过了，它表示代码执行的时间；n 表示数据规模的大小；f(n) 表示每行代码执行的次数总和。由于这是一个公式，因此用 f(n) 来表示。公式中的 O，表示代码的执行时间 T(n) 与 f(n) 表达式成正比。
因此，第一个例子中的 T(n) = O(2n+2)，第二个例子中的 T(n) = O(2n2+2n+3)。这就是大 O 时间复杂度表示法。大 O 时间复杂度实际上并不具体表示代码真正的执行时间，而是表示代码执行时间随数据规模增加的变化趋势，因此，也叫做渐进时间复杂度（asymptotic time complexity），简称时间复杂度。
当 n 很大时，你能够把它想象成 10000、100000。而公式中的低阶、常量、系数三部分并不左右增加趋势，因此均可以忽略。咱们只须要记录一个最大量级就能够了，若是用大 O 表示法表示刚讲的那两段代码的时间复杂度，就能够记为：T(n) = O(n)； T(n) = O(n2)。
时间复杂度分析方法
1. 只关注循环执行次数最多的一段代码
我刚才说了，大 O 这种复杂度表示方法只是表示一种变化趋势。咱们一般会忽略掉公式中的常量、低阶、系数，只须要记录一个最大阶的量级就能够了。因此，咱们在分析一个算法、一段代码的时间复杂度的时候，也只关注循环执行次数最多的那一段代码就能够了。这段核心代码执行次数的 n 的量级，就是整段要分析代码的时间复杂度。
为了便于你理解，我仍是拿前面的例子来讲明。
int cal(int n) {
int sum = 0; //2
int i = 1; //3
for (; i <= n; ++i) { //4
sum = sum + i; //5
}
return sum;
}
其中第 二、3 行代码都是常量级的执行时间，与 n 的大小无关，因此对于复杂度并无影响。循环执行次数最多的是第 四、5 行代码，因此这块代码要重点分析。前面咱们也讲过，这两行代码被执行了 n 次，因此总的时间复杂度就是 O(n)。
2. 加法法则：总复杂度等于量级最大的那段代码的复杂度
我这里还有一段代码。你能够先试着分析一下，而后再往下看跟个人分析思路是否同样。
int cal(int n) {
int sum_1 = 0; //2
int p = 1; //3
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;
}
这个代码分为三部分，分别是求 sum_一、sum_二、sum_3。咱们能够分别分析每一部分的时间复杂度，而后把它们放到一起，再取一个量级最大的做为整段代码的复杂度。
第一段的时间复杂度是多少呢？这段代码循环执行了 100 次，因此是一个常量的执行时间，跟 n 的规模无关。
这里我要再强调一下，即使这段代码循环 10000 次、100000 次，只要是一个已知的数，跟 n 无关，照样也是常量级的执行时间。当 n 无限大的时候，就能够忽略。尽管对代码的执行时间会有很大影响，可是回到时间复杂度的概念来讲，它表示的是一个算法执行效率与数据规模增加的变化趋势，因此无论常量的执行时间多大，咱们均可以忽略掉。由于它自己对增加趋势并无影响。
那第二段代码和第三段代码的时间复杂度是多少呢？答案是 O(n) 和 O(n2)，你应该能容易就分析出来，我就不啰嗦了。
综合这三段代码的时间复杂度，咱们取其中最大的量级。因此，整段代码的时间复杂度就为 O(n2)。也就是说：总的时间复杂度就等于量级最大的那段代码的时间复杂度。那咱们将这个规律抽象成公式就是：
若是 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))).
3. 乘法法则：嵌套代码的复杂度等于嵌套内外代码复杂度的乘积
我刚讲了一个复杂度分析中的加法法则，这儿还有一个乘法法则。类比一下，你应该能“猜到”公式是什么样子的吧？
若是 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)).
也就是说，假设 T1(n) = O(n)，T2(n) = O(n2)，则 T1(n) * T2(n) = O(n3)。落实到具体的代码上，咱们能够把乘法法则当作是嵌套循环，我举个例子给你解释一下。
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() 函数。假设 f() 只是一个普通的操做，那第 4～6 行的时间复杂度就是，T1(n) = O(n)。但 f() 函数自己不是一个简单的操做，它的时间复杂度是 T2(n) = O(n)，因此，整个 cal() 函数的时间复杂度就是，T(n) = T1(n) * T2(n) = O(n*n) = O(n2)。
我刚刚讲了三种复杂度的分析技巧。不过，你并不用刻意去记忆。实际上，复杂度分析这个东西关键在于“熟练”。你只要多看案例，多分析，就能作到“无招胜有招”。
几种常见时间复杂度实例分析
虽然代码千差万别，可是常见的复杂度量级并很少。我稍微总结了一下，这些复杂度量级几乎涵盖了你从此能够接触的全部代码的复杂度量级。
对于刚罗列的复杂度量级，咱们能够粗略地分为两类，多项式量级和非多项式量级。其中，非多项式量级只有两个：O(2n) 和 O(n!)。
咱们把时间复杂度为非多项式量级的算法问题叫做 NP（Non-Deterministic Polynomial，非肯定多项式）问题。
当数据规模 n 愈来愈大时，非多项式量级算法的执行时间会急剧增长，求解问题的执行时间会无限增加。因此，非多项式时间复杂度的算法实际上是很是低效的算法。所以，关于 NP 时间复杂度我就不展开讲了。咱们主要来看几种常见的多项式时间复杂度。
在计算机领域，通常能够将问题分为可解问题和不可解问题。不可解问题也能够分为两类：一类如停机问题，的确无解；另外一类虽然有解，但时间复杂度很高。可解问题也分为多项式问题(Polynomial Problem，P问题)和非肯定性多项式问题(NondeterministicPolynomial Problem，NP问题)。更详细的内容可参照百科
下面是多项式量级复杂度的对比：
1. O(1)
首先你必须明确一个概念，O(1) 只是常量级时间复杂度的一种表示方法，并非指只执行了一行代码。好比这段代码，即使有 3 行，它的时间复杂度也是 O(1），而不是 O(3)。
int i = 8; int j = 6; int sum = i + j;
我稍微总结一下，只要代码的执行时间不随 n 的增大而增加，这样代码的时间复杂度咱们都记做 O(1)。或者说，通常状况下，只要算法中不存在循环语句、递归语句，即便有成千上万行的代码，其时间复杂度也是Ο(1)。
2. O(n)**
这种时间复杂度的算法很常见。
int f(int n) {
int sum = 0;
int i = 1;
for (; i < n; ++i) {
sum = sum + i;
}
return sum;
}
3. O(logn)、O(nlogn)
对数阶时间复杂度很是常见，同时也是最难分析的一种时间复杂度。我经过一个例子来讲明一下。
i=1;
while (i <= n) {
i = i * 2;
}
根据咱们前面讲的复杂度分析方法，第三行代码是循环执行次数最多的。因此，咱们只要能计算出这行代码被执行了多少次，就能知道整段代码的时间复杂度。
从代码中能够看出，变量 i 的值从 1 开始取，每循环一次就乘以 2。当大于 n 时，循环结束。还记得咱们高中学过的等比数列吗？实际上，变量 i 的取值就是一个等比数列。若是我把它一个一个列出来，就应该是这个样子的：
因此，咱们只要知道 x 值是多少，就知道这行代码执行的次数了。经过 2x=n 求解 x 这个问题咱们想高中应该就学过了，我就很少说了。x=log2n，因此，这段代码的时间复杂度就是 O(log2n)。
如今，我把代码稍微改下，你再看看，这段代码的时间复杂度是多少？
i=1;
while (i <= n) {
i = i * 3;
}
根据我刚刚讲的思路，很简单就能看出来，这段代码的时间复杂度为 O(log3n)。
实际上，无论是以 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)。
对数的换底公式：https://www.cnblogs.com/ransn/p/5138643.html
若是你理解了我前面讲的 O(logn)，那 O(nlogn) 就很容易理解了。还记得咱们刚讲的乘法法则吗？若是一段代码的时间复杂度是 O(logn)，咱们循环执行 n 遍，时间复杂度就是 O(nlogn) 了。并且，O(nlogn) 也是一种很是常见的算法时间复杂度。好比，归并排序、快速排序的时间复杂度都是 O(nlogn)。
4. 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))。
空间复杂度分析
前面，我们花了很长时间讲大 O 表示法和时间复杂度分析，理解了前面讲的内容，空间复杂度分析方法学起来就很是简单了。
前面我讲过，时间复杂度的全称是渐进时间复杂度，表示算法的执行时间与数据规模之间的增加关系。类比一下，空间复杂度全称就是渐进空间复杂度（asymptotic space complexity），表示算法的存储空间与数据规模之间的增加关系。
我仍是拿具体的例子来给你说明。（这段代码有点“傻”，通常没人会这么写，我这么写只是为了方便给你解释。）
void print(int n) {
int i = 0; //2
int[] a = new int[n]; //3
for (i; i <n; ++i) {
a[i] = i * i;
}
for (i = n-1; i >= 0; --i) {
print out a[i]
}
}
跟时间复杂度分析同样，咱们能够看到，第 2 行代码中，咱们申请了一个空间存储变量 i，可是它是常量阶的，跟数据规模 n 没有关系，因此咱们能够忽略。第 3 行申请了一个大小为 n 的 int 类型数组，除此以外，剩下的代码都没有占用更多的空间，因此整段代码的空间复杂度就是 O(n)。
咱们常见的空间复杂度就是 O(1)、O(n)、O(n2 )，像 O(logn)、O(nlogn) 这样的对数阶复杂度平时都用不到。并且，空间复杂度分析比时间复杂度分析要简单不少。因此，对于空间复杂度，掌握刚我说的这些内容已经足够了。
最好、最坏、平均、均摊时间复杂度
本节重点：
- 最好状况时间复杂度（best case time complexity）；
- 最坏状况时间复杂度（worst case time complexity）；
- 平均状况时间复杂度（average case time complexity）；
- 均摊时间复杂度（amortized time complexity）
先来看一段代码：
// n表示数组array的长度
int find(int[] array, int n, int x) {
int i = 0;
int pos = -1;
for (; i < n; ++i) {
if (array[i] == x) {
pos = i;
break;
}
}
return pos;
}
这段代码的功能很是简单，就是查找整数x在数组中的位置，找到就直接返回。由于，要查找的变量 x 可能出如今数组的任意位置。若是数组中第一个元素正好是要查找的变量 x，那就不须要继续遍历剩下的 n-1 个数据了，那时间复杂度就是 O(1)。但若是数组中不存在变量 x，那咱们就须要把整个数组都遍历一遍，时间复杂度就成了 O(n)。因此，不一样的状况下，这段代码的时间复杂度是不同的。
为了表示代码在不一样状况下的不一样时间复杂度，咱们须要引入三个概念：最好状况时间复杂度、最坏状况时间复杂度和平均状况时间复杂度。
1.最好状况时间复杂度
最好状况时间复杂度就是，在最理想的状况下，执行这段代码的时间复杂度。在最理想的状况下，要查找的变量 x 正好是数组的第一个元素，这个时候对应的时间复杂度就是最好状况时间复杂度。
2.最坏状况时间复杂度
最坏状况时间复杂度就是，在最糟糕的状况下，执行这段代码的时间复杂度。若是数组中没有要查找的变量 x，咱们须要把整个数组都遍历一遍才行，因此这种最糟糕状况下对应的时间复杂度就是最坏状况时间复杂度。
3. 平均状况时间复杂度
咱们都知道，最好状况时间复杂度和最坏状况时间复杂度对应的都是极端状况下的代码复杂度，发生的几率其实并不大。为了更好地表示平均状况下的复杂度，咱们须要引入另外一个概念：平均状况时间复杂度，后面我简称为平均时间复杂度。
要查找的变量 x 在数组中的位置，有 n+1 种状况：在数组的 0～n-1 位置中和不在数组中。咱们把每种状况下，查找须要遍历的元素个数累加起来，而后再除以 n+1，就能够获得须要遍历的元素个数的平均值，即：
咱们知道，时间复杂度的大 O 标记法中，能够省略掉系数、低阶、常量，因此，我们把刚刚这个公式简化以后，获得的平均时间复杂度就是 O(n)。
这个结论虽然是正确的，可是计算过程稍微有点儿问题。到底是什么问题呢？咱们刚讲的这 n+1 种状况，出现的几率并非同样的。
咱们知道，要查找的变量 x，要么在数组里，要么就不在数组里。这两种状况对应的几率统计起来很麻烦，为了方便你理解，咱们假设在数组中与不在数组中的几率都为 1/2。另外，要查找的数据出如今 0～n-1 这 n 个位置的几率也是同样的，为 1/n。因此，根据几率乘法法则，要查找的数据出如今 0～n-1 中任意位置的几率就是 1/(2n)。
所以，前面的推导过程当中存在的最大问题就是，没有将各类状况发生的几率考虑进去。若是咱们把每种状况发生的几率也考虑进去，那平均时间复杂度的计算过程就变成了这样：
这个值就是几率论中的加权平均值，也叫做指望值，因此平均时间复杂度的全称应该叫加权平均时间复杂度或者指望时间复杂度。
引入几率以后，前面那段代码的加权平均值为 (3n+1)/4。用大 O 表示法来表示，去掉系数和常量，这段代码的加权平均时间复杂度仍然是 O(n)。
实际上，在大多数状况下，咱们并不须要区分最好、最坏、平均状况时间复杂度三种状况。像咱们上一节课举的那些例子那样，不少时候，咱们使用一个复杂度就能够知足需求了。只有同一块代码在不一样的状况下，时间复杂度有量级的差距，咱们才会使用这三种复杂度表示法来区分。
4. 均摊时间复杂度
均摊时间复杂度，听起来跟平均时间复杂度有点儿像。对于初学者来讲，这两个概念确实很是容易弄混。我前面说了，大部分状况下，咱们并不须要区分最好、最坏、平均三种复杂度。平均复杂度只在某些特殊状况下才会用到，而均摊时间复杂度应用的场景比它更加特殊、更加有限。
// array表示一个长度为n的数组
// 代码中的array.length就等于n
int[] array = new int[n];
int count = 0;
void insert(int val) {
if (count == array.length) {
int sum = 0;
for (int i = 0; i < array.length; ++i) {
sum = sum + array[i];
}
array[0] = sum;
count = 1;
}
array[count] = val;
++count;
}
我先来解释一下这段代码。这段代码实现了一个往数组中插入数据的功能。当数组满了以后，也就是代码中的 count == array.length 时，咱们用 for 循环遍历数组求和，并清空数组，将求和以后的 sum 值放到数组的第一个位置，而后再将新的数据插入。但若是数组一开始就有空闲空间，则直接将数据插入数组。
那这段代码的时间复杂度是多少呢？你能够先用咱们刚讲到的三种时间复杂度的分析方法来分析一下。
最理想的状况下，数组中有空闲空间，咱们只须要将数据插入到数组下标为 count 的位置就能够了，因此最好状况时间复杂度为 O(1)。最坏的状况下，数组中没有空闲空间了，咱们须要先作一次数组的遍历求和，而后再将数据插入，因此最坏状况时间复杂度为 O(n)。
那平均时间复杂度是多少呢？答案是 O(1)。咱们仍是能够经过前面讲的几率论的方法来分析。
假设数组的长度是 n，根据数据插入的位置的不一样，咱们能够分为 n 种状况，每种状况的时间复杂度是 O(1)。除此以外，还有一种“额外”的状况，就是在数组没有空闲空间时插入一个数据，这个时候的时间复杂度是 O(n)。并且，这 n+1 种状况发生的几率同样，都是 1/(n+1)。因此，根据加权平均的计算方法，咱们求得的平均时间复杂度就是：
至此为止，前面的最好、最坏、平均时间复杂度的计算，理解起来应该都没有问题。可是这个例子里的平均复杂度分析其实并不须要这么复杂，不须要引入几率论的知识。这是为何呢？咱们先来对比一下这个 insert() 的例子和前面那个 find() 的例子，你就会发现这二者有很大差异。
首先，find() 函数在极端状况下，复杂度才为 O(1)。但 insert() 在大部分状况下，时间复杂度都为 O(1)。只有个别状况下，复杂度才比较高，为 O(n)。这是 insert()第一个区别于 find() 的地方。
咱们再来看第二个不一样的地方。对于 insert() 函数来讲，O(1) 时间复杂度的插入和 O(n) 时间复杂度的插入，出现的频率是很是有规律的，并且有必定的先后时序关系，通常都是一个 O(n) 插入以后，紧跟着 n-1 个 O(1) 的插入操做，循环往复。
因此，针对这样一种特殊场景的复杂度分析，咱们并不须要像以前讲平均复杂度分析方法那样，找出全部的输入状况及相应的发生几率，而后再计算加权平均值。
针对这种特殊的场景，咱们引入了一种更加简单的分析方法：摊还分析法，经过摊还分析获得的时间复杂度咱们起了一个名字，叫均摊时间复杂度。
那究竟如何使用摊还分析法来分析算法的均摊时间复杂度呢？
咱们仍是继续看在数组中插入数据的这个例子。每一次 O(n) 的插入操做，都会跟着 n-1 次 O(1) 的插入操做，因此把耗时多的那次操做均摊到接下来的 n-1 次耗时少的操做上，均摊下来，这一组连续的操做的均摊时间复杂度就是 O(1)。这就是均摊分析的大体思路。你都理解了吗？
均摊时间复杂度和摊还分析应用场景比较特殊，因此咱们并不会常常用到。为了方便你理解、记忆，我这里简单总结一下它们的应用场景。若是你遇到了，知道是怎么回事儿就好了。
对一个数据结构进行一组连续操做中，大部分状况下时间复杂度都很低，只有个别状况下时间复杂度比较高，并且这些操做之间存在先后连贯的时序关系，这个时候，咱们就能够将这一组操做放在一起分析，看是否能将较高时间复杂度那次操做的耗时，平摊到其余那些时间复杂度比较低的操做上。并且，在可以应用均摊时间复杂度分析的场合，通常均摊时间复杂度就等于最好状况时间复杂度。
尽管不少数据结构和算法书籍都花了很大力气来区分平均时间复杂度和均摊时间复杂度，但其实我我的认为，均摊时间复杂度就是一种特殊的平均时间复杂度，咱们不必花太多精力去区分它们。你最应该掌握的是它的分析方法，摊还分析。至于分析出来的结果是叫平均仍是叫均摊，这只是个说法，并不重要。