deploy

chapter_stack_and_queue/deque/index.html

@@ -1794,12 +1794,12 @@
 
 
 <h1 id="53">5.3. &nbsp; 双向队列<a class="headerlink" href="#53" title="Permanent link">&para;</a></h1>
-<p>对于队列，我们只能在头部删除或在尾部添加元素，而「双向队列 Deque」更加灵活，在其头部和尾部都能执行元素添加或删除操作。</p>
+<p>对于队列，我们仅能在头部删除或在尾部添加元素。然而，「双向队列 Deque」提供了更高的灵活性，允许在头部和尾部执行元素的添加或删除操作。</p>
 <p><img alt="双向队列的操作" src="../deque.assets/deque_operations.png" /></p>
 <p align="center"> Fig. 双向队列的操作 </p>
 
 <h2 id="531">5.3.1. &nbsp; 双向队列常用操作<a class="headerlink" href="#531" title="Permanent link">&para;</a></h2>
-<p>双向队列的常用操作见下表，方法名需根据语言来确定。</p>
+<p>双向队列的常用操作如下表所示，具体的方法名称需要根据所使用的编程语言来确定。</p>
 <div class="center-table">
 <table>
 <thead>
@@ -1843,7 +1843,7 @@
 </tbody>
 </table>
 </div>
-<p>相同地，我们可以直接使用编程语言实现好的双向队列类。</p>
+<p>同样地，我们可以直接使用编程语言中已实现的双向队列类。</p>
 <div class="tabbed-set tabbed-alternate" data-tabs="1:10"><input checked="checked" id="__tabbed_1_1" name="__tabbed_1" type="radio" /><input id="__tabbed_1_2" name="__tabbed_1" type="radio" /><input id="__tabbed_1_3" name="__tabbed_1" type="radio" /><input id="__tabbed_1_4" name="__tabbed_1" type="radio" /><input id="__tabbed_1_5" name="__tabbed_1" type="radio" /><input id="__tabbed_1_6" name="__tabbed_1" type="radio" /><input id="__tabbed_1_7" name="__tabbed_1" type="radio" /><input id="__tabbed_1_8" name="__tabbed_1" type="radio" /><input id="__tabbed_1_9" name="__tabbed_1" type="radio" /><input id="__tabbed_1_10" name="__tabbed_1" type="radio" /><div class="tabbed-labels"><label for="__tabbed_1_1">Java</label><label for="__tabbed_1_2">C++</label><label for="__tabbed_1_3">Python</label><label for="__tabbed_1_4">Go</label><label for="__tabbed_1_5">JavaScript</label><label for="__tabbed_1_6">TypeScript</label><label for="__tabbed_1_7">C</label><label for="__tabbed_1_8">C#</label><label for="__tabbed_1_9">Swift</label><label for="__tabbed_1_10">Zig</label></div>
 <div class="tabbed-content">
 <div class="tabbed-block">
@@ -2089,11 +2089,11 @@
 </div>
 </div>
 <h2 id="532">5.3.2. &nbsp; 双向队列实现 *<a class="headerlink" href="#532" title="Permanent link">&para;</a></h2>
-<p>与队列类似，双向队列同样可以使用链表或数组来实现。</p>
+<p>双向队列的实现与队列类似，可以选择链表或数组作为底层数据结构。</p>
 <h3 id="_1">基于双向链表的实现<a class="headerlink" href="#_1" title="Permanent link">&para;</a></h3>
-<p>回忆上节内容，由于可以方便地删除链表头节点（对应出队操作），以及在链表尾节点后添加新节点（对应入队操作），因此我们使用普通单向链表来实现队列。</p>
-<p>而双向队列的头部和尾部都可以执行入队与出队操作，换言之，双向队列的操作是“首尾对称”的，也需要实现另一个对称方向的操作。因此，双向队列需要使用「双向链表」来实现。</p>
-<p>我们将双向链表的头节点和尾节点分别看作双向队列的队首和队尾，并且实现在两端都能添加与删除节点。</p>
+<p>回顾上一节内容，我们使用普通单向链表来实现队列，因为它可以方便地删除头节点（对应出队操作）和在尾节点后添加新节点（对应入队操作）。</p>
+<p>对于双向队列而言，头部和尾部都可以执行入队和出队操作。换句话说，双向队列需要实现另一个对称方向的操作。为此，我们采用「双向链表」作为双向队列的底层数据结构。</p>
+<p>我们将双向链表的头节点和尾节点视为双向队列的队首和队尾，同时实现在两端添加和删除节点的功能。</p>
 <div class="tabbed-set tabbed-alternate" data-tabs="2:5"><input checked="checked" id="__tabbed_2_1" name="__tabbed_2" type="radio" /><input id="__tabbed_2_2" name="__tabbed_2" type="radio" /><input id="__tabbed_2_3" name="__tabbed_2" type="radio" /><input id="__tabbed_2_4" name="__tabbed_2" type="radio" /><input id="__tabbed_2_5" name="__tabbed_2" type="radio" /><div class="tabbed-labels"><label for="__tabbed_2_1">LinkedListDeque</label><label for="__tabbed_2_2">pushLast()</label><label for="__tabbed_2_3">pushFirst()</label><label for="__tabbed_2_4">popLast()</label><label for="__tabbed_2_5">popFirst()</label></div>
 <div class="tabbed-content">
 <div class="tabbed-block">
