Python数据结构与算法（1.7）——算法分析

Posted 2022-01-14 盼小辉丶

Python数据结构与算法（1.7）——算法分析

• • 0. 学习目标
  • 1. 算法的设计要求
  • • 1.1 算法评价的标准
    • 1.2 算法选择的原则
  • 2. 算法效率分析
  • • 2.1 大 $O$ 表示法
    • 2.2 常见算法复杂度
    • 2.3 复杂度对比
  • 3. 算法的存储空间需求分析
  • 4. Python内置数据结构性能分析
  • • 4.1 列表性能分析
    • 4.2 字典性能分析

0. 学习目标

我们已经知道算法是具有有限步骤的过程，其最终的目的是为了解决问题，而根据我们的经验，同一个问题的解决方法通常并非唯一。这就产生一个有趣的问题：如何对比用于解决同一问题的不同算法？为了以合理的方式提高程序效率，我们应该知道如何准确评估一个算法的性能。
通过本节学习，应掌握以下内容：

• 了解算法分析的重要性
• 能够熟练使用大 $O$ 表示法分析算法的时间复杂度
• 掌握空间复杂度分析方法
• 了解 Python 列表和字典常见操作的时间复杂度

1. 算法的设计要求

算法分析的主要目标是从运行时间和内存空间消耗等方面比较算法。

1.1 算法评价的标准

一个好的算法首先应该是“正确”的，其对于每个输入实例均能终止并给出正确的结果，能够正确解决给定的计算问题。此外，还需要考虑以下方面：

• 高效性：执行算法所需要的时间；
• 低存储量：执行算法所耗费的存储空间，其中主要考虑辅助存储空间；
• 可读性：算法应易于理解，易于编码，易于调试等等。

1.2 算法选择的原则

一个算法同时可以满足存储空间小、运行时间短、其它性能也好是很难做到的，很多情况下，我们不得不对性能进行取舍，在实际选择算法时，我们通常遵循以下原则：

• 若该程序使用次数较少，则力求算法简明易懂；
• 对于反复多次使用的程序，应尽可能选用快速的算法；
• 若待解决的问题数据量极大，机器的存储空间较小，则相应算法主要考虑如何节省空间。

2. 算法效率分析

算法效率分析根据算法执行所需的时间进行分析和比较，这也称为算法的执行时间或运行时间。要衡量算法的执行时间，一个方法就是做基准分析，这是一种事后统计的方法，其使用绝对的时间单位来记录程序计算出结果所消耗的实际时间。在 Python 中，可以使用 time 模块的 time 函数记录程序的开始时间和结束时间，然后计算差值，就可以得到以秒为单位的算法执行时间。
以计算斐波那契数列第 n 项为例(斐波那契数列从第3项开始，每一项都等于前两项之和)，在计算斐波那契数列第 n 项前后调用 time 函数，计算执行时间：

import time

def fibo(n):
    start = time.time()
    a, b = 1, 1
    if n > 2:
        for i in range(n-2):
            a, b = b, a + b
    end = time.time()
    running = end-start
    return b, running

for i in range(5):
    results = fibo(100000)
    print('It takes :.8f seconds to calculate the 10000th item of Fibonacci sequence'.format(results[1]))

代码执行结果如下：

It takes 0.08275080 seconds to calculate the 10000th item of Fibonacci sequence
It takes 0.08277822 seconds to calculate the 10000th item of Fibonacci sequence
It takes 0.08176851 seconds to calculate the 10000th item of Fibonacci sequence
It takes 0.08178067 seconds to calculate the 10000th item of Fibonacci sequence
It takes 0.08081150 seconds to calculate the 10000th item of Fibonacci sequence

但是这种方法计算的是执行算法的实际时间，有两个明显的缺陷：1) 必须先运行依据算法编制的程序；2) 依赖于特定的计算机、编译器与编程语言等软硬件环境，容易掩盖算法本身的优劣。因此，我们希望找到一个独立于程序或计算机的指标，以用来比较不同实现下的算法。

2.1 大 $O$ 表示法

为了摆脱与计算机硬件、软件有关的因素，我们需要一种事前分析估算的方法。可以认为特定算法的“运行工作量”大小取决于问题的规模，或者说，它是问题规模的函数，这时我们就需要量化算法的操作或步骤。一个算法是由控制结构和基本操作构成的，因此可以将算法的执行时间描述成解决问题所需重复执行的基本操作数。需要注意的是，确定合适的基本操作取决于不同的算法。例如在计算斐波那契数列第 n 项时，赋值语句就是一个基本操作，而在计算矩阵乘法时，乘法运算则是其基本操作。
在上一节的 fibo 函数中，整个算法的执行时间与基本操作(赋值)重复执行的次数n 成正比，具体而言是 1 加上 n-2 个赋值语句，如果使用将其定义为函数可以表示为 $T(n)=n-1$，其中 $n$ 为大于 2 的正整数。$n$ 常用于表示问题规模，我们可以使用问题规模 $n$ 的某个函数 $f(n)$ 表示算法中基本操作重复执行的次数，算法的时间量度可以表示如下：
$$T(n)=O(f(n))$$
随问题规模 $n$ 的增大，$T(n)$ 函数的某一部分会比其余部分增长得更快，算法间进行比较时这一起部分起决定性作用，$T(n)$ 增长最快的部分也称为数量级函数。算法执行时间的增长率和 $f(n)$ 的增长率相同，称作算法的渐近时间复杂度 (asymptotic time complexity)，简称时间复杂度。数量级 (order of magnitude) 常被称作大 $O$ 记法或大 $O$ 表示法。
通过以上分析，我们可以将算法的渐近复杂度规则描述如下：

