算法时间复杂度计算示例.docx
《算法时间复杂度计算示例.docx》由会员分享，可在线阅读，更多相关《算法时间复杂度计算示例.docx（5页珍藏版）》请在冰豆网上搜索。
算法时间复杂度计算示例
根本盘算步调 示例一：
（1）intnum1,num2;
（2）for（inti=0;i（3） num1+=1;
（4） for（intj=1;j<=n;j*=2）{
（5） num2+=num1;
（6） }
（7）} 剖析步调Step1.剖析各条语句履行时光,得到算法（现实）庞杂性语句intnum1,num2;的频度为1;
语句i=0;的频度为1;
语句i语句j<=n;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（c是一个常量）
|--------------------------|--------------------------|-------------|
较好 一般 较差
--------------------------------------------------------------------------------------------------
庞杂情形的剖析
以上都是对于单个嵌套轮回的情形进行剖析,但现实上还可能有其他的情形,下面将例举解释.
将各个嵌套轮回的时光庞杂度相加.
例如：
for（i=1;i<=n;i++）
x++;
for（i=1;i<=n;i++）
for（j=1;j<=n;j++）
x++;
解：
第一个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）{ intsum=1; sum=count*（count+1）/2; System.out.print（sum）;}如许算法的时光庞杂度将由本来的O（n）降为O
（1）,大大地进步了算法的机能. 3.混杂情形（多个办法挪用与轮回）的庞杂度剖析
例如：
publicvoidsuixiangMethod（intn）{
printsum（n）;//1.1
for（inti=0;i printsum（n）;//1.2
}
for（inti=0;i 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<=n;i++）
for（j=1;j<=n;j++）
sum++; /*履行次数n2*/
解：
T（n）=1+n2=O（n2）
for（i=1;i {
y=y+1; ①
for（j=0;j<=（2*n）;j++）
x++; ②
}
解：
语句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; ①
for（i=1;i<=n;i++）②
{
s=a+b; ③
b=a; ④
a=s; ⑤
}
解：
语句1的频度：
2,
语句2的频度：
n,
语句3的频度：
n,
语句4的频度：
n,
语句5的频度：
n,
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<=n; 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;i {
for（j=0;j {
for（k=0;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）.
升级会员 