02、时间、空间复杂度分析（上）

最新推荐文章于 2022-08-23 17:23:46 发布

Handsome-Zan

最新推荐文章于 2022-08-23 17:23:46 发布

阅读量208

点赞数

分类专栏：数据结构与算法文章标签：算法数据结构

本文链接：https://blog.csdn.net/qq_36847713/article/details/107702887

版权

数据结构与算法专栏收录该内容

5 篇文章 0 订阅

订阅专栏

1. 什么是复杂度分析？

复杂度也叫渐进复杂度，包括时间复杂度和空间复杂度。
复杂度描述的是算法执行时间（或占用空间）与数据规模的增长关系。
数据结构和算法本身是让代码运行得更快，让代码更省空间，提升代码执行效率。
因此需从执行时间和占用空间两个维度来评估数据结构和算法的性能。

2. 为什么要进行复杂度分析？

和性能测试相比（依赖测试环境——硬件；受数据规模影响较大），复杂度分析有不依赖执行环境、成本低、效率高、易操作、指导性强的特点。
掌握复杂度分析，将能编写出性能更优的代码，有利于降低系统开发和维护成本。

3. 如何进行复杂度分析？

大 O 复杂度表示法

算法的执行时间与每行代码的执行次数成正比，公式如下：

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

T(n) 表示算法执行总时间

n 表示数据规模的大小

f(n) 表示每行代码执行总次数

时间复杂度

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

由于时间复杂度描述的是算法执行时间与数据规模的增长变化趋势，当 n （数据规模）很大时，你可以把它想象成 10000、100000。而公式中的低阶、常量、系数实际上对这种增长趋势不产生决定性影响，所以可以忽略这些项。

复杂度分析法则

单段代码看高频：比如循环（只关注循环执行次数最多的一段代码）。
多段代码取最大：比如一段代码中有单循环和多重循环，那么取多重循环的复杂度。（加法法则：总复杂度等于量级最大的那段代码的复杂度）
嵌套代码求乘积：比如递归、多重循环等。(乘法法则：嵌套代码的复杂度等于嵌套内外代码复杂度的乘积）
多个规模求加法：比如方法有两个参数控制两个循环的次数，那么这时就取二者复杂度相加。

常用的复杂度量级

多项式量级

随着数据规模的增长，算法的执行时间和空间占用，按照多项式的比例增长。包括：O(1)（常数阶）、O(logn)（对数阶）、O(n)（线性阶）、O(nlogn)（线性对数阶）、O(n^2)（平方阶）、O(n^3)（立方阶）

非多项式量级（NP（Non-Deterministic Polynomial，非确定多项式））

随着数据规模的增长，算法的执行时间和空间占用暴增，这类算法性能极差。包括：O(2^n)（指数阶）、O(n!)（阶乘阶）

时间复杂度分析小栗子：

1. O(1)

O(1) 只是常量级时间复杂度的一种表示方法，并不是指只执行了一行代码。比如这段代码，即便有 3 行，它的时间复杂度也是 O(1），而不是 O(3)。

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

综上所述，只要代码的执行时间不随 n 的增大而增长，这样代码的时间复杂度都记作 O(1)。或者说，一般情况下，只要算法中不存在循环语句、递归语句，即使有成千上万行的代码，其时间复杂度也是Ο(1)。

2. O(logn)、O(nlogn)

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

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

根据复杂度分析方法，第三行代码是循环执行次数最多的。所以，只要能计算出这行代码被执行了多少次，就能知道整段代码的时间复杂度。

从代码中可以看出，变量 i 的值从 1 开始取，每循环一次就乘以 2。当大于 n 时，循环结束。实际上，变量 i 的取值就是一个等比数列。

只要知道 x 值是多少，就知道这行代码执行的次数了。通过 $2^{x} = n$ 求解 x， $X = \log_2{n}$ 。

所以，这段代码的时间复杂度就是 O( $\log_2{n}$ )。

稍微修改代码，辨别时间复杂度？O( $\log_3{n}$ )。

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

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

因为对数之间是可以互相转换的， $\log_3{n}$ 就等于 $\log_3{2} * \log_2{n}$ ，所以 $O(\log_3n) = O(C * \log_2n)$ ，其中 $C = \log_32$ 是一个常量。

基于前面的一个理论：在采用大 O 标记复杂度的时候，可以忽略系数，即 O(Cf(n)) = O(f(n))。所以， $O(\log_2n)$ 就等于 $O(\log_3n)$ 。因此，在对数阶时间复杂度的表示方法里，忽略对数的“底”，统一表示为 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_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 谁的量级大，所以在表示复杂度的时候，就不能简单地利用加法法则，省略掉其中一个。所以，上面代码的时间复杂度就是 O(m+n)。

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

空间复杂度

空间复杂度全称就是渐进空间复杂度（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(n2 )，像 O(logn)、O(nlogn) 这样的对数阶复杂度平时都用不到。而且，空间复杂度分析比时间复杂度分析要简单很多。所以，对于空间复杂度，掌握这些内容已经足够了。