空间复杂度

程序员Lip
199 阅读5分钟

  空间复杂度

空间复杂度（space complexity）用于衡量算法占用内存空间随着数据量变大时的增长趋势。这个概念与时间复杂度非常类似，只需将“运行时间”替换为“占用内存空间”。

2.4.1   算法相关空间

算法在运行过程中使用的内存空间主要包括以下几种。

  • 输入空间：用于存储算法的输入数据。
  • 暂存空间：用于存储算法在运行过程中的变量、对象、函数上下文等数据。
  • 输出空间：用于存储算法的输出数据。

一般情况下，空间复杂度的统计范围是“暂存空间”加上“输出空间”。

暂存空间可以进一步划分为三个部分。

  • 暂存数据：用于保存算法运行过程中的各种常量、变量、对象等。
  • 栈帧空间：用于保存调用函数的上下文数据。系统在每次调用函数时都会在栈顶部创建一个栈帧，函数返回后，栈帧空间会被释放。
  • 指令空间：用于保存编译后的程序指令，在实际统计中通常忽略不计。

在分析一段程序的空间复杂度时，我们通常统计暂存数据、栈帧空间和输出数据三部分，如图 所示。

4.png

推算方法

空间复杂度的推算方法与时间复杂度大致相同，只需将统计对象从“操作数量”转为“使用空间大小”。

而与时间复杂度不同的是，我们通常只关注最差空间复杂度。这是因为内存空间是一项硬性要求，我们必须确保在所有输入数据下都有足够的内存空间预留。

观察以下代码，最差空间复杂度中的“最差”有两层含义。

  1. 以最差输入数据为准：当 n<10 时，空间复杂度为 O(1) ；但当 n>10 时，初始化的数组 nums 占用 O(n) 空间，因此最差空间复杂度为 O(n) 。
  2. 以算法运行中的峰值内存为准：例如，程序在执行最后一行之前，占用 O(1) 空间；当初始化数组 nums 时，程序占用 O(n) 空间，因此最差空间复杂度为 O(n) 。
def algorithm(n: int):
    a = 0               # O(1)
    b = [0] * 10000     # O(1)
    if n > 10:
        nums = [0] * n  # O(n)

在递归函数中，需要注意统计栈帧空间。观察以下代码：

def function() -> int:
    # 执行某些操作
    return 0

def loop(n: int):
    """循环的空间复杂度为 O(1)"""
    for _ in range(n):
        function()

def recur(n: int):
    """递归的空间复杂度为 O(n)"""
    if n == 1:
        return
    return recur(n - 1)

函数 loop() 和 recur() 的时间复杂度都为 O(n) ，但空间复杂度不同。

  • 函数 loop() 在循环中调用了 n 次 function() ，每轮中的 function() 都返回并释放了栈帧空间，因此空间复杂度仍为 O(1) 。
  • 递归函数 recur() 在运行过程中会同时存在 n 个未返回的 recur() ，从而占用 O(n) 的栈帧空间。

常用的空间复杂度有 O(1)、O(n)、O(n²)

O(1)

只要不会因为算法里的执行，导致额外的空间增长，就算是一万行，空间复杂度也是 O(1)，比如下面这样，时间复杂度也是 O(1) 常数阶常见于数量与输入数据大小 n 无关的常量、变量、对象。

需要注意的是，在循环中初始化变量或调用函数而占用的内存，在进入下一循环后就会被释放，因此不会累积占用空间，空间复杂度仍为 O(1) ：

def foo():
print("开始吃糖")
print("我吃了1颗糖")
print("我吃了2颗糖")
print("我吃了3颗糖")
print("我吃了4颗糖")
# ... 这里需要手动写出所有的print语句直到10000
print("我吃了10000颗糖")

O(n)

线性阶常见于元素数量与 n 成正比的数组、链表、栈、队列等：

比如下面这样，n 的数值越大，算法需要分配的空间就需要越多，来存储数组里的值，所以它的空间复杂度就是 O(n)，时间复杂度也是 O(n)

def foo(n):
    arr = [0] * n  # 创建一个初始值为0的列表，长度为n
    for i in range(1, n):
        arr[i] = i

O(n²)

平方阶常见于矩阵和图，元素数量与 n 成平方关系O(n²) ，这种空间复杂度一般出现在比如二维数组，或是矩阵的情况下

不用说，你肯定明白是啥情况啦

就是遍历生成类似这样格式的

arr = [
    [1, 2, 3, 4, 5],
    [1, 2, 3, 4, 5],
    [1, 2, 3, 4, 5]
]

指数阶 O(2n)

指数阶常见于二叉树。观察图 ，层数为 n 的“满二叉树”的节点数量为 2n−1 ，占用 O(2n) 空间：

def build_tree(n: int) -> TreeNode | None:
    """指数阶（建立满二叉树）"""
    if n == 0:
        return None
    root = TreeNode(0)
    root.left = build_tree(n - 1)
    root.right = build_tree(n - 1)
    return root

5.png

 对数阶 O(log⁡n)

对数阶常见于分治算法。例如归并排序，输入长度为 n 的数组，每轮递归将数组从中点处划分为两半，形成高度为 log⁡n 的递归树，使用 O(log⁡n) 栈帧空间。

再例如将数字转化为字符串，输入一个正整数 n ，它的位数为 ⌊log10⁡n⌋+1 ，即对应字符串长度为 ⌊log10⁡n⌋+1 ，因此空间复杂度为 O(log10⁡n+1)=O(log⁡n) 。

2.4.4   权衡时间与空间

理想情况下，我们希望算法的时间复杂度和空间复杂度都能达到最优。然而在实际情况中，同时优化时间复杂度和空间复杂度通常非常困难。

降低时间复杂度通常需要以提升空间复杂度为代价，反之亦然。我们将牺牲内存空间来提升算法运行速度的思路称为“以空间换时间”；反之，则称为“以时间换空间”。

选择哪种思路取决于我们更看重哪个方面。在大多数情况下，时间比空间更宝贵，因此“以空间换时间”通常是更常用的策略。当然，在数据量很大的情况下，控制空间复杂度也非常重要。

avatar
文章
阅读
粉丝