算法时间复杂度计算示例Word下载.docx

上传人:b****3 文档编号:16912947 上传时间:2022-11-27 格式:DOCX 页数:5 大小:16.74KB
下载 相关 举报
算法时间复杂度计算示例Word下载.docx_第1页
第1页 / 共5页
算法时间复杂度计算示例Word下载.docx_第2页
第2页 / 共5页
算法时间复杂度计算示例Word下载.docx_第3页
第3页 / 共5页
算法时间复杂度计算示例Word下载.docx_第4页
第4页 / 共5页
算法时间复杂度计算示例Word下载.docx_第5页
第5页 / 共5页
亲,该文档总共5页,全部预览完了,如果喜欢就下载吧!
下载资源
资源描述

算法时间复杂度计算示例Word下载.docx

《算法时间复杂度计算示例Word下载.docx》由会员分享,可在线阅读,更多相关《算法时间复杂度计算示例Word下载.docx(5页珍藏版)》请在冰豆网上搜索。

算法时间复杂度计算示例Word下载.docx

(7)} 

剖析步调Step1.剖析各条语句履行时光,得到算法(现实)庞杂性语句intnum1,num2;

的频度为1;

语句i=0;

语句i<

i++;

num1+=1;

j=1;

的频度为n;

语句j<

j*=2;

num2+=num1;

的频度为n*log2n;

算法(现实)庞杂性:

T(n)=2+4n+3n*log2n

step2.盘算渐进庞杂性疏忽失落T(n)中的常量.低次幂和最高次幂的系数,得到f(n)=n*log2n

{可省略:

lim(T(n)/f(n))=(2+4n+3n*log2n)/(n*log2n)

=2*(1/n)*(1/log2n)+4*(1/log2n)+3当n趋势于无限大,1/n趋势于0,1/log2n趋势于0,极限等于3.

}

T(n)=O(n*log2n)简化的盘算步调 

再来剖析一下,可以看出,决议算法庞杂度的是履行次数最多的语句,这里是num2+=num1,一般也是最内轮回的语句.

并且,平日将求解极限是否为常量也省略失落?

于是,以上步调可以简化为:

1.找到履行次数最多的语句 

2.盘算语句履行次数的数目级

3.用大O来暗示成果 

持续以上述算法为例,进行剖析:

1.

履行次数最多的语句为num2+=num1

2.T(n)=n*log2n

f(n)=n*log2n

3.//lim(T(n)/f(n))=1

T(n)=O(n*log2n)

--------------------------------------------------------------------------------

一些填补解释 

最坏时光庞杂度 

算法的时光庞杂度不但与语句频度有关,还与问题范围及输入实例中各元素的取值有关.一般不特殊解释,评论辩论的时光庞杂度均是最坏情形下的时光庞杂度.这就包管了算法的运行时光不会比任何更长.

求数目级 

即求对数值(log),默认底数为10,简略来说就是“一个数用尺度科学计数法暗示后,10的指数”.例如,5000=5x103(log5000=3),数目级为3.别的,一个未知数的数目级为其最接近的数目级,即最大可能的数目级.

庞杂度与时光效力的关系:

c<

log2n<

n<

n*log2n<

n2<

n3<

2n<

3n<

n!

(c是一个常量)

|--------------------------|--------------------------|-------------|

较好 

一般 

较差

--------------------------------------------------------------------------------------------------

庞杂情形的剖析 

以上都是对于单个嵌套轮回的情形进行剖析,但现实上还可能有其他的情形,下面将例举解释.

将各个嵌套轮回的时光庞杂度相加.

例如:

  for(i=1;

i++)

   

x++;

for(j=1;

j++)

解:

第一个for轮回

T(n)=n

f(n)=n

时光庞杂度为Ο(n)

第二个for轮回

T(n)=n2

f(n)=n2

时光庞杂度为Ο(n2)