• 如果运行时间是一个多项式的和，那么仅保留增长速度最快的项，去掉其他各项；
• 如果剩下的项是个乘积，那么去掉所有常数。

假设某一算法的基本步骤数为 $T(n)=3n^2+50n+2000$，当 $n$ 很小时 2000 对于函数的影响最大，但是随着 $n$ 的增长 $n^2$ 将逐渐变得更重要，以至于可以忽略其他两项以及 $n^2$ 的系数 3，因此可以说 $T(n)$ 的数量级是 $n^2$ 或写为 $O(n2)$。
算法的性能有时不仅依赖问题的规模，还取决于算法的输入值，输入令算法运行最慢的情况称为最坏情况，输入令算法运行最快的情况称为最好情况，随机输入的情况下算法的性能介于两种极端情况之间，称为平均情况。

2.2 常见算法复杂度

下表列出了一些常见的大 $O$ 表示法实例：

复杂度	解释	示例
$O(1)$	常数复杂度	100, 500, 1, 30, …
$O(logn)$	对数复杂度	$lo{g}_{2}n$, $lo{g}_{10}n$, $2lo{g}_{2}n$, …
$O(n)$	线性复杂度	$8n+10$, $n$, $100n$, …
$O(nlogn)$	对数线性复杂度	$10nlogn+50$, $5nlogn+30n$, …
$O(n^k)$	多项式复杂度，其中 $k$ 为常数	$4n^2-10n$, $2n^3+10n^2$, $4n^2+5nlogn$, …
$O(c^n)$	指数复杂度，其中 $c$ 为常数	$2^n+5n^2$, $4^n+10nlogn$, …

2.2.1 常数复杂度

常数复杂度表示，算法的渐进复杂度域输入的规模无关，例如求列表的长度等都属于常数复杂度。常数复杂度和代码中是否包含循环没有必然关系，例如循环打印 100 次 “Hello world”，这与输入规模并没有什么关系，因此其也是属于常数复杂度。

2.2.2 对数复杂度

对数复杂度表示函数的增长速度至少是输入规模的对数，当我们谈论对数复杂度时，我们并不关系对数的底数，这是由于可以使用换底公式，将原来底数的对数乘以一个常数转换为另一个底数：
$$lo{g}_{a}n=lo{g}_{a}b\ast lo{g}_{b}n$$
其中，$a$ 和 $b$ 均为常数。例如以下代码，将一个正整数转换为字符串：

def int_to_str(num):
    digits = "0123456789"
    result = ''
    if num == 0:
        result = '0'
    else:
        while num > 0:
            result = digits[num % 10] + result
            num = num // 10
    return result

上述代码中只包括一个循环，且没有调用其它函数，因此我们只需找出循环迭代次数——在 num 为 0 之前所需的整数除法的次数 $lo{g}_{10}n$。因此函数 int_to_str 的复杂度是 $O(logn)$。

2.2.3 线性复杂度

线性复杂度在列表中等序列数据类型总十分常见，因为算法通常需要遍历处理序列中的每一个元素。例如将列表中的每个元素加上常数 10：

def add_constant(list_o):
    for i in range(len(list_o)):
        list_o[i] += 10

这个函数的复杂度就与列表的长度成线性关系，也就是 $O(n)$。

2.2.4 线性对数复杂度

线性对数复杂度是两项的乘积，每个项都依赖于输入的规模，例如将列表中每一项正整数转换为字符串。很多实用算法的复杂度都是对数线性的。

2.2.5 多项式复杂度

多项式复杂度的增长速度是输入规模的 $k$ 次幂，其中最常见的是平方复杂度，例如求列表 list_a 和 list_b 的交集：

def intersect(list_a, list_b):
    # 第一部分
    temp = []
    for i in list_a:
        for j in list_b:
            if i == j:
                temp.append(i)
                break
    # 第二部分
    result = []
    for i in temp:
        if i not in result:
            result.append(i)
    return result

intersect 函数第一部分的复杂度显然是 $O(len(list\_a))\ast O(len(list\_b))$，第二部分代码用于去除第一部分得到结果列表中

以上是关于Python数据结构与算法（1.7）——算法分析的主要内容，如果未能解决你的问题，请参考以下文章

JVM(二) GC算法与分代回收策略

数据结构与算法(Python)-一般概念和算法效率分析

python数据分析与挖掘学习笔记-公司客户价值判断分析与聚类算法

python数据分析与挖掘学习笔记-电商网站数据分析及商品自动推荐实战与关联规则算法

python数据分析与挖掘学习笔记-电商网站数据分析及商品自动推荐实战与关联规则算法

分类与监督学习，朴素贝叶斯分类算法