***************************************************

更多精彩，欢迎进入：http://shop115376623.taobao.com

***************************************************

求解算法的时间复杂度的具体步骤是：

　　⑴ 找出算法中的基本语句；

　　算法中执行次数最多的那条语句就是基本语句，通常是最内层循环的循环体。

　　⑵ 计算基本语句的执行次数的数量级；

　　只需计算基本语句执行次数的数量级，这就意味着只要保证基本语句执行次数的函数中的最高次幂正确即可，可以忽略所有低次幂和最高次幂的系数。这样能够简化算法分析，并且使注意力集中在最重要的一点上：增长率。

　　⑶ 用大Ο记号表示算法的时间性能。

　　将基本语句执行次数的数量级放入大Ο记号中。

　　如果算法中包含嵌套的循环，则基本语句通常是最内层的循环体，如果算法中包含并列的循环，则将并列循环的时间复杂度相加。例如：

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

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

　　第一个for循环的时间复杂度为Ο(n)，第二个for循环的时间复杂度为Ο(n2)，则整个算法的时间复杂度为Ο(n+n2)=Ο(n2)。

　　常见的算法时间复杂度由小到大依次为：

　　Ο(1)＜Ο(log2n)＜Ο(n)＜Ο(nlog2n)＜Ο(n2)＜Ο(n3)＜…＜Ο(2n)＜Ο(n!)

Ο(1)表示基本语句的执行次数是一个常数，一般来说，只要算法中不存在循环语句，其时间复杂度就是Ο(1)。Ο(log2n)、Ο(n)、Ο(nlog2n)、Ο(n2)和Ο(n3)称为多项式时间，而Ο(2n)和Ο(n!)称为指数时间。计算机科学家普遍认为前者是有效算法，把这类问题称为P类问题，而把后者称为NP问题。

这只能基本的计算时间复杂度，具体的运行还会与硬件有关。

上面的这部分内容是比较可靠的，理解的时候，可以参看着下面的这部分内容。

在计算算法时间复杂度时有以下几个简单的程序分析法则:

1.对于一些简单的输入输出语句或赋值语句,近似认为需要O(1)时间

2.对于顺序结构,需要依次执行一系列语句所用的时间可采用大O下"求和法则"

求和法则:是指若算法的2个部分时间复杂度分别为 T1(n)=O(f(n))和 T2(n)=O(g(n)),则 T1(n)+T2(n)=O(max(f(n), g(n)))

特别地,若T1(m)=O(f(m)), T2(n)=O(g(n)),则 T1(m)+T2(n)=O(f(m) + g(n))

3.对于选择结构,如if语句,它的主要时间耗费是在执行then字句或else字句所用的时间,需注意的是检验条件也需要O(1)时间

4.对于循环结构,循环语句的运行时间主要体现在多次迭代中执行循环体以及检验循环条件的时间耗费,一般可用大O下"乘法法则"

乘法法则: 是指若算法的2个部分时间复杂度分别为 T1(n)=O(f(n))和 T2(n)=O(g(n)),则 T1*T2=O(f(n)*g(n))

5.对于复杂的算法,可以将它分成几个容易估算的部分,然后利用求和法则和乘法法则技术整个算法的时间复杂度

另外还有以下2个运算法则:

(1) 若g(n)=O(f(n)),则O(f(n))+ O(g(n))= O(f(n))

(2) O(Cf(n)) = O(f(n)),其中C是一个正常数

可以用以上法则对下面程序段进行简单分析

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

② for (j=0; j<n; j++)

{

③ c[i][j] = 0;

④ for (k=0; k<n; k++)

⑤ c[i][j]= c[i][j]+ a[i][k]* b[k][j];/ * T5(n) = O(1) */

}

第①条与②③④⑤是循环嵌套T1(n)*T2(n)* (T3(n)+ T4(n)* T5(n))= O(n*n*n)即为整个算法的时间复杂度

O(1)<O(log2n)<O(n)<O(n log2 n)<O(n^2)<O(n^3)<O(2^n)

 

转自http://blog.sina.com.cn/s/blog_50ce2abb0100vhem.html

表示时间复杂度的阶有：

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²)  【平方阶】