【CS.AL】算法复杂度分析 —— 空间复杂度详解

1 概述

空间复杂度是衡量一个算法在运行过程中所需要的存储空间量，它描述了算法在处理不同规模的输入时，所需存储空间的增长趋势。空间复杂度同样使用大O记号表示，比如O(1)、O(n)、O(n²)等。以下是一些常见的空间复杂度及其含义：

1. O(1) - 常数空间复杂度

   • 这种算法所需的存储空间在输入规模增大时保持不变。
   • 例如：变量赋值、常量存储。

2. O(n) - 线性空间复杂度

   • 这种算法所需的存储空间与输入规模成正比。
   • 例如：使用数组或列表存储输入数据。

3. O(n²) - 平方空间复杂度

   • 这种算法所需的存储空间随着输入规模的平方级增长。
   • 例如：二维数组的使用。

4. O(log n) - 对数空间复杂度

   • 这种算法的存储空间随输入规模的对数级增长。
   • 例如：递归算法中的栈空间。

5. O(n log n) - 线性对数空间复杂度

   • 这种算法的存储空间是输入规模的线性乘以对数级增长。
   • 例如：复杂递归算法中的临时存储空间。

6. O(2^n) - 指数空间复杂度

   • 这种算法的存储空间随着输入规模的指数级增长。
   • 例如：递归解决组合问题的算法。

7. O(n!) - 阶乘空间复杂度

   • 这种算法的存储空间随着输入规模的阶乘级增长。
   • 例如：排列组合问题的暴力解法。

2 空间复杂度的详细分析

2.1 常数空间复杂度（O(1)）

在这种情况下，算法所需的存储空间不会随着输入规模的变化而变化。例如，简单的变量赋值和算术运算。

2.2 线性空间复杂度（O(n)）

这种复杂度通常出现在需要存储与输入规模成正比的数据结构中。常见的例子包括使用数组、链表等数据结构存储输入数据。

2.3 平方空间复杂度（O(n²)）

这种复杂度通常出现在需要使用二维数据结构的算法中。例如，二维数组用于表示图的邻接矩阵。

2.4 对数空间复杂度（O(log n)）

这种复杂度通常出现在递归算法中，递归调用的栈空间随着递归深度对数级增长。例如，二分查找中的递归实现。

2.5 线性对数空间复杂度（O(n log n)）

这种复杂度通常出现在一些复杂的递归算法中，需要临时存储部分数据。例如，归并排序在合并子数组时需要的额外空间。

2.6 指数空间复杂度（O(2^n)）

这种复杂度通常出现在需要解决组合问题的递归算法中，每次递归调用会生成多个子问题。例如，计算斐波那契数列的递归方法。

2.7 阶乘空间复杂度（O(n!)）

这种复杂度通常出现在处理排列和组合问题的算法中。例如，旅行商问题的暴力解法。

3 计算空间复杂度的方法

为了理解和计算算法的空间复杂度，可以将其类比为一次探险，寻找算法的空间复杂度这个“宝藏”。以下是具体步骤：

1. 分析代码：观察代码中的每一步操作，找到需要分配的存储空间。

2. 分析数据结构：判断数据结构的空间需求，例如数组、链表等。

3. 处理递归：注意递归调用的深度和每次递归所需的栈空间。

4. 计算总空间：将所有分配的空间加总，得到整个算法的空间复杂度。

5. 简化结果：将复杂度表达式简化，保留最高次项，忽略常数项和低次项，得到最终的空间复杂度。

4 实际例子算法题

让我们通过一个实际例子来演示如何计算算法的空间复杂度。

4.1 归并排序算法

void mergeSort(int arr[], int left, int right) {
    if (left < right) {
        int mid = left + (right - left) / 2;

        mergeSort(arr, left, mid);
        mergeSort(arr, mid + 1, right);

        merge(arr, left, mid, right);
    }
}

• 步骤 1：分析代码
  • 每次递归调用时，函数会创建临时数组来合并子数组。
• 步骤 2：分析数据结构
  • 临时数组的大小为 right - left + 1。
• 步骤 3：处理递归
  • 递归调用的深度为 log n，每层递归都需要额外的临时数组。
• 步骤 4：计算总空间
  • 每层递归的临时数组总大小为 O(n)，递归深度为 O(log n)。
• 步骤 5：简化结果
  • 归并排序的空间复杂度为 O(n log n)。

4.2 另一个例子：二分查找

int binarySearch(int arr[], int left, int right, int x) {
    if (right >= left) {
        int mid = left + (right - left) / 2;

        if (arr[mid] == x)
            return mid;

        if (arr[mid] > x)
            return binarySearch(arr, left, mid - 1, x);

        return binarySearch(arr, mid + 1, right, x);
    }

    return -1;
}

• 步骤 1：分析代码
  • 每次递归调用会使用常数空间来存储局部变量 mid。
• 步骤 2：分析数据结构
  • 不需要额外的数据结构。
• 步骤 3：处理递归
  • 递归调用的深度为 log n。
• 步骤 4：计算总空间
  • 总空间需求为递归深度乘以每次调用的常数空间，即 O(log n)。
• 步骤 5：简化结果
  • 二分查找的空间复杂度为 O(log n)。