1、算法的考量指标

算法的考量指标，我们是用时间、空间复杂度来衡量的。

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

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

我把代码跑一遍，通过统计、监控，就能得到算法执行的时间和占用的内存大小
这种评估算法执行效率的方法是正确的。很多数据结构和算法书籍还给这种方法起了一个名字，叫事后统计法。但是，这种统计方法有非常大的局限性。

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

3、大O表示法

大O表示法：算法的时间复杂度通常用大O符号表述，定义为T[n] = O(f(n))。称函数T(n)以f(n)为界或者称T(n)受限于f(n)。如果一个问题的规模是n，解这一问题的某一算法所需要的时间为T(n)。T(n)称为这一算法的“时间复杂度”。当输入量n逐渐加大时，时间复杂度的极限情形称为算法的“渐近时间复杂度”。

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

分析：假设每行代码执行的时间都一样，为 unit_time。
第 2、3 行代码分别需要 1 个 unit_time 的执行时间，第 4、5 行都运行了 n 遍，
所以需要 2n * unit_time 的执行时间，所以这段代码总的执行时间就是 (2n+2) * unit_time。
可以看出来，所有代码的执行时间 T(n) 与每行代码的执行次数成正比。
再看看下面这个例子，同上面的分析方法，我们得出这段代码总的执行时间就是 (2n^2+2n+3)*unit_time。

例2：int sum(int n) {
   int result = 0;
   int i = 1;
   int j = 1;
   for (; i <= n; ++i) {
     j = 1;
     for (; j <= n; ++j) {
       result = result +  i * j;
     }
   }
 }

把这个规律总结成一个公式:T(n) = O(f(n))

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

只关注循环执行次数最多的一段代码
$\color{red}{我们通常会忽略掉公式中的常量、低阶、系数，只需要记录一个最大阶的量级就可以了。}$
例子1中：其中第 2、3、行代码都是常量级的执行时间，与 n 的大小无关，所以对于复杂度并没有影响。
4、5行代码循环执行，与 n 的大小无关，次数最多的是第4、5行代码，所以这块代码要重点分析。前面我们也讲过，这两行代码被执行了 n 次，所以总的时间复杂度就是 O(n)。
例子2中时间复杂度为：O(n^2)
加法法则：总复杂度等于量级最大的那段代码的复杂度

例3：int sum(int n) {
   int result_1 = 0;
   int x = 1;
   for (; x < 1000; ++x) {
     result_1 = result_1 + x;
   }

   int result_2 = 0;
   int y = 1;
   for (; y < n; ++y) {
     result_2 = result_2 + y;
   }
 
   int result_3 = 0;
   int i = 1;
   int j = 1;
   for (; i <= n; ++i) {
     j = 1; 
     for (; j <= n; ++j) {
       result_3 = result_3 +  i * j;
     }
   }
   return result_1 + result_2 + result_3;
 }

这个例子分三部分：求result_1、result_2、result_3。
第一部分跟n没关系：属于常量阶，我们表示为0(1)
第二部分：O(n)
第三部分为：O(n^2)
所以整个sum函数的时间复杂度为：T(n)=O(1)+T1(n)+T2(n)=max(O(f(n)), O(g(n)))=max(O(n),O(n^2)) = n^2

乘法法则：嵌套代码的复杂度等于嵌套内外代码复杂度的乘积
如果 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)

例4： int sum1(int n) {
   int result = 0;
   int i = 1;
   for (; i <= n; ++i) {
     result = sum(i) + i;
   }
   return result;
 }
 
int sum(int n) {
   int result = 0;
   int i = 1;
   int j = 1;
   for (; i <= n; ++i) {
     j = 1;
     for (; j <= n; ++j) {
       result = result +  i * j;
     }
   }
 }

5、常见时间复杂度分析

常见时间复杂度.png

O(m+n)、O(mn)
代码的复杂度由两个数据的规模来决定，如例5：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))。

例5: 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;
}

6、空间复杂度

空间复杂度比较简单，空间复杂度(Space Complexity)是对一个算法在运行过程中临时占用存储空间大小的量度，记做S(n)=O(f(n))。看一个例子。

例6: int sum(int n) {
  int result = 0;
  int[] a = new int[n]; // 开辟了新的存储空间
  for (i; i <n; ++i) {
    a[i] = i * i;
  }
  for (i = n-1; i >= 0; --i) {
    result +=a[i];
  }
  return result;
}

除了第三行申请了一个大小为 n 的 int 类型数组，除此之外，剩下的代码都没有占用更多的空间，所以整段代码的空间复杂度就是 O(n)。
我们常见的空间复杂度就是 O(1)、O(n)、O(n2)，像 O(logn)、O(nlogn) 这样的对数阶复杂度平时都用不到。而且，空间复杂度分析比时间复杂度分析要简单很多。所以，对于空间复杂度，掌握刚我说的这些内容已经足够了。

第2课：算法复杂度分析（上）：时间、空间复杂度分析法