本文共 3342 字，大约阅读时间需要 11 分钟。
1.二分查找的时间复杂度
假使总共有n个元素，那么二分后每次查找的区间大小就是n，n/2，n/4，…，n/2^k（接下来操作元素的剩余个数），其中k就是循环的次数。 最坏的情况是K次二分之后,每个区间的大小为1,找到想要的元素 令n/2^k=1， 可得k=log2n,（是以2为底，n的对数），所以时间复杂度可以表示O()=O(logn).2.算法的时间复杂度
定义： 存在常数 c，使得当 N >= c 时 T(N) <= f(N)，表示为 T(n) = O(f(n)) 。大O记号的两条性质：（1）对于任意常数c>0，有O(f(n))=O(c∙f(n))（2）对于任意常数a>b>0,有O(na+nb)=O(na)
算法的时间复杂度，用来度量算法的运行时间，记作: T(n) = O(f(n))。它表示随着 输入大小n 的增大，算法执行需要的时间的增长速度可以用 f(n) 来描述。
显然如果 T(n) = n^2，那么 T(n) = O(n^2)，T(n) = O(n^3)，T(n) = O(n^4) 都是成立的，但是因为第一个 f(n) 的增长速度与 T(n) 是最接近的，所以第一个是最好的选择，所以我们说这个算法的复杂度是 O(n^2) 。
3. 根据算法的执行次数获得其时间复杂度:
那么当我们拿到算法的执行次数函数 T(n) 之后怎么得到算法的时间复杂度呢？ <1>: 我们知道常数项并不影响函数的增长速度，所以当 T(n) = c，c 为一个常数的时候，我们说这个算法的时间复杂度为 O(1)；如果 T(n) 不等于一个常数项时，直接将常数项省略。 一般来讲,不含转向(循环,递归,调用等)必顺序执行,即是O(1);比如第一个 Hello, World 的例子中 T(n) = 2，所以我们说那个函数(算法)的时间复杂度为 O(1)。T(n) = n + 29，此时时间复杂度为 O(n)。
高效解: O(n),O(logn)
图一:
图二: 
<2>
我们知道高次项对于函数的增长速度的影响是最大的。n^3 的增长速度是远超 n^2 的，同时 n^2 的增长速度是远超 n 的。 同时因为要求的精度不高，所以我们直接忽略低此项。比如T(n) = n^3 + n^2 + 29，此时时间复杂度为 O(n^3)。
图三:
有效解:O(n^c):
难解:O(2^n)
4 .分析法则:
对于一个循环，假设循环体的时间复杂度为 O(n)，循环次数为 m，则这个
循环的时间复杂度为 O(n×m)。void aFunc(int n) { for(int i = 0; i < n; i++) { // 循环次数为 n printf("Hello, World!\n"); // 循环体时间复杂度为 O(1) }} 此时时间复杂度为 O(n × 1)，即 O(n)。
对于多个循环，假设循环体的时间复杂度为 O(n)，各个循环的循环次数分别是a, b, c…，则这个循环的时间复杂度为 O(n×a×b×c…)。分析的时候应该由里向外分析这些循环。
void aFunc(int n) { for(int i = 0; i < n; i++) { // 循环次数为 n for(int j = 0; j < n; j++) { // 循环次数为 n printf("Hello, World!\n"); // 循环体时间复杂度为 O(1) } }} 此时时间复杂度为 O(n × n × 1)，即 O(n^2)。
对于顺序执行的语句或者算法，总的时间复杂度等于其中最大的时间复杂度。
void aFunc(int n) { // 第一部分时间复杂度为 O(n^2) for(int i = 0; i < n; i++) { for(int j = 0; j < n; j++) { printf("Hello, World!\n"); } } // 第二部分时间复杂度为 O(n) for(int j = 0; j < n; j++) { printf("Hello, World!\n"); }} 此时时间复杂度为 max(O(n^2), O(n))，即 O(n^2)。
对于条件判断语句，总的时间复杂度等于其中 时间复杂度最大的路径 的时间复杂度。
void aFunc(int n) { if (n >= 0) { // 第一条路径时间复杂度为 O(n^2) for(int i = 0; i < n; i++) { for(int j = 0; j < n; j++) { printf("输入数据大于等于零\n"); } } } else { // 第二条路径时间复杂度为 O(n) for(int j = 0; j < n; j++) { printf("输入数据小于零\n"); } }} 此时时间复杂度为 max(O(n^2), O(n))，即 O(n^2)。
时间复杂度分析的基本策略是：从内向外分析，从最深层开始分析。如果遇到函数调用，要深入函数进行分析。
5.练习
最后，我们来练习一下一. 基础题
求该方法的时间复杂度void aFunc(int n) { for (int i = 0; i < n; i++) { for (int j = i; j < n; j++) { printf("Hello World\n"); } }} 参考答案：
当 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)。二. 进阶题
求该方法的时间void aFunc(int n) { for (int i = 2; i < n; i++) { i *= 2; printf("%i\n", i); }} 参考答案：
假设循环次数为 t，则循环条件满足 2^t < n。 可以得出，执行次数t = log(2)(n)，即 T(n) = log(2)(n)，可见时间复杂度为 O(log(2)(n))，即 O(log n)。三. 再次进阶
求该方法的时间复杂度long aFunc(int n) { if (n <= 1) { return 1; } else { return aFunc(n - 1) + aFunc(n - 2); }} 参考答案： TODO (20180619)
显然运行次数，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)。**
递归+分治的时间复杂度: 5n/3-2?
因为: T(n)<=3从上图得知;
@参考 :