函数的渐近增长
假设两个算法的输入规模都是n,算法A要做2n+3次操作,可以这么理解:先执行n次的循环,执行完成后再有一个n次的循环,最后有3次运算。
算法B要做3n+1次操作,理解同上,它们哪一个更快些呢?
在解答问题之前,先做个图表参考:
当n=1时,算法A1效率不如算法B1,当n=2时,两者效率相同;
当n>2时,算法A1就开始优于算法B1了,随着n的继续增加,算法A1比算法B1逐步拉大差距。
所以总体上算法A1比算法B1优秀。
函数的渐近增长:给定两个函数f(n)和g(n),如果存在一个整数N,使得对于所有的n>N,f(n)总是比g(n)大。
那么,我们说f(n)的增长渐近快于g(n)。
从刚才的对比中我们还发现,随着n的增大,后面的+3和+1其实是不影响最终的算法变化曲线的。
例如算法A2,B2,在图中他们压根儿被覆盖了。所以,我们可以忽略这些加法常数。
后边举多几个例子,会更明显。
第二个测试,算法C是4n+8,算法D是2n^2+1。
再来看一下线性图。
我们观察发现,哪怕去掉与n相乘的常数,两者的结果还是没有改变,算法C2的次数随着n的增长,还是远小于算法D2。
也就是说,与最高次项相乘的常数并不重要,也可以忽略。
我们再来看第三个测试,算法E是2n^2+3n+1,算法F是2n^3+3n+1。
再来看一下线性图。
,我们通过观察又发现,最高次项的指数大的,函数随着n的增长,结果也会变得增长特别快。
算法G是2n^2,算法H是3n+1,算法I是 2n^+3n+1。
看出啥?一条直线?当他们数据很小的时候是这样的:
这组数据我们看得很清楚,当n的值变得非常大的时候,3n+1已经没法和2n^2的结果相比较,最终几乎可以忽略不计。
而算法G在跟算法I基本已经重合了。
于是我们可以得到这样一个结论,判断一个算法的效率时,函数中的常数和其他次要项常常可以忽略,而更应该关注主项(最高项)的阶数。
注意,判断一个算法好不好,我们只通过少量的数据是不能做出准确判断的,很容易以偏概全。
算法时间复杂度的定义:在进行算法分析时,语句总的执行次数T(n)是关于问题规模n的函数,进而分析T(n)随n的变化情况并确定T(n)的数量级。
算法的时间复杂度,也就是算法的时间量度,记作:T(n)= O(f(n))。
它表示随问题规模n的增大,算法执行时间的增长率和f(n)的增长率相同,称作算法的渐近时间复杂度,简称为时间复杂度。其中f(n)是问题规模n的某个函数。
这样用大写O()来体现算法时间复杂度的记法,我们称之为大O记法。
一般情况下,随着输入规模n的增大,T(n)增长最慢的算法为最优算法。
显然,由此算法时间复杂度的定义可知,我们的三个求和算法的时间复杂度分别为O(1),O(n),O(n^2)。
算法时间复杂度
推导大O阶方法
那么如何分析一个算法的时间复杂度呢?即如何推导大O阶呢?
我们给大家整理了以下攻略:
用常数1取代运行时间中的所有加法常数。
在修改后的运行次数函数中,只保留最高阶项。
如果最高阶项存在且不是1,则去除与这个项相乘的常数。
得到的最后结果就是大O阶。
世界上的东西就是这么简单,老头儿们把它讲复杂,那么它就复杂了,举几个例子:
常数阶
大家觉得这段代码的大O是多少?
O(8)?这是初学者常常犯的错误,总认为有多少条语句就有多少。
分析下,按照我们的概念“T(n)是关于问题规模n的函数”来说,这里大家表示对鱼C的爱固然是好的,要支持的,要鼓励的,要大力表彰的。
但是,跟问题规模有关系吗?没有,跟问题规模的表亲戚都没关系!,所以我们记作O(1)就可以。
另外,如果按照攻略来,那就更简单了,攻略第一条就说明了所有加法常数给他个O(1)即可。
线性阶
一般含有非嵌套循环涉及线性阶,线性阶就是随着问题规模n的扩大,对应计算次数呈直线增长。
int i , n = 100, sum = 0;
for( i=0; i < n; i++ )
{
sum = sum + i;
}
上面这段代码,它的循环的时间复杂度为O(n),因为循环体中的代码需要执行n次。
平方阶
刚才是单个循环结构,那么嵌套呢?
int i, j, n = 100;
for( i=0; i < n; i++ )
{
for( j=0; j < n; j++ )
{
printf(“I love FishC.comn”);
}
}
n等于100,也就是说外层循环每执行一次,内层循环就执行100次,那总共程序想要从这两个循环出来,需要执行100*100次,也就是n的平方。所以这段代码的时间复杂度为O(n^2)。
那如果有三个这样的嵌套循环呢?
没错,那就是n^3啦。所以我们很容易总结得出,循环的时间复杂度等于循环体的复杂度乘以该循环运行的次数。
刚刚我们每个循环的次数都是一样的,如果:
int i, j, n = 100;
for( i=0; i < n; i++ )
{
for( j=i; j < n; j++ )
{
printf(“I love FishC.comn”);
}
}
分析下,由于当i=0时,内循环执行了n次,当i=1时,内循环则执行n-1次……当i=n-1时,内循环执行1次,所以总的执行次数应该是:
n+(n-1)+(n-2)+…+1 = n(n+1)/2
那咱理解后可以继续,n(n+1)/2 = n^2/2+n/2
用我们推导大O的攻略,第一条忽略,因为没有常数相加。第二条只保留最高项,所以n/2这项去掉。第三条,去除与最高项相乘的常数,最终得O(n^2)。
对数阶
我们看下这个程序:
int i = 1, n = 100;
while( i < n )
{
i = i * 2;
}
由于每次i*2之后,就举例n更近一步,假设有x个2相乘后大于或等于n,则会退出循环。
于是由2^x = n得到x = log(2)n,所以这个循环的时间复杂度为O(logn)。
其实理解大O推导不算难,难的是对数列的一些相关运算,这更多的是考察你的数学知识和能力。
函数调用的时间复杂度分析
如果我们把问题再实际化一点,大家是否能自己正确的分析出来呢?
我们来看下边这个例子:
int i, j;
for(i=0; i < n; i++)
{
function(i);
}
void function(int count)
{
printf(“%d”, count);
}
函数体是打印这个参数,这很好理解。function函数的时间复杂度是O(1),所以整体的时间复杂度就是循环的次数O(n)。
假如function是下面这样,又该如何呢:
void function(int count)
{
int j;
for(j=count; j < n; j++)
{
printf(“%d”, j);
}
}
事实上,这和之前我们讲解平方阶的时候举的第二个例子一样:function内部的循环次数随count的增加(接近n)而减少,所以根据游戏攻略算法的时间复杂度为O(n^2)。
尝试自己分析以下程序的时间复杂度:
常见的时间复杂度
常用的时间复杂度所耗费的时间从小到大依次是:O(1) < O(logn) < (n) < O(nlogn) < O(n^2) < O(n^3) < O(2^n) < O(n!) < O(n^n)
O(1),O(logn),O(n),O(n^2)我们前边已经给大家举例谈过了,至于O(nlogn)我们将会在今后的课程中介绍。
而像O(n^3)之后的这些,由于n值的增大都会使得结果大得难以想象,我们没必要去讨论它们。
最坏情况与平均情况
从心理学角度讲,每个人对将来要发生的事情都会有一个预期。
譬如看半杯水,有人会说:哇哦,还有半杯哦!但有人就会失望的说:天,只有半杯了。
一般人常出于一种对未来失败的担忧,而在预期的时候趋向做最坏打算。这样,即使最糟糕的结果出现,当事人也有了心理准备,比较容易接受结果,假如结局并未出现最坏的状况,这也会使人更加快乐,瞧,事情发展的还不错嘛!嗯,这是典型的自慰手法。
算法的分析也是类似,我们查找一个有n个随机数字数组中的某个数字,最好的情况是第一个数字就是,那么算法的时间复杂度为O(1),但也有可能这个数字就在最后一个位置,那么时间复杂度为O(n)。
平均运行时间是期望的运行时间,最坏运行时间是一种保证。
在应用中,这是一种最重要的需求,通常除非特别指定,我们提到的运行时间都是最坏情况的运行时间。
算法的空间复杂度
我们在写代码时,完全可以用空间来换去时间。
举个例子说,要判断某年是不是闰年,你可能会花一点心思来写一个算法,每给一个年份,就可以通过这个算法计算得到是否闰年的结果。
另外一种方法是,事先建立一个有2050个元素的数组,然后把所有的年份按下标的数字对应,如果是闰年,则此数组元素的值是1,如果不是元素的值则为0。
这样,所谓的判断某一年是否为闰年就变成了查找这个数组某一个元素的值的问题。
第一种方法相比起第二种来说很明显非常节省空间,但每一次查询都需要经过一系列的计算才能知道是否为闰年。
第二种方法虽然需要在内存里存储2050个元素的数组,但是每次查询只需要一次索引判断即可。
这就是通过一笔空间上的开销来换取计算时间开销的小技巧。到底哪一种方法好?其实还是要看你用在什么地方。
算法的空间复杂度通过计算算法所需的存储空间实现,算法的空间复杂度的计算公式记作:S(n)=O(f(n)),其中,n为问题的规模,f(n)为语句关于n所占存储空间的函数。
通常,我们都是用“时间复杂度”来指运行时间的需求,是用“空间复杂度”指空间需求。
当直接要让我们求“复杂度”时,通常指的是时间复杂度。
显然对时间复杂度的追求更是属于算法的潮流!
常用的时间复杂度所耗费的时间从小到大依次是:O(1) < O(logn) < (n) < O(nlogn) < O(n^2) < O(n^3) < O(2^n) < O(n!) < O(n^n)
O(1),O(logn),O(n),O(n^2)我们前边已经给大家举例谈过了,至于O(nlogn)我们将会在今后的课程中介绍。
而像O(n^3)之后的这些,由于n值的增大都会使得结果大得难以想象,我们没必要去讨论它们。
最坏情况与平均情况
从心理学角度讲,每个人对将来要发生的事情都会有一个预期。
譬如看半杯水,有人会说:哇哦,还有半杯哦!但有人就会失望的说:天,只有半杯了。
一般人常出于一种对未来失败的担忧,而在预期的时候趋向做最坏打算。这样,即使最糟糕的结果出现,当事人也有了心理准备,比较容易接受结果,假如结局并未出现最坏的状况,这也会使人更加快乐,瞧,事情发展的还不错嘛!嗯,这是典型的自慰手法。
算法的分析也是类似,我们查找一个有n个随机数字数组中的某个数字,最好的情况是第一个数字就是,那么算法的时间复杂度为O(1),但也有可能这个数字就在最后一个位置,那么时间复杂度为O(n)。
平均运行时间是期望的运行时间,最坏运行时间是一种保证。
在应用中,这是一种最重要的需求,通常除非特别指定,我们提到的运行时间都是最坏情况的运行时间。
算法的空间复杂度
我们在写代码时,完全可以用空间来换去时间。
举个例子说,要判断某年是不是闰年,你可能会花一点心思来写一个算法,每给一个年份,就可以通过这个算法计算得到是否闰年的结果。
另外一种方法是,事先建立一个有2050个元素的数组,然后把所有的年份按下标的数字对应,如果是闰年,则此数组元素的值是1,如果不是元素的值则为0。
这样,所谓的判断某一年是否为闰年就变成了查找这个数组某一个元素的值的问题。
第一种方法相比起第二种来说很明显非常节省空间,但每一次查询都需要经过一系列的计算才能知道是否为闰年。
第二种方法虽然需要在内存里存储2050个元素的数组,但是每次查询只需要一次索引判断即可。
这就是通过一笔空间上的开销来换取计算时间开销的小技巧。到底哪一种方法好?其实还是要看你用在什么地方。
算法的空间复杂度通过计算算法所需的存储空间实现,算法的空间复杂度的计算公式记作:S(n)=O(f(n)),其中,n为问题的规模,f(n)为语句关于n所占存储空间的函数。
通常,我们都是用“时间复杂度”来指运行时间的需求,是用“空间复杂度”指空间需求。
当直接要让我们求“复杂度”时,通常指的是时间复杂度。
显然对时间复杂度的追求更是属于算法的潮流!