复杂度分析
数据结构和算法本身解决的是“快”和“省”的问题，即如何让代码运行得更快、更省存储空间。所以，执行效率是算法一个非常重要的考量指标。那如何来衡量你编写的算法代码的执行效率呢？这时就需要用到复杂度分析，它分为“时间复杂度分析”和“空间复杂度分析”，并不具体表示代码真正的执行时间，而是描述代码执行时间（或占用空间）随数据规模增长的变化趋势。
大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遍，所以需要 2n2* O 的执行时间。所以，整段代码总的执行时间 T(n) = (2n2+2n+3)*O。
当 n 很大时，你可以把它想象成 10000、100000。而公式中的低阶、常量、系数三部分并不左右增长趋势，所以都可以忽略。只需要记录一个最大量级就可以了，上面那两段代码的时间复杂度，就可以记为：T(n) = O(n)； T(n) = O(n2)。
时间复杂度分析
有四个比较实用的方法可以分析一段代码的时间复杂度：
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 22 23 24 ... 2x = n
所以，只要知道 x 值是多少，就知道这行代码执行的次数了。x=log2n，所以，这段代码的时间复杂度就是 O(log2n)。实际上，不管是以 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 <n; ++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) 这样的对数阶复杂度平时都用不到。而且，空间复杂度分析比时间复杂度分析要简单很多。所以，对于空间复杂度，掌握这些内容已经足够了。