数据结构与算法—01、复杂度分析

复杂度分析

数据结构和算法本身解决的是“快”和“省”的问题，即如何让代码运行得更快、更省存储空间。所以，执行效率是算法一个非常重要的考量指标。那如何来衡量你编写的算法代码的执行效率呢？这时就需要用到复杂度分析，它分为“时间复杂度分析”和“空间复杂度分析”，并不具体表示代码真正的执行时间，而是描述代码执行时间（或占用空间）随数据规模增长的变化趋势。

大O表示法

所有代码的执行时间 T(n) 与每行代码的执行次数 n 成正比。我们可以把这个规律总结成一个公式。

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

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

按照这个表示法，来看这段代码。

1  int cal(int n) {
2    int sum = 0;
3    int i = 1;
4    for (; i <= n; ++i) {
5      sum = sum + i;
6    }
7    return sum;
8  }

第 2、3 行代码分别需要 1 遍，第 4、5 行都运行了 n 遍，所以需要 2n*O 的执行时间，所以这段代码总的执行时间就是 (2n+2)*O。可以看出来，T(n) = O(2n+2)。

 

再看另一段代码

 1  int cal(int n) {
 2    int sum = 0;
 3    int i = 1;
 4    int j = 1;
 5    for (; i <= n; ++i) {
 6      j = 1;
 7      for (; j <= n; ++j) {
 8        sum = sum +  i * j;
 9      }
10    }
11  }

 

第 2、3、4 行代码，每行都需要执行1遍，第 5、6 行代码循环执行了 n 遍，需要 2n * O 的执行时间，第 7、8 行代码循环执行了 n2遍，所以需要 2n²* O 的执行时间。所以，整段代码总的执行时间 T(n) = (2n²+2n+3)*O。

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

 

时间复杂度分析

有四个比较实用的方法可以分析一段代码的时间复杂度：

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

比如上面第一段代码，第 2、3 行代码都是常量级的执行时间，与 n 的大小无关，所以对于复杂度并没有影响。循环执行次数最多的是第 4、5 行代码，所以这块代码要重点分析，总的时间复杂度就是 O(n)。

2）最大法则：总复杂度等于量级最大的那段代码的复杂度

比如一段代码中有单循环和多重循环，那么取多重循环的复杂度。

 1 int cal(int n) {
 2    int sum_1 = 0;
 3    int p = 1;
 4    for (; p < 100; ++p) {
 5      sum_1 = sum_1 + p;
 6    }
 7 
 8    int sum_2 = 0;
 9    int q = 1;
10    for (; q < n; ++q) {
11      sum_2 = sum_2 + q;
12    }
13  
14    int sum_3 = 0;
15    int i = 1;
16    int j = 1;
17    for (; i <= n; ++i) {
18      j = 1; 
19      for (; j <= n; ++j) {
20        sum_3 = sum_3 +  i * j;
21      }
22    }
23  
24    return sum_1 + sum_2 + sum_3;
25  }

 

这个代码分为三部分，分别是求 sum_1、sum_2、sum_3。我们可以分别分析每一部分的时间复杂度，然后把它们放到一块儿，再取一个量级最大的作为整段代码的复杂度。

这三部分代码的复杂度分别是O(1)、O(n) 和 O(n2)。综合这三段代码的时间复杂度，我们取其中最大的量级。所以，整段代码的时间复杂度就为 O(n2)。也就是说：总的时间复杂度就等于量级最大的那段代码的时间复杂度。

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

比如递归、多重循环等

4）多个规模求加法

比如方法有两个参数控制两个循环的次数，那么这时就取二者复杂度相加。

 1 int cal(int m, int n) {
 2   int sum_1 = 0;
 3   int i = 1;
 4   for (; i < m; ++i) {
 5     sum_1 = sum_1 + i;
 6   }
 7 
 8   int sum_2 = 0;
 9   int j = 1;
10   for (; j < n; ++j) {
11     sum_2 = sum_2 + j;
12   }
13 
14   return sum_1 + sum_2;
15 }

 

从代码中可以看出，m 和 n 是表示两个数据规模。我们无法事先评估 m 和 n 谁的量级大，所以我们在表示复杂度的时候，就不能简单地利用加法法则，省略掉其中一个。所以，上面代码的时间复杂度就是 O(m+n)。

 

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

1. O(1)

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

1  int i = 8;
2  int j = 6;
3  int sum = i + j;

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

2.  O(logn)、O(nlogn)

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

从代码中可以看出，变量 i 的值从 1 开始取，每循环一次就乘以 2。当大于 n 时，循环结束。实际上，变量 i 的取值就是一个等比数列。

2 2² 2³ 2⁴ ... 2^x = n

所以，只要知道 x 值是多少，就知道这行代码执行的次数了。x=log2ⁿ，所以，这段代码的时间复杂度就是 O(log2ⁿ)。实际上，不管是以 2 为底、以 3 为底，还是以 10 为底，在对数阶时间复杂度的表示方法里，我们忽略对数的“底”，统一表示为 O(logn)。

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

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

代码的复杂度由两个数据的规模来决定。代码同时间复杂度分析的“4）”

空间复杂度分析

时间复杂度的全称是渐进时间复杂度，表示算法的执行时间与数据规模之间的增长关系。类比一下，空间复杂度全称就是渐进空间复杂度（asymptotic space complexity），表示算法的存储空间与数据规模之间的增长关系。

 1 void print(int n) {
 2   int i = 0;
 3   int[] a = new int[n];
 4   for (i; i i) {
 5     a[i] = i * i;
 6   }
 7 
 8   for (i = n-1; i >= 0; --i) {
 9     print out a[i]
10   }
11 }

 

跟时间复杂度分析一样，第 2 行代码中，申请了一个空间存储变量 i，但是它是常量阶的，跟数据规模 n 没有关系，所以可以忽略。第 3 行申请了一个大小为 n 的 int 类型数组，除此之外，剩下的代码都没有占用更多的空间，所以整段代码的空间复杂度就是 O(n)。

常见的空间复杂度就是 O(1)、O(n)、O(n2)，像 O(logn)、O(nlogn) 这样的对数阶复杂度平时都用不到。而且，空间复杂度分析比时间复杂度分析要简单很多。所以，对于空间复杂度，掌握这些内容已经足够了。