时间复杂度的计算

表示时间复杂度的阶有：

O(1) ：常量时间阶          O (n)：线性时间阶

O(㏒n) ：对数时间阶    O(n㏒n) ：线性对数时间阶

O (n^k)： k≥2 ，k次方时间阶

例１  两个n阶方阵的乘法

              for(i=1，i<=n; ++i)

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

                     {   c[i][j]=0 ;

                          for(k=1; k<=n; ++k)

                         c[i][j]+=a[i][k]*b[k][j] ; 

}

由于是一个三重循环，每个循环从1到n，则总次数为： n×n×n=n³　时间复杂度为T(n)=O(n³)【立方阶】

例２  {++x; s=0 ;}

将x自增看成是基本操作，则语句频度为１，即时间复杂度为Ｏ(1) 。【常量阶】

如果将s=0也看成是基本操作，则语句频度为２，其时间复杂度仍为Ｏ(1)，即常量阶。

例３   for(i=1; i<=n; ++i)

               { ++x; s+=x ; } 

语句频度为：2n，其时间复杂度为：O(n) ，即为【线性阶】。

例４   for(i=1; i<=n; ++i)

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

                   { ++x; s+=x ; }

   语句频度为：n*n*2=2n² ，其时间复杂度为：O(n²) ，即为【平方阶】。

定理：若A(n)=a_mn^m +a_m-1n^m-1+…+a₁n+a₀是一个m次多项式，则A(n)=O(n^m)

例５   for(i=2;i<=n;++i)

              for(j=2;j<=i-1;++j)

                    {++x; a[i,j]=x; }

语句频度为：   1+2+3+…+n-2=(1+n-2) ×(n-2)/2

=(n-1)(n-2)/2 =n²-3n+2

 ∴时间复杂度为O(n²)，即此算法的时间复杂度为【平方阶】。

一个算法时间为O(1)的算法，它的基本运算执行的次数是固定的。因此，总的时间由一个常数（即零次多项式）来限界。而一个时间为O(n²)的算法则由一个二次多项式来限界。

以下六种计算算法时间的多项式是最常用的。其关系为：

     O(1) < O(㏒n) < O(n) < O(n㏒n) < O(n²) < O(n³)

  指数时间的关系为：

    O(2ⁿ) < O(n!) < O(nⁿ)

当n取得很大时，指数时间算法和多项式时间算法在所需时间上非常悬殊。

例1：素数的判断算法。

void prime( int n)

 

{  

int i=2 ;

while ( (n%i)!=0 && i*1.0< sqrt(n) )  

     i++ ;

if (i*1.0>sqrt(n) )

      printf(“&d 是一个素数\n” , n) ;

else

      printf(“&d 不是一个素数\n” , n) ;

}

嵌套的最深层语句是i++；其频度由条件( (n% i)!=0 && i*1.0< sqrt(n) ) 决定，显然i*1.0< sqrt(n) ，时间复杂度O(n^1/2)。

或者说是O(sqrt(n))；

 

例2：冒泡排序法。

Void bubble_sort(int a[]，int n)

{  

change=false;

for (i=n-1; change=TURE; i>1 && change; --i)

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

if (a[j]>a[j+1])

    {     a[j] ←→a[j+1] ;   change=TURE ; }

}

最好情况：0次

最坏情况：1+2+3+⋯+n-1=n(n-1)/2

平均时间复杂度为： O(n²)  【平方阶】