数据结构与算法之美_lesson2_复杂度分析

为什么需要复杂度分析？
 

1、事后统计法的局限性：

（1）测试结果非常依赖测试环境；

（2）测试结果受数据规模的影响很大；

我们需要一个不用具体的测试数据来测试，就可以粗略地估计算法的执行效率的方法。这就是时间、空间复杂度分析方法。

2、大 O 复杂度表示法

算法的执行效率，粗略地讲，就是算法代码执行的时间。

从CPU的角度来看，代码的每一行都执行着类似的操作：读数据-运算-写数据。

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

T(n) = O(f(n)) -- 大 O 时间复杂度表示法

大 O 时间复杂度实际上并不具体表示代码真正的执行时间，而是表示代码执行时间随着数据规模增长的变化趋势，所以，也叫做 渐进时间复杂度，简称 时间复杂度。

3、时间复杂度分析

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

我们在分析一个算法、一段代码的时间复杂度的时候，也只关注循环执行次数最多的那一段代码就可以了。

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

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

落实到具体的代码上，我们可以把乘法原则看成是嵌套循环。

复杂度量级（按数量级递增）

• 常量阶 O(1)
• 对数阶 O(logn)
• 线性阶 O(n)
• 线性对数阶 O(nlogn)
• 平方阶 O()、立方阶 O() ... k次方阶 O()
• 指数阶 O()
• 阶乘阶 O(n!)

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

当数据规模越来越大，非多项式量级算法的执行时间会急剧增加，求解问题的执行时间会无限增长。所以，非多项式时间复杂度的算法其实是非常低效的算法。因此关于NP时间复杂度就不再展开。我们主要来看几种常见的多项式时间复杂度

1，O(1)

O(1)只是常量级时间复杂度的一种表示方法，并不是指只执行了一行代码。

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

2，O(logn)、O(nlogn)

对数阶时间复杂度非常常见，同时也是最难分析的一种时间复杂度。

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

变量 i 的取值是一个等比数列。       ...   ...   = n  通过  = n 求解 x 。  x =  , 所以，这段代码的时间复杂度就是 O()。

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

根据之前的思路，这段代码的时间复杂度为 O()。

实际上，不管是以 2 为底、以 3 为底、还是以 10 为底，我们可以把所有对数阶的时间复杂度都记为 O(logn)，为什么呢？

我们知道，对数之间是可以相互转换的， 就等于  * ， 所以 O() = O(C*) ，其中 C =  是一个常量。基于我们前面的一个理论：在采用大 O 标记复杂度的时候，可以忽略系数，即 O(Cf(n))= O(f(n))。所以，O()就等于O()。因此，在对数阶时间复杂度的表示方法里，我们忽略对数的“底”，统一表示为O(logn)。

如果理解了前面的 O(logn)，那 O(nlogn) 就很容易理解了。根据乘法原则，如果一段代码的时间复杂度是 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_i + 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 谁的量级大，所以我们在表示复杂度的时候，就不能简单地利用加法法则，省略掉其中一个。所以，上面代码的时间复杂度就是 O(m+n)。

针对这种情况，原来的加法原则就不正确了，我们需要将加法规则改为：T1(m) + T2(n) = O(f(m) + g(n))。但是乘法法则继续有效：T1(m)*T2(n) = O(f(m)*g(n))。

4、空间复杂度分析

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

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

跟时间复杂度分析一样，我们可以看到，第 2 行代码中，我们申请了一个空间存储变量 i，但是它是常量阶的，跟数据规模 n 没关系，所以我们可以忽略。第 3 行申请了一个大小为 n 的 int 类型数组，除此之外，剩下的代码都没有占有更多的空间，所以整段代码的空间复杂度就是 O(n)。

我们常见的空间复杂度就是 O(1)、O(n)、O(), 像 O(logn)、O(nlogn) 这样的对数阶复杂度平时都用不到。而且，空间复杂度分析比时间复杂度分析要简单很多。

5、内容小结

复杂度也叫渐进复杂度，包括时间复杂度和空间复杂度，用来分析算法执行效率与数据规模之间的增长关系，可以粗略地表示，越高阶复杂度的算法，执行效率越低。常见的复杂度并不多，从低阶到高阶有：O(1)、O(logn)、O(n)、O(nlogn)、O()。