数据结构与算法之美01-04讲

一、为什么要学习数据结构和算法？

1、为什么要学习数据结构与算法

• 1.直接好处是能够有写出性能更优的代码。
• 2.算法，是一种解决问题的思路和方法，有机会应用到生活和事业的其他方面。
• 3.长期来看，大脑思考能力是个人最重要的核心竞争力，而算法是为数不多的能够有效训练大脑思考能力的途径之一。

2、算法思想在工作中带来的好处

不同的公司、不同的人做出的 RPC 框架，架构设计思路都差不多，最后实现的功能也都差不
多。但是有的人做出来的框架，Bug 很多、性能一般、扩展性也不好，只能在自己公司仅有的几个项目里面用一下。而有的人做的框架可以开源到 GitHub 上给很多人用，甚至被 Apache收录。为什么会有这么大的差距呢？
我觉得，高手之间的竞争其实就在细节。这些细节包括：你用的算法是不是够优化，数据存取的
效率是不是够高，内存是不是够节省等等。这些累积起来，决定了一个框架是不是优秀。所以，
如果你还不懂数据结构和算法，没听说过大 O 复杂度分析，不知道怎么分析代码的时间复杂度
和空间复杂度，那肯定说不过去了，赶紧来补一补吧！

对编程还有追求？不想被行业淘汰？那就不要只会写凑合能用的代码！
何为编程能力强？是代码的可读性好、健壮？还是扩展性好？我觉得没法列，也列不全。但是，
在我看来，性能好坏起码是其中一个非常重要的评判标准。但是，如果你连代码的时间复杂度、
空间复杂度都不知道怎么分析，怎么写出高性能的代码呢？
你可能会说，我在小公司工作，用户量很少，需要处理的数据量也很少，开发中不需要考虑那么
多性能的问题，完成功能就可以，用什么数据结构和算法，差别根本不大。但是你真的想“十年
如一日”地做一样的工作吗？
经常有人说，程序员 35 岁之后很容易陷入瓶颈，被行业淘汰，我觉得原因其实就在此。有的人
写代码的时候，从来都不考虑非功能性的需求，只是完成功能，凑合能用就好；做事情的时候，
也从来没有长远规划，只把眼前事情做好就满足了。

二、如何抓住重点，系统高效地学习数据结构与算法？

1、什么是数据结构？什么是算法？

广义上：数据结构就是指一组数据的存储结构。算法就是操作数据的一组方法。
狭义上：某些著名的数据结构和算法，比如队列、栈、堆、二分查找、动态规划的等
数据结构和算法解决的是如何更省、更快地存储和处理数据的问题。

2、20 个最常用的、最基础数据结构与算法

• 10 个数据结构：数组、链表、栈、队列、散列表、二叉树、堆、跳表、图、Trie 树；
• 10 个算法：递归、排序、二分查找、搜索、哈希算法、贪心算法、分治算法、回溯算法、动态规划、字符串匹配算法。

学习它的“来历”“自身的特点”“适合解决的问题”以及“实际的应用场景”

三、 复杂度分析（上）：如何分析、统计算法的执行效率和资源消耗？

1、为什么需要复杂度分析？

①. 测试结果非常依赖测试环境
测试环境中硬件的不同会对测试结果有很大的影响。比如，我们拿同样一段代码，分别用 Intel
Core i9 处理器和 Intel Core i3 处理器来运行，不用说，i9 处理器要比 i3 处理器执行的速度快
很多。还有，比如原本在这台机器上 a 代码执行的速度比 b 代码要快，等我们换到另一台机器
上时，可能会有截然相反的结果。
②. 测试结果受数据规模的影响很大
后面我们会讲排序算法，我们先拿它举个例子。对同一个排序算法，待排序数据的有序度不一
样，排序的执行时间就会有很大的差别。极端情况下，如果数据已经是有序的，那排序算法不需
要做任何操作，执行时间就会非常短。除此之外，如果测试数据规模太小，测试结果可能无法真
实地反应算法的性能。比如，对于小规模的数据排序，插入排序可能反倒会比快速排序要快！

2、大O复杂度表示法

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

从 CPU 的角度来看，这段代码的每一行都执行着类似的操作：读数据-运算-写数据。尽管每行
代码对应的 CPU 执行的个数、执行的时间都不一样，但是，我们这里只是粗略估计，所以可以
假设每行代码执行的时间都一样，为 unit_time。在这个假设的基础之上，这段代码的总执行时
间是多少呢？
第 2、3 行代码分别需要 1 个 unit_time 的执行时间，第 4、5 行都运行了 n 遍，所以需要
2n*unit_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) 是多少呢？

第 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) 与每行代码的执行次数 n 成正比。

大O：其中，T(n) 我们已经讲过了，它表示代码执行的时间；n 表示数据规模的大小；f(n) 表示每行代码执行的次数总和。因为这是一个公式，所以用 f(n) 来表示。公式中的 O，表示代码的执行时间 T(n) 与 f(n) 表达式成正比。

所以，第一个例子中的 T(n) = O(2n+2)，第二个例子中的 T(n) = O(2n +2n+3)。这就是大 O
时间复杂度表示法。大 O 时间复杂度实际上并不具体表示代码真正的执行时间，而是表示代码执行时间随数据规模增长的变化趋势，所以，也叫作渐进时间复杂度（asymptotic time
complexity），简称时间复杂度。