@@ -3121,7 +3121,7 @@
 </div>
 </div>
 <h3 id="_2">基于数组的实现<a class="headerlink" href="#_2" title="Permanent link">&para;</a></h3>
-<p>与基于数组实现队列类似，我们也可以使用环形数组来实现双向队列。在实现队列的基础上，增加实现“队首入队”和“队尾出队”方法即可。</p>
+<p>与基于数组实现队列类似，我们也可以使用环形数组来实现双向队列。在队列的实现基础上，仅需增加“队首入队”和“队尾出队”的方法。</p>
 <div class="tabbed-set tabbed-alternate" data-tabs="4:5"><input checked="checked" id="__tabbed_4_1" name="__tabbed_4" type="radio" /><input id="__tabbed_4_2" name="__tabbed_4" type="radio" /><input id="__tabbed_4_3" name="__tabbed_4" type="radio" /><input id="__tabbed_4_4" name="__tabbed_4" type="radio" /><input id="__tabbed_4_5" name="__tabbed_4" type="radio" /><div class="tabbed-labels"><label for="__tabbed_4_1">ArrayDeque</label><label for="__tabbed_4_2">pushLast()</label><label for="__tabbed_4_3">pushFirst()</label><label for="__tabbed_4_4">popLast()</label><label for="__tabbed_4_5">popFirst()</label></div>
 <div class="tabbed-content">
 <div class="tabbed-block">
@@ -3898,8 +3898,8 @@
 </div>
 </div>
 <h2 id="533">5.3.3. &nbsp; 双向队列应用<a class="headerlink" href="#533" title="Permanent link">&para;</a></h2>
-<p>双向队列同时表现出栈与队列的逻辑，<strong>因此可以实现两者的所有应用，并且提供更高的自由度</strong>。</p>
-<p>我们知道，软件的“撤销”功能需要使用栈来实现；系统把每一次更改操作 <code>push</code> 到栈中，然后通过 <code>pop</code> 实现撤销。然而，考虑到系统资源有限，软件一般会限制撤销的步数（例如仅允许保存 <span class="arithmatex">\(50\)</span> 步），那么当栈的长度 <span class="arithmatex">\(&gt; 50\)</span> 时，软件就需要在栈底（即队首）执行删除，<strong>但栈无法实现，此时就需要使用双向队列来替代栈</strong>。注意，“撤销”的核心逻辑仍然是栈的先入后出，只是双向队列可以更加灵活地实现。</p>
+<p>双向队列兼具栈与队列的逻辑，<strong>因此它可以实现这两者的所有应用场景，同时提供更高的自由度</strong>。</p>
+<p>我们知道，软件的“撤销”功能通常使用栈来实现：系统将每次更改操作 <code>push</code> 到栈中，然后通过 <code>pop</code> 实现撤销。然而，考虑到系统资源的限制，软件通常会限制撤销的步数（例如仅允许保存 <span class="arithmatex">\(50\)</span> 步）。当栈的长度超过 <span class="arithmatex">\(50\)</span> 时，软件需要在栈底（即队首）执行删除操作。<strong>但栈无法实现该功能，此时就需要使用双向队列来替代栈</strong>。请注意，“撤销”的核心逻辑仍然遵循栈的先入后出原则，只是双向队列能够更加灵活地实现一些额外逻辑。</p>
 
 
 

chapter_stack_and_queue/queue/index.html

@@ -855,14 +855,7 @@
       
         <li class="md-nav__item">
   <a href="#523" class="md-nav__link">
-    5.2.3. &nbsp; 两种实现对比
-  </a>
-  
-</li>
-      
-        <li class="md-nav__item">
-  <a href="#524" class="md-nav__link">
-    5.2.4. &nbsp; 队列典型应用
+    5.2.3. &nbsp; 队列典型应用
   </a>
   
 </li>
@@ -1772,14 +1765,7 @@
       
         <li class="md-nav__item">
   <a href="#523" class="md-nav__link">
-    5.2.3. &nbsp; 两种实现对比
-  </a>
-  
-</li>
-      
-        <li class="md-nav__item">
-  <a href="#524" class="md-nav__link">
-    5.2.4. &nbsp; 队列典型应用
+    5.2.3. &nbsp; 队列典型应用
   </a>
   
 </li>
@@ -1808,13 +1794,13 @@
 
 
 <h1 id="52">5.2. &nbsp; 队列<a class="headerlink" href="#52" title="Permanent link">&para;</a></h1>
