---

一、算法的时间复杂度

1.1 度量算法执行时间的两种方法

1.1.1 事后统计

直接运行一遍程序，记录程序运行的用时

这种方法可行, 但是有两个问题:

• 一是要想对设计的算法的运行性能进行评测, 需要实际运行该程序;
• 二是所得时间的统计量依赖于计算机的硬件、软件等环境因素, 这种方式, 要在同一台计算机的相同状态下运行, 才能比较哪个算法速度更快。

1.1.2 事前估算

通过分析某个算法的时间复杂度来判断哪个算法更优

1.2 时间频度

1.2.1 基本介绍

时间频度: 一个算法花费的时间与算法中语句的执行次数成正比例, 哪个算法中语句执行次数多, 它花费时间就多。一个算法中的语句执行次数称为语句频度或时间频度。记为 $\mathrm{T}(\mathrm{n})$ 。

1.2.2 举例说明：基本案例

比如计算1-100所有数字之和，我们设计两种算法

第一种算法：T(n) = n + 1

        int total = 0;
        int end = 100;
        for (int i = 1; i <= end; i++) {
            total += i;
        }

第二种算法：T(n) = 1

        int end = 100;
        // 等差数列求和公式
        int total = (1 + end) * end / 2;

1.2.3 举例说明：忽略常数项

结论

• $2\mathrm{n}+20$ 和 $2\mathrm{n}$ 随着 $\mathrm{n}$ 变大, 执行曲线无限接近, 20 可以忽略
• $3\mathrm{n}+10$ 和 $3\mathrm{n}$ 随着 $\mathrm{n}$ 变大, 执行曲线无限接近, 10 可以忽略

1.2.4 举例说明：忽略低次项

结论

• $2n^2+3n+10$ 和 $2n^2$ 随着 $n$ 变大, 执行曲线无限接近, 可以忽略 $3n+10$
• $n^2+5n+20$ 和 $n^2$ 随着 $\mathrm{n}$ 变大,执行曲线无限接近, 可以忽略 $5\mathrm{n}+20$

1.2.5 举例说明：忽略系数

结论

• 随着 $\mathrm{n}$ 值变大, $5n^2+7n$ 和 $3n^2+2n$, 执行曲线重合, 说明这种情况下, 5 和 3 可以忽略。
• 而 $n^3+5n$ 和 $6n^3+4n$, 执行曲线分离, 说明多少次方是关键

1.3 时间复杂度

1. 一般情况下, 算法中的基本操作语句的重复执行次数是问题规模 $\mathbf{n}$ 的某个函数, 用 $\mathrm{T}(\mathrm{n})$ 表示, 若有某个辅 助函数 $\mathrm{f}(\mathrm{n})$, 使得当 $\mathrm{n}$ 趋近于无穷大时, $\mathrm{T}(\mathrm{n})/\mathrm{f}(\mathrm{n})$ 的极限值为不等于零的常数, 则称 $\mathrm{f}(\mathrm{n})$ 是 $\mathrm{T}(\mathrm{n})$ 的同数量级函数。 记作 $T(n)=O(f(n))$, 称 $O(f(n))$ 为算法的渐进时间复杂度, 简称时间复杂度

2. $T(n)$ 不同, 但时间复杂度可能相同。如: $T(n)=n^2+7n+6$ 与 $T(n)=3n^2+2n+2$ 它们的 $T(n)$ 不同, 但时间复杂度相同, 都为 $\mathbf{O}\left({\mathbf{n}}^2\right)$

3. 计算时间复杂度的方法：

• 用常数 1 代替运行时间中的所有加法常数 $T(n)=n^2+7n+6\Rightarrow T(n)=n^2+7n+1$
• 修改后的运行次数函数中, 只保留最高阶项 $\mathrm{T}(\mathrm{n})={\mathrm{n}}^2+7\mathrm{n}+1\Rightarrow \mathrm{T}(\mathrm{n})={\mathrm{n}}^2$
• 去除最高阶项的系数 $\mathrm{T}(\mathrm{n})={\mathrm{n}}^2\Rightarrow \mathrm{T}(\mathrm{n})={\mathrm{n}}^2\Rightarrow \mathrm{O}\left({\mathrm{n}}^2\right)$

1.4 常见的时间复杂度

• 常数阶 $O(1)$
• 对数阶 $\mathrm{O}(\log 2\mathrm{n})$
• 线性阶 $\mathrm{O}(\mathrm{n})$
• 线性对数阶 $\mathrm{O}(n\log 2\mathrm{n})$
• 平方阶 $\mathrm{O}\left({\mathrm{n}}^{\wedge }2\right)$
• 立方阶 $\mathrm{O}\left({\mathrm{n}}^{\wedge }3\right)$
• $\mathrm{k}$ 矢阶 $\mathrm{O}\left({\mathrm{n}}^{\wedge }\mathrm{k}\right)$
• 指数阶 $\mathrm{O}\left(2^{\wedge }n\right)$

