** ** 通常，对于一个给定的算法，我们要做两项分析。第一是从数学上证明算法的正确性，这一步主要用到形式化证明的方法及相关推理模式，如循环不变式、数学归纳法等。而在证明算法是正确的基础上，第二部就是分析算法的时间复杂度。算法的时间复杂度反映了程序执行时间随输入规模增长而增长的量级，在很大程度上能很好反映出算法的优劣与否。因此，作为程序员，掌握基本的算法时间复杂度分析方法是很有必要的。
算法执行时间需通过依据该算法编制的程序在计算机上运行时所消耗的时间来度量。而度量一个程序的执行时间通常有两种方法。
算法的时间复杂度
** （1）时间频度** 一个算法执行所耗费的时间，从理论上是不能算出来的，必须上机运行测试才能知道。但我们不可能也没有必要对每个算法都上机测试，只需知道哪个算法花费的时间多，哪个算法花费的时间少就可以了。并且一个算法花费的时间与算法中语句的执行次数成正比例，哪个算法中语句执行次数多，它花费时间就多。一个算法中的语句执行次数称为语句频度或时间频度。记为T(n)。
** （2）时间复杂度** 在刚才提到的时间频度中，n称为问题的规模，当n不断变化时，时间频度T(n)也会不断变化。但有时我们想知道它变化时呈现什么规律。为此，我们引入时间复杂度概念。 一般情况下，算法中基本操作重复执行的次数是问题规模n的某个函数，用T(n)表示，若有某个辅助函数f(n),使得当n趋近于无穷大时，T(n)/f(n)的极限值为不等于零的常数，则称f(n)是T(n)的同数量级函数。记作T(n)=Ｏ(f(n)),称Ｏ(f(n)) 为算法的渐进时间复杂度，简称时间复杂度。
常见的算法时间复杂度由小到大依次为：
在计算算法时间复杂度时有以下几个简单的程序分析法则:
- (1).对于一些简单的输入输出语句或赋值语句,近似认为需要O(1)时间
- (2).对于顺序结构,需要依次执行一系列语句所用的时间可采用大O下"求和法则"
求和法则:是指若算法的2个部分时间复杂度分别为 T1(n)=O(f(n))和 T2(n)=O(g(n)),则 T1(n)+T2(n)=O(max(f(n), g(n)))。特别地,若T1(m)=O(f(m)), T2(n)=O(g(n)),则 T1(m)+T2(n)=O(f(m) + g(n))
- (3).对于选择结构,如if语句,它的主要时间耗费是在执行then字句或else字句所用的时间,需注意的是检验条件也需要O(1)时间
- (4).对于循环结构,循环语句的运行时间主要体现在多次迭代中执行循环体以及检验循环条件的时间耗费,一般可用大O下"乘法法则"
乘法法则: 是指若算法的2个部分时间复杂度分别为 T1(n)=O(f(n))和 T2(n)=O(g(n)),则 T1*T2=O(f(n)*g(n))
- (5).对于复杂的算法,可以将它分成几个容易估算的部分,然后利用求和法则和乘法法则技术整个算法的时间复杂度另外还有以下2个运算法则:(1) 取最高向项；(2) 去掉常数项。
很多时候困难的是从算法通过分析和数学运算得到 T(n)。对此，提供下列四个便利的法则，这些法则都是可以简单推导出来的，总结出来以便提高效率。
1、对于一个循环，假设循环体的时间复杂度为 O(n)，循环次数为 m，则这个循环的时间复杂度为 O(n×m)。
2
3
4
5
6
2 for(int i = 0; i < n; i++) { // 循环次数为 n
3 printf("Hello, World!\n"); // 循环体时间复杂度为 O(1)
4 }
5}
6
此时时间复杂度为 O(n × 1)，即 O(n)。
2、对于多个循环，假设循环体的时间复杂度为 O(n)，各个循环的循环次数分别是a, b, c…，则这个循环的时间复杂度为 O(n×a×b×c…)。分析的时候应该由里向外分析这些循环。
2
3
4
5
6
7
8
2 for(int i = 0; i < n; i++) { // 循环次数为 n
3 for(int j = 0; j < n; j++) { // 循环次数为 n
4 printf("Hello, World!\n"); // 循环体时间复杂度为 O(1)
5 }
6 }
7}
8
此时时间复杂度为 O(n × n × 1)，即 O(n^2)。
3、对于顺序执行的语句或者算法，总的时间复杂度等于其中最大的时间复杂度。
2
3
4
5
6
7
8
9
10
11
12
13
2 // 第一部分时间复杂度为 O(n^2)
3 for(int i = 0; i < n; i++) {
4 for(int j = 0; j < n; j++) {
5 printf("Hello, World!\n");
6 }
7 }
8 // 第二部分时间复杂度为 O(n)
9 for(int j = 0; j < n; j++) {
10 printf("Hello, World!\n");
11 }
12}
13
此时时间复杂度为 max(O(n^2), O(n))，即 O(n^2)。
4、对于条件判断语句，总的时间复杂度等于其中 时间复杂度最大的路径 的时间复杂度。
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
2 if (n >= 0) {
3 // 第一条路径时间复杂度为 O(n^2)
4 for(int i = 0; i < n; i++) {
5 for(int j = 0; j < n; j++) {
6 printf("输入数据大于等于零\n");
7 }
8 }
9 } else {
10 // 第二条路径时间复杂度为 O(n)
11 for(int j = 0; j < n; j++) {
12 printf("输入数据小于零\n");
13 }
14 }
15}
16
此时时间复杂度为 max(O(n^2), O(n))，即 O(n^2)。
时间复杂度分析的基本策略是：从内向外分析，从最深层开始分析。如果遇到函数调用，要深入函数进行分析。
最后，我们来练习一下
一. 基础题
求该方法的时间复杂度
2
3
4
5
6
7
8
2 for (int i = 0; i < n; i++) {
3 for (int j = i; j < n; j++) {
4 printf("Hello World\n");
5 }
6 }
7}
8
参考答案：
当 i = 0 时，内循环执行 n 次运算，当 i = 1 时，内循环执行 n – 1 次运算……当 i = n – 1 时，内循环执行 1 次运算。所以，执行次数 T(n) = n + (n – 1) + (n – 2)……+ 1 = n(n + 1) / 2 = n^2 / 2 + n / 2。根据上文说的 大O推导法 可以知道，此时时间复杂度为 O(n^2)。
二. 进阶题
求该方法的时间复杂度
2
3
4
5
6
7
2 for (int i = 2; i < n; i++) {
3 i *= 2;
4 printf("%i\n", i);
5 }
6}
7
参考答案：
假设循环次数为 t，则循环条件满足 2^t < n。可以得出，执行次数t = log(2)(n)，即 T(n) = log(2)(n)，可见时间复杂度为 O(log(2)(n))，即 O(log n)。
三. 再次进阶
求该方法的时间复杂度
2
3
4
5
6
7
8
2 if (n <= 1) {
3 return 1;
4 } else {
5 return aFunc(n - 1) + aFunc(n - 2);
6 }
7}
8
参考答案：
显然运行次数，T(0) = T(1) = 1，同时 T(n) = T(n – 1) + T(n – 2) + 1，这里的 1 是其中的加法算一次执行。
显然 T(n) = T(n – 1) + T(n – 2) 是一个斐波那契数列，通过归纳证明法可以证明，当 n >= 1 时 T(n) < (5/3)^n，同时当 n > 4 时 T(n) >= (3/2)^n。
所以该方法的时间复杂度可以表示为 O((5/3)^n)，简化后为 O(2^n)。
可见这个方法所需的运行时间是以指数的速度增长的。如果大家感兴趣，可以试下分别用 1，10，100 的输入大小来测试下算法的运行时间，相信大家会感受到时间复杂度的无穷魅力。