-<p>「队列 Queue」是一种遵循先入先出（first in, first out）数据操作规则的线性数据结构。顾名思义，队列模拟的是排队现象，即外面的人不断加入队列尾部，而处于队列头部的人不断地离开。</p>
-<p>我们将队列头部称为「队首」，队列尾部称为「队尾」，将把元素加入队尾的操作称为「入队」，删除队首元素的操作称为「出队」。</p>
+<p>「队列 Queue」是一种遵循先入先出（First In, First Out）规则的线性数据结构。顾名思义，队列模拟了排队现象，即新来的人不断加入队列的尾部，而位于队列头部的人逐个离开。</p>
+<p>我们把队列的头部称为「队首」，尾部称为「队尾」，把将元素加入队尾的操作称为「入队」，删除队首元素的操作称为「出队」。</p>
 <p><img alt="队列的先入先出规则" src="../queue.assets/queue_operations.png" /></p>
 <p align="center"> Fig. 队列的先入先出规则 </p>
 
 <h2 id="521">5.2.1. &nbsp; 队列常用操作<a class="headerlink" href="#521" title="Permanent link">&para;</a></h2>
-<p>队列的常用操作见下表。需要注意，不同编程语言的方法名是不同的，在这里我们采用与栈相同的方法命名。</p>
+<p>队列的常见操作如下表所示。需要注意的是，不同编程语言的方法名称可能会有所不同。我们在此采用与栈相同的方法命名。</p>
 <div class="center-table">
 <table>
 <thead>
@@ -1843,7 +1829,7 @@
 </tbody>
 </table>
 </div>
-<p>我们可以直接使用编程语言实现好的队列类。</p>
+<p>我们可以直接使用编程语言中现成的队列类。</p>
 <div class="tabbed-set tabbed-alternate" data-tabs="1:10"><input checked="checked" id="__tabbed_1_1" name="__tabbed_1" type="radio" /><input id="__tabbed_1_2" name="__tabbed_1" type="radio" /><input id="__tabbed_1_3" name="__tabbed_1" type="radio" /><input id="__tabbed_1_4" name="__tabbed_1" type="radio" /><input id="__tabbed_1_5" name="__tabbed_1" type="radio" /><input id="__tabbed_1_6" name="__tabbed_1" type="radio" /><input id="__tabbed_1_7" name="__tabbed_1" type="radio" /><input id="__tabbed_1_8" name="__tabbed_1" type="radio" /><input id="__tabbed_1_9" name="__tabbed_1" type="radio" /><input id="__tabbed_1_10" name="__tabbed_1" type="radio" /><div class="tabbed-labels"><label for="__tabbed_1_1">Java</label><label for="__tabbed_1_2">C++</label><label for="__tabbed_1_3">Python</label><label for="__tabbed_1_4">Go</label><label for="__tabbed_1_5">JavaScript</label><label for="__tabbed_1_6">TypeScript</label><label for="__tabbed_1_7">C</label><label for="__tabbed_1_8">C#</label><label for="__tabbed_1_9">Swift</label><label for="__tabbed_1_10">Zig</label></div>
 <div class="tabbed-content">
 <div class="tabbed-block">
@@ -2059,9 +2045,9 @@
 </div>
 </div>
 <h2 id="522">5.2.2. &nbsp; 队列实现<a class="headerlink" href="#522" title="Permanent link">&para;</a></h2>
-<p>队列需要一种可以在一端添加，并在另一端删除的数据结构，也可以使用链表或数组来实现。</p>
+<p>为了实现队列，我们需要一种数据结构，可以在一端添加元素，并在另一端删除元素。因此，链表和数组都可以用来实现队列。</p>
 <h3 id="_1">基于链表的实现<a class="headerlink" href="#_1" title="Permanent link">&para;</a></h3>
-<p>我们将链表的「头节点」和「尾节点」分别看作是队首和队尾，并规定队尾只可添加节点，队首只可删除节点。</p>
+<p>对于链表实现，我们可以将链表的「头节点」和「尾节点」分别视为队首和队尾，规定队尾仅可添加节点，而队首仅可删除节点。</p>
 <div class="tabbed-set tabbed-alternate" data-tabs="2:3"><input checked="checked" id="__tabbed_2_1" name="__tabbed_2" type="radio" /><input id="__tabbed_2_2" name="__tabbed_2" type="radio" /><input id="__tabbed_2_3" name="__tabbed_2" type="radio" /><div class="tabbed-labels"><label for="__tabbed_2_1">LinkedListQueue</label><label for="__tabbed_2_2">push()</label><label for="__tabbed_2_3">pop()</label></div>
 <div class="tabbed-content">
 <div class="tabbed-block">
@@ -2075,7 +2061,7 @@
 </div>
 </div>
 </div>
