时间复杂度简明理解

时间复杂度

定义：

一般情况下，算法中基本操作重复执行的次数是问题规模n的某个函数，用T(n)表示，若有某个辅助函数f(n)，使得当n趋近于无穷大时，T(n)/f(n)的极限值为不等于零的常数，则称f(n)是T(n)的同数量级函数。记作T(n)=O(f(n))，称O(f(n))为算法的渐进时间复杂度(O是数量级的符号 )，简称时间复杂度。

理解：

• 时间频率
  • 一个算法花费的时间与算法中语句的执行次数成正比例，哪个算法中语句执行次数多，它花费时间就多。
  • 一个算法中的语句执行次数称为语句频度或时间频度。记为T(n)。
• 时间复杂度
  • 一般情况下，算法中基本操作重复执行的次数是问题规模n的某个函数，用T(n)表示，若有某个辅助函数f(n),使得当n趋近于无穷大时，T（n)/f(n)的极限值为不等于零的常数，则称f(n)是T(n)的同数量级函数。记作T(n)=O(f(n))
• 常见的时间复杂度
  • 常数阶O(1)<对数阶O(log2n)<线性阶O(n)<线性对数阶O(nlog2n)<平方阶O(n^2)<方阶O(n3)< k次方阶O(n^{k)<指数阶O(2}n)<O(n!)<O(n^n)

求时间复杂度

• 根据定义，可归纳出基本的计算步骤
  1. 计算出基本操作的执行次数T(n)
     • 基本操作即算法中的每条语句的执行次数一般默认为考虑最坏的情况。
  2. 计算出T(n)的数量级
     • 求T(n)的数量级，只要将T(n)进行如下操作：
       • 忽略常量，低次幂和最高次幂的系数 令f(n)=T(n)的数量级。
  3. 用大O来表示时间复杂度

 例:
      for（i=1;i<=n;++i）

      {

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

         {

             c[ i ][ j ]=0; //该步骤属于基本操作 执行次数：n^2

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

                   c[ i ][ j ]+=a[ i ][ k ]*b[ k ][ j ]; //该步骤属于基本操作 执行次数：n^3

         }

      }
      //则有 T（n）= n^2+n^3，根据上面括号里的同数量级，我们可以确定 n^3为T（n）的同数量级则有f（n）= n^3，然后根据T（n）/f（n）求极限可得到常数c则该算法的 时间复杂度：T（n）=O（n^3)

• 于是我们发现根本没必要都算，所以我们有了精简后的步骤：
  1. 找到执行次数最多的语句
  2. 计算语句执行次数的数量级
  3. 用大O来表示结果

    (1) for(i=1;i<=n;i++)     //循环了n*n次，当然是O(n^2)
            for(j=1;j<=n;j++)
                 s++;

    （2）for(i=1;i<=n;i++)   //循环了(n+n-1+...+1)≈(n^2)/2 ,同上
               for(j=i;j<=n;j++)
                     s++;

    (4)   i=1;k=0;
          while(i<=n-1){
               k+=10*i;

          i++;      }//循环了//n-1≈n次，所以是O(n)

    (5)   for(i=1;i<=n;i++)
                 for(j=1;j<=i;j++)
                     for(k=1;k<=j;k++)
                           x=x+1;//循环了(1^2+2^2+3^2+...+n^2)=n(n+1)(2n+1)/6≈(n^3)/3，//即O（n^3)

    （6)x=91; y=100;
        while(y>0) if(x>100) {x=x-10;y--;} 
        else x++;//T(n)=O(1)，与n无关

    （7）i=n-1;
        while(i>=0&&(A[i]!=k))
          i--;
        return i;
//此算法中的语句(3)的频度不仅与问题规模n有关，还与输入实例中A的各元素取值及K的取值有关: ①若A中没有与K相等的元素，则语句(3)的频度f(n)=n； ②若A的最后一个元素等于K,则语句(3)的频度f(n)是常数0。

推导示例

1. 常数阶

例1：    
int sum = 0, n = 100;       /*执行一次*/
sum = (1 + n) * n / 2;      /*执行一次*/
printf("%d",sum);           /*执行一次*/

• 单纯的分支结构(不包含在循环结构中)，其时间复杂度也是0(1)

2. 线性阶

int i;      
for(i = 0; i < n; i++){
    /*时间复杂度为O(1)的程序步骤序列*/
}

• 循环的时间复杂度为O(n),因为循环体中的代码续执行n次
• 在分析算法的复杂度时，关键就是要分析循环结构的运行情况

3. 对数阶

int count = 1;      
while (count < n){
   count = count * 2;
  /*时间复杂度为O(1)的程序步骤序列*/
}

• 由于每次count乘以2之后，就距离n更近了一分。 也就是说，有多少个2相乘后大于n，则会退出循环。 由2^count=n 得到count=logn。 所以这个循环的时间复杂度为O(logn)

4. 平方阶

int i, j;      
for(i = 0; i < n; i++){
    for(j = 0; j < n; j++){
        /*时间复杂度为O(1)的程序步骤序列*/
    }
}

• 内外嵌套时间复杂度都为O(n),故该代码的时间复杂度为O(n^2)
• 若外循环的循环次数为m，时间复杂度则为O(m*n)

int i, j;      
for(i = 0; i < n; i++){
    for(j = i; j < n; j++){   /*注意j = i而不是0*/
        /*时间复杂度为O(1)的程序步骤序列*/
    }
}

• 由于当i=0时，内循环执行了n次，当i = 1时，执行了n-1次，……当i=n-1时，执行了1次。所以总的执行次数为:
  • n+(n-1)+(n-2)+…+1=n(n+1)/2
  • lim((n(n+1)/2)) = n^2
• 等差数列

5. 立方阶

int i, j;      
for(i = 1; i < n; i++)
    for(j = 1; j < n; j++)
        for(j = 1; j < n; j++){
            /*时间复杂度为O(1)的程序步骤序列*/
        }

• 这里循环了(1²⁺²2+3^2+……+n2) = n(n+1)(2n+1)/6次，按照上述大O阶推导方法，时间复杂度为O(n^3)