《大话数据结构》--学习笔记3

2.9  算法的时间复杂度

2.9.1 算法时间复杂度定义

             在进行算法分析时，语句总的执行次数T(n)是关键问题规模n的函数，进而分析T(n)随n的变化情况并确定T(n)的数量级。算法的时间复杂度，记作：T(n)=O(f(n)).它表示随问题规模n的增大，算法执行时间的增长率和f(n)的增长率相同，称作算法渐进时间复杂度，简称为时间复杂度。其中f(n)是时间规模n的某个函数。

          一般情况下，随着n的增大，T(n)增长最慢的算法为最优算法。

显然，由此算法时间复杂度的定义可知，我们三个求和算法的时间复杂的分别为O(n)、O(1)、O(n^2).我们分别取名为：

O(1)：常数阶       O(n)：线性阶         O(n^2)：平方阶

2.9.2 推导大O阶方法

推导大O阶：

1.用常数1取代运行时间中的所有加法常数；

2.在修改后的运行次数函数中，只保留最高阶项；

3.如果最高阶项存在且不是1，则去除与这个项相乘的常数；

得到的结果就是大O阶。

 

常数阶：

首先顺序结构的时间复杂度。下面这个算法，为什么时间复杂度不是O(3)，而是O(1)。

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

这个算法的运行次数函数是f(n)=3. 根据我们推到大O阶的方法，第一步就是把常数项3改为1。在保留最高阶项时发现，它根本没有最高阶项，所以这个算法的时间复杂度是O(1).

另外，我们试想一下，如果这个算法当中的语句sum=(1+n)*n/2有7句，即： 

int  i, sum=0,n=100;    /*执行一次*/
sum = (1+n)*n/2;       /*执行第1次*/
sum = (1+n)*n/2; /*执行第2次*/
sum = (1+n)*n/2; /*执行第3次*/
sum = (1+n)*n/2; /*执行第4次*/
sum = (1+n)*n/2; /*执行第5次*/
sum = (1+n)*n/2; /*执行第6次*/
sum = (1+n)*n/2; /*执行第7次*/
sum = (1+n)*n/2; /*执行一次*/printf("%d",sum); /*执行一次*/
事实上无论n为多少，上面的两段代码就是3次和9次执行的差异，这样与n多少无关的，执行时间恒定的算法，我们称之为具有O(1)的时间复杂度，又称为常数阶。

【注意：不管这个常数是多少，我们都记做O(1),而不是O(3)、O(9)等其他任何数字。】
线性阶
我们要分析算法的复杂度，关键就是要分析循环结构的运行情况。
下面我们来看这段代码，它的循环的时间复杂度为O(n),因为循环体中代码须要执行n次。
int  i;
for (i=0;i<n;i++)
{
   ....
}


对数阶
看下面代码的时间复杂度又是多少？
int count=1;
while(count<0)
{
    count =count*2;
}


由于每次count乘以2之后，就距离n更近一分。也就是说，有多少个2相乘后大于n，则会退出循环。由2^x=n  得到x=log2n.所以这个循环的时间复杂度为O(logn)。
平方阶
下面例子是一个循环嵌套，它的内循环刚才我们已经分析过，时间复杂度为O(n)
int i ,j;
for(i=0; i<n; i++)
{
     for(j=0;j<n;j++)
     {
     }
}


而对于外层的循环，不过是内部这个时间复杂度为O(n)的语句，再循环n次。所以这段代码的时间复杂度为O(n^2)
如果外循环的循环次数改为m，时间复杂度就变为O(m*n)，所以我们总结得出，循环的时间复杂度等于循环体的复杂度乘以该循环运行的次数。
那么下面的循环嵌套，它的时间复杂度是多少？
int  i,j;
for(i=0；i<n ;i++)
{
    for(j=i;j<n;j++)  //注意：j=i 而不是0
    {
    }
}


由于当i=0时，内循环执行了n次，当i=1时，执行了n-1次，......当i=n-1时，执行了1次。所以总的执行次数为：
n+(n-1)+(n-2)+......+1=n(n+1)/2=(n^2)/2+n/2
用我们推导大O阶的方法，第一条，没有加法常数不予考虑；
第二条，只保留最高阶项，因此保留(n^2)/2；
第三条，去除这个项的相乘常数，即/2，最终这段代码的时间复杂度为O(n^2)
 
我们继续看例子，对于方法调用的时间复杂度又如何分析：
int  i ,j;
for (i=0; i<n;i++)
{
    function(i);
}
void  function(int  count)
{
    printf("count");
}


函数体是打印这个参数。其实function函数的时间复杂度是O(1),所以整体的时间复杂度为O(n).
假如function是下面这样的：
void function (int  count)
{

    int  j ;

    for(j=count;  j<n;  j++)

   {

   }

}




事实上，这和刚才举例子的是一样的，只不过把嵌套内循环放到了函数中。最终的时间复杂度是O(n^2)
下面这段相对复杂的语句：
n++;

function(n);

int  i,j;

for(i=0; i<n; i++)

{

   function(i);

}

for(i=0; i<n; i++)

{

   for(j=i; i<n; j++)

   {

      

   }

}




它的执行次数 f(n)=1+n+n^2+n(n+1)/2=3/2(n^2)+3/2(n)+1 根据推导O阶的方法，最终这段代码的时间复杂度也是O(n^2)
2.10 常见的时间复杂度


 
 
执行次数函数
阶
非正常术语
12
O(1)
常数阶
2n+3
O(n)
线性阶
3n^2+2n+1
O(n^2)
平方阶
5log2n+20
O(logn)
对数阶
2n+3nlog2n+19
O(nlogn)
nlogn阶
6n^3+2n^2+3n
O(n^3)
立方阶
2^n
O(2^n)
指数阶

 
常用的时间复杂度所耗的时间从小到大依次是：
O(1)<O(logn)<O(n)<O(nlogn)<O(n^2)<O(n^3)<O(2^n)<O(n!)<O(n^n)