全部算法的时光庞杂度为Ο(n+n2)=Ο(n2).

publicvoidprintsum(intcount){

intsum=1;

for(inti=0;

i++){

sum+=i;

System.out.print(sum);

剖析:

记住,只有可运行的语句才会增长时光庞杂度,是以,上面办法里的内容除了轮回之外,其余的可运行语句的庞杂度都是O

(1).

所以printsum的时光庞杂度=for的O(n)+O

(1)=疏忽常量=O(n)

*这里其实可以应用公式num=n*(n+1)/2,对算法进行优化,改为:

publicvoidprintsum(intcount){ 

sum=count*(count+1)/2;

}如许算法的时光庞杂度将由本来的O(n)降为O

(1),大大地进步了算法的机能. 

3.混杂情形(多个办法挪用与轮回)的庞杂度剖析 

publicvoidsuixiangMethod(intn){

printsum(n);

//1.1

printsum(n);

//1.2

for(intk=0;

k

System.out.print(i,k);

//1.3

suixiangMethod办法的时光庞杂度须要盘算办法体的各个成员的庞杂度.

也就是1.1+1.2+1.3=O

(1)+O(n)+O(n2)---->

疏忽常数和非重要项==O(n2)

示例2.O

(1) 

交流i和j的内容

temp=i;

i=j;

j=temp;

以上三条单个语句的频度为1,该程序段的履行时光是一个与问题范围n无关的常数.算法的时光庞杂度为常数阶,记作T(n)=O

(1).假如算法的履行时光不跟着问题范围n的增长而增长,即使算法中有上千条语句,其履行时光也不过是一个较大的常数.此类算法的时光庞杂度是O

(1).

示例3.O(n2) 

sum=0;

/*履行次数1*/

for(i=1;

i<

i++) 

for(j=1;

j<

j++) 

sum++;

/*履行次数n2*/

T(n)=1+n2=O(n2)

for(i=1;

i++)

y=y+1;

① 

for(j=0;

=(2*n);

j++) 

② 

语句1的频度是n-1

语句2的频度是(n-1)*(2n+1)=2n2-n-1

T(n)=2n2-n-1+(n-1)=2n2-2

f(n)=n2

lim(T(n)/f(n))=2+2*(1/n2)=2

T(n)=O(n2).

示例4.O(n) 

a=0;

b=1;

i++)②

s=a+b;

    ③

b=a;

     ④ 

a=s;

     ⑤

语句1的频度:

2, 

语句2的频度:

n, 

语句3的频度:

语句4的频度:

语句5的频度:

T(n)=2+4n

f(n)=n

lim(T(n)/f(n))=2*(1/n)+4=4

T(n)=O(n). 

示例5.O(log2n) 

i=1;

while(i<

=n)

i=i*2;

语句1的频度是1, 

设语句2的频度是t, 

则:

nt<

t<

=log2n

斟酌最坏情形,取最大值t=log2n,

T(n)=1+log2n

f(n)=log2n

lim(T(n)/f(n))=1/log2n+1=1

T(n)=O(log2n)

示例6.O(n3) 

for(i=0;

for(j=0;

i;

{

for(k=0;

k<

j;

k++)

x=x+2;

当i=m,j=k的时刻,内层轮回的次数为k.当i=m时,j可以取0,1,...,m-1, 

所以这里最内轮回共进行了0+1+...+m-1=(m-1)m/2次.

所以,i从0取到n,则轮回共进行了:

0+(1-1)*1/2+...+(n-1)n/2=n(n+1)(n-1)/2次

T(n)=n(n+1)(n-1)/2=(n3-n)/2

f(n)=n3

所以时光庞杂度为O(n3).

展开阅读全文
相关资源
猜你喜欢
相关搜索

当前位置:首页 > 工程科技 > 电子电路

copyright@ 2008-2022 冰豆网网站版权所有

经营许可证编号:鄂ICP备2022015515号-1