算法——时间复杂度和空间复杂度总结，新手们不懂得快上车了

 

简介

        本文章让我们来聊聊算法相关的时间复杂度和空间复杂度，在我从学习到步入职场，不管是看面试题，还是在看算法的时候，很多时候都看到什么O(n),O(1),O(log2n),这些奇怪的标识。老是不知道这是什么意思，一直想去研究，但是一听是什么时间复杂度，空间复杂度，就感觉很牛逼，还是算了，研究了不一定会，次次都是以这样的借口告终，  这两天听朋友说了说，听起来还可以，可以去尝试学一学。  接下来跟我一起了解一下吧！！！

算法

        算法是指用来操作数据、解决程序问题的一组方法。对于同一个问题，使用不同的算法，也许最终得到的结果是一样的，但在过程中消耗的资源和时间却会有很大的区别。

如何衡量不同算法之间的优劣？

        一个算法的优劣主要从算法的执行时间和所需要占用的存储空间两个方面衡量。

        时间维度：是指执行当前算法所消耗的时间，我们通常用[时间复杂度]来描述。

        空间维度：是指执行当前算法需要占用多少内存空间，我们通常用[空间复杂度]来描述。

        因此，评价一个算法的效率主要是看他的时间复杂度和空间复杂度情况。然后，有的时候和空间却又是[鱼和熊掌]，不可兼得的吗，那么我们就需要从取一个平衡点。

时间复杂度

(1) 时间频度：

        一个算法执行所消费的时间，从理论上是不能算出来的，必须上机运行测试才能知道。但我们不可能也没有必要对每个算法都上机测试，只需知道哪个算法花费的时间多，哪个算法花费的时间少就可以了。并且一个算法花费的时间于的算法中语句的执行次数成正比例，哪个算法中语句执行次数多，它花费时间就多。一个算法中的语句执行次数称为语句频度或时间频度。记为T(n).

(2) 时间复杂度：

        在刚才提到的时间频度中，n称为问题的规模，当n不断变化时，时间频度T(n)也会不断变化。但有时我们想知道它变化时呈现什么规律。为此，我们引入时间复杂度概念。一般情况下，算法中基本操作重复执行的次数是问题规模n的某个函数，用T(n)表示，若有某个辅助函数f(n),使得当n趋近于无穷大时，T(n)/f(n)的极限值为不等于零的常数，则称f(n)是T(n)的同数量级函数。记作T(n) = O(f(n)),称O(f(n))为算法的渐进时间复杂度，简称时间复杂度。

小知识：

上面公式中用到的 Landau符号其实是由德国数论学家保罗·巴赫曼（Paul Bachmann）在其1892年的著作《解析数论》首先引入，由另一位德国数论学家艾德蒙·朗道（Edmund Landau）推广。Landau符号的作用在于用简单的函数来描述复杂函数行为，给出一个上或下（确）界。

在计算算法复杂度时一般只用到大O符号，Landau符号体系中的小o符号、Θ符号等等比较不常用。这里的O，最初是用大写希腊字母，但现在都用大写英语字母O；小o符号也是用小写英语字母o，Θ符号则维持大写希腊字母Θ。

        T (n) = Ο(f (n)) 表示存在一个常数C，使得在当n趋于正无穷时总有 T (n) ≤ C * f(n)。简单来说，就是T(n)在n趋于正无穷时最大也就跟f(n)差不多大。也就是说当n趋于正无穷时T (n)的上界是C * f(n)。其虽然对f(n)没有规定，但是一般都是取尽可能简单的函数。

        如果把T(n)当做一棵树，那么O(f(n))所表达的就是树干，只关心其中的主干，其他的细枝末节全都抛弃不管。

        在各种不同算法中，若算法中语句执行次数为一个常数，则时间复杂度为O(1),另外，在时间频度不相同时，时间复杂度有可能相同，如T(n)=n2+3n+4与T(n)=4n2+2n+1它们的频度不同，但时间复杂度相同，都为O(n2)。

        按数量级递增排列，常见的时间复杂度有：常数阶O(1),对数阶O(log2n),线性阶O(n), 线性对数阶O(nlog^2n),平方阶O(n^2)，立方阶O(n^3),...， k次方阶O(n^k),指数阶O(2^n)。、

        随着问题规模n的不断增大，上述时间复杂度不断增大，算法花费时间越多，算法的执行效率越低。

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

        

 (3) 时间复杂度的具体步骤：

        ① 找出算法中的基本语句：

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

         ② 计算基本语句的执行次数的数量级：

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

         ③ 用大O记号表示算法的时间性能。

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

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

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

常见的时间复杂度示例说明

(1)  O(1)

      Test = i ; i = j; j = test;

以上三条单个语句的频度均为1，该程序段的执行时间是一个与问题规模n无关的常数。算法的时间复杂度为常数阶，记作T(n)=O(1).注意：如果算法的执行时间不随着问题规模n的增加而增长，即使算法中有上千条语句，其执行时间也不过是一个较大的常熟。此类算法的时间复杂度是O(1).  

(2) O(n^2)

 sum=0；                 （一次）
     for(i=1;i<=n;i++)     （n+1次）
        for(j=1;j<=n;j++) （n2次）
         sum++；            （n2次）

解：因为Θ(2n2+n+1)=n2（Θ即：去低阶项，去掉常数项，去掉高阶项的常参得到），所以T(n)= =O(n2)；

(3) O(n)     

a=0;
    b=1;                      ①
    for (i=1;i<=n;i++) ②
    {  
       s=a+b;　　　　③
       b=a;　　　　　④  
       a=s;　　　　　⑤
    }

解：  语句1的频度：2,       
          语句2的频度： n,       
          语句3的频度： n-1,       
          语句4的频度：n-1,   
          语句5的频度：n-1,                                 
          T(n)=2+n+3(n-1)=4n-1=O(n).

(4) O(log2n)

i=1;     ①
    while (i<=n)
       i=i*2; ②

 解： 语句1的频度是1, 
          设语句2的频度是f(n),   则：2^f(n)<=n;f(n)<=log2n    
          取最大值f(n)=log2n,
          T(n)=O(log2n )

(5) O(n3) 

for(i=0;i<n;i++)
    {  
       for(j=0;j<i;j++)  
       {
          for(k=0;k<j;k++)
             x=x+2;  
       }
    }

解：当i=m, j=k的时候,内层循环的次数为k当i=m时, j 可以取 0,1,...,m-1 , 所以这里最内循环共进行了0+1+...+m-1=(m-1)m/2次所以,i从0取到n, 则循环共进行了: 0+(1-1)*1/2+...+(n-1)n/2=n(n+1)(n-1)/6所以时间复杂度为O(n3).

空间复杂度

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

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

(1) 空间复杂度的具体步骤

        ①忽略常数，用O(1)表示
        ②递归算法的空间复杂度=递归深度N*每次递归所要的辅助空间
        ③对于单线程来说，递归有运行时堆栈，求的是递归最深的那一次压栈所耗费的空间的个数，因为递归最深的那一次所耗费的空间足以容纳它所有递归过程。

int fun(int n,)
{
int k=10;
if（n==k)
return n;
else
return fun(++n);
}

递归实现，调用fun函数，每次都创建1个变量k。调用n次，空间复杂度O（n*1）=O（n)。

作者：筱白爱学习！！

欢迎关注转发评论点赞沟通，您的支持是筱白的动力！