【时间复杂度】时间复杂度

                                                                                  ?

                                                                                  ?

                                                                                  //------------------>摘自:http://www.thescrewshack.com/qq_41523096/article/details/82142747《一套图 搞懂“时间复杂度”》

                                                                                  渐进时间复杂度

                                                                                  比如算法A的相对时间是T(n)= 100n,算法B的相对时间是T(n)= 5n^2,这两个到底谁的运行时间更长一些?这就要看n的取值了。

                                                                                  所以,这时候有了渐进时间复杂度(asymptotic time complectiy)的概念,官方的定义如下:

                                                                                  若存在函数 f(n),使得当n趋近于无穷大时,T(n)/ f(n)的极限值为不等于零的常数,则称 f(n)是T(n)的同数量级函数。

                                                                                  记作?T(n)= O(f(n)),称O(f(n)) 为算法的渐进时间复杂度,简称时间复杂度。

                                                                                  渐进时间复杂度用大写O来表示,所以也被称为大O表示法。

                                                                                  640?wx_fmt=jpeg

                                                                                  640?wx_fmt=jpeg

                                                                                  如何推导出时间复杂度呢?有如下几个原则:

                                                                                  1. 如果运行时间是常数量级,用常数1表示;

                                                                                  2. 只保留时间函数中的最高阶项;

                                                                                  3. 如果最高阶项存在,则省去最高阶项前面的系数。

                                                                                  让我们回头看看刚才的四个场景。

                                                                                  场景1:

                                                                                  T(n) = 3n?

                                                                                  最高阶项为3n,省去系数3,转化的时间复杂度为:

                                                                                  T(n) =? O(n)

                                                                                  640?wx_fmt=png

                                                                                  场景2:

                                                                                  T(n) = 5logn?

                                                                                  最高阶项为5logn,省去系数5,转化的时间复杂度为:

                                                                                  T(n) =? O(logn)

                                                                                  640?wx_fmt=png

                                                                                  场景3:

                                                                                  T(n) = 2

                                                                                  只有常数量级,转化的时间复杂度为:

                                                                                  T(n) =? O(1)

                                                                                  640?wx_fmt=png

                                                                                  场景4:

                                                                                  T(n) = 0.5n^2 + 0.5n

                                                                                  最高阶项为0.5n^2,省去系数0.5,转化的时间复杂度为:

                                                                                  T(n) =? O(n^2)

                                                                                  640?wx_fmt=png

                                                                                  这四种时间复杂度究竟谁用时更长,谁节省时间呢?稍微思考一下就可以得出结论:

                                                                                  O(1)<?O(logn)<?O(n)<?O(n^2)

                                                                                  在编程的世界中有着各种各样的算法,除了上述的四个场景,还有许多不同形式的时间复杂度,比如:

                                                                                  O(nlogn),?O(n^3),?O(m*n),O(2^n),O(n!)

                                                                                  今后遨游在代码的海洋里,我们会陆续遇到上述时间复杂度的算法。

                                                                                  //<------------------摘自:http://www.thescrewshack.com/qq_41523096/article/details/82142747《一套图 搞懂“时间复杂度”》

                                                                                  ?

                                                                                  如何得到时间复杂度--摘自:https://www.jianshu.com/p/f4cca5ce055a

                                                                                  ?

                                                                                  算法的时间复杂度,用来度量算法的运行时间,记作: 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) 。

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

                                                                                  1. 我们知道常数项对函数的增长速度影响并不大,所以当 T(n) = c,c 为一个常数的时候,我们说这个算法的时间复杂度为 O(1);如果 T(n) 不等于一个常数项时,直接将常数项省略。
                                                                                  比如
                                                                                  第一个 Hello, World 的例子中 T(n) = 2,所以我们说那个函数(算法)的时间复杂度为 O(1)。
                                                                                  T(n) = n + 29,此时时间复杂度为 O(n)。
                                                                                  
                                                                                  1. 我们知道高次项对于函数的增长速度的影响是最大的。n^3 的增长速度是远超 n^2 的,同时 n^2 的增长速度是远超 n 的。 同时因为要求的精度不高,所以我们直接忽略低此项。
                                                                                  比如
                                                                                  T(n) = n^3 + n^2 + 29,此时时间复杂度为 O(n^3)。
                                                                                  
                                                                                  1. 因为函数的阶数对函数的增长速度的影响是最显著的,所以我们忽略与最高阶相乘的常数。
                                                                                  比如
                                                                                  T(n) = 3n^3,此时时间复杂度为 O(n^3)。
                                                                                  

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

                                                                                  由此可见,由执行次数 T(n) 得到时间复杂度并不困难,很多时候困难的是从算法通过分析和数学运算得到 T(n)。对此,提供下列四个便利的法则,这些法则都是可以简单推导出来的,总结出来以便提高效率。

                                                                                  1. 对于一个循环,假设循环体的时间复杂度为 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)。

                                                                                  1. 对于多个循环,假设循环体的时间复杂度为 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)。

                                                                                  1. 对于顺序执行的语句或者算法,总的时间复杂度等于其中最大的时间复杂度。
                                                                                  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)。

                                                                                  1. 对于条件判断语句,总的时间复杂度等于其中 时间复杂度最大的路径 的时间复杂度。
                                                                                  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)。

                                                                                  时间复杂度分析的基本策略是:从内向外分析,从最深层开始分析。如果遇到函数调用,要深入函数进行分析。

                                                                                  最后,我们来练习一下

                                                                                  一. 基础题
                                                                                  求该方法的时间复杂度

                                                                                  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);
                                                                                      }
                                                                                  }
                                                                                  

                                                                                  参考答案:
                                                                                  显然运行次数,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 的输入大小来测试下算法的运行时间,相信大家会感受到时间复杂度的无穷魅力。

                                                                                  ?



                                                                                  作者:raymondCaptain
                                                                                  链接:https://www.jianshu.com/p/f4cca5ce055a
                                                                                  來源:简书
                                                                                  简书著作权归作者所有,任何形式的转载都请联系作者获得授权并注明出处。

                                                                                  发布了556 篇原创文章 · 获赞 93 · 访问量 20万+
                                                                                  展开阅读全文

                                                                                  没有更多推荐了,返回首页

                                                                                  ??2019 CSDN 皮肤主题: 大白 设计师: CSDN官方博客

                                                                                  分享到微信朋友圈

                                                                                  ×

                                                                                  扫一扫,手机浏览

                                                                                  加拿大28预测计划【复制fh118.com打开】| 加拿大28预测计划【复制fh118.com打开】| 加拿大28预测计划【复制fh118.com打开】| 加拿大28预测计划【复制fh118.com打开】| 加拿大28预测计划【复制fh118.com打开】| 加拿大28预测计划【复制fh118.com打开】| 加拿大28预测计划【复制fh118.com打开】| 加拿大28预测计划【复制fh118.com打开】| 加拿大28预测计划【复制fh118.com打开】| 加拿大28预测计划【复制fh118.com打开】| 加拿大28预测计划【复制fh118.com打开】| 加拿大28预测计划【复制fh118.com打开】| 加拿大28预测计划【复制fh118.com打开】| 加拿大28预测计划【复制fh118.com打开】| 加拿大28预测计划【复制fh118.com打开】| 加拿大28预测计划【复制fh118.com打开】| 加拿大28预测计划【复制fh118.com打开】| 加拿大28预测计划【复制fh118.com打开】| 加拿大28预测计划【复制fh118.com打开】| 加拿大28预测计划【复制fh118.com打开】| 加拿大28预测计划【复制fh118.com打开】| 加拿大28预测计划【复制fh118.com打开】| 加拿大28预测计划【复制fh118.com打开】| 加拿大28预测计划【复制fh118.com打开】| 加拿大28预测计划【复制fh118.com打开】|