1 如何分析、统计算法的指向效率和资源消耗？
实实在在跑一遍代码这种方法叫作事后统计法。这种统计方法有非常大的局限性：
1、测试结果非常依赖测试环境；
2、测试结果受数据规模的影响很大；
所以，我们需要一个不用具体的测试数据来测试，就可以粗略地估算计算法的执行效率的方法。
大 O 时间复杂度表示法实际上并不具体表示代码真正的执行时间，而是表示代码执行时间随数据规模增长的变化趋势，所以，也叫作渐进时间复杂度，简称时间复杂度。
1.1 时间复杂度分析
1.1.1 只关注循环执行次数最多的一段代码
大 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;
}
```
这个代码分为三部分，分别是求 sum_1、sum_2、sum_3.我们可以分别分析每一部分的时间复杂度，然后把它们放到一块儿，再取一个量级最大的作为整段代码的复杂度。
第一段代码循环执行了 100 次，所以是一个常量的执行时间，跟 n 的规模无关。
第二段代码和第三段代码的时间复杂度是多少呢？答案是 O(n) 和 O(n^2^)。
综合这三段代码的时间复杂度，我们取其中最大的量级。所以，整段代码的时间 O(n^2^)。也就是说：**总的时间复杂度就等于量级最大的那段代码的时间复杂度。
#### 1.1.3 乘法法则：嵌套代码的复杂度等于嵌套内外代码复杂度的乘积
````Java
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;
}
```
### 1.2 几种常见时间复杂度实例分析
常见的复杂度量级：
- 常量接 O(1)
- 对数阶 O(log n)
- 线性阶 O(n)
- 线性对数阶 O(nlog n)
- 平方阶 O(n^2^)、立方阶 O(n^3^) ··· k 次方阶 O(n^k^)
- 指数阶 O(2^n^)
- 阶乘阶 O(n !)
对于刚罗列的复杂度量级，我们可以粗略地分为两类，**多项式量级**和**非多项式量级**。其中，非多项式量级只有两个：O(2^n^) 和 O(n !)。
我们把时间复杂度为非多项式量级的算法问题叫作 NP（Non-Deterministic Polynomial，非确定多项式）问题。
当数据规模 n 越来越大时，非多项式量级算法的执行时间会急剧增加，求解问题的执行时间会无限增长。所以，非多项式时间复杂度的算法其实是非常低效的算法。因此，关于 NP 时间复杂度我就不展开了，我们主要来看几种常见的**多项式时间复杂度**。
#### 1.2.1 O(1)
首先你必须明确一个概念，O(1)只是常量级时间复杂度的一种表示方法，并不是指执行了一行代码。比如这段代码，即便有 3 行，它的时间复杂度也是 O(1)，而不是 O(3)。
````Java
int i = 8;
int j = 6;
int sum = i + j;
```
我稍微总结一下，只要代码的执行时间不随 n 的增大而增大，这样代码的时间复杂度我们都记作 O(1)。或者说，**一般情况下，只要算法中不存在循环语句、递归语句，即使有成千上万行的代码，其时间复杂度也是 O(1)**。
#### 1.2.2 O(log n)、O(nlog n)
对数阶时间复杂度非常常见，同时也是最难分析的一种时间复杂度。
````Java
i=1;
while (i <= n) {
i = i * 2;
}
```
根据我们前面讲的复杂度分析方法，第三行代码是循环执行次数最多的。所以，我们只要能计算出这行代码被执行被执行了多少次，就能知道整段代码的时间复杂度。
从代码中可以看出，我把值一一列出应该是这个样子的：2^0^、2^1^、2^2^、···、2^k^、···、2^x^ = n。
所以，我们只要知道 x 值是多少，就知道这行代码执行的次数了。通过 2^x^ = n 求解 x 这个问题我们想高中应该就学过了，我就不多说了。x = log~2~n，所以，这段代码的时间复杂度就是 O(log~2~n)。
在采用大 O 标记复杂度的时候，可以忽略系数。
#### 1.2.3 O(m + n)、O(m * n)
我们再讲一种跟前面都不一样的时间复杂度，代码的复杂度由两个数据的规模来决定。
````Java
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)。
### 1.3 空间复杂度分析
时间复杂度的全称是渐进时间复杂度，表示算法的执行时间与数据规模之间的增长关系。类比一下，空间复杂度全称就是渐进空间复杂度，表示算法的存储空间与数据规模之间的增长关系。
````Java
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]
}
}
```
跟时间复杂度分析一样，我们可以看到，第 2 行代码中，我们申请了一个空间存储变量 i，但是它是常量阶的，跟数据规模 n 没有关系，所以我们可以忽略。第 3 行申请了一个大小为 n 的 int 类型数组，除此之外，剩下的代码都没有占用更多的空间，所以整段代码的空间复杂度就是 O(n)。
我们常见的空间复杂度就是 O(1)、O(n)、O(n2 )，像 O(log n)、O(nlog n) 这样的对数阶复杂度平时都用不到。而且，空间复杂度分析比时间复杂度要简单很多。所以，对于空间复杂度，掌握刚我说的这些内容已经足够了。
### 1.4 内容小结
复杂度也叫渐进复杂度，包括时间复杂度和空间复杂度，用来分析算法执行效率与数据规模之间的增长关系，可以粗略地表示，越高阶复杂度的算法，执行效率越低。常见的复杂度并不多，从低阶到高阶有：O(1)、O(log n)、O(n)、O(nlog n)、O(n^2^)。
### 1.5 课后思考
有人说，我们项目之前都会进行性能测试，再做代码的时间复杂度、空间复杂度分析，是不是多此一举呢？每段代码都分析一下时间复杂度、空间复杂度，是不是很浪费时间呢？
答案：我不认为是多此一举，渐进时间，空间复杂度分析为我们提供了一个很好的理论分析的方向，并且它是宿主平台无关的，能够让我们对我们的程序或算法有一个大致的认识，让我们知道，比如在最坏的情况下程序的执行效率如何，同时也为我们交流提供了一个不错的桥梁，我们可以说，算法1的时间复杂度是O(n)，算法2的时间复杂度是O(logN)，这样我们立刻就对不同的算法有了一个“效率”上的感性认识。
当然，渐进式时间，空间复杂度分析只是一个理论模型，只能提供给粗略的估计分析，我们不能直接断定就觉得O(logN)的算法一定优于O(n), 针对不同的宿主环境，不同的数据集，不同的数据量的大小，在实际应用上面可能真正的性能会不同，个人觉得，针对不同的实际情况，进而进行一定的性能基准测试是很有必要的，比如在统一一批手机上(同样的硬件，系统等等)进行横向基准测试，进而选择适合特定应用场景下的最有算法。
综上所述，渐进式时间，空间复杂度分析与性能基准测试并不冲突，而是相辅相成的，但是一个低阶的时间复杂度程序有极大的可能性会优于一个高阶的时间复杂度程序，所以在实际编程中，时刻关心理论时间，空间度模型是有助于产出效率高的程序的，同时，因为渐进式时间，空间复杂度分析只是提供一个粗略的分析模型，因此也不会浪费太多时间，重点在于在编程时，要具有这种复杂度分析的思维。
## 2 浅析最好、最坏、平均、均摊时间复杂度
### 2.1 最好、最坏情况时间复杂度
````Java
// 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;
}
return pos;
}
```
这段代码的复杂度是 O(n)，其中，n 代表数组的长度。
我们在数组中查找一个数据，并不需要每次都把整个数组都遍历一遍，因为有可能中途找到就可以提前结束循环了。但是，这段代码写得不够高效。我们可以这样优化一下这段查找代码。
````Java
// 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;
}
```
这个时候，问题就来了。我们优化完之后，这段代码的时间复杂度还是 O(n) 吗？很显然，咱们上一节讲的分析方法，解决不了这个问题。
因为，要查找的变量 x 可能出现在数组的任意位置。如果数组中第一个元素正好是要查找的变量 x，那就不需要继续遍历剩下的 n-1 个数据了，那时间复杂度就是 O(1)。但如果数组中不存在变量 x，那我们就需要把整个数组都遍历一遍，时间复杂度就成了 O(n)。所以，不同的情况下，这段代码的时间复杂度是不一样的。
为了表示代码在不同情况下的不同时间复杂度，我们需要引入三个概念：最好情况时间复杂度、最坏情况时间复杂度和平均情况时间复杂度。
**最好情况时间复杂度就是，在最理想的情况下，执行这段代码的时间复杂度。**
**最坏情况时间复杂度就是，在最糟糕的情况下，执行这段代码的时间复杂度。**
### 2.2 平均情况时间复杂度
我们都知道，最好情况时间复杂度和最坏情况时间复杂度对应的都是极端情况下的代码复杂度，发生的概率其实并不大。为了更好地表示平均情况下的复杂度，我们需要引入另一个概念：平均情况时间复杂度，后面我简称为平均时间复杂度。
要查找的变量 x 在数组中的位置，有 n+1 种情况：**在数组的 0 ~ n-1 位置中**和**不在数组中。我们把每种情况下，查找需要遍历的元素都累加起来，再除以 n+1，就可以得到需要遍历元素个数的平均值：
所以得到的平均时间复杂度就是 O(n)。
这个结论虽然是正确的，但是计算过程稍微有点儿问题。究竟是什么问题？我们刚讲过的 n+1 种情况，出现的概率并不是一样的。
我们知道，要查找的变量 x，要么在数组里，要么就不在数组里。这两种情况对应的概率统计起来很麻烦为了方便你理解，我们假设在数组中与不在数组中的概率都为 1/2。另外，要查找的数据出现在 0 ~ n-1 这 n 个位置的概率也是一样的，为 1/n。所以有，根据改立乘法法则要查找的数据出现在 0 ~ n-1 中任意位置的概率就是 1/(2n)。
因此，前面的推导过程中存在的最大问题就是，没有将各种情况发生的概率考虑进去。如果我们把每种情况发生的概率也考虑进去，那平均时间复杂度的计算过程就变成了这样：
这个值就是概率论中的**加权平均值**，也叫作**期望值**，所以平均时间复杂度的全称应该叫**加权平均时间复杂度**或者**期望时间复杂度**。
这段代码的加权平均时间复杂度仍然是 O(n)。
### 2.3 均摊时间复杂度
````Java
// 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-1] = val;
++count;
}
```
这段代码实现了一个往数组中插入数据的功能，当数组满了之后，遍历求和，并清空数组。
那这段代码的时间复杂度是多少呢？你可以先用我们刚讲到的三种时间复杂度的分析方法来分析一下。
最好情况时间复杂度 O(1)；最坏情况时间复杂度 O(n)。
平均时间复杂度是 O(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)。这就是均摊分析的大致思路。
均摊时间复杂度：对于一个数据结构进行一组连续操作中，大部分情况下时间复杂度都很低，只有个别情况下时间复杂度比较高，而且这些操作之间存在前后连贯的时序关系，这个时候，我们就可以将这一组操作放在一块儿分析，看是否能将较高时间复杂度那次操作的耗时，平摊到其他那些时间复杂度比较低的操作上。而且，在能够应用均摊时间复杂度分析的场合，一般均摊时间复杂度就等于最好情况时间复杂度。
均摊时间复杂度就是一种特殊的平均时间复杂度。
### 2.4 内容小结
我们学习了几个复杂度分析相关的概念，分别有：最好情况时间复杂度、最坏情况时间复杂度、平均情况时间复杂度、均摊时间复杂度。之所以引入这几个复杂度概念，是因为，同一段代码，在不同输入的情况下，复杂度量级有可能不一样。
分析一下下面这个 add() 函数的时间复杂度。
```Java
// 全局变量，大小为 10 的数组 array，长度 len，下标 i。
int array[] = new int[10];
int len = 10;
int i = 0;
// 往数组中添加一个元素
void add(int element) {
if (i >= len) { // 数组空间不够了
// 重新申请一个 2 倍大小的数组空间
int new_array[] = new int[len*2];
// 把原来 array 数组中的数据依次 copy 到 new_array
for (int j = 0; j < len; ++j) {
new_array[j] = array[j];
}
// new_array 复制给 array，array 现在大小就是 2 倍 len 了
array = new_array;
len = 2 * len;
}
// 将 element 放到下标为 i 的位置，下标 i 加一
array[i] = element;
++i;
}
```
答案：最好是O(1)，最差是O(n), 均摊是O(1)。
看到好多人纠结于清空数组的问题: 对于可反复读写的存储空间，使用者认为它是空的它就是空的。如果你定义清空是全部重写为0或者某个值，那也可以！但是老师举的例子完全没必要啊！写某个值和写任意值在这里有区别吗，使用值只关心要存的新值！所以老师的例子，清空把下标指到第一个位置就可以了！
7027
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
