算法学习笔记1（复杂度分析）

如何分析、统计算法的执行效率和资源消耗：

一个概念：复杂度分析

两个指标：时间复杂度，空间复杂度

一个表示法：大O复杂度表示法

三大实用法则

 

一：大O复杂度举例说明

 

第一步：概念解释

1 int cal(int n) { 
2    int sum = 0;   
3    int i = 1; 
4    for (; i <= n; ++i) { 
5        sum = sum + i; 
6    } 
7    return sum; 
8}

如何计算该该处代码的运行时间，假设每一行执行的时间为time

则   第二行1time，第三行1time，四五行都执行了n遍则2n*time,一共执行时间为(2n+2)*time.

结论：所有代码的执行时间 T(n) 与每行代码的执行次数成正比

再来看一个例子：

 1 int cal(int n) {
 2  int sum = 0;
 3  int i = 1;
 4  int j = 1;
 5  for (; i <= n; ++i) {
 6    j = 1;
 7    for (; j <= n; ++j) {
 8      sum = sum +  i * j;
 9    }
 10  }
 11}

结论：同上理可得整段代码的执行时间：T(n) = (2n2+2n+3)*time；

 

通过以上两个例子我们可以得出：所有代码的执行时间 T(n) 与每行代码的执行次数 n 成正比。

总结出来一个公式就是：

T(n) 表示代码执行的时间；n 表示数据规模的大小；f(n) 表示每行代码执行的次数总和。因为这是一个公式，所以用 f(n) 来表示。公式中的 O，表示代码的执行时间 T(n) 与 f(n) 表达式成正比。

最后，这就是大 O 时间复杂度表示法。大 O 时间复杂度实际上并不具体表示代码真正的执行时间，而是表示代码执行时间随数据规模增长的变化趋势，所以，也叫作渐进时间复杂度（asymptotic time complexity），简称时间复杂度。

注：当 n 很大时，你可以把它想象成 10000、100000。而公式中的低阶、常量、系数三部分并不左右增长趋势，所以都可以忽略。我们只需要记录一个最大量级就可以了，如果用大 O 表示法表示刚讲的那两段代码的时间复杂度，就可以记为：T(n) = O(n)； T(n) = O(n2)。

 

二：三大法则

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

由于大 O 这种复杂度表示方法只是表示一种变化趋势。我们通常会忽略掉公式中的常量、低阶、系数，只需要记录一个最大阶的量级就可以了。我们在分析一个算法、一段代码的时间复杂度的时候，也只关注循环执行次数最多的那一段代码就可以了

例如我们上面的例子1：

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

可以忽略2，3行代码，只考虑执行次数最多的4，5行，复杂度为O(n)

 

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

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;
 }

可以看出三个地方的主要复杂度为：sum_1由于是常量级的计算，与n无关，所以复杂度为O(1)，sum_2显而易见的为O(n)，sum_3为O(n的平方)。

最终复杂度计算为总的时间复杂度就等于量级最大的那段代码的时间复杂，即O(n的平方)

法则三：乘法法则：嵌套代码的复杂度等于嵌套内外代码复杂度的乘积

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()和f()的复杂度为O(n)，但是由于在实际应用中cal()函数中调用了f()，所以整个cal()的时间复杂度为O(n*n)即O(n的平方)。

 

补充：

常见的几种时间复杂度实例分析：

对于刚罗列的复杂度量级，我们可以粗略地分为两类，多项式量级和非多项式量级。其中，非多项式量级只有两个：O(2n) 和 O(n!)。

我们把时间复杂度为非多项式量级的算法问题叫作 NP（Non-Deterministic Polynomial，非确定多项式）问题。

 

主要的多项式时间复杂度的分析：

1：O(1)

 int i = 8;
 int j = 6;
 int sum = i + j;

一般情况下，只要算法中不存在循环语句、递归语句，即使有成千上万行的代码，其时间复杂度也是Ο(1)。

 

2:O(logn)、O(nlogn)

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

从代码中可以看出，变量 i 的值从 1 开始取，每循环一次就乘以 2。当大于 n 时，循环结束,实际上，变量 i 的取值就是一个等比数列。如果我把它一个一个列出来，就应该是这个样子的：

所以，我们只要知道 x 值是多少，就知道这行代码执行的次数了。通过 2x=n 求解 x 这个问题我们想高中应该就学过了，我就不多说了。x=log2n，所以，这段代码的时间复

杂度就是 O(log2n)。

如果把代码稍微改成这样

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

这段代码的时间复杂度为 O(log3n)。

实际上，不管是以 2 为底、以 3 为底，还是以 10 为底，我们可以把所有对数阶的时间复杂度都记为 O(logn)。为什么呢？我们知道，对数之间是可以互相转换的，log3n 就等于 log32 * log2n，所以 O(log3n) = O(C * log2n)，其中 C=log32 是一个常量。基于我们前面的一个理论：在采用大 O 标记复杂度的时候，可以忽略系数，即 O(Cf(n)) = O(f(n))。所以，O(log2n) 就等于 O(log3n)。因此，在对数阶时间复杂度的表示方法里，我们忽略对数的“底”，统一表示为 O(logn)。

如果一段代码的时间复杂度是 O(logn)，我们循环执行 n 遍，时间复杂度就是 O(nlogn) 了。而且，O(nlogn) 也是一种非常常见的算法时间复杂度。比如，归并排序、快速排序的时间复杂度都是 O(nlogn)。

 

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的量级无法判断量级，就不能简单地利用加法法则，省略掉其中一个。所以，上面代码的时间复杂度就是 O(m+n)。

空间复杂度分析：

空间复杂度全称就是渐进空间复杂度（asymptotic space complexity），表示算法的存储空间与数据规模之间的增长关系。