算法的时间复杂度和空间复杂度

一、大O表示法

int cal(int n) {
   int sum = 0;
   int i = 1;
   int j = 1;
   for (; i <= n; ++i) {
     j = 1;
     for (; j <= n; ++j) {
       sum = sum +  i * j;
     }
   }
 }

我们分析上面程序的时间是T(n)=(2n²+2n+3)*unit_time,unit_time表示每一行代码执行的时间
所有代码的执行时间和每行代码的执行次数成正比，那么我们就可以用如下的公式来表示：

  T(n)=O(f(n))

T(n)表示代码执行的时间，f(n)表示每行代码执行的次数总和，大O表示代码的执行时间和执行次数成的正比关系，所以上例的时间T(n)=O(2n²+2n+3)，这就是大O时间复杂度表示，大O实际表达的是代码执行时间随数据增加的趋势，也叫作渐进时间复杂度（asymptotic time complexity），简称时间复杂度。

二、时间复杂度分析

1.只关注循环执行最多的一段代码

 int cal(int n) {
   int sum = 0;
   int i = 1;
   for (; i <= n; ++i) {
     sum = sum + i;
   }
   return sum;
 }

上述代码，我们只需关注循环的代码，所以时间复杂度是O(n)

2.加法规则：总复杂度等于量级最大的那段代码的复杂度

int cal(int n) {
   int sum_1 = 0;
   int p = 1;
   for (; p < 100; ++p) {
     sum_1 = sum_1 + p;
   }

   int sum_2 = 0;
   int q = 1;
   for (; q < n; ++q) {
     sum_2 = sum_2 + q;
   }
 
   int sum_3 = 0;
   int i = 1;
   int j = 1;
   for (; i <= n; ++i) {
     j = 1; 
     for (; j <= n; ++j) {
       sum_3 = sum_3 +  i * j;
     }
   }
 
   return sum_1 + sum_2 + sum_3;
 }

第一个循环因为只有100次，所以时间复杂度是O(1),第二个时间复杂度是O(n)，第三个时间复杂度是O(n²)，所以整个代码的时间复杂度去最大量级的就是O(n²)

3.乘法法则：嵌套代码的时间复杂度等于嵌套内外代码的复杂度的乘积

int cal(int n) {
   int ret = 0; 
   int i = 1;
   for (; i < n; ++i) {
     ret = ret + f(i);
   } 
 } 
 
 int f(int n) {
  int sum = 0;
  int i = 1;
  for (; i < n; ++i) {
    sum = sum + i;
  } 
  return sum;
 }

单独看cal(n)函数中循环的时间复杂度是T1(n)=O(n),但是循环内部嵌套了个f(n)函数，f(n)的时间复杂度是T2(n)=O(n)，所以总的时间复杂度是T(n)=T1(n)*T2(n)=O(n)*O(n)=O(n²)

三、常见的时间复杂度分析

常量:O(1)
线性:O(n)
对数:O(Logn)
线性对数:O(nLogⁿ)
k次方阶:O(n²),O(n³)…O
指数阶:O(2ⁿ)
阶乘:n!

1.分析一下O(Logⁿ)和O(nLogⁿ)

 i=1;
 while (i <= n)  {
   i = i * 2;
 }

分析上述代码的循环执行多少次，就可以知道此代码的执行时间复杂度
i的取值如下:

2º,2¹,2²,....n

可以知道时间复杂度是O(logn)

2.O(m+n),O(m*n)时间复杂度由两个数据的规模来决定

int cal(int m, int n) {
  int sum_1 = 0;
  int i = 1;
  for (; i < m; ++i) {
    sum_1 = sum_1 + i;
  }

  int sum_2 = 0;
  int j = 1;
  for (; j < n; ++j) {
    sum_2 = sum_2 + j;
  }

  return sum_1 + sum_2;
}

上述代码，事先无法评判m还是n大，所以时间复杂度是O(m+n)

四、最好、最坏、平均时间复杂度

// n表示数组array的长度
int find(int[] array, int n, int x) {
  int i = 0;
  int pos = -1;
  for (; i < n; ++i) {
    if (array[i] == x) {
       pos = i;
       break;
    }
  }
  return pos;
}

上述代码，从一个数组中查找变量x,如果x在第一个位置，那么时间复杂度就是O(1),如果x在最后一个位置，那么时间复杂度就是O(n)，每种情况下的时间复杂度是不同的

1、最好时间复杂度

在最理想的情况下执行这段代码的时间
上述代码的最好时间复杂度是O(1)

2、最坏情况时间复杂度

在最糟糕的情况下，执行这段代码的时间复杂度
上述代码的最坏时间复杂度是O(n)

3、平均时间复杂度

上述变量x要么在数组中，要么不在数组中，在数组中的概率是1/2，不在数组中的概率也是1/2，如果在数组中，那么在0~n-1位置之间的概率是1/n，考虑每种情况的概率，那么平均时间复杂度如下:

4.均摊时间复杂度

这段代码的平均时间复杂度就是O(n)

五、空间复杂度

空间复杂度表示的算法占用的存储空间与数据规模之间的增长关系

void print(int n) {
  int i = 0;
  int[] a = new int[n];
  for (i; i <n; ++i) {
    a[i] = i * i;
  }

  for (i = n-1; i >= 0; --i) {
    print out a[i]
  }
}

上述代码的空间复杂度就是O(n)
常见的空间复杂度有O(1),O(n),O(n²)…