算法时间复杂度计算示例Word下载.docx
《算法时间复杂度计算示例Word下载.docx》由会员分享，可在线阅读，更多相关《算法时间复杂度计算示例Word下载.docx（5页珍藏版）》请在冰豆网上搜索。
（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）.
升级会员 