数据结构—算法的时间复杂度和空间复杂度

时间复杂度

1、什么是时间复杂度

      一般情况下，算法中基本语句重复执行的次数是问题规模n的某个函数f(n)，算法的时间量度记作T(n)=O(f(n))。它表示随问题规模n的增大，算法执行时间的增长率和f(n)的增长率相同，称作算法的渐进时间复杂度，简称时间复杂度(Time complexity)。

2、为什么要学习时间复杂度

     首先我们知道一道算法题可以用多种算法来实现，算法在编写成可执行程序之后，运行时则需要消耗时间资源和空间资源，那么判断一个算法的好坏，一般是从时间和空间两个维度来衡量的，即时间复杂度和空间复杂度。时间复杂度主要衡量一个算法的运行快慢。

3、时间复杂度分析方法的特点

• 不依赖具体的执行环境
• 不用具体的测试数据
• 在算法实现之前，在脑海中就可以评估算法的性能

4、时间复杂度的类型

1）常数阶O(1)

int x = 5;
int y = 10;
int result = x + y;
System.out.println(result);

第一行语句执行1次

第二行语句执行1次

第三行语句执行1次

第四行语句执行1次

f(n) = 4          T(n) = O(4)         T(n) = O(1)

只要你的程序执行的时间和输入数据规模n没有关系的话，即使需要成千上万行的代码，那么你的程序时间复杂度仍然是O(1)

2）对数阶O(log₂n)

int i = 1;
for(;i <= n;i += i){
       System.out.println(i);
}

第一次：i = 1      即 i = 2^(1-1) = 2⁰

第二次：i = 2      即 i = 2^(2-1) = 2¹

第三次：i = 4      即 i = 2^(3-1) = 2²

第四次：i = 8      即 i = 2^(4-1) = 2³

第五次：i = 16    即 i = 2^(5-1) = 2⁴

....................

第x次：i = 2^(x-1)

因为 i <= n，所以2^(x-1) <= n，得到：x = 1 + log₂n

f(n) =(4 + 3log₂n)       T(n) =O(4 + 3log₂n)      O(n) = log₂n

再一例

int i = 1;
for (; i <= n; i = i * 3){
         System.out.println(i);
}

第一次：i = 1      即 i = 3^(1-1) = 3⁰

第二次：i = 3      即 i = 3^(2-1) = 3¹

第三次：i = 9      即 i = 3^(3-1) = 3²

第四次：i = 27    即 i = 3^(4-1) = 3³

第五次：i = 81    即 i = 3^(5-1) = 3⁴

....................

第x次：i = 3^(x-1)

因为 i <= n，所以3^(x-1) <= n，得到：x = 1 + log₃n

f(n) =(4 + 3log₃n)       T(n) =O(4 + 3log₃n)      O(n) = log₃n

log₃n = log₃2 * (log₂n)

O(log₃n) = O(Clog₂n)，其中常量C = log₃2

O(log₃n) = O(log₂n)

3）线性阶O(n)

for (i = 1; i <= n; ++1)
{
     j = i;
     j++;
}

第一行语句执行1+2n次

第二行语句执行n次

第三行语句执行n次

f(n) = 1+ 4n     T(n) = O(1 + 4n)    O(n) = n

4）线性对数阶

     线性对数阶其实很好理解，就是将时间复杂度为对数阶的语句执行n遍。

5）平方阶O(n²)

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

第一行语句执行1+2n次

第二行语句执行2n次

第三行语句执行n*n次

第四行语句执行n*n次

f(n) = 1+4n+2n²      T(n) = O(1+4n+2n²)     O(n) = n²

6）立方阶O(n³)

    与平方阶类似。平方阶是双层循环嵌套，则立方阶就是三层循环嵌套。

5、时间复杂度法则

1）加法法则

private static long sum(int n){
      int sum1 = 0;
      for (int i = 1; i <= 1000; i++){
           sum1 += i;
      }
     
      int sum2 = 0;
      for (int i = 1;i <= n; i++){
           sum2 += i;
      }
 
      int sum3 = 0;
      for (int i = 1;i <= n; i++){
           for (int j = 1; j <= n; j++)
                sum3 += i;    
      }
}

第一段for循环语句时间复杂度为O(1)

第二段for循环语句时间复杂度为O(n)

第三段for循环语句时间复杂度为O(n²)

如果：T₁(n) = O(f(n))   T₂(n) = O(f(n))    那么：T(n) = max(T₁(n),T₂(n)) = max(O(f(n)),O(g(n))) = O(max(f(n),g(n)))

所以此算法的时间复杂度为O(n²)

再一例

private static long sum_1(int n,int m){
      int sum1 = 0;
      for(int i = 1; i <= 1000;i++){
           sum1 += 1;
      }
     
      int sum2 = 0;
      for (int i = 1; i <= n; i++){
         sum2 += i;
      }
  
      int sum3 = 0;
      for (int i = 1; i <= m; i++){
          sum3 += i;
      }

      return sum1 + sum2 + sum3;
}

第一段for 循环语句时间复杂度为O(1)

第二段for循环语句时间复杂度为O(n)

第三段for循环语句时间复杂度为O(m)

此算法的时间复杂度为O(n + m)

2）乘法法则

private static long sum_3(int n){
     int sum = 0;
     for (int i = 1; i <= n; i++){
             sum += sumSquare(i);
     }
     return sum;
}

private static long sumSquare(int n){
     int res = 0;
     for (int i = 1; i <= n; i++){
             res += (i * i);
     }
     return res;
}

第一段语句时间复杂度为O(n)

第二段语句时间复杂度为O(n)

如果： T1(n) = O(f(n))  T2(n) = O(g(n))   那么：T(n) = T1(n)*T(n) = O(f(n)*O(g(n))) = O(f(n)*g(n))

此算法的时间复杂度为O(n*n)

6、常用时间复杂度的排序

从小到大：O(1) < O(log₂n) < O(nlog₂n) < O(n²⁾ < O(n³⁾ < O(2n) < O(3n) < O(n!) < O(nⁿ⁾

空间复杂度

       空间复杂度(Space Complexity)是对一个算法在运行过程中临时占用存储空间大小的量度。一个算法在计算机存储器上所占用的存储空间包括存储算法本身所占用的存储空间，算法的输入输出数据所占用的存储空间和算法在运行过程中临时占用的存储空间这三个方面。算法的输入输出数据所占用的存储空间是由要解决的问题决定的，是通过参数表由调用函数传递而来的，它不随本算法的不同而改变。存储算法本身所占用的存储空间与算法书写的长短成正比，要压缩这方面的存储空间，就必须编写出较短的算法。

def test(num):
       total = 0
       for i in range(num):
            total += i
       return total

算法中的total = 0此语句占存储空间，且所占的存储空间不变。 所以此算法空间复杂度为O(1)。

另一例

def test(nums):
     array = []
     for num in nums:
           array.append(num)
     return array

算法中的array = [ ]语句占存储空间，且所占的存储空间取决于array中存储的数据的多少所以此算法的空间复杂度为O(n)。

一般情况下常用的空间复杂度为O(1)、O(n)