deploy

chapter_array_and_linkedlist/array/index.html

@@ -4085,7 +4085,7 @@
 </div>
 </div>
 </div>
-<p>总的来看，数组的插入与删除操作有以下缺点：</p>
+<p>总的来看，数组的插入与删除操作有以下缺点。</p>
 <ul>
 <li><strong>时间复杂度高</strong>：数组的插入和删除的平均时间复杂度均为 <span class="arithmatex">\(O(n)\)</span> ，其中 <span class="arithmatex">\(n\)</span> 为数组长度。</li>
 <li><strong>丢失元素</strong>：由于数组的长度不可变，因此在插入元素后，超出数组长度范围的元素会丢失。</li>
@@ -4599,20 +4599,20 @@
 </div>
 </div>
 <h2 id="412">4.1.2 &nbsp; 数组优点与局限性<a class="headerlink" href="#412" title="Permanent link">&para;</a></h2>
-<p>数组存储在连续的内存空间内，且元素类型相同。这包含丰富的先验信息，系统可以利用这些信息来优化操作和运行效率，包括：</p>
+<p>数组存储在连续的内存空间内，且元素类型相同。这种做法包含丰富的先验信息，系统可以利用这些信息来优化数据结构的操作效率。</p>
 <ul>
 <li><strong>空间效率高</strong>: 数组为数据分配了连续的内存块，无须额外的结构开销。</li>
 <li><strong>支持随机访问</strong>: 数组允许在 <span class="arithmatex">\(O(1)\)</span> 时间内访问任何元素。</li>
 <li><strong>缓存局部性</strong>: 当访问数组元素时，计算机不仅会加载它，还会缓存其周围的其他数据，从而借助高速缓存来提升后续操作的执行速度。</li>
 </ul>
-<p>连续空间存储是一把双刃剑，它导致的缺点有：</p>
+<p>连续空间存储是一把双刃剑，其存在以下缺点。</p>
 <ul>
 <li><strong>插入与删除效率低</strong>:当数组中元素较多时，插入与删除操作需要移动大量的元素。</li>
 <li><strong>长度不可变</strong>: 数组在初始化后长度就固定了，扩容数组需要将所有数据复制到新数组，开销很大。</li>
 <li><strong>空间浪费</strong>: 如果数组分配的大小超过了实际所需，那么多余的空间就被浪费了。</li>
 </ul>
 <h2 id="413">4.1.3 &nbsp; 数组典型应用<a class="headerlink" href="#413" title="Permanent link">&para;</a></h2>
-<p>数组是一种基础且常见的数据结构，既频繁应用在各类算法之中，也可用于实现各种复杂数据结构，主要包括：</p>
+<p>数组是一种基础且常见的数据结构，既频繁应用在各类算法之中，也可用于实现各种复杂数据结构。</p>
 <ul>
 <li><strong>随机访问</strong>：如果我们想要随机抽取一些样本，那么可以用数组存储，并生成一个随机序列，根据索引实现样本的随机抽取。</li>
 <li><strong>排序和搜索</strong>：数组是排序和搜索算法最常用的数据结构。快速排序、归并排序、二分查找等都主要在数组上进行。</li>

chapter_array_and_linkedlist/linked_list/index.html

@@ -3561,8 +3561,8 @@
 <p>观察图 4-5 ，链表的组成单位是「节点 node」对象。每个节点都包含两项数据：节点的“值”和指向下一节点的“引用”。</p>
 <ul>
 <li>链表的首个节点被称为“头节点”，最后一个节点被称为“尾节点”。</li>
-<li>尾节点指向的是“空”，它在 Java, C++, Python 中分别被记为 <span class="arithmatex">\(\text{null}\)</span> , <span class="arithmatex">\(\text{nullptr}\)</span> , <span class="arithmatex">\(\text{None}\)</span> 。</li>
-<li>在 C, C++, Go, Rust 等支持指针的语言中，上述的“引用”应被替换为“指针”。</li>
+<li>尾节点指向的是“空”，它在 Java、C++ 和 Python 中分别被记为 <span class="arithmatex">\(\text{null}\)</span>、<span class="arithmatex">\(\text{nullptr}\)</span> 和 <span class="arithmatex">\(\text{None}\)</span> 。</li>
+<li>在 C、C++、Go 和 Rust 等支持指针的语言中，上述的“引用”应被替换为“指针”。</li>
 </ul>
 <p>如以下代码所示，链表节点 <code>ListNode</code> 除了包含值，还需额外保存一个引用（指针）。因此在相同数据量下，<strong>链表比数组占用更多的内存空间</strong>。</p>
 <div class="tabbed-set tabbed-alternate" data-tabs="1:12"><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" /><input id="__tabbed_1_11" name="__tabbed_1" type="radio" /><input id="__tabbed_1_12" 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">JS</label><label for="__tabbed_1_6">TS</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><label for="__tabbed_1_11">Dart</label><label for="__tabbed_1_12">Rust</label></div>