常见的时间复杂度对应的图

说明

• 常见的算法时间复杂度由小到大依次为: $O(1)<O(\log 2n)<O(n)<O(n\log 2n)<O(n^2)<O(n^3)<O(n^k)<$ $O(2^n)$, 随着问题规模 $\mathrm{n}$ 的不断增大, 上述时间复杂度不断增大, 算法的执行效率越低
• 从图中可见, 我们应该尽可能避免使用指数阶的算法

1.4.1 常数阶 $O(1)$

无论代码执行了多少行，只要没有循环等复杂结构，那这个代码的时间复杂度就是 $O(1)$

        int i = 1;
        int j = 2;
        int k = j - i;
        ++k;
        j++;
        i += 1;

上述代码在执行的时侯, 它消耗的时候并不随着某个变量的增长而增长, 那么无论这类代码有多长, 即使有几万、几十万行, 都可以用 O(1) 来表示它的时间复杂度。

1.4.2 对数阶 $O(\log 2n)$

在while循环里面, 每次都将 $\mathrm{i}$ 乘以 2 , 乘完之后, $\mathrm{i}$ 距离 $\mathrm{n}$ 就越来越近了。
假设循环 $x$ 次之后, $i$ 就大于 2 了, 此时这个循环就退出了, 也就是说 2 的 $x$ 次方等于 $n$, 那么 $x=$ ${\log }_{2}n$ 也就是说当循环 ${\log }_{2}n$ 次以后, 这个代码就结束了。
因此这个代码的时间复杂度为: $\mathrm{O}\left({\log }_{2}n\right)$ 。
$\mathrm{O}\left({\log }_{2}n\right)$ 的这个 2 时间上是根据代码变化的, 假设是 $\mathrm{i}=\mathrm{i}\ast 3$, 则是 $\mathrm{O}\left({\log }_{3}n\right)$.

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

1.4.3 线性阶 $O(n)$

说明: 这段代码, for循环里面的代码会执行 $n$ 遍, 因此它消耗的时间是随着 $n$ 的变化而变 化的, 因此这类代码都可以用 $O(n)$ 来表示它的时间复杂度。当然，前提条件是for循环里的代码是 O(1) 的

        for (int i = 0; i < n; i++) {
            // some O(1) code ...
        }

1.4.4 线性对数阶 $O(n\log 2n)$

线性对数阶就很好理解了，就是将时间复杂度为 $O(\log 2n)$的代码循环执行 n 次

    for (int i = 0; i < n; i++) {
        
        int k = 1;
        while (k < n) {
            k = k * 2;
        }
        
    }

1.4.5 平方阶 $O(n^2)$

2层for循环，最内层是O(1)的代码

        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                // some O(1) code ...
            }
        }

1.4.6 立方阶 $O(n^3)$

3层for循环，最内层是O(1)的代码

        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                for (int k = 0; k < n; k++) {
                    // some O(1) code ...
                }
            }
        }

1.4.7 $k$ 次方阶 $O(n^k)$

$k$ 层for循环，最内层是O(1)的代码

        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                for (int k = 0; k < n; k++) {
                    for (int l = 0; l < n; l++) {
                        for (int m = 0; m < n; m++) {
                            ......
                        }
                    }
                }
            }
        }

1.5 平均时间复杂度和最坏时间复杂度

• 平均时间复杂度是指所有可能的输入实例均以等概率出现的情况下, 该算法的运行时间。
• 最坏情况下的时间复杂度称最坏时间复杂度。一般讨论的时间复杂度均是最坏情况下的时间复杂度。这样做的 原因是: 最坏情况下的时间复杂度是算法在任何输入实例上运行时间的界限, 这就保证了算法的运行时间不会 比最坏情况更长。
• 平均时间复杂度和最坏时间复杂度是否一致, 和算法有关(如下图所示)。

---

二、算法的空间复杂度

2.1 基本介绍

• 类似于时间复杂度的讨论, 一个算法的空间复杂度(Space Complexity)定义为该算法所耗费的存储空间, 它也是 问题规模 $\mathrm{n}$ 的函数。
• 空间复杂度(Space Complexity)是对一个算法在运行过程中临时占用存储空间大小的量度。有的算法需要占用的 临时工作单元数与解决问题的规模 $\mathrm{n}$ 有关, 它随着 $\mathrm{n}$ 的增大而增大, 当 $\mathrm{n}$ 较大时, 将占用较多的存储单元, 例 如快速排序和归并排序算法, 基数排序就属于这种情况
• 在做算法分析时, 主要讨论的是时间复杂度。从用户使用体验上看, 更看重的程序执行的速度。一些缓存产品 (redis, memcache)和算法(基数排序)本质就是用空间换时间.