-<p>以下是使用链表实现队列的示例代码。</p>
+<p>以下是用链表实现队列的示例代码。</p>
 <div class="tabbed-set tabbed-alternate" data-tabs="3:10"><input checked="checked" id="__tabbed_3_1" name="__tabbed_3" type="radio" /><input id="__tabbed_3_2" name="__tabbed_3" type="radio" /><input id="__tabbed_3_3" name="__tabbed_3" type="radio" /><input id="__tabbed_3_4" name="__tabbed_3" type="radio" /><input id="__tabbed_3_5" name="__tabbed_3" type="radio" /><input id="__tabbed_3_6" name="__tabbed_3" type="radio" /><input id="__tabbed_3_7" name="__tabbed_3" type="radio" /><input id="__tabbed_3_8" name="__tabbed_3" type="radio" /><input id="__tabbed_3_9" name="__tabbed_3" type="radio" /><input id="__tabbed_3_10" name="__tabbed_3" type="radio" /><div class="tabbed-labels"><label for="__tabbed_3_1">Java</label><label for="__tabbed_3_2">C++</label><label for="__tabbed_3_3">Python</label><label for="__tabbed_3_4">Go</label><label for="__tabbed_3_5">JavaScript</label><label for="__tabbed_3_6">TypeScript</label><label for="__tabbed_3_7">C</label><label for="__tabbed_3_8">C#</label><label for="__tabbed_3_9">Swift</label><label for="__tabbed_3_10">Zig</label></div>
 <div class="tabbed-content">
 <div class="tabbed-block">
@@ -2708,14 +2694,14 @@
 </div>
 </div>
 <h3 id="_2">基于数组的实现<a class="headerlink" href="#_2" title="Permanent link">&para;</a></h3>
-<p>数组的删除首元素的时间复杂度为 <span class="arithmatex">\(O(n)\)</span> ，这会导致出队操作效率低下。然而，我们可以采取下述的巧妙方法来避免这个问题。</p>
-<p>考虑借助一个变量 <code>front</code> 来指向队首元素的索引，并维护变量 <code>queSize</code> 来记录队列长度。我们定义 <code>rear = front + queSize</code> ，该公式计算出来的 <code>rear</code> 指向“队尾元素索引 <span class="arithmatex">\(+1\)</span> ”的位置。</p>
-<p>在该设计下，<strong>数组中包含元素的有效区间为 <code>[front, rear - 1]</code></strong> ，进而</p>
+<p>由于数组删除首元素的时间复杂度为 <span class="arithmatex">\(O(n)\)</span> ，这会导致出队操作效率较低。然而，我们可以采用以下巧妙方法来避免这个问题。</p>
+<p>我们可以使用一个变量 <code>front</code> 指向队首元素的索引，并维护一个变量 <code>queSize</code> 用于记录队列长度。定义 <code>rear = front + queSize</code> ，这个公式计算出的 <code>rear</code> 指向队尾元素之后的下一个位置。</p>
+<p>基于此设计，<strong>数组中包含元素的有效区间为 [front, rear - 1]</strong>，进而：</p>
 <ul>
-<li>对于入队操作，将输入元素赋值给 <code>rear</code> 索引处，并将 <code>queSize</code> 自增 <span class="arithmatex">\(1\)</span> 即可；</li>
-<li>对于出队操作，仅需将 <code>front</code> 自增 <span class="arithmatex">\(1\)</span> ，并将 <code>queSize</code> 自减 <span class="arithmatex">\(1\)</span> 即可；</li>
+<li>对于入队操作，将输入元素赋值给 <code>rear</code> 索引处，并将 <code>queSize</code> 增加 1 ；</li>
+<li>对于出队操作，只需将 <code>front</code> 增加 1 ，并将 <code>queSize</code> 减少 1 ；</li>
 </ul>
-<p>观察发现，入队与出队操作都仅需单次操作即可完成，时间复杂度皆为 <span class="arithmatex">\(O(1)\)</span> 。</p>
+<p>可以看到，入队和出队操作都只需进行一次操作，时间复杂度均为 <span class="arithmatex">\(O(1)\)</span> 。</p>
 <div class="tabbed-set tabbed-alternate" data-tabs="4:3"><input checked="checked" id="__tabbed_4_1" name="__tabbed_4" type="radio" /><input id="__tabbed_4_2" name="__tabbed_4" type="radio" /><input id="__tabbed_4_3" name="__tabbed_4" type="radio" /><div class="tabbed-labels"><label for="__tabbed_4_1">ArrayQueue</label><label for="__tabbed_4_2">push()</label><label for="__tabbed_4_3">pop()</label></div>
 <div class="tabbed-content">
 <div class="tabbed-block">
@@ -2729,8 +2715,8 @@
 </div>
 </div>
 </div>
