空间复杂度精解：定义、推算方法与常见类型

小刘鸭地下城
67 阅读4分钟

空间复杂度

算法相关空间

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

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

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

推算方法

最差空间复杂度中的“最差”有两层含义。

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

在递归函数中，需要注意统计栈帧空间。

function constFunc() {
    // 执行某些操作
    return 0;
}
/* 循环的空间复杂度为 O(1) */
function loop(n) {
    for (let i = 0; i < n; i++) {
        constFunc();
    }
}
/* 递归的空间复杂度为 O(n) */
function recur(n) {
    if (n === 1) return;
    return recur(n - 1);
}

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

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

常见类型

image.png

常数阶

常数阶常见于数量与输入数据大小 nn 无关的常量、变量、对象。

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

线性阶

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

image.png

平方阶

平方阶常见于矩阵和图，元素数量与 nn 成平方关系

/* 平方阶（递归实现） */
function quadraticRecur(n) {
    if (n <= 0) return 0;
    const nums = new Array(n);
    console.log(`递归 n = ${n} 中的 nums 长度 = ${nums.length}`);
    return quadraticRecur(n - 1);
}

image.png

指数阶

指数阶常见于二叉树。

/* 指数阶（建立满二叉树） */
function buildTree(n) {
    if (n === 0) return null;
    const root = new TreeNode(0);
    root.left = buildTree(n - 1);
    root.right = buildTree(n - 1);
    return root;
}

 对数阶

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

再例如将数字转化为字符串

权衡时间与空间

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

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

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

空间复杂度分析

时间复杂度的全称是 渐进时间复杂度，表示 算法的执行时间与数据规模之间的增长关系 。

类比一下，空间复杂度全称就是 渐进空间复杂度（asymptotic space complexity），表示 算法的存储空间与数据规模之间的增长关系 。

定义：算法的空间复杂度通过计算算法所需的存储空间实现，算法的空间复杂度的计算公式记作：S(n) = O(f(n)) ，其中，n 为问题的规模，f(n) 为语句关于 n 所占存储空间的函数。

function print(n) {
 const newArr = []; // 第 2 行
 newArr.length = n; // 第 3 行
  for (let i = 0; i <n; ++i) {
    newArr[i] = i * i;
  }

  for (let j = n-1; j >= 0; --j) {
    console.log(newArr[i])
  }
}

跟时间复杂度分析一样，我们可以看到，第 2 行代码中，我们申请了一个空间存储变量 newArr ，是个空数组。第 3 行把 newArr 的长度修改为 n 的长度的数组，每项的值为 undefined ，除此之外，剩下的代码都没有占用更多的空间，所以整段代码的空间复杂度就是 O(n)。

我们常见的空间复杂度就是 O(1)、O(n)、O(n(2))，像 O(logn)、O(nlogn) 这样的对数阶复杂度平时都用不到。

avatar
文章
阅读
粉丝