数据结构和算法 ＜基础＞（一、时间空间复杂度(上)）

数据结构和算法本身解决的是“快”和“省”的问题，就是如何让代码运行得更快，如何让代码更省存储空间。所以执行效率是算法一个非常重要的考量指标。我们如何来衡量这些指标呢？其实就是我们说的时间、空间复杂度分析。

王争老师说：复杂度分析是整个算法学习的精髓，只要掌握了它，数据结构和算法的内容基本上就掌握了一半。

那我们就把这块硬骨头给啃下来。

其实我们分析复杂度也是有两种方法的第一是事后统计法，第二是事前分析估算方法。

1.1 事后统计法

事后统计法，听名字都知道是，我们把代码跑一遍，通过统计、监控然后得出算法执行的时间和占用内存大小。但是这种做法有很大的局限性。

1. 测试结果非常依赖测试环境（不同的cpu，处理速度肯定不一样了）
2. 测试结果受数据规模的影响很大（处理大量数据和小量数据的结果是不一样的）

我们一般不用具体的测试数据来测试，我们一般都是使用事前估算的方法，来估算算法的执行效率。

1.2 事前估算分析法

在前面装逼说了出来，怎么也要吹水一波，不过概念的东西确实难受，简单描述一下即可，反正这个也不是重点。

在计算机程序编制前，依据统计方法对算法进行估算。

经过分析，一个高级程序语言编写的程序在计算机上运行时所消耗的时间取决于下面：

1. 算法采用的策略、方法
2. 编译产生的代码质量
3. 问题的输入规模
4. 机器执行指令的速度

一个程序的运行时间，依赖于算法的好坏和问题输入规模。输入规模是指输入量多少。

1.3 大O复杂度表示法

算了，水不好吹。接下来我们来点重要的大O复杂度表示法。

基本我们问的算法复杂度，都是问大O复杂度表示法，所以接下来要好好分析。

先看这个累加和：

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

这里我们假设每行代码执行的时间都一样（一点点的差距问题不大）为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)是多少？

T(n)=（2n²+2n+3）* unit_time

通过两个例子可以看到，T(n)其实跟每行代码执行次数n成正比。

所以我们就总结成一个公式，

T(n) = O(f(n))

T(n)代码执行的时间，n是数据规模大小，f(n)表示每行代码执行的次数综合，公式的O表示代码执行时间T(n)与f(n)表达式成正比。

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

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

1.4 时间复杂度分析

王争老师又三个比较实用的方法可以快速分析时间复杂度

1.4.1 只关注循环执行次数最多的一段代码

我们在分析一个算法，一段代码的时间复杂度的时候，也只关注循环执行次数最多的那一段代码就可以了。因为我们大O表示法，只看最高次数的。

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

1.4.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;
 }

三段代码的时间复杂度分别是：O(1)，O(n)，O(n²)

总计复杂度为O(n²)

总的时间复杂度等于量级最大的那段代码的时间复杂度。

1.4.3 乘法法则：嵌套代码的复杂度等于嵌套内外代码复杂度的乘积

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()函数，复杂度就是O(n)，但是cal()函数又有一个函数f().而f()复杂度为O(n)，所以这种嵌套行为，就是复杂度乘积O(n²)。

这三种法则比较重要，我学了之后分析，也是这么分析的，真的很有用。