build

chapter_stack_and_queue/deque.md

@@ -4,7 +4,7 @@ comments: true
 
 # 5.3   双向队列
 
-对于队列，我们仅能在头部删除或在尾部添加元素。然而，「双向队列 deque」提供了更高的灵活性，允许在头部和尾部执行元素的添加或删除操作。
+在队列中，我们仅能在头部删除或在尾部添加元素。如下图所示，「双向队列 deque」提供了更高的灵活性，允许在头部和尾部执行元素的添加或删除操作。
 
 ![双向队列的操作](deque.assets/deque_operations.png)
 
@@ -336,7 +336,7 @@ comments: true
 
 对于双向队列而言，头部和尾部都可以执行入队和出队操作。换句话说，双向队列需要实现另一个对称方向的操作。为此，我们采用“双向链表”作为双向队列的底层数据结构。
 
-我们将双向链表的头节点和尾节点视为双向队列的队首和队尾，同时实现在两端添加和删除节点的功能。
+如下图所示，我们将双向链表的头节点和尾节点视为双向队列的队首和队尾，同时实现在两端添加和删除节点的功能。
 
 === "LinkedListDeque"
     ![基于链表实现双向队列的入队出队操作](deque.assets/linkedlist_deque.png)
@@ -355,7 +355,7 @@ comments: true
 
 <p align="center"> 图：基于链表实现双向队列的入队出队操作 </p>
 
-以下是具体实现代码。
+实现代码如下所示。
 
 === "Java"
 
@@ -1975,7 +1975,7 @@ comments: true
 
 ### 2. &nbsp; 基于数组的实现
 
-与基于数组实现队列类似，我们也可以使用环形数组来实现双向队列。在队列的实现基础上，仅需增加“队首入队”和“队尾出队”的方法。
+如下图所示，与基于数组实现队列类似，我们也可以使用环形数组来实现双向队列。
 
 === "ArrayDeque"
     ![基于数组实现双向队列的入队出队操作](deque.assets/array_deque.png)
@@ -1994,7 +1994,7 @@ comments: true
 
 <p align="center"> 图：基于数组实现双向队列的入队出队操作 </p>
 
-以下是具体实现代码。
+在队列的实现基础上，仅需增加“队首入队”和“队尾出队”的方法。
 
 === "Java"
 

chapter_stack_and_queue/queue.md

@@ -6,7 +6,7 @@ comments: true
 
 「队列 queue」是一种遵循先入先出规则的线性数据结构。顾名思义，队列模拟了排队现象，即新来的人不断加入队列的尾部，而位于队列头部的人逐个离开。
 
-我们把队列的头部称为“队首”，尾部称为“队尾”，把将元素加入队尾的操作称为“入队”，删除队首元素的操作称为“出队”。
+如下图所示，我们将队列的头部称为“队首”，尾部称为“队尾”，将把元素加入队尾的操作称为“入队”，删除队首元素的操作称为“出队”。
 
 ![队列的先入先出规则](queue.assets/queue_operations.png)
 
@@ -299,7 +299,7 @@ comments: true
 
 ### 1.   基于链表的实现
 
-对于链表实现，我们可以将链表的“头节点”和“尾节点”分别视为“队首”和“队尾”，规定队尾仅可添加节点，队首仅可删除节点。
+如下图所示，我们可以将链表的“头节点”和“尾节点”分别视为“队首”和“队尾”，规定队尾仅可添加节点，队首仅可删除节点。
 
 === "LinkedListQueue"
     ![基于链表实现队列的入队出队操作](queue.assets/linkedlist_queue.png)
@@ -312,7 +312,7 @@ comments: true
 
 <p align="center"> 图：基于链表实现队列的入队出队操作 </p>
 
-以下是用链表实现队列的示例代码。
+以下是用链表实现队列的代码。
 
 === "Java"
 
@@ -1188,10 +1188,10 @@ comments: true
 
 我们可以使用一个变量 `front` 指向队首元素的索引，并维护一个变量 `queSize` 用于记录队列长度。定义 `rear = front + queSize` ，这个公式计算出的 `rear` 指向队尾元素之后的下一个位置。
 
