算法复杂度

【1】算法复杂度

同一个问题可用不同的算法解决，而一个算法的质量优劣将影响到算法乃至程序的效率。算法分析的目的在于选择合适算法和改进算法。

算法复杂度分为时间复杂度和空间复杂度。

时间复杂度是度量算法执行的时间长短；而空间复杂度是度量算法所需存储空间的大小。

【2】时间复杂度

（1）时间频度

一个算法执行所耗费的时间，从理论上是不能算出来的，必须上机运行测试才能知道。

但我们不可能也没有必要对每个算法都上机测试，只需知道那个算法花费的时间多，哪个算法花费的时间少就可以了。

并且一个算法花费的时间与算法中语句的执行次数成正比例，那个算法中语句执行次数多，它花费时间就多。

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

（2）时间复杂度

<1>在时间频度中，n称为问题的规模，当n不断变化时，时间频度T(n)也会不断变化。

但有时我们想知道它变化时呈现什么规律。为此，我们引入时间复杂度概念。

<2>一般情况下，算法的基本操作重复执行的次数是与模块n相关的某一个函数f（n），因此，算法的时间复杂度记做：T（n）=O（f（n））。

随着模块n的增大，算法执行的时间的增长率和f（n）的增长率成正比，所以f（n）越小，算法的时间复杂度越低，算法的效率越高。

<3>计算时间复杂度步骤：

1：先找出算法的基本操作

2：根据相应的各语句确定它的执行次数，再找出T（n）的同数量级（它的同数量级有以下：1，Log2n ，n ，nLog2n ，n的平方，n的三次方，2的n次方，n！）。

3：f（n）= 该数量级，若T(n)/f(n)求极限可得到一常数c，则时间复杂度T（n）= O（f（n））。

4：示例计算如下：

for(int i = 1; i <= n; ++i)
{ 
     for(int j = 1; j <= n; ++j) 
    { 
        c[i][j] = 0;          //该步骤属于基本操作 执行次数:n的平方次 
        for(int k = 1; k <= n; ++k)
        {
            c[i][j] += a[i][k] * b[k][j]; //该步骤属于基本操作 执行次数:n的三次方次 
        }
    } 
}

则有 T（n）= n的平方 + n的三次方。根据上面括号里的同数量级，我们可以确定n的三次方为T（n）的同数量级 

则有f（n）= n的三次方，然后根据T（n）/f（n）求极限可得到常数c。 

则该算法的 时间复杂度：T（n）=O（n^3） 注：n^3即是n的3次方。

（3）下面五个例子分析

//(1)
for(i = 1; i <= n; i++)
{
     for(j = 1; j <= n; j++)
     {
        s++;
     }
}
//(2)
for(i = 1; i <= n; i++)
{
    for(j = i; j <= n; j++)
    {
        s++;
    }
}
//(3)
for(i = 1; i <= n; i++)
{
    for(j = 1; j <= i; j++)
    {
        s++;
    }
}
//(4)
i = 1; k = 0;
while(i <= n-1)
{
    k += 10*i;
    i++;
}
//(5)
for(i = 1; i <= n; i++)
{
    for(j = 1; j <= i; j++)
    {
        for(k = 1; k <= j; k++)
        {
            x = x + 1;
        }
    }
}

一般来说，时间复杂度是总运算次数表达式中受n的变化影响最大的那一项(不含系数)

比如：一般总运算次数表达式类似于这样：a*2^n + b*n^3 + c*n^2 + d*n*lg(n) + e*n + f

a<>0时，时间复杂度就是O(2^n);

a = 0, b<>0  =>  O(n^3);

a, b=0, c<>0 =>  O(n^2) 依此类推。

那么，总运算次数又是如何计算出的呢？

一般来说，我们经常使用for循环，就像上面五道题，我们就以它们为例：

1.循环了n*n次，当然是O(n^2)

2.循环了(n+n-1+n-2+...+1)≈(n^2)/2，因为时间复杂度是不考虑系数的，所以也是O(n^2)

3.循环了(1+2+3+...+n)≈(n^2)/2，当然也是O(n^2)

4.循环了n-1≈n次，所以是O(n)

5.循环了(1^2+2^2+3^2+...+n^2)=n(n+1)(2n+1)/6(这个公式要记住哦)≈(n^3)/3，不考虑系数，自然是O(n^3)

所以，答案为：

1.时间复杂度O(n^2)

2.时间复杂度O(n^2)

3.时间复杂度O(n^2)

4.时间复杂度O(n)

5.时间复杂度O(n^3)

另外，在时间复杂度中，log(2,n)(以2为底)与lg(n)(以10为底)是等价的，因为对数换底公式：

log(a,b)=log(c,b)/log(c,a)

所以，log(2,n) = log(2,10)*lg(n)，忽略掉系数，二者当然是等价的。

【3】空间复杂度

（1）一个算法的空间复杂度定义为该算法所耗费的存储空间，它也是问题规模n的函数。渐近空间复杂度也常常简称为空间复杂度。

空间复杂度是对一个算法在运行过程中临时占用存储空间大小的量度。

（2）一个算法在计算机存储器上所占用的存储空间，包括存储算法本身所占用的存储空间，算法的输入输出数据所占用的存储空间和算法在运行过程中临时占用的存储空间这三个方面。

算法的输入输出数据所占用的存储空间是由要解决的问题决定的，是通过参数表由调用函数传递而来的，它不随本算法的不同而改变。

存储算法本身所占用的存储空间与算法书写的长短成正比，要压缩这方面的存储空间，就必须编写出较短的算法。算法在运行过程中临时占用的存储空间随算法的不同而异。

有的算法只需要占用少量的临时工作单元，而且不随问题规模的大小而改变，我们称这种算法是“就地"进行的，是节省存储的算法。

有的算法需要占用的临时工作单元数与解决问题的规模n有关，它随着n的增大而增大，当n较大时，将占用较多的存储单元，例如快速排序和归并排序算法就属于这种情况。

（3）如当一个算法的空间复杂度为一个常量，即不随被处理数据量n的大小而改变时，可表示为O(1)；

当一个算法的空间复杂度与以2为底的n的对数成正比时，可表示为0(10g2n)；

当一个算法的空间复杂度与n成线性比例关系时，可表示为0(n)；

若形参为数组，则只需要为它分配一个存储由实参传送来的一个地址指针的空间，即一个机器字长空间；

若形参为引用方式，则也只需要为其分配存储一个地址的空间，用它来存储对应实参变量的地址，以便由系统自动引用实参变量。

 

Good Good Study, Day Day Up.

顺序  选择  循环  坚持  总结