编辑“︁空间复杂度”︁

{{DISPLAYTITLE:空间复杂度}}

'''空间复杂度'''（Space Complexity）是算法分析中的一个重要概念，用于衡量算法在运行过程中所需占用的额外存储空间随输入规模增长的变化趋势。它与[[时间复杂度]]共同构成了评估算法效率的两大核心指标。

== 基本概念 ==
空间复杂度描述的是算法在执行过程中除输入数据外，额外需要的存储空间大小。通常用大O符号（Big-O notation）表示，例如 <math>O(1)</math>、<math>O(n)</math>、<math>O(n^2)</math> 等。

=== 关键点 ===
* '''输入空间'''：存储输入数据本身所需的空间（通常不计入空间复杂度分析）
* '''辅助空间'''：算法运行过程中临时占用的额外空间（如变量、栈、堆内存等）
* '''输出空间'''：存储结果所需的空间（某些情况下需要单独考虑）

== 常见空间复杂度分类 ==
以下是典型的空间复杂度类别（按效率从高到低排列）：

=== 常数空间 <math>O(1)</math> ===
算法所需的额外空间不随输入规模变化。

<syntaxhighlight lang="python">
def swap(a, b):
    temp = a  # 仅使用1个临时变量
    a = b
    b = temp
    return a, b
</syntaxhighlight>

=== 线性空间 <math>O(n)</math> ===
所需空间与输入规模成线性关系。

<syntaxhighlight lang="python">
def copy_list(original):
    new_list = []  # 空间与输入列表长度成正比
    for item in original:
        new_list.append(item)
    return new_list
</syntaxhighlight>

=== 平方空间 <math>O(n^2)</math> ===
常见于二维数据结构或嵌套遍历。

<syntaxhighlight lang="python">
def create_matrix(n):
    matrix = [[0] * n for _ in range(n)]  # n×n的矩阵
    return matrix
</syntaxhighlight>

=== 对数空间 <math>O(\log n)</math> ===
通常出现在分治算法的递归调用中。

<syntaxhighlight lang="python">
def recursive_power(x, n):
    if n == 0:
        return 1
    if n % 2 == 1:
        return x * recursive_power(x, n-1)
    else:
        half = recursive_power(x, n//2)  # 递归深度为log(n)
        return half * half
</syntaxhighlight>

== 递归算法的空间复杂度 ==
递归调用会占用栈空间，其空间复杂度需要考虑：
* 递归深度
* 每次递归调用所需的局部变量空间

示例：斐波那契数列的递归实现
<syntaxhighlight lang="python">
def fibonacci(n):
    if n <= 1:
        return n
    return fibonacci(n-1) + fibonacci(n-2)  # 空间复杂度O(n)（调用栈深度）
</syntaxhighlight>

<mermaid>
graph TD
    A[fib(5)] --> B[fib(4)]
    A --> C[fib(3)]
    B --> D[fib(3)]
    B --> E[fib(2)]
    C --> F[fib(2)]
    C --> G[fib(1)]
    D --> H[fib(2)]
    D --> I[fib(1)]
</mermaid>

== 实际案例分析 ==
=== 案例1：原地排序 ===
'''问题'''：实现数组的原地反转<br>
'''空间优化'''：<math>O(1)</math>（仅使用固定数量的指针）

<syntaxhighlight lang="python">
def reverse_in_place(arr):
    left, right = 0, len(arr)-1
    while left < right:
        arr[left], arr[right] = arr[right], arr[left]
        left += 1
        right -= 1
</syntaxhighlight>

=== 案例2：哈希表查询 ===
'''问题'''：统计数组中元素的频率<br>
'''空间权衡'''：<math>O(n)</math>（需要存储频率字典）

<syntaxhighlight lang="python">
def count_frequency(arr):
    freq = {}
    for num in arr:
        freq[num] = freq.get(num, 0) + 1
    return freq
</syntaxhighlight>

== 空间与时间的权衡 ==
在算法设计中常需要在空间和时间效率之间做出取舍：

{| class="wikitable"
|-
! 策略 !! 时间效率 !! 空间效率
|-
| 预计算（查表法） || <math>O(1)</math> || <math>O(n)</math>
|-
| 动态计算 || <math>O(n)</math> || <math>O(1)</math>
|}

== 高级话题 ==
=== 空间复杂度的渐进分析 ===
* '''最坏情况'''：算法在任何输入下所需的最大空间
* '''平均情况'''：随机输入时期望的空间需求
* '''摊销分析'''：考虑连续操作的整体空间成本

=== 空间复杂度的隐藏因素 ===
* 函数调用开销
* 内存对齐和填充
* 语言运行时环境（如Python列表的实际内存占用）

== 总结 ==
掌握空间复杂度分析可以帮助开发者：
# 评估算法对内存资源的消耗
# 在资源受限的环境中做出合理选择
# 理解不同算法设计对系统整体性能的影响

{{算法复杂度分析}}

[[Category:计算机科学]]
[[Category:面试技巧]]
[[Category:算法基础]]