当 n 很大时，你可以把它想象成 10000、100000。而公式中的低阶、常量、系数三部分并不左
右增长趋势，所以都可以忽略。我们只需要记录一个最大量级就可以了，如果用大 O 表示法表
示刚讲的那两段代码的时间复杂度，就可以记为：T(n) = O(n)； T(n) = O(n )。

3、时间复杂度分析

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

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

4、几种常见时间复杂度实例分析

4.1. O(1)

首先你必须明确一个概念，O(1) 只是常量级时间复杂度的一种表示方法，并不是指只执行了一
行代码。比如这段代码，即便有 3 行，它的时间复杂度也是 O(1），而不是 O(3)。

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

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

4.2. O(logn)、O(nlogn)

对数阶时间复杂度非常常见，同时也是最难分析的一种时间复杂度。我通过一个例子来说明一
下。

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

根据我们前面讲的复杂度分析方法，第三行代码是循环执行次数最多的。所以，我们只要能计算出这行代码被执行了多少次，就能知道整段代码的时间复杂度。

从代码中可以看出，变量 i 的值从 1 开始取，每循环一次就乘以 2。当大于 n 时，循环结束。
还记得我们高中学过的等比数列吗？实际上，变量 i 的取值就是一个等比数列。如果我把它一个
一个列出来，就应该是这个样子的：

所以，我们只要知道 x 值是多少，就知道这行代码执行的次数了。通过 2 =n 求解 x 这个问题
我们想高中应该就学过了，我就不多说了。x=log2n，所以，这段代码的时间复杂度就O(log2n)。

现在，我把代码稍微改下，你再看看，这段代码的时间复杂度是多少？

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

根据我刚刚讲的思路，很简单就能看出来，这段代码的时间复杂度为 O(log3n)。

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

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

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

5、空间复杂度分析

• 时间复杂度的全称是渐进时间复杂度，表示算法的执行时间与数据规模之间的增长
  关系。类比一下，空间复杂度全称就是渐进空间复杂度（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)。

• 思考题：有人说，我们项目之前都会进行性能测试，再做代码的时间复杂度、空间复杂度分析，是不是多此一举呢？而且，每段代码都分析一下时间复杂度、空间复杂度，是不是很浪费时间呢？你怎么看待这个问题呢？

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

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

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

四、复杂度分析（下）：浅析最好、最坏、平均、均摊时间复杂度

1、最好、最坏情况时间复杂度

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

你应该可以看出来，这段代码要实现的功能是，在一个无序的数组（array）中，查找变量 x 出
现的位置。如果没有找到，就返回 -1。按照上节课讲的分析方法，这段代码的复杂度是 O(n)，
其中，n 代表数组的长度。

我们在数组中查找一个数据，并不需要每次都把整个数组都遍历一遍，因为有可能中途找到就可
以提前结束循环了。但是，这段代码写得不够高效。我们可以这样优化一下这段查找代码。

// 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，那就不需要继续遍历剩下的 n-1 个数据了，那时间复杂度就是 O(1)。但如果数组中不存
在变量 x，那我们就需要把整个数组都遍历一遍，时间复杂度就成了 O(n)。所以，不同的情况
下，这段代码的时间复杂度是不一样的。

顾名思义，最好情况时间复杂度就是，在最理想的情况下，执行这段代码的时间复杂度。就像我们刚刚讲到的，在最理想的情况下，要查找的变量 x 正好是数组的第一个元素，这个时候对应
的时间复杂度就是最好情况时间复杂度。

同理，最坏情况时间复杂度就是，在最糟糕的情况下，执行这段代码的时间复杂度。就像刚举的那个例子，如果数组中没有要查找的变量 x，我们需要把整个数组都遍历一遍才行，所以这种最糟糕情况下对应的时间复杂度就是最坏情况时间复杂度。

2、平均情况时间复杂度

我们都知道，最好情况时间复杂度和最坏情况时间复杂度对应的都是极端情况下的代码复杂度，
发生的概率其实并不大。为了更好地表示平均情况下的复杂度，我们需要引入另一个概念：平均情况时间复杂度，后面我简称为平均时间复杂度。

要查找的变量 x 在数组中的位置，有 n+1 种情况：在数组的 0～n-1 位置中和不在数组中。我
们把每种情况下，查找需要遍历的元素个数累加起来，然后再除以 n+1，就可以得到需要遍历
的元素个数的平均值，即：

平均时间复杂度就是 O(n)。

我们知道，要查找的变量 x，要么在数组里，要么就不在数组里。这两种情况对应的概率统计起
来很麻烦，为了方便你理解，我们假设在数组中与不在数组中的概率都为 1/2。另外，要查找的
数据出现在 0～n-1 这 n 个位置的概率也是一样的，为 1/n。所以，根据概率乘法法则，要查找
的数据出现在 0～n-1 中任意位置的概率就是 1/(2n)。

因此，前面的推导过程中存在的最大问题就是，没有将各种情况发生的概率考虑进去。如果我们
把每种情况发生的概率也考虑进去，那平均时间复杂度的计算过程就变成了这样：

这个值就是概率论中的加权平均值，也叫作期望值，所以平均时间复杂度的全称应该叫加权平均时间复杂度或者期望时间复杂度。

引入概率之后，前面那段代码的加权平均值为 (3n+1)/4。用大 O 表示法来表示，去掉系数和常
量，这段代码的加权平均时间复杂度仍然是 O(n)。

3、均摊时间复杂度

// 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)。所
以，根据加权平均的计算方法，我们求得的平均时间复杂度就是：