-<p>细心的同学可能会发现一个问题：在不断入队与出队的过程中，<code>front</code> 和 <code>rear</code> 都在向右移动，<strong>在到达数组尾部后就无法继续移动了</strong>。为解决此问题，<strong>我们考虑将数组看作是首尾相接的</strong>，这样的数组被称为「环形数组」。</p>
-<p>对于环形数组，我们需要令 <code>front</code> 或 <code>rear</code> 在越过数组尾部后，直接绕回到数组头部接续遍历。这种周期性规律可以通过「取余操作」来实现，详情请见以下代码。</p>
+<p>你可能会发现一个问题：在不断进行入队和出队的过程中，<code>front</code> 和 <code>rear</code> 都在向右移动，<strong>当它们到达数组尾部时就无法继续移动了</strong>。为解决此问题，我们可以将数组视为首尾相接的「环形数组」。</p>
+<p>对于环形数组，我们需要让 <code>front</code> 或 <code>rear</code> 在越过数组尾部时，直接回到数组头部继续遍历。这种周期性规律可以通过“取余操作”来实现，代码如下所示。</p>
 <div class="tabbed-set tabbed-alternate" data-tabs="5:10"><input checked="checked" id="__tabbed_5_1" name="__tabbed_5" type="radio" /><input id="__tabbed_5_2" name="__tabbed_5" type="radio" /><input id="__tabbed_5_3" name="__tabbed_5" type="radio" /><input id="__tabbed_5_4" name="__tabbed_5" type="radio" /><input id="__tabbed_5_5" name="__tabbed_5" type="radio" /><input id="__tabbed_5_6" name="__tabbed_5" type="radio" /><input id="__tabbed_5_7" name="__tabbed_5" type="radio" /><input id="__tabbed_5_8" name="__tabbed_5" type="radio" /><input id="__tabbed_5_9" name="__tabbed_5" type="radio" /><input id="__tabbed_5_10" name="__tabbed_5" type="radio" /><div class="tabbed-labels"><label for="__tabbed_5_1">Java</label><label for="__tabbed_5_2">C++</label><label for="__tabbed_5_3">Python</label><label for="__tabbed_5_4">Go</label><label for="__tabbed_5_5">JavaScript</label><label for="__tabbed_5_6">TypeScript</label><label for="__tabbed_5_7">C</label><label for="__tabbed_5_8">C#</label><label for="__tabbed_5_9">Swift</label><label for="__tabbed_5_10">Zig</label></div>
 <div class="tabbed-content">
 <div class="tabbed-block">
@@ -3389,13 +3375,12 @@
 </div>
 </div>
 </div>
-<p>以上实现的队列仍存在局限性，即长度不可变。不过这个问题很容易解决，我们可以将数组替换为列表（即动态数组），从而引入扩容机制。有兴趣的同学可以尝试自行实现。</p>
-<h2 id="523">5.2.3. &nbsp; 两种实现对比<a class="headerlink" href="#523" title="Permanent link">&para;</a></h2>
-<p>与栈的结论一致，在此不再赘述。</p>
-<h2 id="524">5.2.4. &nbsp; 队列典型应用<a class="headerlink" href="#524" title="Permanent link">&para;</a></h2>
+<p>以上实现的队列仍然具有局限性，即其长度不可变。然而，这个问题不难解决，我们可以将数组替换为动态数组，从而引入扩容机制。有兴趣的同学可以尝试自行实现。</p>
+<p>两种实现的对比结论与栈一致，在此不再赘述。</p>
+<h2 id="523">5.2.3. &nbsp; 队列典型应用<a class="headerlink" href="#523" title="Permanent link">&para;</a></h2>
 <ul>
-<li><strong>淘宝订单</strong>。购物者下单后，订单就被加入到队列之中，随后系统再根据顺序依次处理队列中的订单。在双十一时，在短时间内会产生海量的订单，如何处理「高并发」则是工程师们需要重点思考的问题。</li>
-<li><strong>各种待办事项</strong>。任何需要实现“先来后到”的功能，例如打印机的任务队列、餐厅的出餐队列等等。</li>
+<li><strong>淘宝订单</strong>。购物者下单后，订单将加入队列中，系统随后会根据顺序依次处理队列中的订单。在双十一期间，短时间内会产生海量订单，高并发成为工程师们需要重点攻克的问题。</li>
+<li><strong>各类待办事项</strong>。任何需要实现“先来后到”功能的场景，例如打印机的任务队列、餐厅的出餐队列等。队列在这些场景中可以有效地维护处理顺序。</li>
 </ul>
 
 

chapter_stack_and_queue/stack/index.html

@@ -1862,14 +1862,14 @@
 
 
 <h1 id="51">5.1. &nbsp; 栈<a class="headerlink" href="#51" title="Permanent link">&para;</a></h1>
-<p>「栈 Stack」是一种遵循先入后出（first in, last out）数据操作规则的线性数据结构。我们可以将栈类比为放在桌面上的一摞盘子，如果需要拿出底部的盘子，则需要先将上面的盘子依次取出。</p>
-<p>“盘子”是一种形象比喻，我们将盘子替换为任意一种元素（例如整数、字符、对象等），就得到了栈数据结构。</p>
-<p>我们将这一摞元素的顶部称为「栈顶」，将底部称为「栈底」，将把元素添加到栈顶的操作称为「入栈」，将删除栈顶元素的操作称为「出栈」。</p>
+<p>「栈 Stack」是一种遵循先入后出（First In, Last Out）原则的线性数据结构。</p>
+<p>我们可以将栈类比为桌面上的一摞盘子，如果需要拿出底部的盘子，则需要先将上面的盘子依次取出。我们将盘子替换为各种类型的元素（如整数、字符、对象等），就得到了栈数据结构。</p>
+<p>在栈中，我们把堆叠元素的顶部称为「栈顶」，底部称为「栈底」。将把元素添加到栈顶的操作叫做「入栈」，而删除栈顶元素的操作叫做「出栈」。</p>
 <p><img alt="栈的先入后出规则" src="../stack.assets/stack_operations.png" /></p>
 <p align="center"> Fig. 栈的先入后出规则 </p>
 
 <h2 id="511">5.1.1. &nbsp; 栈常用操作<a class="headerlink" href="#511" title="Permanent link">&para;</a></h2>