@@ -3901,9 +3901,9 @@
 </div>
 </div>
 </div>
-<p>数组整体是一个变量，比如数组 <code>nums</code> 包含元素 <code>nums[0]</code> , <code>nums[1]</code> 等，而链表是由多个独立的节点对象组成的。<strong>我们通常将头节点当作链表的代称</strong>，比如以上代码中的链表可被记做链表 <code>n0</code> 。</p>
+<p>数组整体是一个变量，比如数组 <code>nums</code> 包含元素 <code>nums[0]</code> 和 <code>nums[1]</code> 等，而链表是由多个独立的节点对象组成的。<strong>我们通常将头节点当作链表的代称</strong>，比如以上代码中的链表可被记做链表 <code>n0</code> 。</p>
 <h3 id="2">2. &nbsp; 插入节点<a class="headerlink" href="#2" title="Permanent link">&para;</a></h3>
-<p>在链表中插入节点非常容易。如图 4-6 所示，假设我们想在相邻的两个节点 <code>n0</code> , <code>n1</code> 之间插入一个新节点 <code>P</code> ，<strong>则只需要改变两个节点引用（指针）即可</strong>，时间复杂度为 <span class="arithmatex">\(O(1)\)</span> 。</p>
+<p>在链表中插入节点非常容易。如图 4-6 所示，假设我们想在相邻的两个节点 <code>n0</code> 和 <code>n1</code> 之间插入一个新节点 <code>P</code> ，<strong>则只需要改变两个节点引用（指针）即可</strong>，时间复杂度为 <span class="arithmatex">\(O(1)\)</span> 。</p>
 <p>相比之下，在数组中插入元素的时间复杂度为 <span class="arithmatex">\(O(n)\)</span> ，在大数据量下的效率较低。</p>
 <p><img alt="链表插入节点示例" src="../linked_list.assets/linkedlist_insert_node.png" /></p>
 <p align="center"> 图 4-6 &nbsp; 链表插入节点示例 </p>

chapter_array_and_linkedlist/list/index.html

@@ -4254,8 +4254,8 @@
 </div>
 </div>
 <h2 id="432">4.3.2 &nbsp; 列表实现<a class="headerlink" href="#432" title="Permanent link">&para;</a></h2>
-<p>许多编程语言都提供内置的列表，例如 Java, C++, Python 等。它们的实现比较复杂，各个参数的设定也非常有考究，例如初始容量、扩容倍数等。感兴趣的读者可以查阅源码进行学习。</p>
-<p>为了帮助你理解列表的工作原理，我们在此提供一个简易版列表实现，重点包括：</p>
+<p>许多编程语言都提供内置的列表，例如 Java、C++、Python 等。它们的实现比较复杂，各个参数的设定也非常有考究，例如初始容量、扩容倍数等。感兴趣的读者可以查阅源码进行学习。</p>
+<p>为了加深对列表工作原理的理解，我们尝试实现一个简易版列表，包括以下三个重点设计。</p>
 <ul>
 <li><strong>初始容量</strong>：选取一个合理的数组初始容量。在本示例中，我们选择 10 作为初始容量。</li>
 <li><strong>数量记录</strong>：声明一个变量 size，用于记录列表当前元素数量，并随着元素插入和删除实时更新。根据此变量，我们可以定位列表尾部，以及判断是否需要扩容。</li>

chapter_array_and_linkedlist/summary/index.html

@@ -3446,7 +3446,7 @@
 </div>
 <div class="admonition question">
 <p class="admonition-title">为什么数组要求相同类型的元素，而在链表中却没有强调同类型呢？</p>
