mirror of
https://github.com/krahets/hello-algo.git
synced 2025-12-19 07:17:54 +08:00
Polish the content
Polish the chapter preface, introduction and complexity anlysis
This commit is contained in:
krahets
@@ -2,35 +2,35 @@
|
||||
|
||||
## 算法评价维度
|
||||
|
||||
从总体上看，算法设计追求以下两个层面的目标：
|
||||
在算法设计中，我们先后追求以下两个层面的目标：
|
||||
|
||||
1. **找到问题解法**。算法需要在规定的输入范围内，可靠地求得问题的正确解。
|
||||
2. **寻求最优解法**。同一个问题可能存在多种解法，我们希望找到尽可能高效的算法。
|
||||
1. **找到问题解法**：算法需要在规定的输入范围内，可靠地求得问题的正确解。
|
||||
2. **寻求最优解法**：同一个问题可能存在多种解法，我们希望找到尽可能高效的算法。
|
||||
|
||||
因此，在能够解决问题的前提下，算法效率成为主要的评价维度，主要包括：
|
||||
因此在能够解决问题的前提下，算法效率成为主要的评价维度，包括：
|
||||
|
||||
- **时间效率**，即算法运行速度的快慢。
|
||||
- **空间效率**，即算法占用内存空间的大小。
|
||||
|
||||
简而言之，**我们的目标是设计“既快又省”的数据结构与算法**。掌握评估算法效率的方法则至关重要，因为只有了解评价标准，我们才能进行算法之间的对比分析，从而指导算法设计与优化过程。
|
||||
简而言之，**我们的目标是设计“既快又省”的数据结构与算法**。而有效地评估算法效率至关重要，因为只有了解评价标准，我们才能对比分析各种算法，从而指导算法设计与优化过程。
|
||||
|
||||
## 效率评估方法
|
||||
|
||||
### 实际测试
|
||||
|
||||
假设我们现在有算法 A 和算法 B，它们都能解决同一问题，现在需要对比这两个算法的效率。我们最直接的方法就是找一台计算机，运行这两个算法，并监控记录它们的运行时间和内存占用情况。这种评估方式能够反映真实情况，但也存在较大局限性。
|
||||
假设我们现在有算法 `A` 和算法 `B` ，它们都能解决同一问题，现在需要对比这两个算法的效率。最直接的方法是找一台计算机，运行这两个算法，并监控记录它们的运行时间和内存占用情况。这种评估方式能够反映真实情况，但也存在较大局限性。
|
||||
|
||||
**难以排除测试环境的干扰因素**。硬件配置会影响算法的性能表现。例如，在某台计算机中，算法 A 的运行时间比算法 B 短；但在另一台配置不同的计算机中，我们可能得到相反的测试结果。这意味着我们需要在各种机器上进行测试，而这是不现实的。
|
||||
**难以排除测试环境的干扰因素**。硬件配置会影响算法的性能表现。比如在某台计算机中，算法 `A` 的运行时间比算法 `B` 短；但在另一台配置不同的计算机中，我们可能得到相反的测试结果。这意味着我们需要在各种机器上进行测试，统计平均效率，而这是不现实的。
|
||||
|
||||
**展开完整测试非常耗费资源**。随着输入数据量的变化，算法会表现出不同的效率。例如，输入数据量较小时，算法 A 的运行时间可能短于算法 B；而输入数据量较大时，测试结果可能相反。因此，为了得到有说服力的结论，我们需要测试各种规模的输入数据，这样需要占用大量的计算资源。
|
||||
**展开完整测试非常耗费资源**。随着输入数据量的变化，算法会表现出不同的效率。例如，在输入数据量较小时，算法 `A` 的运行时间比算法 `B` 更少；而输入数据量较大时，测试结果可能恰恰相反。因此，为了得到有说服力的结论，我们需要测试各种规模的输入数据，而这样需要耗费大量的计算资源。
|
||||
|
||||
### 理论估算
|
||||
|
||||
由于实际测试具有较大的局限性，我们可以考虑仅通过一些计算来评估算法的效率。这种估算方法被称为「复杂度分析 Complexity Analysis」或「渐近复杂度分析 Asymptotic Complexity Analysis」。
|
||||
由于实际测试具有较大的局限性，我们可以考虑仅通过一些计算来评估算法的效率。这种估算方法被称为「渐近复杂度分析 Asymptotic Complexity Analysis」，简称为「复杂度分析」。
|
||||
|
||||
**复杂度分析评估的是算法运行效率随着输入数据量增多时的增长趋势**。这个定义有些拗口，我们可以将其分为三个重点来理解：
|
||||
|
||||
- “算法运行效率”可分为“运行时间”和“占用空间”，因此我们可以将复杂度分为「时间复杂度 Time Complexity」和「空间复杂度 Space Complexity」。
|
||||
- “算法运行效率”可分为运行时间和占用空间两部分，与之对应地，复杂度可分为「时间复杂度 Time Complexity」和「空间复杂度 Space Complexity」。
|
||||
- “随着输入数据量增多时”表示复杂度与输入数据量有关，反映了算法运行效率与输入数据量之间的关系。
|
||||
- “增长趋势”表示复杂度分析关注的是算法时间与空间的增长趋势，而非具体的运行时间或占用空间。
|
||||
|
||||
@@ -38,8 +38,10 @@
|
||||
|
||||
如果你对复杂度分析的概念仍感到困惑，无需担心，我们会在后续章节详细介绍。
|
||||
|
||||
## 复杂度分析重要性
|
||||
## 复杂度的重要性
|
||||
|
||||
复杂度分析为我们提供了一把评估算法效率的“标尺”，告诉我们执行某个算法所需的时间和空间资源，并使我们能够对比不同算法之间的效率。
|
||||
复杂度分析为我们提供了一把评估算法效率的“标尺”，帮助我们衡量了执行某个算法所需的时间和空间资源，并使我们能够对比不同算法之间的效率。
|
||||
|
||||
复杂度是个数学概念，对于初学者可能比较抽象，学习难度相对较高。从这个角度看，复杂度分析可能不太适合作为第一章的内容。然而，当我们讨论某个数据结构或算法的特点时，我们难以避免要分析其运行速度和空间使用情况。**因此，在深入学习数据结构与算法之前，建议读者先对复杂度建立初步的了解，并能够完成简单案例的复杂度分析**。
|
||||
复杂度是个数学概念，对于初学者可能比较抽象，学习难度相对较高。从这个角度看，复杂度分析可能不太适合作为第一章的内容。
|
||||
|
||||
然而，当我们讨论某个数据结构或算法的特点时，难以避免要分析其运行速度和空间使用情况。因此，在深入学习数据结构与算法之前，**建议你先对复杂度建立初步的了解，能够完成简单算法的复杂度分析**。
|
||||
|
||||
@@ -1,24 +1,24 @@
|
||||
# 空间复杂度
|
||||
|
||||
「空间复杂度 Space Complexity」用于衡量算法使用内存空间随着数据量变大时的增长趋势。这个概念与时间复杂度非常类似。
|
||||
「空间复杂度 Space Complexity」用于衡量算法占用内存空间随着数据量变大时的增长趋势。这个概念与时间复杂度非常类似，只需将“运行时间”替换为“占用内存空间”。
|
||||
|
||||
## 算法相关空间
|
||||
|
||||
算法运行过程中使用的内存空间主要包括以下几种：
|
||||
|
||||
- 「输入空间」用于存储算法的输入数据。
|
||||
- 「暂存空间」用于存储算法运行过程中的变量、对象、函数上下文等数据。
|
||||
- 「输出空间」用于存储算法的输出数据。
|
||||
- **输入空间**：用于存储算法的输入数据。
|
||||
- **暂存空间**：用于存储算法运行过程中的变量、对象、函数上下文等数据。
|
||||
- **输出空间**：用于存储算法的输出数据。
|
||||
|
||||
通常情况下，空间复杂度统计范围是「暂存空间」+「输出空间」。
|
||||
一般情况下，空间复杂度的统计范围是“暂存空间”加上“输出空间”。
|
||||
|
||||
暂存空间可以进一步划分为三个部分：
|
||||
|
||||
- 「暂存数据」用于保存算法运行过程中的各种常量、变量、对象等。
|
||||
- 「栈帧空间」用于保存调用函数的上下文数据。系统在每次调用函数时都会在栈顶部创建一个栈帧，函数返回后，栈帧空间会被释放。
|
||||
- 「指令空间」用于保存编译后的程序指令，在实际统计中通常忽略不计。
|
||||
- **暂存数据**：用于保存算法运行过程中的各种常量、变量、对象等。
|
||||
- **栈帧空间**：用于保存调用函数的上下文数据。系统在每次调用函数时都会在栈顶部创建一个栈帧，函数返回后，栈帧空间会被释放。
|
||||
- **指令空间**：用于保存编译后的程序指令，在实际统计中通常忽略不计。
|
||||
|
||||
因此，在分析一段程序的空间复杂度时，我们一般统计 **暂存数据、输出数据、栈帧空间** 三部分。
|
||||
因此在分析一段程序的空间复杂度时，**我们通常统计暂存数据、输出数据、栈帧空间三部分**。
|
||||
|
||||
|
||||
|
||||
@@ -288,12 +288,14 @@
|
||||
|
||||
## 推算方法
|
||||
|
||||
空间复杂度的推算方法与时间复杂度大致相同，只是将统计对象从“计算操作数量”转为“使用空间大小”。与时间复杂度不同的是，**我们通常只关注「最差空间复杂度」**，这是因为内存空间是一项硬性要求，我们必须确保在所有输入数据下都有足够的内存空间预留。
|
||||
空间复杂度的推算方法与时间复杂度大致相同，只需将统计对象从“计算操作数量”转为“使用空间大小”。
|
||||
|
||||
**最差空间复杂度中的“最差”有两层含义**，分别是输入数据的最差分布和算法运行过程中的最差时间点。
|
||||
而与时间复杂度不同的是，**我们通常只关注「最差空间复杂度」**。这是因为内存空间是一项硬性要求，我们必须确保在所有输入数据下都有足够的内存空间预留。
|
||||
|
||||
- **以最差输入数据为准**。当 $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"
|
||||
|
||||
@@ -424,7 +426,10 @@
|
||||
|
||||
```
|
||||
|
||||
**在递归函数中，需要注意统计栈帧空间**。例如，函数 `loop()` 在循环中调用了 $n$ 次 `function()` ，每轮中的 `function()` 都返回并释放了栈帧空间，因此空间复杂度仍为 $O(1)$ 。而递归函数 `recur()` 在运行过程中会同时存在 $n$ 个未返回的 `recur()` ，从而占用 $O(n)$ 的栈帧空间。
|
||||
**在递归函数中，需要注意统计栈帧空间**。例如以下代码：
|
||||
|
||||
- 函数 `loop()` 在循环中调用了 $n$ 次 `function()` ，每轮中的 `function()` 都返回并释放了栈帧空间，因此空间复杂度仍为 $O(1)$ 。
|
||||
- 递归函数 `recur()` 在运行过程中会同时存在 $n$ 个未返回的 `recur()` ，从而占用 $O(n)$ 的栈帧空间。
|
||||
|
||||
=== "Java"
|
||||
|
||||
@@ -647,7 +652,7 @@
|
||||
|
||||
## 常见类型
|
||||
|
||||
设输入数据大小为 $n$ ，常见的空间复杂度类型有（从低到高排列）
|
||||
设输入数据大小为 $n$ ，常见的空间复杂度类型有（从低到高排列）：
|
||||
|
||||
$$
|
||||
\begin{aligned}
|
||||
@@ -660,7 +665,7 @@ $$
|
||||
|
||||
!!! tip
|
||||
|
||||
部分示例代码需要一些前置知识，包括数组、链表、二叉树、递归算法等。如果遇到看不懂的地方无需担心，可以在学习完后面章节后再来复习，现阶段我们先专注于理解空间复杂度的含义和推算方法。
|
||||
部分示例代码需要一些前置知识，包括数组、链表、二叉树、递归算法等。如果你遇到看不懂的地方，可以在学习完后面章节后再来复习。
|
||||
|
||||
### 常数阶 $O(1)$
|
||||
|
||||
@@ -671,72 +676,96 @@ $$
|
||||
=== "Java"
|
||||
|
||||
```java title="space_complexity.java"
|
||||
[class]{space_complexity}-[func]{function}
|
||||
|
||||
[class]{space_complexity}-[func]{constant}
|
||||
```
|
||||
|
||||
=== "C++"
|
||||
|
||||
```cpp title="space_complexity.cpp"
|
||||
[class]{}-[func]{func}
|
||||
|
||||
[class]{}-[func]{constant}
|
||||
```
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python title="space_complexity.py"
|
||||
[class]{}-[func]{function}
|
||||
|
||||
[class]{}-[func]{constant}
|
||||
```
|
||||
|
||||
=== "Go"
|
||||
|
||||
```go title="space_complexity.go"
|
||||
[class]{}-[func]{function}
|
||||
|
||||
[class]{}-[func]{spaceConstant}
|
||||
```
|
||||
|
||||
=== "JS"
|
||||
|
||||
```javascript title="space_complexity.js"
|
||||
[class]{}-[func]{constFunc}
|
||||
|
||||
[class]{}-[func]{constant}
|
||||
```
|
||||
|
||||
=== "TS"
|
||||
|
||||
```typescript title="space_complexity.ts"
|
||||
[class]{}-[func]{constFunc}
|
||||
|
||||
[class]{}-[func]{constant}
|
||||
```
|
||||
|
||||
=== "C"
|
||||
|
||||
```c title="space_complexity.c"
|
||||
[class]{}-[func]{func}
|
||||
|
||||
[class]{}-[func]{constant}
|
||||
```
|
||||
|
||||
=== "C#"
|
||||
|
||||
```csharp title="space_complexity.cs"
|
||||
[class]{space_complexity}-[func]{function}
|
||||
|
||||
[class]{space_complexity}-[func]{constant}
|
||||
```
|
||||
|
||||
=== "Swift"
|
||||
|
||||
```swift title="space_complexity.swift"
|
||||
[class]{}-[func]{function}
|
||||
|
||||
[class]{}-[func]{constant}
|
||||
```
|
||||
|
||||
=== "Zig"
|
||||
|
||||
```zig title="space_complexity.zig"
|
||||
[class]{}-[func]{function}
|
||||
|
||||
[class]{}-[func]{constant}
|
||||
```
|
||||
|
||||
=== "Dart"
|
||||
|
||||
```dart title="space_complexity.dart"
|
||||
[class]{}-[func]{function}
|
||||
|
||||
[class]{}-[func]{constant}
|
||||
```
|
||||
|
||||
=== "Rust"
|
||||
|
||||
```rust title="space_complexity.rs"
|
||||
[class]{}-[func]{function}
|
||||
|
||||
[class]{}-[func]{constant}
|
||||
```
|
||||
|
||||
|
||||
@@ -40,6 +40,8 @@
|
||||
|
||||
!!! question "图片“空间复杂度的常见类型”反映的是否是占用空间的绝对大小？"
|
||||
|
||||
不是，该图片展示的是空间复杂度（即增长趋势），而不是占用空间的绝对大小。每个曲线都包含一个常数项，用来把所有曲线的取值范围压缩到一个视觉舒适的范围内。
|
||||
不是，该图片展示的是空间复杂度，其反映的是即增长趋势，而不是占用空间的绝对大小。
|
||||
|
||||
假设取 $n = 8$ ，你可能会发现每条曲线的值与函数对应不上。这是因为每条曲线都包含一个常数项，用于将取值范围压缩到一个视觉舒适的范围内。
|
||||
|
||||
实际中，因为我们通常不知道每个方法的“常数项”复杂度是多少，所以一般无法仅凭复杂度来选择 $n = 8$ 之下的最优解法；但相对地 $n = 8^5$ 就很好选了，这是复杂度占主导的情况。
|
||||
在实际中，因为我们通常不知道每个方法的“常数项”复杂度是多少，所以一般无法仅凭复杂度来选择 $n = 8$ 之下的最优解法。但对于 $n = 8^5$ 就很好选了，这时增长趋势已经占主导了。
|
||||
|
||||
@@ -1,14 +1,12 @@
|
||||
# 时间复杂度
|
||||
|
||||
## 统计算法运行时间
|
||||
|
||||
运行时间可以直观且准确地反映算法的效率。然而，如果我们想要准确预估一段代码的运行时间，应该如何操作呢？
|
||||
运行时间可以直观且准确地反映算法的效率。如果我们想要准确预估一段代码的运行时间，应该如何操作呢？
|
||||
|
||||
1. **确定运行平台**，包括硬件配置、编程语言、系统环境等，这些因素都会影响代码的运行效率。
|
||||
2. **评估各种计算操作所需的运行时间**，例如加法操作 `+` 需要 1 ns，乘法操作 `*` 需要 10 ns，打印操作需要 5 ns 等。
|
||||
3. **统计代码中所有的计算操作**，并将所有操作的执行时间求和，从而得到运行时间。
|
||||
|
||||
例如以下代码，输入数据大小为 $n$ ，根据以上方法，可以得到算法运行时间为 $6n + 12$ ns 。
|
||||
例如以下代码，输入数据大小为 $n$ 。根据以上方法，可以得到算法运行时间为 $6n + 12$ ns 。
|
||||
|
||||
$$
|
||||
1 + 1 + 10 + (1 + 5) \times n = 6n + 12
|
||||
@@ -183,17 +181,13 @@ $$
|
||||
}
|
||||
```
|
||||
|
||||
然而实际上，**统计算法的运行时间既不合理也不现实**。首先，我们不希望预估时间和运行平台绑定，因为算法需要在各种不同的平台上运行。其次，我们很难获知每种操作的运行时间，这给预估过程带来了极大的难度。
|
||||
但实际上，**统计算法的运行时间既不合理也不现实**。首先，我们不希望预估时间和运行平台绑定，因为算法需要在各种不同的平台上运行。其次，我们很难获知每种操作的运行时间，这给预估过程带来了极大的难度。
|
||||
|
||||
## 统计时间增长趋势
|
||||
|
||||
「时间复杂度分析」采取了一种不同的方法，其统计的不是算法运行时间，**而是算法运行时间随着数据量变大时的增长趋势**。
|
||||
|
||||
“时间增长趋势”这个概念较为抽象，我们通过一个例子来加以理解。假设输入数据大小为 $n$ ，给定三个算法 `A` , `B` , `C` 。
|
||||
|
||||
- 算法 `A` 只有 $1$ 个打印操作，算法运行时间不随着 $n$ 增大而增长。我们称此算法的时间复杂度为「常数阶」。
|
||||
- 算法 `B` 中的打印操作需要循环 $n$ 次，算法运行时间随着 $n$ 增大呈线性增长。此算法的时间复杂度被称为「线性阶」。
|
||||
- 算法 `C` 中的打印操作需要循环 $1000000$ 次，但运行时间仍与输入数据大小 $n$ 无关。因此 `C` 的时间复杂度和 `A` 相同，仍为「常数阶」。
|
||||
“时间增长趋势”这个概念比较抽象，我们通过一个例子来加以理解。假设输入数据大小为 $n$ ，给定三个算法函数 `A` , `B` , `C` 。
|
||||
|
||||
=== "Java"
|
||||
|
||||
@@ -430,23 +424,25 @@ $$
|
||||
}
|
||||
```
|
||||
|
||||
算法 `A` 只有 $1$ 个打印操作，算法运行时间不随着 $n$ 增大而增长。我们称此算法的时间复杂度为「常数阶」。
|
||||
|
||||
算法 `B` 中的打印操作需要循环 $n$ 次，算法运行时间随着 $n$ 增大呈线性增长。此算法的时间复杂度被称为「线性阶」。
|
||||
|
||||
算法 `C` 中的打印操作需要循环 $1000000$ 次，虽然运行时间很长，但它与输入数据大小 $n$ 无关。因此 `C` 的时间复杂度和 `A` 相同，仍为「常数阶」。
|
||||
|
||||
|
||||
|
||||
相较于直接统计算法运行时间，时间复杂度分析有哪些优势和局限性呢？
|
||||
相较于直接统计算法运行时间，时间复杂度分析有哪些特点呢？
|
||||
|
||||
**时间复杂度能够有效评估算法效率**。例如，算法 `B` 的运行时间呈线性增长，在 $n > 1$ 时比算法 `A` 慢，在 $n > 1000000$ 时比算法 `C` 慢。事实上，只要输入数据大小 $n$ 足够大，复杂度为「常数阶」的算法一定优于「线性阶」的算法，这正是时间增长趋势所表达的含义。
|
||||
**时间复杂度能够有效评估算法效率**。例如，算法 `B` 的运行时间呈线性增长，在 $n > 1$ 时比算法 `A` 更慢，在 $n > 1000000$ 时比算法 `C` 更慢。事实上，只要输入数据大小 $n$ 足够大，复杂度为“常数阶”的算法一定优于“线性阶”的算法，这正是时间增长趋势所表达的含义。
|
||||
|
||||
**时间复杂度的推算方法更简便**。显然，运行平台和计算操作类型都与算法运行时间的增长趋势无关。因此在时间复杂度分析中，我们可以简单地将所有计算操作的执行时间视为相同的“单位时间”，从而将“计算操作的运行时间的统计”简化为“计算操作的数量的统计”，这样的简化方法大大降低了估算难度。
|
||||
**时间复杂度的推算方法更简便**。显然，运行平台和计算操作类型都与算法运行时间的增长趋势无关。因此在时间复杂度分析中，我们可以简单地将所有计算操作的执行时间视为相同的“单位时间”，从而将“计算操作的运行时间的统计”简化为“计算操作的数量的统计”，这样以来估算难度就大大降低了。
|
||||
|
||||
**时间复杂度也存在一定的局限性**。例如，尽管算法 `A` 和 `C` 的时间复杂度相同，但实际运行时间差别很大。同样，尽管算法 `B` 的时间复杂度比 `C` 高，但在输入数据大小 $n$ 较小时，算法 `B` 明显优于算法 `C` 。在这些情况下，我们很难仅凭时间复杂度判断算法效率高低。当然，尽管存在上述问题，复杂度分析仍然是评判算法效率最有效且常用的方法。
|
||||
|
||||
## 函数渐近上界
|
||||
|
||||
设算法的计算操作数量是一个关于输入数据大小 $n$ 的函数，记为 $T(n)$ ，则以下算法的操作数量为
|
||||
|
||||
$$
|
||||
T(n) = 3 + 2n
|
||||
$$
|
||||
给定一个函数 `algorithm()` ：
|
||||
|
||||
=== "Java"
|
||||
|
||||
@@ -607,11 +603,17 @@ $$
|
||||
}
|
||||
```
|
||||
|
||||
$T(n)$ 是一次函数，说明时间增长趋势是线性的，因此可以得出时间复杂度是线性阶。
|
||||
设算法的计算操作数量是一个关于输入数据大小 $n$ 的函数，记为 $T(n)$ ，则以上函数的的操作数量为：
|
||||
|
||||
$$
|
||||
T(n) = 3 + 2n
|
||||
$$
|
||||
|
||||
$T(n)$ 是一次函数，说明时间的增长趋势是线性的，因此其时间复杂度是线性阶。
|
||||
|
||||
我们将线性阶的时间复杂度记为 $O(n)$ ，这个数学符号称为「大 $O$ 记号 Big-$O$ Notation」，表示函数 $T(n)$ 的「渐近上界 Asymptotic Upper Bound」。
|
||||
|
||||
推算时间复杂度本质上是计算“操作数量函数 $T(n)$”的渐近上界。接下来，我们来看函数渐近上界的数学定义。
|
||||
时间复杂度分析本质上是计算“操作数量函数 $T(n)$”的渐近上界。接下来，我们来看函数渐近上界的数学定义。
|
||||
|
||||
!!! abstract "函数渐近上界"
|
||||
|
||||
@@ -626,7 +628,7 @@ $T(n)$ 是一次函数，说明时间增长趋势是线性的，因此可以得
|
||||
|
||||
|
||||
|
||||
从本质上讲，计算渐近上界就是寻找一个函数 $f(n)$ ，使得当 $n$ 趋向于无穷大时，$T(n)$ 和 $f(n)$ 处于相同的增长级别，仅相差一个常数项 $c$ 的倍数。
|
||||
也就是说，计算渐近上界就是寻找一个函数 $f(n)$ ，使得当 $n$ 趋向于无穷大时，$T(n)$ 和 $f(n)$ 处于相同的增长级别，仅相差一个常数项 $c$ 的倍数。
|
||||
|
||||
## 推算方法
|
||||
|
||||
@@ -638,11 +640,11 @@ $T(n)$ 是一次函数，说明时间增长趋势是线性的，因此可以得
|
||||
|
||||
针对代码，逐行从上到下计算即可。然而，由于上述 $c \cdot f(n)$ 中的常数项 $c$ 可以取任意大小，**因此操作数量 $T(n)$ 中的各种系数、常数项都可以被忽略**。根据此原则，可以总结出以下计数简化技巧：
|
||||
|
||||
1. **忽略与 $n$ 无关的操作**。因为它们都是 $T(n)$ 中的常数项，对时间复杂度不产生影响。
|
||||
1. **忽略 $T(n)$ 中的常数项**。因为它们都与 $n$ 无关，所以对时间复杂度不产生影响。
|
||||
2. **省略所有系数**。例如，循环 $2n$ 次、$5n + 1$ 次等，都可以简化记为 $n$ 次，因为 $n$ 前面的系数对时间复杂度没有影响。
|
||||
3. **循环嵌套时使用乘法**。总操作数量等于外层循环和内层循环操作数量之积，每一层循环依然可以分别套用上述 `1.` 和 `2.` 技巧。
|
||||
|
||||
以下示例展示了使用上述技巧前、后的统计结果。
|
||||
以下示例展示了使用上述技巧前、后的统计结果。两者推出的时间复杂度相同，即为 $O(n^2)$ 。
|
||||
|
||||
$$
|
||||
\begin{aligned}
|
||||
@@ -652,8 +654,6 @@ T(n) & = n^2 + n & \text{偷懒统计 (o.O)}
|
||||
\end{aligned}
|
||||
$$
|
||||
|
||||
最终，两者都能推出相同的时间复杂度结果，即 $O(n^2)$ 。
|
||||
|
||||
=== "Java"
|
||||
|
||||
```java title=""
|
||||
@@ -875,7 +875,7 @@ $$
|
||||
|
||||
<div class="center-table" markdown>
|
||||
|
||||
| 操作数量 $T(n)$ | 时间复杂度 $O(f(n))$ |
|
||||
| 操作数量 $T(n)$ | 时间复杂度 $O(f(n))$ |
|
||||
| ---------------------- | -------------------- |
|
||||
| $100000$ | $O(1)$ |
|
||||
| $3n + 2$ | $O(n)$ |
|
||||
@@ -900,7 +900,7 @@ $$
|
||||
|
||||
!!! tip
|
||||
|
||||
部分示例代码需要一些预备知识，包括数组、递归算法等。如果遇到不理解的部分，请不要担心，可以在学习完后面章节后再回顾。现阶段，请先专注于理解时间复杂度的含义和推算方法。
|
||||
部分示例代码需要一些预备知识，包括数组、递归等。如果你遇到不理解的部分，可以在学习完后面章节后再回顾。现阶段，请先专注于理解时间复杂度的含义和推算方法。
|
||||
|
||||
### 常数阶 $O(1)$
|
||||
|
||||
@@ -1058,10 +1058,6 @@ $$
|
||||
|
||||
遍历数组和遍历链表等操作的时间复杂度均为 $O(n)$ ，其中 $n$ 为数组或链表的长度。
|
||||
|
||||
!!! question "如何确定输入数据大小 $n$ ？"
|
||||
|
||||
**数据大小 $n$ 需根据输入数据的类型来具体确定**。例如，在上述示例中，我们直接将 $n$ 视为输入数据大小；在下面遍历数组的示例中，数据大小 $n$ 为数组的长度。
|
||||
|
||||
=== "Java"
|
||||
|
||||
```java title="time_complexity.java"
|
||||
@@ -1134,6 +1130,8 @@ $$
|
||||
[class]{}-[func]{array_traversal}
|
||||
```
|
||||
|
||||
值得注意的是，**数据大小 $n$ 需根据输入数据的类型来具体确定**。比如在第一个示例中，变量 $n$ 为输入数据大小；在第二个示例中，数组长度 $n$ 为数据大小。
|
||||
|
||||
### 平方阶 $O(n^2)$
|
||||
|
||||
平方阶的操作数量相对于输入数据大小以平方级别增长。平方阶通常出现在嵌套循环中，外层循环和内层循环都为 $O(n)$ ，因此总体为 $O(n^2)$ 。
|
||||
@@ -1292,11 +1290,9 @@ $$
|
||||
|
||||
### 指数阶 $O(2^n)$
|
||||
|
||||
!!! note
|
||||
生物学的“细胞分裂”是指数阶增长的典型例子：初始状态为 $1$ 个细胞，分裂一轮后变为 $2$ 个，分裂两轮后变为 $4$ 个，以此类推，分裂 $n$ 轮后有 $2^n$ 个细胞。
|
||||
|
||||
生物学的“细胞分裂”是指数阶增长的典型例子：初始状态为 $1$ 个细胞，分裂一轮后变为 $2$ 个，分裂两轮后变为 $4$ 个，以此类推，分裂 $n$ 轮后有 $2^n$ 个细胞。
|
||||
|
||||
指数阶增长非常迅速，在实际应用中通常是不可接受的。若一个问题使用「暴力枚举」求解的时间复杂度为 $O(2^n)$ ，那么通常需要使用「动态规划」或「贪心算法」等方法来解决。
|
||||
以下代码模拟了细胞分裂的过程。
|
||||
|
||||
=== "Java"
|
||||
|
||||
@@ -1372,7 +1368,7 @@ $$
|
||||
|
||||
|
||||
|
||||
在实际算法中，指数阶常出现于递归函数。例如以下代码，不断地一分为二，经过 $n$ 次分裂后停止。
|
||||
在实际算法中，指数阶常出现于递归函数。例如以下代码，其递归地一分为二，经过 $n$ 次分裂后停止。
|
||||
|
||||
=== "Java"
|
||||
|
||||
@@ -1446,13 +1442,11 @@ $$
|
||||
[class]{}-[func]{exp_recur}
|
||||
```
|
||||
|
||||
指数阶增长非常迅速，在穷举法（暴力搜索、回溯等）中比较常见。对于数据规模较大的问题，指数阶是不可接受的，通常需要使用「动态规划」或「贪心」等算法来解决。
|
||||
|
||||
### 对数阶 $O(\log n)$
|
||||
|
||||
与指数阶相反，对数阶反映了“每轮缩减到一半的情况”。对数阶仅次于常数阶，时间增长缓慢，是理想的时间复杂度。
|
||||
|
||||
对数阶常出现于「二分查找」和「分治算法」中，体现了“一分为多”和“化繁为简”的算法思想。
|
||||
|
||||
设输入数据大小为 $n$ ，由于每轮缩减到一半，因此循环次数是 $\log_2 n$ ，即 $2^n$ 的反函数。
|
||||
与指数阶相反，对数阶反映了“每轮缩减到一半”的情况。设输入数据大小为 $n$ ，由于每轮缩减到一半，因此循环次数是 $\log_2 n$ ，即 $2^n$ 的反函数。
|
||||
|
||||
=== "Java"
|
||||
|
||||
@@ -1602,6 +1596,8 @@ $$
|
||||
[class]{}-[func]{log_recur}
|
||||
```
|
||||
|
||||
对数阶常出现于基于「分治」的算法中，体现了“一分为多”和“化繁为简”的算法思想。它增长缓慢，是理想的时间复杂度，仅次于常数阶。
|
||||
|
||||
### 线性对数阶 $O(n \log n)$
|
||||
|
||||
线性对数阶常出现于嵌套循环中，两层循环的时间复杂度分别为 $O(\log n)$ 和 $O(n)$ 。
|
||||
@@ -1684,7 +1680,7 @@ $$
|
||||
|
||||
### 阶乘阶 $O(n!)$
|
||||
|
||||
阶乘阶对应数学上的「全排列」问题。给定 $n$ 个互不重复的元素，求其所有可能的排列方案，方案数量为：
|
||||
阶乘阶对应数学上的“全排列”问题。给定 $n$ 个互不重复的元素，求其所有可能的排列方案，方案数量为：
|
||||
|
||||
$$
|
||||
n! = n \times (n - 1) \times (n - 2) \times \cdots \times 2 \times 1
|
||||
@@ -1766,14 +1762,16 @@ $$
|
||||
|
||||
|
||||
|
||||
请注意，因为 $n! > 2^n$ ，所以阶乘阶比指数阶增长地更快，在 $n$ 较大时也是不可接受的。
|
||||
|
||||
## 最差、最佳、平均时间复杂度
|
||||
|
||||
**某些算法的时间复杂度不是固定的，而是与输入数据的分布有关**。例如，假设输入一个长度为 $n$ 的数组 `nums` ，其中 `nums` 由从 $1$ 至 $n$ 的数字组成，但元素顺序是随机打乱的；算法的任务是返回元素 $1$ 的索引。我们可以得出以下结论：
|
||||
**算法的时间效率往往不是固定的，而是与输入数据的分布有关**。假设输入一个长度为 $n$ 的数组 `nums` ，其中 `nums` 由从 $1$ 至 $n$ 的数字组成，但元素顺序是随机打乱的，任务目标是返回元素 $1$ 的索引。我们可以得出以下结论：
|
||||
|
||||
- 当 `nums = [?, ?, ..., 1]` ，即当末尾元素是 $1$ 时，需要完整遍历数组，此时达到 **最差时间复杂度 $O(n)$** 。
|
||||
- 当 `nums = [1, ?, ?, ...]` ，即当首个数字为 $1$ 时，无论数组多长都不需要继续遍历，此时达到 **最佳时间复杂度 $\Omega(1)$** 。
|
||||
- 当 `nums = [?, ?, ..., 1]` ，即当末尾元素是 $1$ 时，需要完整遍历数组，**达到最差时间复杂度 $O(n)$** 。
|
||||
- 当 `nums = [1, ?, ?, ...]` ，即当首个数字为 $1$ 时，无论数组多长都不需要继续遍历，**达到最佳时间复杂度 $\Omega(1)$** 。
|
||||
|
||||
“函数渐近上界”使用大 $O$ 记号表示，代表「最差时间复杂度」。相应地，“函数渐近下界”用 $\Omega$ 记号来表示，代表「最佳时间复杂度」。
|
||||
「最差时间复杂度」对应函数渐近上界，使用大 $O$ 记号表示。相应地，「最佳时间复杂度」对应函数渐近下界，用 $\Omega$ 记号表示。
|
||||
|
||||
=== "Java"
|
||||
|
||||
@@ -1890,15 +1888,13 @@ $$
|
||||
[class]{}-[func]{find_one}
|
||||
```
|
||||
|
||||
!!! tip
|
||||
值得说明的是，我们在实际中很少使用「最佳时间复杂度」，因为通常只有在很小概率下才能达到，可能会带来一定的误导性。**而「最差时间复杂度」更为实用，因为它给出了一个效率安全值**，让我们可以放心地使用算法。
|
||||
|
||||
实际应用中我们很少使用「最佳时间复杂度」，因为通常只有在很小概率下才能达到，可能会带来一定的误导性。相反，「最差时间复杂度」更为实用，因为它给出了一个“效率安全值”，让我们可以放心地使用算法。
|
||||
|
||||
从上述示例可以看出，最差或最佳时间复杂度只出现在“特殊分布的数据”中，这些情况的出现概率可能很小，因此并不能最真实地反映算法运行效率。相较之下，**「平均时间复杂度」可以体现算法在随机输入数据下的运行效率**，用 $\Theta$ 记号来表示。
|
||||
从上述示例可以看出，最差或最佳时间复杂度只出现于“特殊的数据分布”，这些情况的出现概率可能很小，并不能真实地反映算法运行效率。相比之下，**「平均时间复杂度」可以体现算法在随机输入数据下的运行效率**，用 $\Theta$ 记号来表示。
|
||||
|
||||
对于部分算法，我们可以简单地推算出随机数据分布下的平均情况。比如上述示例，由于输入数组是被打乱的，因此元素 $1$ 出现在任意索引的概率都是相等的，那么算法的平均循环次数则是数组长度的一半 $\frac{n}{2}$ ，平均时间复杂度为 $\Theta(\frac{n}{2}) = \Theta(n)$ 。
|
||||
|
||||
但在实际应用中，尤其是较为复杂的算法，计算平均时间复杂度比较困难，因为很难简便地分析出在数据分布下的整体数学期望。在这种情况下，我们通常使用最差时间复杂度作为算法效率的评判标准。
|
||||
但对于较为复杂的算法，计算平均时间复杂度往往是比较困难的，因为很难分析出在数据分布下的整体数学期望。在这种情况下，我们通常使用最差时间复杂度作为算法效率的评判标准。
|
||||
|
||||
!!! question "为什么很少看到 $\Theta$ 符号？"
|
||||
|
||||
|
||||
Reference in New Issue
Block a user