-<p>栈的常用操作见下表，方法名需根据编程语言来确定，此处我们以常见的 <code>push</code> , <code>pop</code> , <code>peek</code> 为例。</p>
+<p>栈的常用操作如下表所示，具体的方法名需要根据所使用的编程语言来确定。在此，我们以常见的 <code>push()</code> , <code>pop()</code> , <code>peek()</code> 命名为例。</p>
 <div class="center-table">
 <table>
 <thead>
@@ -1898,7 +1898,7 @@
 </tbody>
 </table>
 </div>
-<p>我们可以直接使用编程语言实现好的栈类。 某些语言并未专门提供栈类，但我们可以直接把该语言的「数组」或「链表」看作栈来使用，并通过“脑补”来屏蔽无关操作。</p>
+<p>通常情况下，我们可以直接使用编程语言内置的栈类。然而，某些语言可能没有专门提供栈类，这时我们可以将该语言的「数组」或「链表」视作栈来使用，并通过“脑补”来忽略与栈无关的操作。</p>
 <div class="tabbed-set tabbed-alternate" data-tabs="1:10"><input checked="checked" id="__tabbed_1_1" name="__tabbed_1" type="radio" /><input id="__tabbed_1_2" name="__tabbed_1" type="radio" /><input id="__tabbed_1_3" name="__tabbed_1" type="radio" /><input id="__tabbed_1_4" name="__tabbed_1" type="radio" /><input id="__tabbed_1_5" name="__tabbed_1" type="radio" /><input id="__tabbed_1_6" name="__tabbed_1" type="radio" /><input id="__tabbed_1_7" name="__tabbed_1" type="radio" /><input id="__tabbed_1_8" name="__tabbed_1" type="radio" /><input id="__tabbed_1_9" name="__tabbed_1" type="radio" /><input id="__tabbed_1_10" name="__tabbed_1" type="radio" /><div class="tabbed-labels"><label for="__tabbed_1_1">Java</label><label for="__tabbed_1_2">C++</label><label for="__tabbed_1_3">Python</label><label for="__tabbed_1_4">Go</label><label for="__tabbed_1_5">JavaScript</label><label for="__tabbed_1_6">TypeScript</label><label for="__tabbed_1_7">C</label><label for="__tabbed_1_8">C#</label><label for="__tabbed_1_9">Swift</label><label for="__tabbed_1_10">Zig</label></div>
 <div class="tabbed-content">
 <div class="tabbed-block">
@@ -2110,11 +2110,11 @@
 </div>
 </div>
 <h2 id="512">5.1.2. &nbsp; 栈的实现<a class="headerlink" href="#512" title="Permanent link">&para;</a></h2>
-<p>为了更加清晰地了解栈的运行机制，接下来我们来自己动手实现一个栈类。</p>
-<p>栈规定元素是先入后出的，因此我们只能在栈顶添加或删除元素。然而，数组或链表都可以在任意位置添加删除元素，因此 <strong>栈可被看作是一种受约束的数组或链表</strong>。换言之，我们可以“屏蔽”数组或链表的部分无关操作，使之对外的表现逻辑符合栈的规定即可。</p>
+<p>为了深入了解栈的运行机制，我们来尝试自己实现一个栈类。</p>
+<p>栈遵循先入后出的原则，因此我们只能在栈顶添加或删除元素。然而，数组和链表都可以在任意位置添加和删除元素，<strong>因此栈可以被视为一种受限制的数组或链表</strong>。换句话说，我们可以“屏蔽”数组或链表的部分无关操作，使其对外表现的逻辑符合栈的特性。</p>
 <h3 id="_1">基于链表的实现<a class="headerlink" href="#_1" title="Permanent link">&para;</a></h3>
-<p>使用「链表」实现栈时，将链表的头节点看作栈顶，将尾节点看作栈底。</p>
-<p>对于入栈操作，将元素插入到链表头部即可，这种节点添加方式被称为“头插法”。而对于出栈操作，则将头节点从链表中删除即可。</p>
+<p>使用链表来实现栈时，我们可以将链表的头节点视为栈顶，尾节点视为栈底。</p>
+<p>对于入栈操作，我们只需将元素插入链表头部，这种节点插入方法被称为“头插法”。而对于出栈操作，只需将头节点从链表中删除即可。</p>
 <div class="tabbed-set tabbed-alternate" data-tabs="2:3"><input checked="checked" id="__tabbed_2_1" name="__tabbed_2" type="radio" /><input id="__tabbed_2_2" name="__tabbed_2" type="radio" /><input id="__tabbed_2_3" name="__tabbed_2" type="radio" /><div class="tabbed-labels"><label for="__tabbed_2_1">LinkedListStack</label><label for="__tabbed_2_2">push()</label><label for="__tabbed_2_3">pop()</label></div>
 <div class="tabbed-content">
 <div class="tabbed-block">
@@ -2678,7 +2678,7 @@
 </div>
 </div>
 <h3 id="_2">基于数组的实现<a class="headerlink" href="#_2" title="Permanent link">&para;</a></h3>
