算法复杂度分析

算法复杂度定义：

        算法复杂度分为时间复杂度和空间复杂度，算法的复杂性体现在运行该算法时计算机所需资源的多少上，而计算机资源最重要的是时间和空间（寄存器）资源。

        时间复杂度指的是执行算法所需要的计算工作量；

        空间复杂度指的是执行这个算法所需要的内存空间。

 

时间复杂度：

      一算法中的语句执行的次数称为时间频度（T(n)）。

       一般情况下，算法的基本操作重复执行的次数是模块A的某一个函数f(n)，因此，算法的时间复杂度记做：T(n)=O(f(n))。随着模块A的增大，算法执行的时间的增长率和 f(n) 的增长率成正比，因此当 f(n) 越小，算法的时间复杂度越低，算法的效率越高。

        在计算时间复杂度时，要先找出算法的基本操作，然后根据相应的各语句确定它的执行次数，再找出 T(n) 的同数量级

（它的同数量级有：1、 log(2)n、 n、 n log(2)n 、 n的平方、 n的三次方、 2的n次方、 n!），f(n) = 该数量级，若 T(n)/f(n) 求极限可得到一常数c，则时间复杂度T(n) = O(f(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];

    }

}

 

T(n) = n 的平方+n的三次方，根据上面括号里的同数量级，我们可以确定 n的三次方 为T（n）的同数量级，则f(n) = n的三次方，然后根据 T(n)/f(n) 求极限可得到

 

常数c，则该算法法的时间复杂度：T(n) = O(n^3) 注：n^3即是n的3次方。

看有几重for循环，只有一重则时间复杂度为O(n)，二重则为O(n^2)，依此类推，如果有二分则为O(logn)，二分例如快速幂、二分查找，如果一个for循环套一个二分，那么时间

 

复杂度则为O(nlogn)。

 

例：

 

循环体的复杂度是对数级的 如下

　　int count = 1;

　　while(count < n){

　　　　count *= 2;

　　　　//一些列复杂度为O(1)的步骤....
　　}

该循环是O(logn)的, 通常情况是2为底的 也就是O(log2n)。

 

例：

例：例：例：例：如果一个方法体是由多个方法调用and多个循环组成的,那么其复杂度又如何!
如果一个方法体是由多个方法调用and多个循环组成的,那么其复杂度又如何!
如果一个方法体是由多个方法调用and多个循环组成的,那么其复杂度又如何!
五如果一个方法体是由多个方法调用and多个循环组成的,那么其复杂度又如何!

　　public void suixiangMethod(int n){
　　　　printsum(n);//1.1
　　　　for(int i= 0; i 　　　　　　printsum(n);
　　　　}
　　　　for(int i= 0; i 　　　　　　for(int k=0; k
　　　　　　　　System.out.print(i,k);
　　　　　　}
　　}
suixiangMethod 方法的时间复杂度需要计算方法体的各个成员的复杂度?
也就是1.1+1.2+1.3 = O(1)+O(n)+O(n2) ----> 忽略常数 和 非主要项 == O(n2)五如果一个方法体是由多个方法调用and多个循环组成的,那么其复杂度又如何!

　　public void suixiangMethod(int n){
　　　　printsum(n);//1.1
　　　　for(int i= 0; i 　　　　　　printsum(n);
　　　　}
　　　　for(int i= 0; i 　　　　　　for(int k=0; k
　　　　　　　　System.out.print(i,k);
　　　　　　}
　　}
suixiangMethod 方法的时间复杂度需要计算方法体的各个成员的复杂度?
也就是1.1+1.2+1.3 = O(1)+O(n)+O(n2) ----> 忽略常数 和 非主要项 == O(n2)五如果一个方法体是由多个方法调用and多个循环组成的,那么其复杂度又如何!

　　public void suixiangMethod(int n){
　　　　printsum(n);//1.1
　　　　for(int i= 0; i 　　　　　　printsum(n);
　　　　}
　　　　for(int i= 0; i 　　　　　　for(int k=0; k
　　　　　　　　System.out.print(i,k);
　　　　　　}
　　}
suixiangMethod 方法的时间复杂度需要计算方法体的各个成员的复杂度?
也就是1.1+1.2+1.3 = O(1)+O(n)+O(n2) ----> 忽略常数 和 非主要项 == O(n2)五如果一个方法体是由多个方法调用and多个循环组成的,那么其复杂度又如何!

　　public void suixiangMethod(int n){
　　　　printsum(n);//1.1
　　　　for(int i= 0; i 　　　　　　printsum(n);
　　　　}
　　　　for(int i= 0; i 　　　　　　for(int k=0; k
　　　　　　　　System.out.print(i,k);
　　　　　　}
　　}
suixiangMethod 方法的时间复杂度需要计算方法体的各个成员的复杂度?
也就是1.1+1.2+1.3 = O(1)+O(n)+O(n2) ----> 忽略常数 和 非主要项 == O(n2)五如果一个方法体是由多个方法调用and多个循环组成的,那么其复杂度又如何!

　　public void suixiangMethod(int n){
　　　　printsum(n);//1.1
　　　　for(int i= 0; i 　　　　　　printsum(n);
　　　　}
　　　　for(int i= 0; i 　　　　　　for(int k=0; k
　　　　　　　　System.out.print(i,k);
　　　　　　}
　　}
suixiangMethod 方法的时间复杂度需要计算方法体的各个成员的复杂度?
也就是1.1+1.2+1.3 = O(1)+O(n)+O(n2) ----> 忽略常数 和 非主要项 == O(n2)void XXXMethod(int n){

　　　　printsum(n);//1.1

　　　　for(int i= 0; i  < 100, i++)

              {

　　　　　　

                             \\
　　　　}

　　　　for(int i= 0; i <100, i++)

              {　　　　　　

                      for(int k=0; k < 50; k++)

                          {
　　　　　　　　 //

                          }
　　　　}
　　}

 

        时间复杂度就是1.1+1.2+1.3 = O(1)+O(n)+O(n2) ----> 忽略常数 和 非主要项 == O(n^2)。

 

 

按数量级递增排列，常见的时间复杂度有：

 

常数阶O(1)、对数阶O(log2n)、线性阶O(n)、

 

线性对数阶O(nlog2n)、平方阶O(n^2)、立方阶O(n^3)、k次方阶O(n^k)、指数阶O(2^n)。随着问题规模n的不断增大，上述时间复杂度不断增大，算法的执行效率越低。

 

 

空间复杂度

 

        一个程序的空间复杂度是指运行完一个程序所需内存的大小。利用程序的空间复杂度，可以对程序的运行所需要的内存多少有个预先估计。一个程序执行时除了需要存储

 

空间和存储本身所使用的指令、常数、变量和输入数据外，还需要一些对数据进行操作的工作单元和存储一些为现实计算所需信息的辅助空间。程序执行时所需存储空间包括以下两部分。

 

       固定部分：这部分空间的大小与输入/输出的数据的个数多少、数值无关。主要包括指令空间（即代码空间）、数据空间（常量、简单变量）等所占的空间。这部分属于静

 

态空间。

 

       可变空间：这部分空间的主要包括动态分配的空间，以及递归栈所需的空间等。这部分的空间大小与算法有关。

 

      一个算法所需的存储空间用f(n)表示。

 

则空间复杂度表示为：

                                 S(n)=O(f(n))                        其中n为问题的规模。