时间复杂度

时间复杂度

本篇文章参考：https://www.jianshu.com/p/f4cca5ce055a

我们假设计算机运行一行基础代码需要执行一次运算。

int aFunc(void) {
    printf("Hello, World!
");      //  需要执行 1 次
    return 0;       // 需要执行 1 次
}

那么上面这个方法需要执行 2 次运算

int aFunc(int n) {
    for(int i = 0; i<n; i++) {         // 需要执行 (n + 1) 次
        printf("Hello, World!
");      // 需要执行 n 次
    }
    return 0;       // 需要执行 1 次
}

这个方法需要 (n + 1 + n + 1) = 2n + 2 次运算。

我们把 算法需要执行的运算次数 用 输入大小n 的函数 表示，即 T(n) 。

即T(n)可以看做是一个关于n（n不是程序运行的次数）的函数。

定义： 存在常数 c，使得当 N >= c 时 T(N) <= f(N)，表示为 T(n) = O(f(n)) 。
如图：

 

 

当 N >= 2 的时候，f(n) = n^2 总是大于 T(n) = n + 2 的，于是我们说 f(n) 的增长速度是大于或者等于 T(n) 的，也说 f(n) 是 T(n) 的上界，可以表示为 T(n) = O(f(n))。

因为f(n) 的增长速度是大于或者等于 T(n) 的，即T(n) = O(f(n))，所以我们可以用 f(n) 的增长速度来度量 T(n) 的增长速度，所以我们说这个算法的时间复杂度是 O(f(n))。

此时为了 估算算法需要的运行时间 和 简化算法分析，我们引入时间复杂度的概念。

算法的时间复杂度，用来度量算法的运行时间，记作: T(n) = O(f(n))。它表示随着 输入大小n 的增大，算法执行需要的时间的增长速度可以用 f(n) 来描述。

那么当我们拿到算法的执行次数函数 T(n) 之后怎么得到算法的时间复杂度呢？

1. 我们知道常数项并不影响函数的增长速度，所以当 T(n) = c，c 为一个常数的时候，我们说这个算法的时间复杂度为 O(1)；如果 T(n) 不等于一个常数项时，直接将常数项省略。

比如

第一个 Hello, World 的例子中 T(n) = 2，所以我们说那个函数(算法)的时间复杂度为 O(1)。
T(n) = n + 29，此时时间复杂度为 O(n)。

2. 我们知道高次项对于函数的增长速度的影响是最大的。n^3 的增长速度是远超 n^2 的，同时 n^2 的增长速度是远超 n 的。 同时因为要求的精度不高，所以我们直接忽略低此项。

比如

T(n) = n^3 + n^2 + 29，此时时间复杂度为 O(n^3)。

3. 因为函数的阶数对函数的增长速度的影响是最显著的，所以我们忽略与最高阶相乘的常数。

比如

T(n) = 3n^3，此时时间复杂度为 O(n^3)。

 综合起来：如果一个算法的执行次数是 T(n)，那么只保留最高次项，同时忽略最高项的系数后得到函数 f(n)，此时算法的时间复杂度就是 O(f(n))。为了方便描述，下文称此为 大O推导法

1. 对于一个循环，假设循环体的时间复杂度为 O(n)，循环次数为 m，则这个
   循环的时间复杂度为 O(n×m)。

   void aFunc(int n) {
       for(int i = 0; i < n; i++) {         // 循环次数为 n
           printf("Hello, World!
   ");      // 循环体时间复杂度为 O(1)
       }
   }

 　　此时时间复杂度为 O(n × 1)，即 O(n)。
　　　　

2. 对于多个循环，假设循环体的时间复杂度为 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!
   ");      // 循环体时间复杂度为 O(1)
           }
       }
   } 

 此时时间复杂度为 O(n × n × 1)，即 O(n^2)。

3. 对于顺序执行的语句或者算法，总的时间复杂度等于其中最大的时间复杂度。

   void aFunc(int n) {
       // 第一部分时间复杂度为 O(n^2)
       for(int i = 0; i < n; i++) {
           for(int j = 0; j < n; j++) {
               printf("Hello, World!
   ");
           }
       }
       // 第二部分时间复杂度为 O(n)
       for(int j = 0; j < n; j++) {
           printf("Hello, World!
   ");
       }
   }

    此时时间复杂度为 max(O(n^2), O(n))，即 O(n^2)。

4. 对于条件判断语句，总的时间复杂度等于其中 时间复杂度最大的路径 的时间复杂度。

   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("输入数据大于等于零
   ");
               }
           }
       } else {
           // 第二条路径时间复杂度为 O(n)
           for(int j = 0; j < n; j++) {
               printf("输入数据小于零
   ");
           }
       }
   }

    此时时间复杂度为 max(O(n^2), O(n))，即 O(n^2)。

 　　

常见的时间复杂度：

执行次数函数	阶	术语描述
12	O(1)	常数阶
2n+3	O(n)	线性阶
3n2+2n+1	O(n2)	平方阶
5log2n+20	O(log2n)	对数阶
2n+3nlog2n+19	O(nlogn)	nlog2n阶
6n3+2n2+3n+4	O(n3)	立方阶
2n	O(2n)	指数阶

 

 

 

 

 

 

 

 

时间复杂度所耗费的时间是：

O(1) < O(logn) < O(n) < O(nlogn) < O(n²) < O(n³) <O(2ⁿ) < O(n!) <O(nⁿ)