时间复杂度（一）

分析复杂度三个方法：

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

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

unit_time为一行代码执行时间
T(n) = (2 + 2n) * unit_time
f(n)为每行代码执行的次数总和
T(n) = O( f(n) ) = O(2 + 2n)
由于公式中的低阶、常量、系数三部分并不左右增长趋势，所以都可以忽略。
T(n) = 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;
 }

这段代码分为3部分，分别为求sum_1、sum_2、sum_3，其中sum_1执行次数为100次由于是常量即使是100000次都与n无关，当n无限大时就可以忽略。第二段和第三段代码时间复杂度分别为O(n)和O(n²)。综合这三部分的时间复杂度，选取最大量级因此这段代码的时间复杂度为为O(n²)。
总结：总的时间复杂度就等于量级最大的那段代码的时间复杂度。抽象为公式：
如果 T1(n)=O(f(n))，T2(n)=O(g(n)) 那么 T(n)=T1(n)+T2(n)=max(O(f(n)),O(g(n)))=O(max(f(n), g(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;
 }

类比加法公式可得乘法公式为：
如果 T1(n)=O(f(n))，T2(n)=O(g(n));那么 T(n)=T1(n)T2(n)=O(f(n))O(g(n))=O(f(n)*g(n))

单独看cal()，假设f()为普通操作，那么T1(n)=O(n)。但f()的时间复杂度为T2(n)=O(n),所以整个cal()的时间复杂度为
T(n)=T1(n)T2(n)=O(nn)=O(n²)

常见时间复杂度：

复杂度量级可分为多项式量级和非多项式量级。上表中仅指数阶和阶乘阶为非多项量级，随着n变大，非多项式量级算法执行时间会急剧增加，因此非多项式时间复杂度算法是非常低效的算法。

1. O(1)

只要代码的执行时间不随n的增大而增大，这样代码的时间复杂度都记为O(1)。一般情况下，只要算法中不存在循环语句、递归语句，无论有多少代码时间复杂度都为O(1)

2. O(logn)、O(nlogn)

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

每一次循环i的值乘以2，因此i的取值为等比数列，如下图：

求得x即为代码执行次数，求得,时间复杂度为

另：无论以几为底,都可以把对数阶的时间复杂度写为记为。如,可得:

由于前者为常量系数因此在计算时间复杂度时可以忽略。因此在时间复杂度中我们忽略对数底，统一表示为。利用上文讲述的乘法法则，当循环n次执行的代码时，时间复杂度即为。归并排序，快速排序时间复杂度都为。

3. 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，因此无法判断m与n的量级谁更大，不能进行省略，因此上文中的加法原则在此处并不适用，上述代码的时间复杂度为。
在这种情况下，原先加法法则不正确，我们需要修改加法法则为：
乘法法则仍然有效为：