diff --git a/docs-en/chapter_computational_complexity/time_complexity.md b/docs-en/chapter_computational_complexity/time_complexity.md
index f1716a9fb..4dc7c0ae8 100644
--- a/docs-en/chapter_computational_complexity/time_complexity.md
+++ b/docs-en/chapter_computational_complexity/time_complexity.md
@@ -1466,7 +1466,7 @@ Quadratic order means the number of operations grows quadratically with the inpu
def quadratic(n: int) -> int:
"""平方阶"""
count = 0
- # 循环次数与数组长度成平方关系
+ # 循环次数与数据大小 n 成平方关系
for i in range(n):
for j in range(n):
count += 1
@@ -1479,7 +1479,7 @@ Quadratic order means the number of operations grows quadratically with the inpu
/* 平方阶 */
int quadratic(int n) {
int count = 0;
- // 循环次数与数组长度成平方关系
+ // 循环次数与数据大小 n 成平方关系
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
count++;
@@ -1495,7 +1495,7 @@ Quadratic order means the number of operations grows quadratically with the inpu
/* 平方阶 */
int quadratic(int n) {
int count = 0;
- // 循环次数与数组长度成平方关系
+ // 循环次数与数据大小 n 成平方关系
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
count++;
@@ -1511,7 +1511,7 @@ Quadratic order means the number of operations grows quadratically with the inpu
/* 平方阶 */
int Quadratic(int n) {
int count = 0;
- // 循环次数与数组长度成平方关系
+ // 循环次数与数据大小 n 成平方关系
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
count++;
@@ -1527,7 +1527,7 @@ Quadratic order means the number of operations grows quadratically with the inpu
/* 平方阶 */
func quadratic(n int) int {
count := 0
- // 循环次数与数组长度成平方关系
+ // 循环次数与数据大小 n 成平方关系
for i := 0; i < n; i++ {
for j := 0; j < n; j++ {
count++
@@ -1543,7 +1543,7 @@ Quadratic order means the number of operations grows quadratically with the inpu
/* 平方阶 */
func quadratic(n: Int) -> Int {
var count = 0
- // 循环次数与数组长度成平方关系
+ // 循环次数与数据大小 n 成平方关系
for _ in 0 ..< n {
for _ in 0 ..< n {
count += 1
@@ -1559,7 +1559,7 @@ Quadratic order means the number of operations grows quadratically with the inpu
/* 平方阶 */
function quadratic(n) {
let count = 0;
- // 循环次数与数组长度成平方关系
+ // 循环次数与数据大小 n 成平方关系
for (let i = 0; i < n; i++) {
for (let j = 0; j < n; j++) {
count++;
@@ -1575,7 +1575,7 @@ Quadratic order means the number of operations grows quadratically with the inpu
/* 平方阶 */
function quadratic(n: number): number {
let count = 0;
- // 循环次数与数组长度成平方关系
+ // 循环次数与数据大小 n 成平方关系
for (let i = 0; i < n; i++) {
for (let j = 0; j < n; j++) {
count++;
@@ -1591,7 +1591,7 @@ Quadratic order means the number of operations grows quadratically with the inpu
/* 平方阶 */
int quadratic(int n) {
int count = 0;
- // 循环次数与数组长度成平方关系
+ // 循环次数与数据大小 n 成平方关系
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
count++;
@@ -1607,7 +1607,7 @@ Quadratic order means the number of operations grows quadratically with the inpu
/* 平方阶 */
fn quadratic(n: i32) -> i32 {
let mut count = 0;
- // 循环次数与数组长度成平方关系
+ // 循环次数与数据大小 n 成平方关系
for _ in 0..n {
for _ in 0..n {
count += 1;
@@ -1623,7 +1623,7 @@ Quadratic order means the number of operations grows quadratically with the inpu
/* 平方阶 */
int quadratic(int n) {
int count = 0;
- // 循环次数与数组长度成平方关系
+ // 循环次数与数据大小 n 成平方关系
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
count++;
@@ -1640,7 +1640,7 @@ Quadratic order means the number of operations grows quadratically with the inpu
fn quadratic(n: i32) i32 {
var count: i32 = 0;
var i: i32 = 0;
- // 循环次数与数组长度成平方关系
+ // 循环次数与数据大小 n 成平方关系
while (i < n) : (i += 1) {
var j: i32 = 0;
while (j < n) : (j += 1) {
@@ -1653,8 +1653,8 @@ Quadratic order means the number of operations grows quadratically with the inpu
??? pythontutor "Code Visualization"
-
-
+
+
The following image compares constant order, linear order, and quadratic order time complexities.
diff --git a/docs-en/chapter_stack_and_queue/queue.md b/docs-en/chapter_stack_and_queue/queue.md
index 8850efb4c..cf360f9ad 100755
--- a/docs-en/chapter_stack_and_queue/queue.md
+++ b/docs-en/chapter_stack_and_queue/queue.md
@@ -4,9 +4,9 @@ comments: true
# 5.2 Queue
-"Queue" is a linear data structure that follows the First-In-First-Out (FIFO) rule. As the name suggests, a queue simulates the phenomenon of lining up, where newcomers join the back of the queue, and people at the front of the queue leave one by one.
+"Queue" is a linear data structure that follows the First-In-First-Out (FIFO) rule. As the name suggests, a queue simulates the phenomenon of lining up, where newcomers join the queue at the rear, and the person at the front leaves the queue first.
-As shown in the Figure 5-4 , we call the front of the queue the "head" and the back the "tail." The operation of adding elements to the tail of the queue is termed "enqueue," and the operation of removing elements from the head is termed "dequeue."
+As shown in the Figure 5-4 , we call the front of the queue the "head" and the back the "tail." The operation of adding elements to the rear of the queue is termed "enqueue," and the operation of removing elements from the front is termed "dequeue."
{ class="animation-figure" }
@@ -14,7 +14,7 @@ As shown in the Figure 5-4 , we call the front of the queue the "head" and the b
## 5.2.1 Common Operations on Queue
-The common operations on a queue are shown in the Table 5-2 . Note that method names may vary across different programming languages. Here, we adopt the same naming convention as used for stacks.
+The common operations on a queue are shown in the Table 5-2 . Note that method names may vary across different programming languages. Here, we use the same naming convention as that used for stacks.
Table 5-2 Efficiency of Queue Operations
@@ -47,7 +47,7 @@ We can directly use the ready-made queue classes in programming languages:
que.append(5)
que.append(4)
- # Access the front element
+ # Access the first element
front: int = que[0]
# Dequeue an element
@@ -73,7 +73,7 @@ We can directly use the ready-made queue classes in programming languages:
queue.push(5);
queue.push(4);
- /* Access the front element */
+ /* Access the first element*/
int front = queue.front();
/* Dequeue an element */
@@ -99,7 +99,7 @@ We can directly use the ready-made queue classes in programming languages:
queue.offer(5);
queue.offer(4);
- /* Access the front element */
+ /* Access the first element */
int peek = queue.peek();
/* Dequeue an element */
@@ -125,7 +125,7 @@ We can directly use the ready-made queue classes in programming languages:
queue.Enqueue(5);
queue.Enqueue(4);
- /* Access the front element */
+ /* Access the first element */
int peek = queue.Peek();
/* Dequeue an element */
@@ -152,7 +152,7 @@ We can directly use the ready-made queue classes in programming languages:
queue.PushBack(5)
queue.PushBack(4)
- /* Access the front element */
+ /* Access the first element */
peek := queue.Front()
/* Dequeue an element */
@@ -180,7 +180,7 @@ We can directly use the ready-made queue classes in programming languages:
queue.append(5)
queue.append(4)
- /* Access the front element */
+ /* Access the first element */
let peek = queue.first!
/* Dequeue an element */
@@ -208,7 +208,7 @@ We can directly use the ready-made queue classes in programming languages:
queue.push(5);
queue.push(4);
- /* Access the front element */
+ /* Access the first element */
const peek = queue[0];
/* Dequeue an element */
@@ -236,7 +236,7 @@ We can directly use the ready-made queue classes in programming languages:
queue.push(5);
queue.push(4);
- /* Access the front element */
+ /* Access the first element */
const peek = queue[0];
/* Dequeue an element */
@@ -264,7 +264,7 @@ We can directly use the ready-made queue classes in programming languages:
queue.add(5);
queue.add(4);
- /* Access the front element */
+ /* Access the first element */
int peek = queue.first;
/* Dequeue an element */
@@ -291,7 +291,7 @@ We can directly use the ready-made queue classes in programming languages:
deque.push_back(5);
deque.push_back(4);
- /* Access the front element */
+ /* Access the first element */
if let Some(front) = deque.front() {
}
@@ -327,9 +327,9 @@ We can directly use the ready-made queue classes in programming languages:
To implement a queue, we need a data structure that allows adding elements at one end and removing them at the other. Both linked lists and arrays meet this requirement.
-### 1. Implementation Based on Linked List
+### 1. Implementation Based on a Linked List
-As shown in the Figure 5-5 , we can consider the "head node" and "tail node" of a linked list as the "head" and "tail" of the queue, respectively. We restrict the operations so that nodes can only be added at the tail and removed at the head.
+As shown in the Figure 5-5 , we can consider the "head node" and "tail node" of a linked list as the "front" and "rear" of the queue, respectively. It is stipulated that nodes can only be added at the rear and removed at the front.
=== "LinkedListQueue"
{ class="animation-figure" }
@@ -1217,11 +1217,11 @@ Below is the code for implementing a queue using a linked list:
-### 2. Implementation Based on Array
+### 2. Implementation Based on an Array
Deleting the first element in an array has a time complexity of $O(n)$, which would make the dequeue operation inefficient. However, this problem can be cleverly avoided as follows.
-We can use a variable `front` to point to the index of the head element and maintain a `size` variable to record the length of the queue. Define `rear = front + size`, which points to the position right after the tail element.
+We use a variable `front` to indicate the index of the front element and maintain a variable `size` to record the queue's length. Define `rear = front + size`, which points to the position immediately following the tail element.
With this design, **the effective interval of elements in the array is `[front, rear - 1]`**. The implementation methods for various operations are shown in the Figure 5-6 .
@@ -1241,9 +1241,9 @@ Both enqueue and dequeue operations only require a single operation, each with a
Figure 5-6 Implementing Queue with Array for Enqueue and Dequeue Operations
-You might notice a problem: as enqueue and dequeue operations are continuously performed, both `front` and `rear` move to the right and **will eventually reach the end of the array and can't move further**. To resolve this issue, we can treat the array as a "circular array."
+You might notice a problem: as enqueue and dequeue operations are continuously performed, both `front` and `rear` move to the right and **will eventually reach the end of the array and can't move further**. To resolve this, we can treat the array as a "circular array" where connecting the end of the array back to its beginning.
-For a circular array, `front` or `rear` needs to loop back to the start of the array upon reaching the end. This cyclical pattern can be achieved with a "modulo operation," as shown in the code below:
+In a circular array, `front` or `rear` needs to loop back to the start of the array upon reaching the end. This cyclical pattern can be achieved with a "modulo operation" as shown in the code below:
=== "Python"
@@ -2133,7 +2133,7 @@ For a circular array, `front` or `rear` needs to loop back to the start of the a
-The above implementation of the queue still has limitations: its length is fixed. However, this issue is not difficult to resolve. We can replace the array with a dynamic array to introduce an expansion mechanism. Interested readers can try to implement this themselves.
+The above implementation of the queue still has its limitations: its length is fixed. However, this issue is not difficult to resolve. We can replace the array with a dynamic array that can expand itself if needed. Interested readers can try to implement this themselves.
The comparison of the two implementations is consistent with that of the stack and is not repeated here.
diff --git a/docs/chapter_appendix/terminology.md b/docs/chapter_appendix/terminology.md
index 8f35e33ce..3ff5170b6 100644
--- a/docs/chapter_appendix/terminology.md
+++ b/docs/chapter_appendix/terminology.md
@@ -4,74 +4,134 @@ comments: true
# 16.3 术语表
-表 16-1 列出了书中出现的重要术语。建议读者同时记住它们的中英文叫法，以便阅读英文文献。
+表 16-1 列出了书中出现的重要术语，值得注意以下几点。
+
+- 部分名词在简体中文和繁体中文下的叫法不同。
+- 建议记住名词的英文叫法，以便阅读英文文献。
表 16-1 数据结构与算法的重要名词
-| 中文 | English | 中文 | English |
-| -------------- | ------------------------------ | -------------- | --------------------------- |
-| 算法 | algorithm | AVL 树 | AVL tree |
-| 数据结构 | data structure | 红黑树 | red-black tree |
-| 渐近复杂度分析 | asymptotic complexity analysis | 层序遍历 | level-order traversal |
-| 时间复杂度 | time complexity | 广度优先遍历 | breadth-first traversal |
-| 空间复杂度 | space complexity | 深度优先遍历 | depth-first traversal |
-| 迭代 | iteration | 二叉搜索树 | binary search tree |
-| 递归 | recursion | 平衡二叉搜索树 | balanced binary search tree |
-| 尾递归 | tail recursion | 平衡因子 | balance factor |
-| 递归树 | recursion tree | 堆 | heap |
-| 大 $O$ 记号 | big-$O$ notation | 大顶堆 | max heap |
-| 渐近上界 | asymptotic upper bound | 小顶堆 | min heap |
-| 原码 | sign-magnitude | 优先队列 | priority queue |
-| 反码 | 1’s complement | 堆化 | heapify |
-| 补码 | 2’s complement | Top-$k$ 问题 | Top-$k$ problem |
-| 数组 | array | 图 | graph |
-| 索引 | index | 顶点 | vertex |
-| 链表 | linked list | 无向图 | undirected graph |
-| 链表节点 | linked list node, list node | 有向图 | directed graph |
-| 头节点 | head node | 连通图 | connected graph |
-| 尾节点 | tail node | 非连通图 | disconnected graph |
-| 列表 | list | 有权图 | weighted graph |
-| 动态数组 | dynamic array | 邻接 | adjacency |
-| 硬盘 | hard disk | 路径 | path |
-| 内存 | random-access memory (RAM) | 入度 | in-degree |
-| 缓存 | cache memory | 出度 | out-degree |
-| 缓存未命中 | cache miss | 邻接矩阵 | adjacency matrix |
-| 缓存命中率 | cache hit rate | 邻接表 | adjacency list |
-| 栈 | stack | 广度优先搜索 | breadth-first search |
-| 栈顶 | top of the stack | 深度优先搜索 | depth-first search |
-| 栈底 | bottom of the stack | 二分查找 | binary search |
-| 队列 | queue | 搜索算法 | searching algorithm |
-| 双向队列 | double-ended queue | 排序算法 | sorting algorithm |
-| 队首 | front of the queue | 选择排序 | selection sort |
-| 队尾 | rear of the queue | 冒泡排序 | bubble sort |
-| 哈希表 | hash table | 插入排序 | insertion sort |
-| 桶 | bucket | 快速排序 | quick sort |
-| 哈希函数 | hash function | 归并排序 | merge sort |
-| 哈希冲突 | hash collision | 堆排序 | heap sort |
-| 负载因子 | load factor | 桶排序 | bucket sort |
-| 链式地址 | separate chaining | 计数排序 | counting sort |
-| 开放寻址 | open addressing | 基数排序 | radix sort |
-| 线性探测 | linear probing | 分治 | divide and conquer |
-| 懒删除 | lazy deletion | 汉诺塔问题 | hanota problem |
-| 二叉树 | binary tree | 回溯算法 | backtracking algorithm |
-| 树节点 | tree node | 约束 | constraint |
-| 左子节点 | left-child node | 解 | solution |
-| 右子节点 | right-child node | 状态 | state |
-| 父节点 | parent node | 剪枝 | pruning |
-| 左子树 | left subtree | 全排列问题 | permutations problem |
-| 右子树 | right subtree | 子集和问题 | subset-sum problem |
-| 根节点 | root node | n 皇后问题 | n-queens problem |
-| 叶节点 | leaf node | 动态规划 | dynamic programming |
-| 边 | edge | 初始状态 | initial state |
-| 层 | level | 状态转移方程 | state-trasition equation |
-| 度 | degree | 背包问题 | knapsack problem |
-| 高度 | height | 编辑距离问题 | edit distance problem |
-| 深度 | depth | 贪心算法 | greedy algorithm |
-| 完美二叉树 | perfect binary tree | | |
-| 完全二叉树 | complete binary tree | | |
-| 完满二叉树 | full binary tree | | |
-| 平衡二叉树 | balanced binary tree | | |
+| English | 简体中文 | 繁体中文 |
+| ------------------------------ | -------------- | -------------- |
+| algorithm | 算法 | 算法 |
+| data structure | 数据结构 | 資料結構 |
+| asymptotic complexity analysis | 渐近复杂度分析 | 漸近複雜度分析 |
+| time complexity | 时间复杂度 | 時間複雜度 |
+| space complexity | 空间复杂度 | 空間複雜度 |
+| iteration | 迭代 | 迭代 |
+| recursion | 递归 | 遞迴 |
+| tail recursion | 尾递归 | 尾遞迴 |
+| recursion tree | 递归树 | 遞迴樹 |
+| big-$O$ notation | 大 $O$ 记号 | 大 $O$ 記號 |
+| asymptotic upper bound | 渐近上界 | 漸近上界 |
+| sign-magnitude | 原码 | 原碼 |
+| 1’s complement | 反码 | 反碼 |
+| 2’s complement | 补码 | 補碼 |
+| array | 数组 | 陣列 |
+| index | 索引 | 索引 |
+| linked list | 链表 | 連結串列 |
+| linked list node, list node | 链表节点 | 連結串列節點 |
+| head node | 头节点 | 頭節點 |
+| tail node | 尾节点 | 尾節點 |
+| list | 列表 | 列表 |
+| dynamic array | 动态数组 | 動態陣列 |
+| hard disk | 硬盘 | 硬碟 |
+| random-access memory (RAM) | 内存 | 內存 |
+| cache memory | 缓存 | 快取 |
+| cache miss | 缓存未命中 | 快取未命中 |
+| cache hit rate | 缓存命中率 | 快取命中率 |
+| stack | 栈 | 堆疊 |
+| top of the stack | 栈顶 | 堆疊頂 |
+| bottom of the stack | 栈底 | 堆疊底 |
+| queue | 队列 | 佇列 |
+| double-ended queue | 双向队列 | 雙向佇列 |
+| front of the queue | 队首 | 佇列首 |
+| rear of the queue | 队尾 | 佇列尾 |
+| hash table | 哈希表 | 雜湊表 |
+| bucket | 桶 | 桶 |
+| hash function | 哈希函数 | 雜湊函式 |
+| hash collision | 哈希冲突 | 雜湊衝突 |
+| load factor | 负载因子 | 負載因子 |
+| separate chaining | 链式地址 | 鏈結位址 |
+| open addressing | 开放寻址 | 開放定址 |
+| linear probing | 线性探测 | 線性探查 |
+| lazy deletion | 懒删除 | 懶刪除 |
+| binary tree | 二叉树 | 二元樹 |
+| tree node | 树节点 | 樹節點 |
+| left-child node | 左子节点 | 左子節點 |
+| right-child node | 右子节点 | 右子節點 |
+| parent node | 父节点 | 父節點 |
+| left subtree | 左子树 | 左子樹 |
+| right subtree | 右子树 | 右子樹 |
+| root node | 根节点 | 根節點 |
+| leaf node | 叶节点 | 葉節點 |
+| edge | 边 | 邊 |
+| level | 层 | 層 |
+| degree | 度 | 度 |
+| height | 高度 | 高度 |
+| depth | 深度 | 深度 |
+| perfect binary tree | 完美二叉树 | 完美二元樹 |
+| complete binary tree | 完全二叉树 | 完全二元樹 |
+| full binary tree | 完满二叉树 | 完滿二元樹 |
+| balanced binary tree | 平衡二叉树 | 平衡二元樹 |
+| AVL tree | AVL 树 | AVL 樹 |
+| red-black tree | 红黑树 | 紅黑樹 |
+| level-order traversal | 层序遍历 | 層序走訪 |
+| breadth-first traversal | 广度优先遍历 | 廣度優先走訪 |
+| depth-first traversal | 深度优先遍历 | 深度優先走訪 |
+| binary search tree | 二叉搜索树 | 二元搜尋樹 |
+| balanced binary search tree | 平衡二叉搜索树 | 平衡二元搜尋樹 |
+| balance factor | 平衡因子 | 平衡因子 |
+| heap | 堆 | 堆 |
+| max heap | 大顶堆 | 大頂堆 |
+| min heap | 小顶堆 | 小頂堆 |
+| priority queue | 优先队列 | 優先佇列 |
+| heapify | 堆化 | 堆化 |
+| top-$k$ problem | Top-$k$ 问题 | Top-$k$ 問題 |
+| graph | 图 | 圖 |
+| vertex | 顶点 | 頂點 |
+| undirected graph | 无向图 | 無向圖 |
+| directed graph | 有向图 | 有向圖 |
+| connected graph | 连通图 | 連通圖 |
+| disconnected graph | 非连通图 | 非連通圖 |
+| weighted graph | 有权图 | 有權圖 |
+| adjacency | 邻接 | 鄰接 |
+| path | 路径 | 路徑 |
+| in-degree | 入度 | 入度 |
+| out-degree | 出度 | 出度 |
+| adjacency matrix | 邻接矩阵 | 鄰接矩陣 |
+| adjacency list | 邻接表 | 鄰接表 |
+| breadth-first search | 广度优先搜索 | 廣度優先搜尋 |
+| depth-first search | 深度优先搜索 | 深度優先搜尋 |
+| binary search | 二分查找 | 二分查找 |
+| searching algorithm | 搜索算法 | 搜尋演算法 |
+| sorting algorithm | 排序算法 | 排序演算法 |
+| selection sort | 选择排序 | 選擇排序 |
+| bubble sort | 冒泡排序 | 泡沫排序 |
+| insertion sort | 插入排序 | 插入排序 |
+| quick sort | 快速排序 | 快速排序 |
+| merge sort | 归并排序 | 合併排序 |
+| heap sort | 堆排序 | 堆排序 |
+| bucket sort | 桶排序 | 桶排序 |
+| counting sort | 计数排序 | 計數排序 |
+| radix sort | 基数排序 | 基數排序 |
+| divide and conquer | 分治 | 分治 |
+| hanota problem | 汉诺塔问题 | 漢諾塔問題 |
+| backtracking algorithm | 回溯算法 | 回溯演算法 |
+| constraint | 约束 | 約束 |
+| solution | 解 | 解 |
+| state | 状态 | 狀態 |
+| pruning | 剪枝 | 剪枝 |
+| permutations problem | 全排列问题 | 全排列問題 |
+| subset-sum problem | 子集和问题 | 子集合問題 |
+| $n$-queens problem | $n$ 皇后问题 | $n$ 皇后問題 |
+| dynamic programming | 动态规划 | 動態規劃 |
+| initial state | 初始状态 | 初始狀態 |
+| state-trasition equation | 状态转移方程 | 狀態轉移方程 |
+| knapsack problem | 背包问题 | 背包問題 |
+| edit distance problem | 编辑距离问题 | 編輯距離問題 |
+| greedy algorithm | 贪心算法 | 貪心演算法 |
diff --git a/docs/chapter_computational_complexity/time_complexity.md b/docs/chapter_computational_complexity/time_complexity.md
index 4f3f7dcc2..95bb2ab3c 100755
--- a/docs/chapter_computational_complexity/time_complexity.md
+++ b/docs/chapter_computational_complexity/time_complexity.md
@@ -1470,7 +1470,7 @@ $$
def quadratic(n: int) -> int:
"""平方阶"""
count = 0
- # 循环次数与数组长度成平方关系
+ # 循环次数与数据大小 n 成平方关系
for i in range(n):
for j in range(n):
count += 1
@@ -1483,7 +1483,7 @@ $$
/* 平方阶 */
int quadratic(int n) {
int count = 0;
- // 循环次数与数组长度成平方关系
+ // 循环次数与数据大小 n 成平方关系
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
count++;
@@ -1499,7 +1499,7 @@ $$
/* 平方阶 */
int quadratic(int n) {
int count = 0;
- // 循环次数与数组长度成平方关系
+ // 循环次数与数据大小 n 成平方关系
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
count++;
@@ -1515,7 +1515,7 @@ $$
/* 平方阶 */
int Quadratic(int n) {
int count = 0;
- // 循环次数与数组长度成平方关系
+ // 循环次数与数据大小 n 成平方关系
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
count++;
@@ -1531,7 +1531,7 @@ $$
/* 平方阶 */
func quadratic(n int) int {
count := 0
- // 循环次数与数组长度成平方关系
+ // 循环次数与数据大小 n 成平方关系
for i := 0; i < n; i++ {
for j := 0; j < n; j++ {
count++
@@ -1547,7 +1547,7 @@ $$
/* 平方阶 */
func quadratic(n: Int) -> Int {
var count = 0
- // 循环次数与数组长度成平方关系
+ // 循环次数与数据大小 n 成平方关系
for _ in 0 ..< n {
for _ in 0 ..< n {
count += 1
@@ -1563,7 +1563,7 @@ $$
/* 平方阶 */
function quadratic(n) {
let count = 0;
- // 循环次数与数组长度成平方关系
+ // 循环次数与数据大小 n 成平方关系
for (let i = 0; i < n; i++) {
for (let j = 0; j < n; j++) {
count++;
@@ -1579,7 +1579,7 @@ $$
/* 平方阶 */
function quadratic(n: number): number {
let count = 0;
- // 循环次数与数组长度成平方关系
+ // 循环次数与数据大小 n 成平方关系
for (let i = 0; i < n; i++) {
for (let j = 0; j < n; j++) {
count++;
@@ -1595,7 +1595,7 @@ $$
/* 平方阶 */
int quadratic(int n) {
int count = 0;
- // 循环次数与数组长度成平方关系
+ // 循环次数与数据大小 n 成平方关系
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
count++;
@@ -1611,7 +1611,7 @@ $$
/* 平方阶 */
fn quadratic(n: i32) -> i32 {
let mut count = 0;
- // 循环次数与数组长度成平方关系
+ // 循环次数与数据大小 n 成平方关系
for _ in 0..n {
for _ in 0..n {
count += 1;
@@ -1627,7 +1627,7 @@ $$
/* 平方阶 */
int quadratic(int n) {
int count = 0;
- // 循环次数与数组长度成平方关系
+ // 循环次数与数据大小 n 成平方关系
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
count++;
@@ -1644,7 +1644,7 @@ $$
fn quadratic(n: i32) i32 {
var count: i32 = 0;
var i: i32 = 0;
- // 循环次数与数组长度成平方关系
+ // 循环次数与数据大小 n 成平方关系
while (i < n) : (i += 1) {
var j: i32 = 0;
while (j < n) : (j += 1) {
@@ -1657,8 +1657,8 @@ $$
??? pythontutor "可视化运行"
-
-
+
+
图 2-10 对比了常数阶、线性阶和平方阶三种时间复杂度。