-<p>使用「数组」实现栈时，考虑将数组的尾部当作栈顶。这样设计下，「入栈」与「出栈」操作就对应在数组尾部「添加元素」与「删除元素」，时间复杂度都为 <span class="arithmatex">\(O(1)\)</span> 。</p>
+<p>在基于「数组」实现栈时，我们可以将数组的尾部作为栈顶。在这样的设计下，入栈与出栈操作就分别对应在数组尾部添加元素与删除元素，时间复杂度都为 <span class="arithmatex">\(O(1)\)</span> 。</p>
 <div class="tabbed-set tabbed-alternate" data-tabs="4:3"><input checked="checked" id="__tabbed_4_1" name="__tabbed_4" type="radio" /><input id="__tabbed_4_2" name="__tabbed_4" type="radio" /><input id="__tabbed_4_3" name="__tabbed_4" type="radio" /><div class="tabbed-labels"><label for="__tabbed_4_1">ArrayStack</label><label for="__tabbed_4_2">push()</label><label for="__tabbed_4_3">pop()</label></div>
 <div class="tabbed-content">
 <div class="tabbed-block">
@@ -2692,7 +2692,7 @@
 </div>
 </div>
 </div>
-<p>由于入栈的元素可能是源源不断的，因此可以使用支持动态扩容的「列表」，这样就无需自行实现数组扩容了。以下是示例代码。</p>
+<p>由于入栈的元素可能会源源不断地增加，因此我们可以使用动态数组，这样就无需自行处理数组扩容问题。以下为示例代码。</p>
 <div class="tabbed-set tabbed-alternate" data-tabs="5:10"><input checked="checked" id="__tabbed_5_1" name="__tabbed_5" type="radio" /><input id="__tabbed_5_2" name="__tabbed_5" type="radio" /><input id="__tabbed_5_3" name="__tabbed_5" type="radio" /><input id="__tabbed_5_4" name="__tabbed_5" type="radio" /><input id="__tabbed_5_5" name="__tabbed_5" type="radio" /><input id="__tabbed_5_6" name="__tabbed_5" type="radio" /><input id="__tabbed_5_7" name="__tabbed_5" type="radio" /><input id="__tabbed_5_8" name="__tabbed_5" type="radio" /><input id="__tabbed_5_9" name="__tabbed_5" type="radio" /><input id="__tabbed_5_10" name="__tabbed_5" type="radio" /><div class="tabbed-labels"><label for="__tabbed_5_1">Java</label><label for="__tabbed_5_2">C++</label><label for="__tabbed_5_3">Python</label><label for="__tabbed_5_4">Go</label><label for="__tabbed_5_5">JavaScript</label><label for="__tabbed_5_6">TypeScript</label><label for="__tabbed_5_7">C</label><label for="__tabbed_5_8">C#</label><label for="__tabbed_5_9">Swift</label><label for="__tabbed_5_10">Zig</label></div>
 <div class="tabbed-content">
 <div class="tabbed-block">
@@ -3125,23 +3125,23 @@
 </div>
 <h2 id="513">5.1.3. &nbsp; 两种实现对比<a class="headerlink" href="#513" title="Permanent link">&para;</a></h2>
 <h3 id="_3">支持操作<a class="headerlink" href="#_3" title="Permanent link">&para;</a></h3>
-<p>两种实现都支持栈定义中的各项操作，数组实现额外支持随机访问，但这已经超出栈的定义范畴，一般不会用到。</p>
+<p>两种实现都支持栈定义中的各项操作。数组实现额外支持随机访问，但这已超出了栈的定义范畴，因此一般不会用到。</p>
 <h3 id="_4">时间效率<a class="headerlink" href="#_4" title="Permanent link">&para;</a></h3>
-<p>在数组（列表）实现中，入栈与出栈操作都是在预先分配好的连续内存中操作，具有很好的缓存本地性，效率很好。然而，如果入栈时超出数组容量，则会触发扩容机制，那么该次入栈操作的时间复杂度为 <span class="arithmatex">\(O(n)\)</span> 。</p>
-<p>在链表实现中，链表的扩容非常灵活，不存在上述数组扩容时变慢的问题。然而，入栈操作需要初始化节点对象并修改指针，因而效率不如数组。进一步地思考，如果入栈元素不是 <code>int</code> 而是节点对象，那么就可以省去初始化步骤，从而提升效率。</p>
-<p>综上所述，当入栈与出栈操作的元素是基本数据类型（例如 <code>int</code> , <code>double</code> ）时，则结论如下：</p>
+<p>在基于数组的实现中，入栈和出栈操作都是在预先分配好的连续内存中进行，具有很好的缓存本地性，因此效率较高。然而，如果入栈时超出数组容量，会触发扩容机制，导致该次入栈操作的时间复杂度变为 <span class="arithmatex">\(O(n)\)</span> 。</p>
+<p>在链表实现中，链表的扩容非常灵活，不存在上述数组扩容时效率降低的问题。但是，入栈操作需要初始化节点对象并修改指针，因此效率相对较低。不过，如果入栈元素本身就是节点对象，那么可以省去初始化步骤，从而提高效率。</p>
+<p>综上所述，当入栈与出栈操作的元素是基本数据类型（如 <code>int</code> , <code>double</code> ）时，我们可以得出以下结论：</p>
 <ul>
