精华内容
下载资源
问答
  • 算法复杂度
    2020-07-03 00:08:08

    算法复杂度详解

    在本篇文章中你将了解到:

    • O(1),O(n),O(logn),O(nlogn)…的区别及分析方法

    • 时间复杂度的优劣对比

      首先o(1), o(n), o(logn), o(nlogn)是用来表示对应算法的时间复杂度,这是算法的时间复杂度的表示。不仅仅用于表示时间复杂度,也用于表示空间复杂度。

    算法复杂度分为时间复杂度和空间复杂度。其作用:

    • 时间复杂度是指执行这个算法所需要的计算工作量;
    • 空间复杂度是指执行这个算法所需要的内存空间;

    O后面的括号中有一个函数,指明某个算法的耗时/耗空间与数据增长量之间的关系。其中的n代表输入数据的量。

    O(1),O(n),O(logn),O(nlogn)…的区别及分析方法

    1. 时间复杂度为O(n)—线性阶,就代表数据量增大几倍,耗时也增大几倍。比如常见的遍历算法。
    //循环遍历N次即可得到结果
    count = 0;
    for(int i = 0;i < 10 ; i ++){
    	count ++;
    }
    
    
    1. 时间复杂度O(n^2)—平方阶, 就代表数据量增大n倍时,耗时增大n的平方倍,这是比线性更高的时间复杂度。比如冒泡排序,就是典型的O(n x n)的算法,对n个数排序,需要扫描n x n次。
     for(int i =1;i<arr.length;i++) { //遍历n次
        for(int j=0;j<arr.length-i;j++) {//遍历n-1次
           if(arr[j]>arr[j+1]) {
                  int temp = arr[j];
                  arr[j]=arr[j+1];
                  arr[j+1]=temp;
             }
         }    
    }
    //整体复杂度n*(n-1)
    
    
    1. 时间复杂度O(logn)—对数阶,当数据增大n倍时,耗时增大logn倍(这里的log是以2为底的,比如,当数据增大256倍时,耗时只增大8倍,是比线性还要低的时间复杂度)。二分查找就是O(logn)的算法,每找一次排除一半的可能,256个数据中查找只要找8次就可以找到目标。

      int count = 1;
      while(count < n)
      {  
       
         count = count*2;
         //时间复杂度O(1)的程序步骤序列
         ......
       
      }
      

    由于每次count成衣2之后,就距离n更近了一分。也就是说,有多少个2相乘后大于n,则会退出循环。由2^x=n 得到x=logn。所以这个循环的时间复杂度为O(logn).

      ```js
      int binarySearch(int a[], int key) {
          int low = 0;
          int high = a.length - 1;
          while (low <= high) {
              int mid = low + (high - low) / 2;
              if (a[mid] > key)
                  high = mid - 1;
              else if (a[mid] < key)
                  low = mid + 1;
              else
                  return mid;
          }
          return -1;
      }
      
      ```
    
    1. 时间复杂度O(nlogn)—线性对数阶,就是n乘以logn,当数据增大256倍时,耗时增大256*8=2048倍。这个复杂度高于线性低于平方。归并排序就是O(nlogn)的时间复杂度。

    2. O(1)—常数阶:最低的时空复杂度,也就是耗时与输入数据大小无关,无论输入数据增大多少倍,耗时/耗空间都不变。 哈希算法就是典型的O(1)时间复杂度,无论数据规模多大,都可以在一次计算后找到目标。

      index = a;
      a = b;
      b = index;
      //运行一次就可以得到结果
      
      

      时间复杂度的优劣对比

      O(1) < O(logn) < O(n) < O(nlogn) < O(n^2) < O(n^3)< O(2^n) < O(n!) < O(n^n)

    更多相关内容
  • 算法复杂度速查表

    2017-11-28 21:19:27
    程序员应该掌握的算法复杂度速查表 这个总结非常方便 不仅形象地把各个算法对比开来 也特别利于面试前的复习。
  • 算法复杂度

    千次阅读 2020-12-14 20:58:20
    什么是算法复杂度 算法复杂度,即算法在编写写成可执行程序后,运行时所需要的资源,资源包括时间资源和内存资源 通俗的说,就是执行一段代码所需要的资源(主要是花费的时间以及占用的空间)。 为什么需要算法...

    什么是算法复杂度

    算法复杂度,即算法在编写写成可执行程序后,运行时所需要的资源,资源包括时间资源和内存资源

    通俗的说,就是执行一段代码所需要的资源(主要是花费的时间以及占用的空间)。

    大 O 复杂度表示法

    我们记一个算法的复杂度为O(n),表示数据规模为n的情况下,算法使用的时间和空间资源。(也可以理解O(n)描述着,代码执行花费的时间和空间随着n增大变化的趋势)。
    算法复杂度从时间上考虑是时间复杂度(快不快),从空间上考虑是空间复杂度(占的内存多不多)。

    时间复杂度

    1、O(1)

    	public void method1(int n){
            int a = 5; // 执行1次
            int b = 6; // 执行1次
            int c =  a + b;// 执行1次
            System.out.println(c);// 执行1次
        }
    

    现在有如上的一段代码,假定每一行执行的时间为“1”,那么上述代码用掉的时间为4。无论n是多大,使用的时间都是4,记为O(n) =4。**当n趋于无限大的时候,这个4可以近似的认为是1。**为什么呢,还记得我们为什么需要算法复杂度吗?我们需要通过时间复杂度来描述这个代码随着n的增大,所需要时间的变化趋势。而常数项对变化趋势影响很小,所以可以认为是O(1)。

    2、O(n)

    	public void method2(int n){ 
            for (int i = 1 ; i <= n; ++i) {
                System.out.println("haha"); // 第3行
            }
        }
    

    同样假定每一行执行的时间为“1”,那么这个代码要花费多长时间呢。这个时候,我们只需要看第3行执行多少次即可。
    这个很轻易的看出这是与n有关的。n=1,那么System.out.println("haha")只要执行1次;n=2,执行2次;n=3,执行3次。当等于n时,执行n次。所以这个时间的变化是成线性上升的,所以O(n)=n;

    3、O( n 2 n^2 n2)

    	public void method3(int n){
            for (int i = 1 ; i <= n; ++i) { // 第2行   第1层嵌套
                System.out.println("haha"); // 第3行
                for (int j = 1 ; j <= n; ++j) { // 第4行  第2层嵌套
                    System.out.println("heihei");// 第5行
                }
            }
        }
    

    老规矩,假定每一行执行的时间为“1”。
    上面说过,常数项对变化趋势影响很小,所以可以认为是O(1)。那么同样, 当高次项与低次项同时存在时,比如 n 3 n^3 n3 + n 2 n^2 n2 + n n n,只有高次项对变化的趋势影响最大。所以我们只需要保留高次项,删除低次项即可。即: n 3 n^3 n3 + n 2 n^2 n2 + n n n = O( n 3 n^3 n3)(这个不是上述代码的复杂度,还没有开始计算呢,)

    注意:1、具有多层嵌套的情况下,从最里层嵌套开始看。
    在这里插入图片描述
    首先看下2号嵌套,
    对于System.out.println("heihei")来说,无论j取什么值,2号for循环的循环体都执行一次,j=2,System.out.println("heihei")执行一次,j=100还是执行一次。j的取值在1到n之间,所以对于整个2号for循环,一共执行了n次(n个1累加)。然后看1号for循环。
    当i=1时,1号的循环体执行1+n次(System.out.println(“haha”)1次,2号for循环体n次);i=2时,1好的循环体执行1+n次(System.out.println(“haha”)1次,2号for循环体n次);i=3时,1号的循环体执行1+n次(System.out.println(“haha”)1次,2号for循环体n次)。那么i=n时,1号的循环体1+n次(System.out.println(“haha”)1次,2号for循环体n次)。累加起来就是: ∑ i = 1 n 1 + n \displaystyle\sum_{i=1}^{n} 1+n i=1n1+n = n + n 2 n^2 n2。只保留高次项,所以时间复杂度O( n 2 n^2 n2)。(从此也可以看出,我们其实只需要算出具有最多次嵌套中的代码执行的次数即可。于本例子中就是算出第5行执行多少次就ok了)

    4、O( n 2 n^2 n2)

    	public void method4(int n){
            for (int i = 1 ; i <= n; ++i) {
                System.out.println("haha");
                for (int j = 1 ; j <= i; ++j) {
                    System.out.println("heihei");
                }
            }
    
        }
    

    在这里插入图片描述
    仔细看看,这个和3还是有区别的,2号for里面的n变成i了。
    同样先看下2号嵌套,
    j=1时,执行1次,
    j=2时,执行1次,
    当 j=i时,还是执行1次,所以2号for循环执行i次(i个1累加)。
    对于1号for循环,
    当i=1时,执行1次(因为最终计算复杂度时,会忽略低次项,所以此次直接忽略System.out.println(“haha”)的执行次数,并且上面已经得出2号for循环的执行次数是i,此时i=2,也意味着2号for循环的执行次数是2),
    当i=2时,执行2次
    当i=3时,执行3次,
    当i=n时,执行n次,
    所以时间复杂度: ∑ i = 1 n i = \displaystyle\sum_{i=1}^{n} i = i=1ni= n ∗ ( n + 1 ) 2 \frac{n*(n+1)}{2} 2n(n+1) = n 2 + n 2 \frac{n^2+n}{2} 2n2+n ,忽略低次项以及系数后,为O( n 2 n^2 n2)

    5、O( n 2 n^2 n2)

    	public void method5(int n){
            for (int i = 1 ; i <= n; ++i) {
                System.out.println("haha");
                for (int j = i ; j <= n; ++j) {
                    System.out.println("heihei");
                }
            }
        }
    

    在这里插入图片描述
    仔细看看,这个和3还有4相比,又变化了
    同样先看下2号嵌套,
    j=i时,执行1次,
    j=i+1时,执行1次,
    当 j=n时,还是执行1次,所以2号for循环执行n-i+1次(n-i+1个1累加)。
    对于1号for循环,
    当i=1时,执行n次(因为最终计算复杂度时,会忽略低次项,所以此次直接忽略System.out.println(“haha”)的执行次数,并且上面已经得出2号for循环的执行次数是n-i+1,此时i=1,也意味着2号for循环的执行次数是n),
    当i=2时,执行n-1次,
    当i=3时,执行n-2次,
    当i=n时,执行1次,
    所以时间复杂度: ∑ i = 1 n i = \displaystyle\sum_{i=1}^{n} i = i=1ni= n ∗ ( n + 1 ) 2 \frac{n*(n+1)}{2} 2n(n+1) = n 2 + n 2 \frac{n^2+n}{2} 2n2+n ,忽略低次项以及系数后,为O( n 2 n^2 n2)

    6、O( n 3 n^3 n3)

    	public void method6(int n){
            for (int i = 1 ; i <= n; ++i) {
                System.out.println("haha");
                for (int j = 1 ; j <= i; ++j) {
                    System.out.println("heihei");
                    for (int k = 1 ; k <= j; ++k) {
                        System.out.println("hehe");
                    }
                }
    
            }
    
        }
    

    在这里插入图片描述
    这次来个3层循环的。
    老规矩,3号for的执行次数为j,
    那么2号for的循环次数就是 n 2 + n 2 \frac{n^2+n}{2} 2n2+n
    对于1号for来说,
    i=1,执行 1 2 + 1 2 \frac{1^2+1}{2} 212+1
    i=2,执行 2 2 + 2 2 \frac{2^2+2}{2} 222+2
    i=3,执行 3 2 + 3 2 \frac{3^2+3}{2} 232+3
    i=n,执行 n 2 + n 2 \frac{n^2+n}{2} 2n2+n

    所以时间复杂度: ∑ i = 1 n i 2 + i 2 = \displaystyle\sum_{i=1}^{n} \frac{i^2+i}{2}= i=1n2i2+i= O( n 3 n^3 n3)

    7、O( l o g n log n logn)

    	public void method10(int n){
            for (int i = 1 ; i <= n; i*=2) {
                System.out.println("heihei");
            }
        }
    

    当i= l o g 2 n log_2^n log2n时,跳出循环。
    i取值范围(( 2 0 2^0 20 2 1 2^1 21 2 2 2^2 22 2 3 2^3 23,…, 2 t 2^t 2t),(t = l o g 2 n log_2^n log2n)
    所以这个循环一共走 l o g 2 n log_2^n log2n次,即O( l o g 2 n log_2^n log2n)

    8、O(n l o g n logn logn)

     public void method8(int n){
    
            for (int i = 1 ; i <= n; i*=2) {
                System.out.println("haha");
    
                for (int j = 1 ; j <= n; ++j) {
                    System.out.println("heihei");
                }
    
            }
    
        }
    

    在这里插入图片描述
    2号for的执行次数为n
    1号for的i实际的取值范围( 2 0 2^0 20 2 1 2^1 21 2 2 2^2 22 2 3 2^3 23,…, 2 t 2^t 2t),(t = l o g 2 n log_2^n log2n)
    i= 2 0 2^0 20 ,执行n 次,
    i= 2 1 2^1 21,执行n 次 ,
    i= 2 2 2^2 22,执行n 次 ,
    i=n,执行n 次 ,
    所以时间复杂度: ∑ x = 0 l o g 2 n n = \displaystyle\sum_{x=0}^{log_2^n} n= x=0log2nn= n* l o g 2 n log_2^n log2n 。此处直接忽略系数 O(n l o g n logn logn)

    9、O(n)

    	public void method9(int n){
            for (int i = 1 ; i <= n; i*=2) {
                System.out.println("haha");
                for (int j = 1 ; j <= i; ++j) {
                    System.out.println("heihei");
                }
            }
        }
    

    在这里插入图片描述
    2号for的执行次数为i
    1号for的i实际的取值范围( 2 0 2^0 20 2 1 2^1 21 2 2 2^2 22 2 3 2^3 23,…, 2 t 2^t 2t),(t = l o g 2 n log_2^n log2n)
    i= 2 0 2^0 20 ,执行 2 0 2^0 20 次,
    i= 2 1 2^1 21,执行 2 1 2^1 21 次 ,
    i= 2 2 2^2 22,执行 2 2 2^2 22 次 ,
    i=n,执行n 次 ,
    所以时间复杂度: ∑ x = 0 l o g 2 n 2 x = \displaystyle\sum_{x=0}^{log_2^n} 2^x= x=0log2n2x= 2 0 ( 1 − 2 t ) 1 − 2 \frac{2^0(1-2^t)}{1-2} 1220(12t)
    又因为t= l o g 2 n log_2^n log2n
    所以 2 0 ( 1 − 2 t ) 1 − 2 \frac{2^0(1-2^t)}{1-2} 1220(12t) = (n-1)
    因此:O(n)

    总结:
     没有循环,时间复杂度:O(1)
     有循环:从最内层循环开始,
      1、确定变量取值范围
      2、确定变量每次取值的时间复杂度,记为f(n)
      3、循环相加f(n)
     重复1到3步,即可计算出嵌套循环的时间复杂度

    各种时间复杂度比较

    上面的例子中,演示了O(1)、O(n)、O( n 2 n^2 n2)、O( n 3 n^3 n3)、O( l o g n logn logn)、O( n ∗ l o g n n*logn nlogn)
    下图是几个复杂度比较
    在这里插入图片描述

    最好、最坏、平均、均摊时间复杂度

    最好时间复杂度:在最理想的情况下,执行这段代码的时间复杂度。就是代码最少执行多少次。
    最坏时间复杂度:在最糟糕的情况下,执行这段代码的时间复杂度。就是代码最多------------------------------------执行多少次。

    那么在最好与最坏的情况下一定会存在这其他的情况,累加 这些情况下的时间复杂度 乘以 每种情况出现的频率 即可求出平均时间复杂度。
    平均时间复杂度: ∑ i = 1 n O ( i ) ∗ P ( i ) \displaystyle\sum_{i=1}^{n} O(i)*P(i) i=1nO(i)P(i).
    O ( i ) O(i) O(i)代表i情况下花费的时间
    P ( i ) P(i) P(i)代表出现i这种情况的概率。

    1

        // array表示一个长度为n的数组
        // 代码中的array.length就等于n
        int[] array = new int[n];
        int count = 0;
    
        void insert(int val) {
            if (count == array.length) {
                int sum = 0;
                for (int i = 0; i < array.length; ++i) {
                    sum = sum + array[i];
                }
                array[0] = sum;
                count = 1;
            }
    
            array[count] = val;
            ++count;
        }
    

    最好时间复杂度:不执行if语句,O(1)
    最坏时间复杂度:执行if语句,if语句里面有个for循环,需要执行n次,所以O(n)
    平均时间复杂度:对于数据规模n,即取值范围为1,2,3,…,n

    展开全文
  • 用matlab实现dft和fft算法复杂度比较
  • 算法复杂度计算方法

    2017-08-16 10:47:45
    算法复杂度计算方法
  • 但是时光流逝,如今计算机的江湖之中,存储容量已到达极之巅峰,我们已无需特别关注算法复杂度了。 007.题目难度 ⭐️ 007.一个算法应该是( )。 A.程序 B.问题求解步骤的描述 C.要满足五个基本特性 D.A和C 详细...

    🌕写在前面


    Hello🤗大家好啊,我是kikokingzz,名字太长不好记,大家可以叫我kiko哦~

    从今天开始,我将正式开启一个新的打卡专题——【数据结构·水滴计划】,没错!这是今年上半年的一整个系列计划!本专题目的是通过百天刷题计划,通过题目和知识点串联的方式刷够1000道题完成对数据结构相关知识的全方位复习和巩固;同时还配有专门的笔记总结和文档教程哦!想要搞定,搞透数据结构的同学

    🎉🎉欢迎订阅本专栏🎉🎉

    🍊博客主页:kikoking的江湖背景🍊


    🌟🌟往期必看🌟🌟

    🔥【水滴计划】第一话·数据结构入门竟如此简单?🔥

    目录

    🌕写在前面

    🍺知识点2:算法及其评价

    🥝2.1 算法的基本概念

    🍊1.什么是算法?

    🍊2.数据结构与算法有什么关系?

    🍊3.算法具有什么特性呢?

    🍊4.怎样算一个好的算法?

    🍊5.什么是算法的效率?

    🥝2.2 算法的时间复杂度

    🍊1.什么是时间复杂度?

    🍊2.大O的渐进表示法

    🍊3.时间复杂度有哪3种情况?

    🍊4.计算复杂度的两条规则

    📜实战案例

    🥝2.3 算法的空间复杂度

    🍊1.什么是空间复杂度?

    📝LeetCode之消失的数字

    📝LeetCode之旋转数组

    📜水滴石穿

    🌕写在最后

    热爱所热爱的, 学习伴随终生,kikokingzz与你同在!❥(^_-)

    🍺知识点2:算法及其评价

    🥝2.1 算法的基本概念


    🍊1.什么是算法?

    算法是对特定问题求解步骤的一种描述,它是指令的有限序列,其中每条指令表示一个或多个操作。


    🍊2.数据结构与算法有什么关系?

    程序 = 数据结构 + 算法

    • 数据结构:如何用数据正确地描述现实世界的问题(逻辑结构),并存入计算机(存储结构)。
    • 算法:如何高效地处理上述这些数据,以解决实际问题。

    可见数据结构是将现实问题转化为电脑可以处理的数据,而算法则是求解问题的步骤;因此针对同一数据结构,求解问题的步骤方法可以不同,因此使用的算法也可以不同。


    🍊3.算法具有什么特性呢?

    (1)有穷性:一个算法必须总在执行有穷步后结束,且每一步都可在有穷时间内完成。

    • 注:算法必须是有穷的,而程序可以是无穷的,如手机上的CSDN是程序,而不是算法。

    (2)确定性:算法中每条指令必须有确切的含义,对于相同的输入只能得到相同的输出。

    (3)可行性:算法中描述的操作都可以通过已经实现的基本运算执行有限次来实现。

    (4)输入:一个算法有零个或多个输入,这些输入取自于某个特定的对象的集合。

    (5)输出:一个算法有一个或多个输出,这些输出是与输入有着某种特定关系的量。


    🍊4.怎样算一个好的算法?

    (1)正确性:算法能够正确地解决求解问题。

    (2)可读性:算法应具有良好的可读性,以帮助人们理解。

    (3)健壮性:输入非法数据时,算法能适当地做出反应或进行处理,而不会产生莫名其名的输出结果。

    (4)高效率与低存储需求:时间复杂度低,空间复杂度低。


    🍊5.什么是算法的效率?

    江湖中,传闻,算法效率有时空之分,具体来说便是时间效率与空间效率之分:

    • 时间效率被称为时间复杂度——衡量一个算法的运行速度
    • 空间效率被称为空间复杂度——衡量一个算法所需的额外空间

    在计算机发展早期,计算机存储容量很小,所以很在意空间复杂度;但是时光流逝,如今计算机的江湖之中,存储容量已到达极之巅峰,我们已无需特别关注算法复杂度了。


    📜007.题目难度 ⭐️

    007.一个算法应该是( )。
    A.程序
    B.问题求解步骤的描述
    C.要满足五个基本特性
    D.A和C

    🍊详细题解:

    A. 程序是一组计算机能识别和执行的指令,运行于电子计算机上,其不一定满足有穷性,如死循环、操作系统等。

    C. 是算法的特性而不是它的基本定义。

    算法:对特定问题求解步骤的一种描述,它是指令的有限序列,其中每条指令表示一个或多个操作;算法代表对问题求解步骤的描述,而程序则是算法在计算机上的实现。

    ✅正确答案:B 

     ✨✨✨我是分割线✨✨✨

    🥝2.2 算法的时间复杂度


    🍊1.什么是时间复杂度?

    算法的时间复杂度是一个函数,它定量描述了该算法的运行时间。一个算法所花费的时间与其中语句的执行次数成正比,算法中的基本操作的执行次数,为算法的时间复杂度。

    Q1:可以使用“算法先运行,事后统计运行时间”的方法来估算时间开销吗?

    A1:使用如此方法是不客观的,主要有以下几个原因:

    • 机器性能越强,开销越少;如:超级计算机 vs 单片机。
    • 编程语言越高级,执行效率越低;如:Java写的程序要比用C写的效率低一些。
    • 和编译程序产生的机器指令质量有关。
    • 有些算法是不能事后统计的,如:导弹精准控制算法

    🍊2.大O的渐进表示法

    实际中我们计算时间复杂度只需要计算大概执行次数,那么我们使用大O的渐进表示法。

    大O符号:用于描述函数渐进式行为的数学符号

    通过上面我们会发现大O的渐进表示法去掉了那些对结果影响不大的项,简洁明了的表示出了执行次数。


    🍊3.时间复杂度有哪3种情况?

    最坏情况:任意输入规模的最大运行次数(上界)。

    平均情况:任意输入规模的期望运行次数。

    最好情况:任意输入规模的最小运行次数(下界) 。


    🍊4.计算复杂度的两条规则

    (1)加法规则:多项相加,只保留最高阶的项,且系数变为1。

    • T(n,m) = T1(n) + T2(n) = O [ max ( f(n), g(m) ) ]

    (2)乘法规则:多项相乘,都保留。

    • T(n,m) = T1(n) * T2(m) = O [ f(n) * g(m) ]

     记忆方式:常 < 对 < 幂< 指 < 阶


    📜008.题目难度 ⭐️⭐️

    008.某算法的时间复杂度为O(n^2)表明该算法的( )。
    A.问题规模是(n^2)
    B.执行时间等于(n^2)
    C.执行时间与(n^2)成正比
    D.问题规模与(n^2)成正比

    🍊详细题解:

    算法时间复杂度:O[ F(N) 意味着算法在任何情况下,规模为n的前提下,所花费的时间小于等于K*F(N),其中K是与N无关的常数。

    A/D. 在评价一个算法的复杂度时,已经默认问题规模为n。

    B. 执行时间不是等于(n^2),时间复杂度是该算法的一个上界(即时该算法的最坏情况),应当是小于等于。

    C. 算法时间复杂度本身就是一个数量级问题,表示该算法的执行时间小于等于K*(n^2),即与(n^2)成正比。

    ✅正确答案:C

     ✨✨✨我是分割线✨✨✨ 

    📜实战案例


    📜案例1——复杂度相加运算

    该例中有两个for循环,循环的上限分别为M+1次和N+1次(+1是因为跳出循环时还计算了一次),由大O的渐进表示法可以计算为:O(M+N+2) 近似为O(M+N),本题没有其他条件,不知道M和N的数量级大小,因此O(M+N)可以作为最终答案。

    • 当 M>>N时:时间复杂度为O(M)
    • 当 N>>M时:时间复杂度为O(N)


    📜案例2——用1代替所有常数次

    该案例中有一个for循环,循环的上限取决于条件判断的常数大小,此处是100,说明最多进行101次循环;如果这里的100改为100000000,也同样是进行常数次循环。因此依照大O的渐进表示法,用1替代所有常数,则其时间复杂度为O(1)

    相对的O(1)并不是代表只执行1次,而是代表执行常数次,可以是100次、1000次,也可以是1000万次,不管次数多大,都是常数次!


    📜案例3——strchr采用最坏时间复杂度

    strchr函数功能为在一个串中查找给定字符的第一个匹配之处。函数原型为:

    char *strchr(const char *str, int c);
    

    即在参数 str 所指向的字符串中搜索第一次出现字符 c(一个无符号字符)的位置。


    📜案例4——冒泡排序的时间复杂度

    最好情况:所有数字已经按序排列,自身有序排列,只需要冒泡排序一遍,由于没有发生交换,因此exchange值不发生改变,仍然为0,最后跳出循环,因此一共就执行了(N-1)次交换,所以其时间复杂度为O(N)。

    最坏情况:所有数字倒序排列,每一轮都需要冒泡排序,第一遍冒泡排序(N-1)次,将最大的数字安排到最后一位,然后继续从头开始进行冒泡排序,此时只需要交换(N-2)次,将次大的数安排在倒数第二位,按此顺序一直计算到最后交换1次,此时所有数字排序完成,总共排序了 [(N-1)+(N-2)+·····+ 2 + 1 ] 次,最终计算的时间复杂度为O(N^{2})


    📜案例5——二分查找的时间复杂度

    二分查找法这里假设数组元素呈升序排列,将n个元素分成个数大致相同的两半,取a[n/2]与欲查找的x作比较,如果x=a[n/2]则找到x,算法终止;如 果x<a[n/2],则我们只要在数组a的左半部继续搜索x;如果x>a[n/2],则我们只要在数组a的右 半部继续搜索x。

    最好情况:直接1次就找到了,常数次找到,因此时间复杂度为O(1)。

    最坏情况:当找不到该数时,需要不断进行折半,一直折半到最后 begin==end 时,退出循环,此时一共执行了 \ logN次(具体计算步骤见下图)。

    注:时间复杂度中,习惯将log2(N) 简写为 logN


    📜案例6——递归阶乘的时间复杂度

    (1)单次递归函数调用为O(1)时,就看它递归的次数:

    本题在疯狂进行递归,每一次递归中包含了常数次的运算:1次逻辑判断运算和乘法运算,但从时间复杂度角度来看可以近似忽略为O(1)次;而真正占据时间复杂度的应当是其向下递归的次数,其递归次数取决于N,是幂函数,因此其时间复杂度为O(N)。

    (2)单次递归函数调用不为O(1)时,就看他递归调用中次数的累加:

    long long Fac(size_t N)
    {
    	if (0 == N)
    		return 1;
    	for (size_t i = 0; i < N; ++i)
    	{
    		printf("%d", i);
    	}
    	printf("\n");
    	return Fac(N - 1) * N;
    }

    对于上面这种变式情况,每次递归调用不是O(1),每次递归调用中的运算次数是变化的,第一次递归时,函数内部进行N次循环;递归到第二次时,函数内部进行N-1次循环;···;递归到第N-1次时,函数内部循环2次;通过计算我们可以得出:


    📜009.题目难度 ⭐️

    009.【2012统考真题】求整数n (n≥0)的阶乘的算法如下,其时间复杂度是( )。
        int fact(int n) {
            if(n<=1) return 1;
            return n*fact (n-1) ;
        }
    
    A.O(logn)        B.O(n)       C.O(nlogn)        D.O(n^2)
    

    🍊详细题解:

    本题就属于上面第(1)种情况,单次递归函数调用为O(1),其只包含了一次乘法运算,因此其时间复杂度就看它向下递归调用的次数,该例有n次递归,因此其时间复杂度为O(n)。

    ✅正确答案:B


    📜案例7——斐波那契数列的时间复杂度

    斐波那契数列的递归其实像是一个N-1层金字塔(当然是有残缺的金字塔),但我们计算复杂度时候真正关心的是数量级问题,残缺的那部分根本不会改变数量级,因此可以将其近似看成一个满元素的金字塔,因此从顶向下挨个计算,也就是计算一个等比数列求和,公比为2;最终计算出其时间复杂度为 :O(2^{n})


    📜案例8——三层循环的时间复杂度

    我希望通过这题,可以让大家明白复杂度的核心是数量级的问题,在计算步骤上,只要不改变其最终数量级,可以通过省略和近似的方式来估算其复杂度:

    for (i=1 ;i<=n ;i++)
        for(j=1 ;j<=i; j++)
            for(k=1; k<=j; k++)
                x++;

    对于上题我们可以从内层向外层来看,首先最内层循环的次数为 j 次,次外层循环为 i 次,此时计算内部两层循环的次数为(1+2+3+4+·····+i)次,即 (1+i)*i/2,这时我们再计算最外层循环,由于最外层循环n次,i的取值范围为(1~n),因此其执行总次数为:

    由上述计算过程可得其最后的时间复杂度为O(n^3)。

    注意:通过这题我希望大家明白的一个道理是,时间复杂度并不是准确计算出来的一种度量,而是一种算法的最坏情况,或者是算法的一种数量级情况,对于上题,在计算过程中我都采取了局部的省略和近似,这是因为,这些省略和近似并不会改变复杂度的最终数量级,也就是n^3,通过这种省略和近似可以节约复杂度的计算时间。

     ✨✨✨我是分割线✨✨✨

    🥝2.3 算法的空间复杂度


    🍊1.什么是空间复杂度?

    空间复杂度是对一个算法在运行过程中临时占用存储空间大小的量度 。空间复杂度不是程序占用了多少 bytes的空间,因为这个也没太大意义,所以空间复杂度算的是变量的个数。空间复杂度计算规则基本跟时间复杂度类似,也使用大O渐进表示法。


    📜案例1——冒泡排序的空间复杂度

    空间复杂度计算的是在程序运行过程中,为了满足程序需求,临时创建的空间个数。在下例冒泡排序中,总共开了三个空间,分别是变量end、exchange、i;尽管在这个循环中,exchange这个变量被循环使用,但是用的始终都是exchange这1个空间,只是使用次数在增加,使用的空间个数始终为1,没有发生改变,因此其时间复杂度为O(N),而空间复杂度为O(1)。

    注意:使用了常数个空间==空间复杂度为O(1)


    📜案例2——斐波那契数列的空间复杂度

    下例中,我们单单计算fibArray动态开辟的空间就已经有(n+1)个了,其他剩下的变量开设的都是常数个,因此时间复杂度为O(N);我们这里只需要算一个大概的即可,计算开辟空间数最多的那个即可。

    注意:空间复杂度的计算比时间复杂度的简单,一般来说不是O(1)就是O(N)。

    // 计算Fibonacci的空间复杂度?
    // 返回斐波那契数列的前n项
    long long* Fibonacci(size_t n)
     {
         if(n==0)
         return NULL;
     
         long long * fibArray = (long long *)malloc((n+1) * sizeof(long long));
         fibArray[0] = 0;
         fibArray[1] = 1;
         for (int i = 2; i <= n ; ++i)
             {
                 fibArray[i] = fibArray[i - 1] + fibArray [i - 2];
             }
         return fibArray;
     }

    📜案例3——计算阶乘递归Fac的空间复杂度

    long long Fac(size_t N)
     {
         if(N == 0)
             return 1;
         return Fac(N-1)*N; 
    }

    对于本题,递归出N个栈帧,栈帧开辟的空间是常数个,可以认为是O(1),因此决定其开辟空间个数的主要取决于其递归的次数,本题递归次数为N次,因此空间复杂度为O(N)。


    📜案例4——计算斐波那契数列的空间复杂度

    long long Fib(size_t N) 
    {
         if(N < 3)
             return 1;
     
         return Fib(N-1) + Fib(N-2);
    }

    上例中我们不断调用,当我们一直递归调用到Fib(2)时,将Fib(2)的值返回给Fib(3),这时Fib(2)栈帧就销毁了,Fib(3)将接着调用Fib(1),这时Fib(1)使用了之前Fib(2)使用的空间,使用了同一块空间;同理在向上返回的时候将不断重复使用销毁过的空间,从Fib(2)到Fib(N)总共建立了N-1个栈帧;而后该开始递归调用Fib(N-2),而这块空间正是之前Fib(N-1)使用过的空间,即空间是可以回收复用的。因此本题的空间复杂度为O(N)。

    注意:时间是累计的不可复用,而空间回收之后是可以重复利用的。

    程序证明:

    当调用完f1( )函数后,将f1中的空间释放;调用f2( )函数,由a和b的地址相同可见,f2( )使用的空间正是刚刚f1释放的空间,证明空间被重复利用了。

    void f1()
    {
    	int a = 0;
    	printf("%p\n", & a);
    }
    
    void f2()
    {
    	int b = 0;
    	printf("%p\n", & b);
    }
    
    int main()
    {
    	f1(); //调用函数开始会创建栈帧;结束会销毁栈帧
    	f2();
    	return 0;
    }


    📜010.题目难度 ⭐️⭐️

    010.下面的说法中,错误的是( )。
    I.算法原地工作的含义是指不需要任何额外的辅助空间
    II.在相同规模n下,复杂度为O(n)的算法在时间上总是优于复杂度为O(2")的算法
    III.所谓时间复杂度,是指最坏情况下估算算法执行时间的一个上界
    IV.同一个算法,实现语言的级别越高,执行效率越低
    A.I                B.I、II            C.I、IV            D.III

    🍊详细题解:

    I. 算法原地工作是指算法所需的辅助空间是常量,即O(1)个空间。

    II. 算法的负责度是一个宏观上的理解,O(n)的算法一定是优于O(2")的算法。

    III. 时间复杂度总是考虑最坏情况下的时间复杂度,以保证算法的运行时间不会比它更长。

    IV. 越高级的语言,需要层层转换为低级语言给计算机读取,因此执行效率会降低。

    ✅正确答案:A

     ✨✨✨我是分割线✨✨✨

    📝LeetCode之消失的数字



    思路1-排序

    思路:将这些数字进行挨个排序,如果后一个数字不是前一个数字+1,那么缺的数就是这两个数共同相邻的那个数。例如我们将数字排序后得到{1,2,4},我们从前向后挨个比较相邻两个数,我们发现2后面的数字不等于2+1,因此我们得出缺少的数字是3。

    优点:简单易想

    缺点:时间复杂度太大,以下算法时间复杂度均未满足题目要求。

    • 采用冒泡排序—— 时间复杂度:O(N^{2})
    • 采用快排qsort——时间复杂度:O(N*logN)

    思路2-映射方式

    思路:建立一个可以完整包含0~n的所有整数的数组并将其初始化为全-1;然后将输入的数字x放到对应下标为[x]的数组空间中(如数字6就放到下标为[6]的空间里);全部放完后,数组中元素值为-1对应的下标,就是缺失的数字。

    缺点:这种方式有O(N)的空间复杂度。


    思路3-异或^

    前情提要:

    1.异或运算中顺序发生改变,并不会影响最终结果:

     a^b^c = b^a^c = b^c^a = c^b^a =···

    2.两个相同数字异或的最终结果为0;

    a^a = b^b = 0

    3.0和任意非零数x相异或,其结果等于非零数x;

    0 ^ x = x

    思路:对于本题,可先对0-n的连续数字异或一遍,接着对含有欠缺数字的数组中的每个数字异或,那么该数组中未欠缺的数字和0-n连续数字会异或2次,结果为0;而因为数组中缺少1位数字,原先0-n的连续数字中必有1位只参与异或1次,因此最后异或计算出的值即为缺失的数字。

    代码实现:

    int missingNumber(int* nums, int numsSize){
        int sum=0;
        for(int i=0;i<numsSize;++i)
        {
            sum^=nums[i];//计算数列中的异或
        }//时间复杂度为O(N)
        
        for(int j=0;j<numsSize+1;++j)
        {
            sum^=j;//求0-n的异或
        }//时间复杂度为O(N)
     
        return sum;
    }

    思路4-数列和相减

    (0-n计算等差数列的和)-(数组中的值相加)
           O(1)               O(N) 

    优点:算法时间复杂度满足√

    代码实现:

    int missingNumber(int* nums, int numsSize){
        int sum1=0 , sum2=0 ,ret=0;
        for(int i=0;i<numsSize;++i)
        {
            sum2+=nums[i];//计算数列中的和
        }//时间复杂度为O(N)
        sum1=numsSize*(numsSize+1)/2;//计算0-n的等差数列之和
        ret=sum1-sum2;
        return ret;
    }

     ✨✨✨我是分割线✨✨✨

    📝LeetCode之旋转数组


    进阶:

    • 尽可能想出更多的解决方案,至少有三种不同的方法可以解决这个问题。
    • 你可以使用空间复杂度为 O(1) 的原地算法解决这个问题吗?

    思路1-依次右移动

    思路:右旋K次,依次移动一个;当K=N时,等于数组没有发生旋转,当K=N+1时,等于数组旋转1次,即旋转的次数=(K%N);当(K%N=N-1)时,旋转的次数最多。

    时间复杂度:旋转1次需要移动N次,旋转K次就需要移动N*K次,因此为O(K*N);当K的值为N-1时,复杂度为O(N^2),但是由于K也是未知数,因此该算法的时间复杂度为O(N*K)。

    空间复杂度:没有额外开数组,用的是原数组,因此为O(1)。


    思路2-额外开数组

    思路:用空间来换时间,额外建立一个数组,将后K个数拷贝到新建数组的前端,将(n-K)个剩下的数,拷贝到新数组的后端。

    时间复杂度:将从前向后挨个计算,将前(n-k)个数拷贝到新数组后(n-k)个位置,再将后k个数拷贝到新数组的前k个位置,计算量即为n,因此时间复杂度为O(N)。

    空间复杂度:这时额外开了一个数组,因此空间复杂度为O(N)。


    思路3-三轮逆置

    思路:用空间来换时间,额外建立一个数组,将后K个数拷贝到新建数组的前端,将(n-K)个剩下的数,拷贝到新数组的后端。

    时间复杂度:进行三轮逆置,因此时间复杂度的量级依然取决于元素个数n,时间复杂度为O(N)。

    空间复杂度:没有额外开数组,用的是原数组,因此为O(1)。

    代码实现:

    void reverse(int*a, int left , int right)//创建一个逆置函数
    {
        while(left<right)
        {
            int tmp=a[left];
            a[left]=a[right];
            a[right]=tmp;
            ++left;
            --right;
        }
    }
    
    void rotate(int* nums, int numsSize, int k){
        k=k%numsSize;
        reverse(nums,0,numsSize-k-1);//step1.逆置前n-k个
        reverse(nums,numsSize-k,numsSize-1);//step2.逆置后k个
        reverse(nums,0,numsSize-1);//step3.逆置整体n个
    }

     ✨✨✨我是分割线✨✨✨

    📜水滴石穿


    📜011.题目难度 ⭐️

    011.以下算法的时间复杂度为( )。
    void fun(int n) {
    	int i = 1;
    	while (i <= n)
    		i = i * 2;
    }
    A.O(n)        B.O(n^2)        C.O(nlogn)        D.O(logn)
    

    🍊详细题解:

    ✅正确答案:D


    📜012.题目难度 ⭐️

    012.以下算法的时间复杂度为( )。
    void fun(int n) {
    	int i = 0;
    	while (i * i * i <= n)
    		i++;
    }
    A.O(n)        B.O(nlogn)        C.O(³√n)        D.O(√n)

    🍊详细题解:

    ✅正确答案:C


    📜013.题目难度 ⭐️

    013.以下算法中最后一行语句的执行次数为( )。
    	int m = 0, i, j;
    	for (i = 1; i <= n; i++)
    		for (j = 1; j <= 2 * i; j++)
    			m++;
    A.n(n+1)        B.n        C.n+1        D.n^2

    🍊详细题解:

    ✅正确答案:A


    📜014.题目难度 ⭐️⭐️

    014.程序段如下:
    	for (i=n-1;i>1;i--)
    		for (j=1;j<i;j++)
    			if (A[j]> A[j+1])
    				A[j]与A[j+1]对换;
    
    其中n为正整数,则最后一行语句的频度在最坏情况下是( )。
    A.O(n)        B.O(nlogn)        C.O(n³)        D.O(n²)

    🍊详细题解:

    ✅正确答案:D


    📜015.题目难度 ⭐️⭐️

    015.【2014统考真题】下列程序段的时间复杂度是( )。
    count=0;
    for (k=1 ; k<=n ; k*=2)
        for(j=1;j<=n;j++)
            count++;
    A.O(logn)        B.O(n)        C.O(nlogn)        D.O(n^2)

    🍊详细题解:

    ✅正确答案:C


    📜016.题目难度 ⭐️⭐️⭐️

    016.【2017统考真题】下列函数的时间复杂度是( )。
        int func(int n){
            int i=0,sum=0;
            while (sum<n) sum +=++i;
            return i;
        }
    A.O(logn)        B.O(√n)        C.O(n)        D.O(nlogn)
    

    🍊详细题解:

    ✅正确答案:B


     📜017.题目难度 ⭐️⭐️⭐️

    🍊详细题解:

    🌕写在最后


    数据结构的世界是相当丰富的,内容方向繁多,但只要一步一个脚印,跟随【水滴计划】水滴石穿吃透、搞懂、拿捏住数据结构是完全没有问题的!后期该系列还会有视频教程和经验分享,关于更多这方面的内容,请关注本专栏哦!

    热爱所热爱的, 学习伴随终生,kikokingzz与你同在!❥(^_-)

    展开全文
  • 算法复杂度分析

    2021-12-09 14:47:37
    判断一个算法是不是属于这种时间复杂度的一个简单方法是关注循环执行次数最多的那一段代码,这段代码执行次数对应n的量级,就是整个算法的时间复杂度。如果是一层n的循环,那么时间复杂度就是O(n);如果嵌套了两层n...

    迭代复杂度分析

    1、常数阶:O(1)

    算法中不存在循环语句、递归语句,即使有成千上万行的代码,其时间复杂度也是O(1)
    在这里插入图片描述

    2、多项式:O(n)、O(n2)、O(n3)

    判断一个算法是不是属于这种时间复杂度的一个简单方法是关注循环执行次数最多的那一段代码,这段代码执行次数对应n的量级,就是整个算法的时间复杂度。如果是一层n的循环,那么时间复杂度就是O(n);如果嵌套了两层n的循环,那么时间复杂度就是O(n2),以此类推。
    在这里插入图片描述

    3、是对数阶:O(logn)和O(nlogn)

    二分查找的时间复杂度通常是O(logn),一些基于比较的排序算法的时间复杂度可以达到O(nlogn),典型的有快速排序、归并排序
    在这里插入图片描述
    上面的代码是一个典型的二分查找,由于每次循环都可以将问题的规模缩减一半,其时间复杂度是O(logn)

    4、 指数阶:O(2的n次方)

    指数的增长非常恐怖,一个指数阶的算法通常是不可用的,或者存在优化的空间。一个典型的例子是fibonacci数列的递归实现版本
    在这里插入图片描述
    可以看出fibonacci(n)等价于fibonacci(n-1)+fibonacci(n-2)。这一过程可以持续下去,即fibonacci(n-1)等价于fibonacci(n-2)+fibonacci(n-3 )……如果你把上述每一个计算过程看成树的一个节点,那么整个计算过程就像一棵很大的树。一个节点分裂为2个节点,2个节点分裂为4个节点。
    在这里插入图片描述
    算法的时间复杂度和图中树的节点数同阶,而树的节点数的数量级为O(2n),因此这个算法的时间复杂度是 O(2n)。可以看出其中有许多重复的计算,可以通过存储记忆的方式进行优化

    5、阶乘复杂度:O(n!)

    递归复杂度分析

    1、递归树法

    递归树分析是一种将递归过程描述成树结构的方法。初始树只有一个节点,随着每一次递归,树的深度加1。每一层的节点数取决于具体的场景。在得到递归树后,将树每层中的节点求和,然后将所有层的节点求和,就大致可以得出树的总节点数n了。而整个算法的基本操作数等于树上每一个节点的基本操作数t乘以树的总节点个数n。以归并排序为例,它是一个典型的分治算法。其基本过程分成两个阶段:分与合。其中分的过程采用自顶向下的方式,每次将问题规模缩小一半,直到问题规模缩小到寻常情况,即可以被直观解决的情况。合的过程恰好相反,采用自底向上的方式,将问题一步步解决,直到还原到原问题规模。如果你将这两个过程化成递归树的话,就会发现这两个过程递归树的深度都是logn。而每一层的节点数都是n,也就是说总节点数是nlogn,而节点的基本操作数是常数(这一点读者可以通过归并代码发现),因此总的算法时间复杂度为O(nlogn)。
    在这里插入图片描述

    2、代入法

    这种分析方法需要一点数学知识,相对来说没有那么直观,这种方法的入手点在于递归公式。比如有如下递归公式:T(n)=T(n-1)+T(0),如何求解其时间复杂度?T(n)=T(n-1)+T(0)指的是规模为n的问题,可以转化为规模为n-1的子问题和一个常数的操作。我们来尝试代入,就像高中数学那样。T(n)=T(n-1)+T(0)=T(n-2)+T(0)+T(0)=T(n-3)+T(0)+T(0)+T(0)=T(0)+…+T(0)+T(0)+T(0)=n×T(0)可以得出其时间复杂度为O(n)。

    算法复杂度对比图

    在这里插入图片描述

    注以上内容来自于算法通关之路一书
    算法学习推荐书籍:《算法设计与分析》《算法导论》《算法图解》《大话数据结构》《剑指offer》《编程之美》《
    算法》

    展开全文
  • 什么是算法复杂度

    千次阅读 2019-08-30 23:20:16
    一流程序员靠数学,二流靠算法,三流靠逻辑,四流靠SDK,五流靠Google和StackOverFlow,六流靠百度和CSDN。低端的看高端的就是黑魔法! 对于程序员来说,写一个可以运行的程序肯定是信手拈来,但是如果要求写一...
  • 计算算法复杂度FLOPs

    2021-12-10 18:07:20
    搜遍全网,流传的在网上的能方便计算FLOPs的有3个小工具。 THOP: PyTorch-OpCounter torchstat ptflops 一个不行的话多试两个。我的程序用2、3报错,最终用的1
  • KMeans 算法复杂度

    2021-11-22 13:02:31
    k-means 算法复杂度分析
  • 算法复杂度分析看这一篇就够了

    千次阅读 2020-04-18 12:05:56
    执行效率是算法一个非常重要的考量指标,而时间复杂度和空间复杂度则是衡量算法代码的执行效率。 为什么需要复杂度分析 通常情况下,我们可以在写完代码的情况下把程序跑一遍,通过统计、监控,就能得出算法执行的...
  • 算法复杂度:是指算法在编写成可执行程序后,运行时所需要的资源,包括时间资源(运行算法耗费的时间)和内存资源(程序运行占用的内存大小)。它是一个衡量算法优劣的重要指标,按照所需资源的又细分为时间复杂度和...
  • 1.算法复杂度是指:算法在编写成可执行程序后,运行时所需要的资源,资源包括时间资源和内存资源 2. 算法复杂度包括: 时间复杂度、空间复杂度 3. 时间复杂度:即算法的执行效率,是指算法的执行时间与算法的输入...
  • 算法复杂度分为时间复杂度和空间复杂度。 时间复杂度用于度量算法执行的时间长短;而空间复杂度则是用于度量算法所需存储空间的大小。 目录 时间复杂度 1.时间频度 2.计算方法 3.分类 空间复杂度 算法的时间...
  • 数据结构中算法复杂度总结

    千次阅读 2020-10-16 19:36:25
    采用邻接表存储方式时,每个顶点均需搜索一次(或入队一次),故时间复杂度为0(V),在搜索任一顶点时,顶点后边的链表都要访问一次,在搜索完V个顶点后,边表也就都访问了,故时间复杂度为O(E),算法总的时间复杂度为O(V+E)...
  • 算法复杂度比较

    千次阅读 2018-09-04 19:15:50
    常见函数算法时间复杂度由小到大依次为: Ο(1)Ο(loga^n)Ο(n)Ο(nlogn)Ο(n2)Ο(n3)Ο(n!)Ο(N^n) 常见算法复杂度对比 ...冒泡排序 在改良的冒泡下 最优...对N个数进行排序,在各自最优条件下以下算法复杂度最...
  • 首先给出并证明了在分割的最大层数给定时算法假设空间的VC维,在此基础上结合可能近似正确(Probably Approximately Correct,PAC)学习框架,得出了对算法样本复杂度的估计,使得分类超曲面算法保证可PAC学习到任意目标...
  • 【算法】算法复杂度

    2020-08-18 17:22:53
    算法复杂度是衡量算法难度的尺度。 • 算法需要的资源越多,复杂度越高。计算机的资源,最重要的是运算所需的时间和存储程序和数据所需的空间资源。 • 算法复杂度包括时间复杂度和空间复杂度。 • 复杂问题或...
  • 常见算法复杂度样例

    千次阅读 2020-02-15 15:29:26
    大O表示法 用O(n)来体现算法时间复杂度的记法被称作大O表示法。一般我们我们评估一个算法都是直接评估它...常见算法复杂度样例 常数阶 int sum = 0, n = 10; // 语句执行一次 int sum = (1+n)*n/2; // 语句执行...
  • \tilde{O} O~\tilde{O}O~ 来源:https://tex.stackexchange.com/questions/66418/tilde-over-a-symbol-phi
  • 均值滤波很常见 但一般的算法复杂度都和取值窗口w*h有关 算法复杂度太高 本算法优化了基础的均值滤波算法 算法复杂度大大降低
  • 算法复杂度——时间复杂度和空间复杂度.doc
  • 欧几里德算法复杂度分析

    千次阅读 2018-09-14 21:50:21
    欧几里得算法 function Euclid(a; b) 1: if b = 0 then 2: return a; 3: end if 4: return Euclid(b; a mod b); 复杂度分析: 设a&gt;=ba&gt;=ba >= b ,则有amodb&lt;a2amodb&lt;a2a \mod ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 673,772
精华内容 269,508
关键字:

算法复杂度

友情链接: RTF-Spec-1.2.rar