-基于此设计，**数组中包含元素的有效区间为 [front, rear - 1]**，进而：
+基于此设计，**数组中包含元素的有效区间为 `[front, rear - 1]`**，各种操作的实现方法如下图所示。
 
-- 对于入队操作，将输入元素赋值给 `rear` 索引处，并将 `queSize` 增加 1 。
-- 对于出队操作，只需将 `front` 增加 1 ，并将 `queSize` 减少 1 。
+- 入队操作：将输入元素赋值给 `rear` 索引处，并将 `queSize` 增加 1 。
+- 出队操作：只需将 `front` 增加 1 ，并将 `queSize` 减少 1 。
 
 可以看到，入队和出队操作都只需进行一次操作，时间复杂度均为 $O(1)$ 。
 

chapter_stack_and_queue/stack.md

@@ -8,7 +8,7 @@ comments: true
 
 我们可以将栈类比为桌面上的一摞盘子，如果需要拿出底部的盘子，则需要先将上面的盘子依次取出。我们将盘子替换为各种类型的元素（如整数、字符、对象等），就得到了栈数据结构。
 
-在栈中，我们把堆叠元素的顶部称为“栈顶”，底部称为“栈底”。将把元素添加到栈顶的操作叫做“入栈”，而删除栈顶元素的操作叫做“出栈”。
+如下图所示，我们把堆叠元素的顶部称为“栈顶”，底部称为“栈底”。将把元素添加到栈顶的操作叫做“入栈”，删除栈顶元素的操作叫做“出栈”。
 
 ![栈的先入后出规则](stack.assets/stack_operations.png)
 
@@ -301,7 +301,7 @@ comments: true
 
 使用链表来实现栈时，我们可以将链表的头节点视为栈顶，尾节点视为栈底。
 
-对于入栈操作，我们只需将元素插入链表头部，这种节点插入方法被称为“头插法”。而对于出栈操作，只需将头节点从链表中删除即可。
+如下图所示，对于入栈操作，我们只需将元素插入链表头部，这种节点插入方法被称为“头插法”。而对于出栈操作，只需将头节点从链表中删除即可。
 
 === "LinkedListStack"
     ![基于链表实现栈的入栈出栈操作](stack.assets/linkedlist_stack.png)
@@ -1070,7 +1070,7 @@ comments: true
 
 ### 2.   基于数组的实现
 
-使用数组实现栈时，我们可以将数组的尾部作为栈顶。在这样的设计下，入栈与出栈操作就分别对应在数组尾部添加元素与删除元素，时间复杂度都为 $O(1)$ 。
+使用数组实现栈时，我们可以将数组的尾部作为栈顶。如下图所示，入栈与出栈操作分别对应在数组尾部添加元素与删除元素，时间复杂度都为 $O(1)$ 。
 
 === "ArrayStack"
     ![基于数组实现栈的入栈出栈操作](stack.assets/array_stack.png)
@@ -1675,11 +1675,11 @@ comments: true
 
 ## 5.1.3   两种实现对比
 
-### 1.   支持操作
+**支持操作**
 
 两种实现都支持栈定义中的各项操作。数组实现额外支持随机访问，但这已超出了栈的定义范畴，因此一般不会用到。
 
-### 2.   时间效率
+**时间效率**
 
 在基于数组的实现中，入栈和出栈操作都是在预先分配好的连续内存中进行，具有很好的缓存本地性，因此效率较高。然而，如果入栈时超出数组容量，会触发扩容机制，导致该次入栈操作的时间复杂度变为 $O(n)$ 。
 
@@ -1690,7 +1690,7 @@ comments: true
 - 基于数组实现的栈在触发扩容时效率会降低，但由于扩容是低频操作，因此平均效率更高。
 - 基于链表实现的栈可以提供更加稳定的效率表现。
 
-### 3.   空间效率
+**空间效率**
 
 在初始化列表时，系统会为列表分配“初始容量”，该容量可能超过实际需求。并且，扩容机制通常是按照特定倍率（例如 2 倍）进行扩容，扩容后的容量也可能超出实际需求。因此，**基于数组实现的栈可能造成一定的空间浪费**。