-<li>数组实现的栈在触发扩容时会变慢，但由于扩容是低频操作，因此 <strong>总体效率更高</strong>；</li>
-<li>链表实现的栈可以提供 <strong>更加稳定的效率表现</strong>；</li>
+<li>基于数组实现的栈在触发扩容时效率会降低，但由于扩容是低频操作，因此平均效率更高；</li>
+<li>基于链表实现的栈可以提供更加稳定的效率表现；</li>
 </ul>
 <h3 id="_5">空间效率<a class="headerlink" href="#_5" title="Permanent link">&para;</a></h3>
-<p>在初始化列表时，系统会给列表分配“初始容量”，该容量可能超过我们的需求。并且扩容机制一般是按照特定倍率（比如 2 倍）进行扩容，扩容后的容量也可能超出我们的需求。因此，<strong>数组实现栈会造成一定的空间浪费</strong>。</p>
-<p>当然，由于节点需要额外存储指针，因此 <strong>链表节点比数组元素占用更大</strong>。</p>
-<p>综上，我们不能简单地确定哪种实现更加省内存，需要 case-by-case 地分析。</p>
+<p>在初始化列表时，系统会为列表分配“初始容量”，该容量可能超过实际需求。并且，扩容机制通常是按照特定倍率（例如 2 倍）进行扩容，扩容后的容量也可能超出实际需求。因此，<strong>基于数组实现的栈可能造成一定的空间浪费</strong>。</p>
+<p>然而，由于链表节点需要额外存储指针，<strong>因此链表节点占用的空间相对较大</strong>。</p>
+<p>综上，我们不能简单地确定哪种实现更加节省内存，需要针对具体情况进行分析。</p>
 <h2 id="514">5.1.4. &nbsp; 栈典型应用<a class="headerlink" href="#514" title="Permanent link">&para;</a></h2>
 <ul>
-<li><strong>浏览器中的后退与前进、软件中的撤销与反撤销</strong>。每当我们打开新的网页，浏览器就将上一个网页执行入栈，这样我们就可以通过「后退」操作来回到上一页面，后退操作实际上是在执行出栈。如果要同时支持后退和前进，那么则需要两个栈来配合实现。</li>
-<li><strong>程序内存管理</strong>。每当调用函数时，系统就会在栈顶添加一个栈帧，用来记录函数的上下文信息。在递归函数中，向下递推会不断执行入栈，向上回溯阶段时出栈。</li>
+<li><strong>浏览器中的后退与前进、软件中的撤销与反撤销</strong>。每当我们打开新的网页，浏览器就会将上一个网页执行入栈，这样我们就可以通过「后退」操作回到上一页面。后退操作实际上是在执行出栈。如果要同时支持后退和前进，那么需要两个栈来配合实现。</li>
+<li><strong>程序内存管理</strong>。每次调用函数时，系统都会在栈顶添加一个栈帧，用于记录函数的上下文信息。在递归函数中，向下递推阶段会不断执行入栈操作，而向上回溯阶段则会执行出栈操作。</li>
 </ul>
 
 

chapter_stack_and_queue/summary/index.html

@@ -1681,11 +1681,11 @@
 
 <h1 id="54">5.4. &nbsp; 小结<a class="headerlink" href="#54" title="Permanent link">&para;</a></h1>
 <ul>
-<li>栈是一种遵循先入后出的数据结构，可以使用数组或链表实现。</li>
-<li>在时间效率方面，栈的数组实现具有更好的平均效率，但扩容时会导致单次入栈操作的时间复杂度劣化至 <span class="arithmatex">\(O(n)\)</span> 。相对地，栈的链表实现具有更加稳定的效率表现。</li>
-<li>在空间效率方面，栈的数组实现会造成一定空间浪费，然而链表节点比数组元素占用内存更大。</li>
-<li>队列是一种遵循先入先出的数据结构，可以使用数组或链表实现。对于两种实现的时间效率与空间效率对比，与上述栈的结论相同。</li>
-<li>双向队列的两端都可以添加与删除元素。</li>
+<li>栈是一种遵循先入后出原则的数据结构，可通过数组或链表来实现。</li>
+<li>从时间效率角度看，栈的数组实现具有较高的平均效率，但在扩容过程中，单次入栈操作的时间复杂度会降低至 <span class="arithmatex">\(O(n)\)</span> 。相比之下，基于链表实现的栈具有更为稳定的效率表现。</li>
+<li>在空间效率方面，栈的数组实现可能导致一定程度的空间浪费。但需要注意的是，链表节点所占用的内存空间比数组元素更大。</li>
+<li>队列是一种遵循先入先出原则的数据结构，同样可以通过数组或链表来实现。在时间效率和空间效率的对比上，队列的结论与前述栈的结论相似。</li>
+<li>双向队列是一种具有更高自由度的队列，它允许在两端进行元素的添加和删除操作。</li>
 </ul>