精华内容
下载资源
问答
  • 数据结构是什么 是一种“存储结构” ...时间复杂度 概念算法的执行时间与数据规模关系 怎么求就是看哪个代码执行次数最多 而且有未知数 常数 系数 有高阶时低阶都对时间复杂度影响较低 可以忽略不记 T(n) = O.
    • 数据结构是什么 是一种“存储结构” 算法是什么 是一种操作数据得一种方法,数据结构和算法相辅相成 离了数据结构 某些算法就没有用了 比如二分查找需要随机访问也就是在数组这个数据结构下操作,但是在链表下就不适用了,因为链表是不能随机访问的,数据结构只是一种数据的存在形式如果没有算法来操作数据,那么孤立存在的数据结构就是没有用的
    • 时间复杂度 概念 是算法的执行时间与数据规模的关系 怎么求就是看哪个代码执行的次数最多 而且有未知数 常数 系数 有高阶时的低阶都对时间复杂度影响较低 可以忽略不记
    • T(n) = O(f(n));大O时间复杂度
    • O(1)常数时间复杂度 没有循环 没有递归 那么无论多少条代码都是O(1)
    • O(n) 一行代码执行n次 第三行代码执行了n次 其实第二行代码也得执行n次 就是 2n了 但是系数可以省略
      void test(int n){
      	for(int i = 0;i<n;i++){
      	 i = i +i ;
      	}
      }
      
    • O(n^2) 嵌套循环 俩层循环
    • O(log n)
    	void test(int n){
    		int i=0;
    		for(i=0;i<n;){
    			i = i * 2;
    		}
    		return i;
    	}
    	
    

    2^1 2^2 2^3 最后2^x=n 停止执行 则执行了多少次第四行代码
    x次 x=以2为底的log n 若是i=i*3;则是以3为底的 则表示在大O就是O(log n)

    • O(nlog n)就是多加了一层for执行了n次 快速排序 归并排序就是这么个时间复杂度
    void insert(int value,int n){
    	int temp = -1;
        int[] a = new int[n]
        for(int i=0;i<n;i++){
    		if(a[i] == value) {
    			temp = i;
    			break;
    		}
        }
        return temp;
    }
    
    • 这是一个查找方法 没有找到返回-1 找到返回value在数组中的位置

    • 最好时间复杂度 O(1) 执行一次就找到

    • 最坏时间复杂度 O(n) 执行结束了才找到

    • 平均时间复杂度 假设在数组中占概率1/2 在某一个位置为1/n 则存在概率为1/(2*n) 则加权平均值为(3n+1)/4 则简化一下就是O(n)

    • 还有一个均摊时间复杂度 如果O(1)出现的次数大于O(n)则为O(1) 靠感觉吧 看了一会也感觉和平均差不多

    • 空间复杂度 代码存储大小和数据增长规模的关系

    • 复杂度分析法则

      1. 单段代码 :看执行次数最多的代码 循环
      2. 多段代码:比如说一段代码里有单重循环和多重循环 看多重循环
      3. 嵌套代码:求乘积 O(n^2) 递归 多重循环
      4. 多个参数:求加法 有多个参数影响的代码 但不是多重循环 比如说两个单重循环 一个执行m次 一个执行n次 则O(m+n)
    展开全文
  • 写法记作 T(n)=O(f(n))T(n):语句执行的总次数关于n的函数n:问题规模f(n):问题规模n的某个函数用O()来体现算法时间复杂度的记法时间复杂度的定义是:如果一个问题的规模是n,解决这一问题所需算法所需要的时间是n的...

    想要学会算法时间复杂度,那么就要先弄清楚几个概念。

    1. 什么是算法时间复杂度?
    2. 它有什么用呢?
    3. 写法记作 T(n)=O(f(n))
    • T(n):语句执行的总次数关于n的函数
    • n:问题规模
    • f(n):问题规模n的某个函数
    • 用O()来体现算法时间复杂度的记法

    时间复杂度的定义是:如果一个问题的规模是n,解决这一问题所需算法所需要的时间是n的一个函数T(n),则T(n)称为这一算法的时间复杂度。
    所谓算法时间复杂度就是一句话:算法中基本操作的执行次数。既然是T(n)的函数,随着模块n的增大,算法执行的时间的增长率和T(n)的增长率成正比,所以T(n)越小,算法的时间复杂度越低,算法的效率越高。

    那么它有什么用呢?刚才也说了,可以通过f(n)的函数关系来评估算法的效率问题,说白了就是通过时间复杂度来看算法的好坏

    值得注意的是:有的算法中基本操作执行次数不仅仅跟初始输入的数据规模(n)有关,还和数据本身有关。例如一些排序算法,同样n个待处理数据,数据初始有序性不同,基本操作执行次数也会不同。如果算法中有特殊要求,一般依照使得基本操作执行次数最多的输入来计算时间复杂度,即将最坏的情况最为算法时间复杂度的度量。

    常见的是按复杂度的大小



                                                                            常见的时间复杂度

    有的人会对log2 n与log n做对比,不理解这里为什么不一样,其实这两个是一样的也就是图中第2个和第4个都是可以替换以2为底的对数形式。

    对数时间
    主条目:对数时间
    若算法的T(n) = O(log n),则称其具有对数时间。由于计算机使用二进制的记数系统,对数常常以2为底(即log2 n,有时写作lg n)。然而,由对数的换底公式,loga n和logb n只有一个常数因子不同,这个因子在大O记法中被丢弃。因此记作O(log n),而不论对数的底是多少,是对数时间算法的标准记法。————维基

    如何计算或者推导时间复杂度呢##

    我们来分析一下常规做法:

    1. 确定算法中的基本操作以及问题的规模。
    2. 根据基本操作执行情况计算出规模n的函数f(n),并确定时间复杂度为T(n)=O( f(n)中增长最快的项/此项的系数 ).

    那么是什么意思呢?记住这个利器,这三句话即可。

    1. 用常数1替换所有加法常数。
    2. 在修改后的运行次数的函数中,只保留最高阶项。
    3. 如果最高阶项不是1(例如O(1)),则把该项的系数除掉,得到O

    开始实战##

    这不是演戏,这不是演习,实战之后就可以完全掌握概念了。

    第一类

    看下面一对代码,进行分析:

    int i=0,n=100;        /*执行了一次*/
    i=n/2+n;              /*执行了一次*/
    printf("i=%d",i);     /*执行了一次*/ 
    

    那么不难分析出这段代码一共执行了3次,那么时间复杂度就是O(3),对吧?是不是很简单,如果真的是这样,那就错了,看我们的利器第一句,它是f(n)=3,所以应该把3改为1,即O(1)。那么看下面这个:

    int i=0,n=100;        /*执行了一次*/
    i=n/2+n;              /*执行了一次*/
    printf("i=%d",i);     /*执行了一次*/ 
    printf("i=%d",i);     /*执行了一次*/ 
    printf("i=%d",i);     /*执行了一次*/ 
    printf("i=%d",i);     /*执行了一次*/ 
    printf("i=%d",i);     /*执行了一次*/ 
    

    这段代码一共执行了7次,那么时间复杂度为多少呢,经过上面的坑,这个应该没问题了,对,f(n)=7,把7改为1,即O(1)。那么我们可以得知,这种代码是具有恒定的执行时间的,也就是代码不会因为问题规模n的变化而发生变化,所以我们都记为O(1).

    第二类

    void fun(int n)
    {
        int i=1,j=100;
        while(i<n)
        {
            ++j;
            i+=2;
        }
    }
    

    这个显然n确定以后,循环的开始结束都是与i有关的,且每次自增2,假设m次后结束循环,那么i应该等于1+2m,那么就有n=1+2m,因为我们要是执行次数,也就是解得m=(n-1)/2,此时我们可以看出n/2增长的是最快的项,根据我们的法宝,我们需要把前面的系数除掉即可得到O,即(n/2)/(1/2)=n,得O(n).

    有的为了更严谨的推导,会对上面的式子进行修改,即1+2m+K=n ,K为一个常数,因为循环的结束的时候往往i是稍稍大于n的,所以用一个K来修正这个式子,m=(n-1-K)/2,当然因为K为常数,所以不会影响最终结果,毕竟有一个增长更快的家伙把它的影响干掉了。

    做到这,是不是感觉很简单了呢?那么我们趁热打铁进行下一个。

    int i=1;
    while(i<n)
    {
        i=i*2;
    }
    

    推导时间复杂度,最重要的就是要分析算法的执行次数。那么这段程序怎么分析呢?试着自己分析一下,再来看吧。好啦,i起始值为1,每次都乘2,也就意味着每次都会距离n近一些,那么什么时候超过n而终止循环呢?很简单就是i22222...*2>n,那么假设k次之后大于n,就有2^k=n,得出k=logn(上面说了还有些log2 n,都是一样的,以后都写最简形。)
    马上就要成功了,主要是练就分析算法和推导的思路。再来一个:

    int i,j,x=0;
    for(i=0;i<n;i++)
    {
        for(j=0;j<n;j++)
            x++;
    }
    

    这段代码不用多想就知道,外循环执行n次,内循环也是执行n,则O(n^2).那么这段呢?

    int i,j,x=0;
    for(i=0;i<n;i++)
    {
        for(j=i;j<n;j++)
            x++;
    }
    

    由于当i=0,时内循环执行了n次,i=1时,执行了n-1次,...i=n-1时,执行了1次,那么总次数为 n+(n-1)+(n-2)+..+1=n(n+1)/2,那么就是n2/2,即O(n2).

    到这里基础的就结束了,我想大家也应该能看懂了吧,当然还有一些比较复杂的算法,大家可以去自行试试,对于该文章不懂得可以在文章下面留言,看到了我会回复的。

    最后给大家做个练习吧。

    i++;
    function(n)  /* 方法function(n)为时间复杂度O(n)*/
    int k,m;
    while(k<n)
    {
        function(n);
        k++;
    }
    for(k=0;k<n;k++)
    {
        for(m=k;m<n;m++)
        {
            /*时间复杂度为O(1)的序列*/
        }
    }
    

    小试牛刀,检验成果吧,大家联系完这个,函数调用的时间复杂度也被你征服了,对于这个题可以在评论区留下你的答案,并和大家分享吧!

    展开全文
  • 版权声明:本文为 Codeagles 原创文章,可以随意转载,但必须在明确位置注明出处!!! 想要学会算法时间复杂度,那么就要先弄...用O()来体现算法时间复杂度的记法 时间复杂度的定义是:如果一个问题的规模是n,...

    版权声明:本文为 Codeagles 原创文章,可以随意转载,但必须在明确位置注明出处!!!

    想要学会算法时间复杂度,那么就要先弄清楚几个概念。

    1. 什么是算法时间复杂度?
    2. 它有什么用呢?
    3. 写法记作 T(n)=O(f(n))
    • T(n):语句执行的总次数关于n的函数
    • n:问题规模
    • f(n):问题规模n的某个函数
    • 用O()来体现算法时间复杂度的记法

    时间复杂度的定义是:如果一个问题的规模是n,解决这一问题所需算法所需要的时间是n的一个函数T(n),则T(n)称为这一算法的时间复杂度。 所谓算法时间复杂度就是一句话:**算法中基本操作的执行次数。**既然是T(n)的函数,随着模块n的增大,算法执行的时间的增长率和T(n)的增长率成正比,所以T(n)越小,算法的时间复杂度越低,算法的效率越高。

    那么它有什么用呢?刚才也说了,可以通过f(n)的函数关系来评估算法的效率问题,说白了就是通过时间复杂度来看算法的好坏

    值得注意的是:有的算法中基本操作执行次数不仅仅跟初始输入的数据规模(n)有关,还和数据本身有关。例如一些排序算法,同样n个待处理数据,数据初始有序性不同,基本操作执行次数也会不同。如果算法中有特殊要求,一般依照使得基本操作执行次数最多的输入来计算时间复杂度,即将最坏的情况最为算法时间复杂度的度量。

    常见的是按复杂度的大小

    有的人会对log2 n与log n做对比,不理解这里为什么不一样,其实这两个是一样的也就是图中第2个和第4个都是可以替换以2为底的对数形式。

    对数时间 主条目:对数时间 若算法的T(n) = O(log n),则称其具有对数时间。由于计算机使用二进制的记数系统,对数常常以2为底(即log2 n,有时写作lg n)。然而,由对数的换底公式,loga n和logb n只有一个常数因子不同,这个因子在大O记法中被丢弃。因此记作O(log n),而不论对数的底是多少,是对数时间算法的标准记法。————维基

    ##如何计算或者推导时间复杂度呢## 我们来分析一下常规做法:

    1. 确定算法中的基本操作以及问题的规模。
    2. 根据基本操作执行情况计算出规模n的函数f(n),并确定时间复杂度为T(n)=O( f(n)中增长最快的项/此项的系数 ).

    那么是什么意思呢?记住这个利器,这三句话即可。

    1. 用常数1替换所有加法常数。
    2. 在修改后的运行次数的函数中,只保留最高阶项。
    3. 如果最高阶项不是1(例如O(1)),则把该项的系数除掉,得到O

    ##开始实战## 这不是演戏,这不是演习,实战之后就可以完全掌握概念了。 ###第一类 看下面一对代码,进行分析:

    int i=0,n=100;        /*执行了一次*/
    i=n/2+n;              /*执行了一次*/
    printf("i=%d",i);     /*执行了一次*/ 
    复制代码

    那么不难分析出这段代码一共执行了3次,那么时间复杂度就是O(3),对吧?是不是很简单,如果真的是这样,那就错了,看我们的利器第一句,它是f(n)=3,所以应该把3改为1,即O(1)。那么看下面这个:

    int i=0,n=100;        /*执行了一次*/
    i=n/2+n;              /*执行了一次*/
    printf("i=%d",i);     /*执行了一次*/ 
    printf("i=%d",i);     /*执行了一次*/ 
    printf("i=%d",i);     /*执行了一次*/ 
    printf("i=%d",i);     /*执行了一次*/ 
    printf("i=%d",i);     /*执行了一次*/ 
    复制代码

    这段代码一共执行了7次,那么时间复杂度为多少呢,经过上面的坑,这个应该没问题了,对,f(n)=7,把7改为1,即O(1)。那么我们可以得知,这种代码是具有恒定的执行时间的,也就是代码不会因为问题规模n的变化而发生变化,所以我们都记为O(1). ###第二类 void fun(int n) { int i=1,j=100; while(i<n) { ++j; i+=2; } }

    这个显然n确定以后,循环的开始结束都是与i有关的,且每次自增2,假设m次后结束循环,那么i应该等于1+2m,那么就有n=1+2m,因为我们要是执行次数,也就是解得m=(n-1)/2,此时我们可以看出n/2增长的是最快的项,根据我们的法宝,我们需要把前面的系数除掉即可得到O,即(n/2)/(1/2)=n,得O(n).

    有的为了更严谨的推导,会对上面的式子进行修改,即1+2m+K=n ,K为一个常数,因为循环的结束的时候往往i是稍稍大于n的,所以用一个K来修正这个式子,m=(n-1-K)/2,当然因为K为常数,所以不会影响最终结果,毕竟有一个增长更快的家伙把它的影响干掉了。

    做到这,是不是感觉很简单了呢?那么我们趁热打铁进行下一个。

    int i=1;
    while(i<n)
    {
        i=i*2;
    }
    复制代码

    推导时间复杂度,最重要的就是要分析算法的执行次数。那么这段程序怎么分析呢?试着自己分析一下,再来看吧。好啦,i起始值为1,每次都乘2,也就意味着每次都会距离n近一些,那么什么时候超过n而终止循环呢?很简单就是i22222...*2>n,那么假设k次之后大于n,就有2^k=n,得出k=logn(上面说了还有些log2 n,都是一样的,以后都写最简形。) 马上就要成功了,主要是练就分析算法和推导的思路。再来一个:

    int i,j,x=0;
    for(i=0;i<n;i++)
    {
        for(j=0;j<n;j++)
            x++;
    }
    复制代码

    这段代码不用多想就知道,外循环执行n次,内循环也是执行n,则O(n^2).那么这段呢?

    int i,j,x=0;
    for(i=0;i<n;i++)
    {
        for(j=i;j<n;j++)
            x++;
    }
    复制代码

    由于当i=0,时内循环执行了n次,i=1时,执行了n-1次,...i=n-1时,执行了1次,那么总次数为 n+(n-1)+(n-2)+..+1=n(n+1)/2,那么就是n^2/2,即O(n^2).

    到这里基础的就结束了,我想大家也应该能看懂了吧,当然还有一些比较复杂的算法,大家可以去自行试试,对于该文章不懂得可以在文章下面留言,看到了我会回复的。

    ###最后给大家做个练习吧。

    i++;
    function(n)  /* 方法function(n)为时间复杂度O(n)*/
    int k,m;
    while(k<n)
    {
        function(n);
        k++;
    }
    for(k=0;k<n;k++)
    {
        for(m=k;m<n;m++)
        {
            /*时间复杂度为O(1)的序列*/
        }
    }
    复制代码

    小试牛刀,检验成果吧,大家联系完这个,函数调用的时间复杂度也被你征服了,对于这个题可以在评论区留下你的答案,并和大家分享吧!

    展开全文
  • 有穷性指是:算法在执行有限步骤之后,自动结束而不会出现无限循环,并且每一个步骤在可接受的时间内完成 确定性:算法的每一步都有确定含义,不会出现二义性 可行性:算法的每一步都是可行 2.算法的设计...

    1.算法的特性

    输入、输出、有穷性、确定性、可行性

    有穷性指的是:算法在执行有限的步骤之后,自动结束而不会出现无限循环,并且每一个步骤在可接受的时间内完成

    确定性:算法的每一步都有确定的含义,不会出现二义性

    可行性:算法的每一步都是可行的

    2.算法的设计要求

    1)正确性

    层次3是:

    2).可读性

    算法设计为的是便于阅读、理解和交流

    3).健壮性

    当输入数据不合法的时候,算法也能做出相应处理,而不是产生异常或者莫名奇妙的结果

    设计算法应该应该尽量满足时间效率高和存储量低的需求

    3.算法 的时间复杂度定义

    依旧离不开:操作数的个数(执行次数)及算法执行时间的增速的概念,看第二遍,果然更有提高

    4.大O阶法

    eg:非常好的例子

    eg1:

     

    eg2:

     

    5.常见的shi时间复杂度名字,随便看看啦

    6.我们提到的运行时间都是最坏情况的运行时间

     

     

     

    展开全文
  • 数据结构是一门研究非数值计算程序设计问题中操作对象,以及他们之间关系和操作等相关问题学科。 数据 计算机可识别操作符号集合 视频音频文字图片等等 数据元素 有一定意义基本单位 畜类 牛 马 猪 人类...
  • 算法时间复杂度,也就是算法时间度量,记作:T(n) = O(f(n))。 它随着问题规模n增大。算法执行时间增长率和f(n) 增长率相同,称作算法渐进时间复杂度,简称为时间复杂度。其中f(n) 是问题规模n某个...
  •   这个考点一般会单独出现在选择题前两道,需要你熟练掌握 算法基本概念算法时间复杂度 和 空间复杂度 分析判断等。其次,还会出现在大题编程部分,将算法复杂度作为一个限制条件,要求你给出满足给定...
  • 1.0 数据结构的相关概念 2.0 一些基本算法的时间复杂度 O(1): int x=1; O(n): for(int i = 0; i &amp;lt; n; i++){ printf(&quot;%d&quot;,i); } O(log2n): int n = 8,count = 0; for...
  • 算法时间复杂度算法是为求解一个问题需要遵循,被清楚指定简单指令集合。 对于一个问题,一旦某种算法(以某种形式)被确定为是正确,那么重要一步就是算法所消耗 时间、空间等资源量问题。这小节...
  • 数据结构的基本概念和术语,算法的时间复杂度,讲述了数据结构的一些概念点,也就是最基本一些东西,还有如何计算算法的时间复杂度之类一些问题及举例
  • 3.分别用时间复杂度和空间复杂度两个概念来描述性能问题,二者统称为复杂度。 4.复杂度描述算法执行时间(或占用空间)与数据规模增长关系。 二、为什么要进行复杂度分析? 1.和性能测试相比,复杂度分析有不...
  • 文章目录一:算法效率-时间和空间复杂度二:时间复杂度(1)时间复杂度的概念(2)大O的渐进表示法A:例子 一:算法效率-时间和空间复杂度     完成某个功能可能有多种实现的算法,可是如何去...
  • 1、算法的概念算法 (Algorithm),是对特定问题求解步骤的一种描述。 解决一个问题往往有不止一种方法,算法也是如此。那么解决特定问题的多个算法之间如何衡量它们的优劣呢?有如下的指标: 2、衡量算法的指标...
  • 时间复杂度——大O表示法计算时间复杂度举例计算最坏时间复杂度常见时间复杂度常见时间复杂度关系 参考文章 https://www.jianshu.com/p/f4cca5ce055a 1. 算法的特征 输入: 算法具有0个或多个输入 输出: 算法至少有1...
  • 绪论1.1基本概念和术语1.2 算法算法分析1.2.1 算法的特性1.2.2 评价算法优劣基本标准1.2.3 时间复杂度1.2.4 空间复杂度 1.1基本概念和术语 1.数据:客观事物符号表示。 2. 数据元素(元素/记录/结点):数据的...
  • 算法复杂度求解时间复杂度常见时间复杂度什么是数据结构,什么是算法数据结构(data structure),从字面上来看,是“数据结构”。在计算机科学中,数据结构是一种数据组织、管理和存储格式,它可以帮助我们实现...
  • 为了对算法的好坏进行评价,我们引入 “算法复杂度的概念。1、引例:斐波那契数列(Fibonacci sequence)已知斐波那契数列: ,求它的通项公式 。求解斐波那契数列的方法有很多种,这里只介绍两种:递归法和平推法...
  • 这里我们引出来算法复杂度的概念算法复杂度又分为时间复杂度和空间复杂度。下面我们就一一来详细看下时间复杂度和空间复杂度。 时间复杂度 首先我们看下官方是怎么定义时间复杂度的算法的时间复杂度是一...
  • 本文难度略高于考研数据结构中关于时间...时间复杂度的概念以及皮皮灰的一些看法。2.非递归函数时间复杂度的计算。3.递归函数时间复杂度的计算。1.时间复杂度的概念以及本人的一些看法。概念:时间复杂度是指执行...
  • 一般来说,我们评价一个程序好坏往往从其所占用空间和所运行时间方面考虑,也就是考虑程序运行“快”与“省”问题,所以说执行效率是算法的一个重要评价标准,因此我们引入时间复杂度和空间复杂度两个概念。...
  • 本文难度略高于考研数据结构中关于时间...时间复杂度的概念以及皮皮灰的一些看法。2.非递归函数时间复杂度的计算。3.递归函数时间复杂度的计算。1.时间复杂度的概念以及本人的一些看法。概念:时间复杂度是指执行...
  • 四大逻辑结构 集合结构 定义:处于同一数据集合中...定义:数据元素之间存在着“一对一”线性关系的数据结构。 1.集合中必存在唯一一个"第一个元素"; 2.集合中必存在唯一一个"最后元素"; 3.除最后元...
  • 预测算法的运行时间 在给定输入规模时,所执行基本操作数量,或者称为算法复杂度(Algorithm Complexity) 如何衡量算法复杂度? 内存(Memory)时间(Time)指令数量(Number of Steps)特定
  • 时间复杂度的概念 时间复杂度的定义:在计算机科学中,算法的时间复杂度是一个函数,它定量描述了该算法的运行时间。一 个算法执行所耗费的时间,从理论上说,是不能算出来的,只有你把你的程序放在机器上跑起来,...
  • 算法要作用在特定的数据结构之上,复杂度分析试图定量分析算法所消耗的时间和空间与数据规模对应关系 二、复杂度分析意义 掌握复杂度分析可以很快分析出,不同算法之间效率和性能上差异,复杂度分析是一种事前...
  • 时间复杂度(时间复杂性),定性描述算法的运行时间,这是一个代表算法输入值字符串长度函数。 时间复杂度常用大O符号表述,不包括这个函数低阶项和首项系数。使用这种方式时,时间复杂度可被称为是渐近...
  • 转载原文:算法的时间复杂度和空间复杂度详解 一、时间复杂度 1.时间频度 一个算法语句执行次数称为语句频度或时间频度,记为T(n)。 2.时间复杂度 (1) 在时间频度中,n称为问题规模,当n不断变化时,时间...
  • 数据结构算法时间复杂度详解 目录 排序算法的介绍和分类 算法的时间复杂度概念 常见的时间复杂度解析 平均时间复杂度和最坏时间复杂度 空间复杂度介绍 1. 排序算法的介绍和分类 排序算法的介绍 排序也称...
  • 算法时间复杂度 时间复杂度 O(1)——常数阶 线性阶 对数阶 平方阶 总结 下面我们开始第二部分复习和总结 这一部分主要内容是关于算法相关概念的讲解,对于从小就接触数学我们来说算法一定不陌生,只.....

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,318
精华内容 527
关键字:

数据结构算法时间复杂度的概念

数据结构 订阅