xinyin025/hello-algo
1
0
Fork 0
mirror of https://github.com/krahets/hello-algo.git synced 2026-07-09 14:06:06 +00:00
Code Issues Packages Projects Releases Wiki Activity

build

Browse Source
This commit is contained in:
krahets
2023-08-08 23:15:13 +08:00
parent 48adefba25
commit 6d41b5da04
11 changed files with 350 additions and 150 deletions
Download Patch File Download Diff File Expand all files Collapse all files
chapter_computational_complexity/space_complexity.md
+91 -18
View File
@@ -4,25 +4,25 @@ comments: true
# 2.3.   空间复杂度
「空间复杂度 Space Complexity」用于衡量算法使用内存空间随着数据量变大时的增长趋势。这个概念与时间复杂度非常类似。
「空间复杂度 Space Complexity」用于衡量算法占用内存空间随着数据量变大时的增长趋势。这个概念与时间复杂度非常类似，只需将“运行时间”替换为“占用内存空间”。
## 2.3.1.   算法相关空间
算法运行过程中使用的内存空间主要包括以下几种：
- 「输入空间」用于存储算法的输入数据。
- 「暂存空间」用于存储算法运行过程中的变量、对象、函数上下文等数据。
- 「输出空间」用于存储算法的输出数据。
- **输入空间**：用于存储算法的输入数据。
- **暂存空间**：用于存储算法运行过程中的变量、对象、函数上下文等数据。
- **输出空间**：用于存储算法的输出数据。
通常情况下，空间复杂度统计范围是「暂存空间」+「输出空间」。
一般情况下，空间复杂度的统计范围是“暂存空间”加上“输出空间”。
暂存空间可以进一步划分为三个部分：
- 「暂存数据」用于保存算法运行过程中的各种常量、变量、对象等。
- 「栈帧空间」用于保存调用函数的上下文数据。系统在每次调用函数时都会在栈顶部创建一个栈帧，函数返回后，栈帧空间会被释放。
- 「指令空间」用于保存编译后的程序指令，在实际统计中通常忽略不计。
- **暂存数据**：用于保存算法运行过程中的各种常量、变量、对象等。
- **栈帧空间**：用于保存调用函数的上下文数据。系统在每次调用函数时都会在栈顶部创建一个栈帧，函数返回后，栈帧空间会被释放。
- **指令空间**：用于保存编译后的程序指令，在实际统计中通常忽略不计。
因此，在分析一段程序的空间复杂度时，我们一般统计 **暂存数据、输出数据、栈帧空间** 三部分。
因此在分析一段程序的空间复杂度时，**我们通常统计暂存数据、输出数据、栈帧空间三部分**。
![算法使用的相关空间](space_complexity.assets/space_types.png)
@@ -294,12 +294,14 @@ comments: true
## 2.3.2.   推算方法
空间复杂度的推算方法与时间复杂度大致相同，只是将统计对象从“计算操作数量”转为“使用空间大小”。与时间复杂度不同的是，**我们通常只关注「最差空间复杂度」**，这是因为内存空间是一项硬性要求，我们必须确保在所有输入数据下都有足够的内存空间预留。
空间复杂度的推算方法与时间复杂度大致相同，只需将统计对象从“计算操作数量”转为“使用空间大小”。
**最差空间复杂度中的“最差”有两层含义**，分别是输入数据的最差分布和算法运行过程中的最差时间点。
而与时间复杂度不同的是，**我们通常只关注「最差空间复杂度」**。这是因为内存空间是一项硬性要求，我们必须确保在所有输入数据下都有足够的内存空间预留。
- **以最差输入数据为准**。当 $n < 10$ 时，空间复杂度为 $O(1)$ ；但当 $n > 10$ 时，初始化的数组 `nums` 占用 $O(n)$ 空间；因此最差空间复杂度为 $O(n)$ 。
- **以算法运行过程中的峰值内存为准**。例如，程序在执行最后一行之前，占用 $O(1)$ 空间；当初始化数组 `nums` 时，程序占用 $O(n)$ 空间；因此最差空间复杂度为 $O(n)$ 。
观察以下代码，最差空间复杂度中的“最差”有两层含义。
1. **以最差输入数据为准**：当 $n < 10$ 时，空间复杂度为 $O(1)$ ；但当 $n > 10$ 时，初始化的数组 `nums` 占用 $O(n)$ 空间；因此最差空间复杂度为 $O(n)$ 。
2. **以算法运行中的峰值内存为准**：例如，程序在执行最后一行之前，占用 $O(1)$ 空间；当初始化数组 `nums` 时，程序占用 $O(n)$ 空间；因此最差空间复杂度为 $O(n)$ 。
=== "Java"
@@ -430,7 +432,10 @@ comments: true
```
**在递归函数中，需要注意统计栈帧空间**。例如，函数 `loop()` 在循环中调用了 $n$ 次 `function()` ，每轮中的 `function()` 都返回并释放了栈帧空间，因此空间复杂度仍为 $O(1)$ 。而递归函数 `recur()` 在运行过程中会同时存在 $n$ 个未返回的 `recur()` ，从而占用 $O(n)$ 的栈帧空间。
**在递归函数中，需要注意统计栈帧空间**。例如以下代码：
- 函数 `loop()` 在循环中调用了 $n$ 次 `function()` ，每轮中的 `function()` 都返回并释放了栈帧空间，因此空间复杂度仍为 $O(1)$ 。
- 递归函数 `recur()` 在运行过程中会同时存在 $n$ 个未返回的 `recur()` ，从而占用 $O(n)$ 的栈帧空间。
=== "Java"
@@ -653,7 +658,7 @@ comments: true
## 2.3.3. &nbsp; 常见类型
设输入数据大小为 $n$ ，常见的空间复杂度类型有（从低到高排列）
设输入数据大小为 $n$ ，常见的空间复杂度类型有（从低到高排列）：
$$
\begin{aligned}
@@ -668,7 +673,7 @@ $$
!!! tip
部分示例代码需要一些前置知识，包括数组、链表、二叉树、递归算法等。如果遇到看不懂的地方无需担心，可以在学习完后面章节后再来复习，现阶段我们先专注于理解空间复杂度的含义和推算方法。
部分示例代码需要一些前置知识，包括数组、链表、二叉树、递归算法等。如果你遇到看不懂的地方，可以在学习完后面章节后再来复习。
### 常数阶 $O(1)$
@@ -679,6 +684,12 @@ $$
=== "Java"
```java title="space_complexity.java"
/* 函数 */
int function() {
// do something
return 0;
}
/* 常数阶 */
void constant(int n) {
// 常量、变量、对象占用 O(1) 空间
@@ -700,6 +711,12 @@ $$
=== "C++"
```cpp title="space_complexity.cpp"
/* 函数 */
int func() {
// do something
return 0;
}
/* 常数阶 */
void constant(int n) {
// 常量、变量、对象占用 O(1) 空间
@@ -721,6 +738,11 @@ $$
=== "Python"
```python title="space_complexity.py"
def function() -> int:
"""函数"""
# do something
return 0
def constant(n: int):
"""常数阶"""
# 常量、变量、对象占用 O(1) 空间
@@ -738,6 +760,12 @@ $$
=== "Go"
```go title="space_complexity.go"
/* 函数 */
func function() int {
// do something...
return 0
}
/* 常数阶 */
func spaceConstant(n int) {
// 常量、变量、对象占用 O(1) 空间
@@ -761,6 +789,12 @@ $$
=== "JS"
```javascript title="space_complexity.js"
/* 函数 */
function constFunc() {
// do something
return 0;
}
/* 常数阶 */
function constant(n) {
// 常量、变量、对象占用 O(1) 空间
@@ -782,6 +816,12 @@ $$
=== "TS"
```typescript title="space_complexity.ts"
/* 函数 */
function constFunc(): number {
// do something
return 0;
}
/* 常数阶 */
function constant(n: number): void {
// 常量、变量、对象占用 O(1) 空间
@@ -803,6 +843,12 @@ $$
=== "C"
```c title="space_complexity.c"
/* 函数 */
int func() {
// do something
return 0;
}
/* 常数阶 */
void constant(int n) {
// 常量、变量、对象占用 O(1) 空间
@@ -825,6 +871,12 @@ $$
=== "C#"
```csharp title="space_complexity.cs"
/* 函数 */
int function() {
// do something
return 0;
}
/* 常数阶 */
void constant(int n) {
// 常量、变量、对象占用 O(1) 空间
@@ -846,6 +898,13 @@ $$
=== "Swift"
```swift title="space_complexity.swift"
/* 函数 */
@discardableResult
func function() -> Int {
// do something
return 0
}
/* 常数阶 */
func constant(n: Int) {
// 常量、变量、对象占用 O(1) 空间
@@ -867,6 +926,8 @@ $$
=== "Zig"
```zig title="space_complexity.zig"
[class]{}-[func]{function}
// 常数阶
fn constant(n: i32) void {
// 常量、变量、对象占用 O(1) 空间
@@ -895,6 +956,12 @@ $$
=== "Dart"
```dart title="space_complexity.dart"
/* 函数 */
int function() {
// do something
return 0;
}
/* 常数阶 */
void constant(int n) {
// 常量、变量、对象占用 O(1) 空间
@@ -916,6 +983,12 @@ $$
=== "Rust"
```rust title="space_complexity.rs"
/* 函数 */
fn function() ->i32 {
// do something
return 0;
}
/* 常数阶 */
#[allow(unused)]
fn constant(n: i32) {
@@ -987,9 +1060,9 @@ $$
# 长度为 n 的列表占用 O(n) 空间
nums = [0] * n
# 长度为 n 的哈希表占用 O(n) 空间
mapp = dict[int, str]()
hmap = dict[int, str]()
for i in range(n):
mapp[i] = str(i)
hmap[i] = str(i)
```
=== "Go"