学王争老师《数据结构与算法之美》笔记总结
前言
数据结构和算法本身解决的问题就是如何让代码运行得更快，如何让代码更省存储空间。所以执行效率是算法一个非常重要的考量指标。
我们不用去死磕数据结构和算法的严格定义，从广义上讲，数据结构就是指一组数据的存储结构，算法就是操作数据的一组方法。数据结构和算法是相辅相成的。数据结构是为算法服务的，算法要作用在特定的数据结构之上。 因此，我们无法孤立数据结构来讲算法，也无法孤立算法来讲数据结构。
关于复杂度
上面说到，执行效率是算法一个非常重要的考量指标。那如何来衡量你编写的算法代码的执行效率？就是我们常说的：时间、空间复杂度。时间、空间复杂度分析是伴随这数据结构与算法的，复杂度分析是整个算法学习的精髓。
那为什么要事先进行复杂度的评估呢，我们把代码跑一遍，通过监控统计可以的带时间和空间的占用数据的，那为什么还要提前进行复杂度分析。其实，执行代码的估算效率的方法肯定是没有问题的，但这属于一种事后统计法，而且有一定的局限性：
-
测试结果非常依赖测试环境，测试环境中硬件的不同会对测试结果有很大的影响，比如处理器性能的不同等情况。
-
测试结果受数据规模的影响比较大，对同一个排序算法，待排序数据的有序度不一样，排序的执行时间就会有很大的差别。如果测试数据规模太小，测试结果可能无法真实地反映算法的性能。比如，对于小规模的数据排序，插入排序可能反倒会比快速排序要快！
所以，我们需要一个不用具体的测试数据来测试，就可以粗略地估计算法的执行效率的方法。
大O复杂度表示法
算法的执行效率，其实就是算法代码执行的时间。但是如果在不运行代码的情况下，靠我们阅读代码得到执行时间呢？下面这段简单的代码，是求1，2，3，n的累加，我们可以估算一下这段代码的执行时间
int total(int n) {
int sum = 0;
int i = 1;
for (; i <= n; i++) {
sum = sum + i;
}
return sum;
}
可以假设每行代码执行的时间都一样，为 unit_time。在这个假设的基础之上，我们来计算一下这段代码的执行时间。第 2、3 行代码分别需要 1 个 unit_time 的执行时间，第 4、5 行都运行了 n 遍，所以需要 2n个unit_time 的执行时间，所以这段代码总的执行时间就是 (2n+2)个unit_time。可以看出来，所有代码的执行时间 T(n) 与每行代码的执行次数成正比。
按照这个思路，我们可以再看一个案例代码，如下：
int total(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;
}
}
}
第 2、3、4 行代码，每行都需要 1 个 unit_time 的执行时间，第 5、6 行代码循环执行了 n 遍，需要 2n 个 unit_time 的执行时间，第 7、8 行代码循环执行了 n²遍，所以需要 2n² 个 unit_time 的执行时间。所以，整段代码总的执行时间 T(n) = (2n²+2n+3)个unit_time。尽管我们不知道 unit_time 的具体值，但是通过这两段代码执行时间的推导过程，我们可以得到一个非常重要的规律，那就是，所有代码的执行时间 T(n) 与每行代码的执行次数 f(n) 成正比。
我们可以把这个规律总结成一个公式
其中，T(n)代表代码执行的时间，n代码数据规模的大小，f(n)表示每行代码执行的次数的总和。所以第一个例子中的T(n) = O(2n+2)，第二个例子中的T(n) = O(2n²+2n+3)。这就是大O时间复杂度表示法。大O时间复杂度实际上并不具体表示代码真正的执行时间，而是表示代码执行时间随数据规模增加的变化趋势，所以也叫做渐进时间复杂度，简称时间复杂度。
当n很大的时候，公式中的低阶、常量、系数三分部并不左右增长趋势，可以忽略，所以用大O表示法，可以这样表示上面的两个公式：T(n) = O(n)，T(n) = O(n²)。
时间复杂度
关于时间复杂度的计算，我们可以牢记这句话：1、只关注循环执行次数最多的一段代码 2. 加法法则：总复杂度等于量级最大的那段代码的复杂度 3. 乘法法则：嵌套代码的复杂度等于嵌套内外代码复杂度的乘积。
几种常见的时间复杂度实例分析
虽然代码前叉万别，但是常见的复杂度量级其实并不多，下面途中的复杂度量级涵盖了几乎平时我们能接触到的所有代码的复杂度量级
图上的复杂度量级，我们可以粗略地分为两类，多项式量级和非多项式量级。其中，非多项式量级只有两个：O(2ⁿ) 和 O(n!)。
下面看看几种常见的多项式时间复杂度
- O(1) 首先明确一个概念，O(1)只是常量级时间复杂度的一种表示方法，并不是指只执行了一行代码。例如下面的这段代码，即使他有4行，那他的时间复杂度也是O(1)，而不是O(4).
int a = 1;
int b = 2;
int c = 3;
int sum = a + b + c;
从写代码的角度来看，可以总结为：一般情况下，只要算法中不存在循环语句、递归语句，即使有10000行代码，那它的时间复杂度也是O(1).
- O(logn)、O(nlogn) 对数阶时间复杂度很常见，同时也是最难肥西的一种时间复杂度。来看下面的例子
i=1;
while (i <= n) {
i = i * 2;
}
根据我们前面讲的复杂度分析方法，第三行代码是循环执行次数最多的。所以，我们只要能计算出这行代码被执行了多少次，就能知道整段代码的时间复杂度。从代码中可以看出，变量 i 的值从 1 开始取，每循环一次就乘以 2。当大于 n 时，循环结束。实际上，变量 i 的取值就是一个等比数列。如果我把它一个一个列出来，就应该是这个样子的：
所以，我们只要知道 x 值是多少，就知道这行代码执行的次数了。通过 2x=n 求解 x 这个问题我们想高中应该就学过了，我就不多说了。x=log₂n，所以，这段代码的时间复杂度就是 O(log₂n)。再来看看下面的代码
i=1;
while (i <= n) {
i = i * 4;
}
按照上面的思路，很简单就能看出来，这段代码的时间复杂度为 O(log₄n)，实际上，不管是以 2 为底、以 4 为底，还是以 10 为底，我们可以把所有对数阶的时间复杂度都记为 O(logn)。为什么呢？我们知道，对数之间是可以互相转换的，log₃n 就等于 log₃2 * log₂n，所以 O(log₃n) = O(C * log₂n)，其中 C=log₃2 是一个常量。基于我们前面的一个理论：在采用大 O 标记复杂度的时候，可以忽略系数，即 O(Cf(n)) = O(f(n))。所以，O(log₂n) 就等于 O(log₃n)。因此，在对数阶时间复杂度的表示方法里，我们忽略对数的“底”，统一表示为 O(logn)。
如果你理解了我前面讲的 O(logn)，那 O(nlogn) 就很容易理解了。还记得我们刚讲的乘法法则吗？如果一段代码的时间复杂度是 O(logn)，我们循环执行 n 遍，时间复杂度就是 O(nlogn) 了。而且，O(nlogn) 也是一种非常常见的算法时间复杂度。比如，归并排序、快速排序的时间复杂度都是 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]
}
}
跟时间复杂度分析一样，我们可以看到，第 2 行代码中，我们申请了一个空间存储变量 i，但是它是常量阶的，跟数据规模 n 没有关系，所以我们可以忽略。第 3 行申请了一个大小为 n 的 int 类型数组，除此之外，剩下的代码都没有占用更多的空间，所以整段代码的空间复杂度就是 O(n)。基本上时间复杂度分析出来后，看一下分配资源的代码位置，空间复杂度就出来了
总结
复杂度也叫渐进复杂度，包括时间复杂度和空间复杂度，用来分析算法执行效率与数据规模之间的增长关系，可以粗略地表示，越高阶复杂度的算法，执行效率越低。常见的复杂度并不多，从低阶到高阶有：O(1)、O(logn)、O(n)、O(nlogn)、O(n2 )。如图
相信很大部分小伙伴和我一样，觉得算法相关内容除了面试，其他时间用不到，我也一度这样认为，但是从深入学习后会有一种感受，就是这种复杂度分析的思维，能帮助你有效提升代码设计的能力。