-<p>链表由结点组成，结点之间通过引用（指针）连接，各个结点可以存储不同类型的数据，例如 int, double, string, object 等。</p>
+<p>链表由结点组成，结点之间通过引用（指针）连接，各个结点可以存储不同类型的数据，例如 int、double、string、object 等。</p>
 <p>相对地，数组元素则必须是相同类型的，这样才能通过计算偏移量来获取对应元素位置。例如，如果数组同时包含 int 和 long 两种类型，单个元素分别占用 4 bytes 和 8 bytes ，那么此时就不能用以下公式计算偏移量了，因为数组中包含了两种 <code>elementLength</code> 。</p>
 <div class="highlight"><pre><span></span><code><a id="__codelineno-0-1" name="__codelineno-0-1" href="#__codelineno-0-1"></a>// 元素内存地址 = 数组内存地址 + 元素长度 * 元素索引
 <a id="__codelineno-0-2" name="__codelineno-0-2" href="#__codelineno-0-2"></a>elementAddr = firtstElementAddr + elementLength * elementIndex
@@ -3455,7 +3455,7 @@
 <div class="admonition question">
 <p class="admonition-title">删除节点后，是否需要把 <code>P.next</code> 设为 <span class="arithmatex">\(\text{None}\)</span> 呢？</p>
 <p>不修改 <code>P.next</code> 也可以。从该链表的角度看，从头结点遍历到尾结点已经遇不到 <code>P</code> 了。这意味着结点 <code>P</code> 已经从链表中删除了，此时结点 <code>P</code> 指向哪里都不会对这条链表产生影响了。</p>
-<p>从垃圾回收的角度看，对于 Java, Python, Go 等拥有自动垃圾回收的语言来说，节点 <code>P</code> 是否被回收取决于是否有仍存在指向它的引用，而不是 <code>P.next</code> 的值。在 C, C++ 等语言中，我们需要手动释放节点内存。</p>
+<p>从垃圾回收的角度看，对于 Java、Python、Go 等拥有自动垃圾回收的语言来说，节点 <code>P</code> 是否被回收取决于是否有仍存在指向它的引用，而不是 <code>P.next</code> 的值。在 C 和 C++ 等语言中，我们需要手动释放节点内存。</p>
 </div>
 <div class="admonition question">
 <p class="admonition-title">在链表中插入和删除操作的时间复杂度是 <span class="arithmatex">\(O(1)\)</span> 。但是增删之前都需要 <span class="arithmatex">\(O(n)\)</span> 查找元素，那为什么时间复杂度不是 <span class="arithmatex">\(O(n)\)</span> 呢？</p>
@@ -3463,9 +3463,9 @@
 </div>
 <div class="admonition question">
 <p class="admonition-title">图片“链表定义与存储方式”中，浅蓝色的存储结点指针是占用一块内存地址吗？还是和结点值各占一半呢？</p>
-<p>文中只是一个示意图，只是定性表示。定量的话需要根据具体情况分析：</p>
+<p>文中的示意图只是定性表示，定量表示需要根据具体情况进行分析。</p>
 <ul>
-<li>不同类型的结点值占用的空间是不同的，比如 int, long, double, 或者是类的实例等等。</li>
+<li>不同类型的结点值占用的空间是不同的，比如 int、long、double 和实例对象等。</li>
 <li>指针变量占用的内存空间大小根据所使用的操作系统及编译环境而定，大多为 8 字节或 4 字节。</li>
 </ul>
 </div>
@@ -3484,11 +3484,11 @@
 </div>
 <div class="admonition question">
 <p class="admonition-title">C++ STL 里面的 std::list 已经实现了双向链表，但好像一些算法的书上都不怎么直接用这个，是不是有什么局限性呢?</p>
-<p>一方面，我们往往更青睐使用数组实现算法，而只有在必要时才使用链表。这是因为：</p>
-<ol>
+<p>一方面，我们往往更青睐使用数组实现算法，而只有在必要时才使用链表，主要有两个原因。</p>
+<ul>
 <li>空间开销：由于每个元素需要两个额外的指针（一个用于前一个元素，一个用于后一个元素），所以 <code>std::list</code> 通常比 <code>std::vector</code> 更占用空间。</li>
 <li>缓存不友好：由于数据不是连续存放的，<code>std::list</code> 对缓存的利用率较低。一般情况下，<code>std::vector</code> 的性能会更好。</li>
-</ol>
+</ul>
 <p>另一方面，必要使用链表的情况主要是二叉树和图。栈和队列往往会使用编程语言提供的 <code>stack</code> 和 <code>queue</code> ，而非链表。</p>
 </div>