deploy

chapter_graph/graph/index.html

@@ -1808,7 +1808,7 @@
 
 
 <h1 id="91">9.1. &nbsp; 图<a class="headerlink" href="#91" title="Permanent link">&para;</a></h1>
-<p>「图 Graph」是一种非线性数据结构，由「顶点 Vertex」和「边 Edge」组成。我们可将图 <span class="arithmatex">\(G\)</span> 抽象地表示为一组顶点 <span class="arithmatex">\(V\)</span> 和一组边 <span class="arithmatex">\(E\)</span> 的集合。例如，以下表示一个包含 5 个顶点和 7 条边的图</p>
+<p>「图 Graph」是一种非线性数据结构，由「顶点 Vertex」和「边 Edge」组成。我们可以将图 <span class="arithmatex">\(G\)</span> 抽象地表示为一组顶点 <span class="arithmatex">\(V\)</span> 和一组边 <span class="arithmatex">\(E\)</span> 的集合。以下示例展示了一个包含 5 个顶点和 7 条边的图。</p>
 <div class="arithmatex">\[
 \begin{aligned}
 V &amp; = \{ 1, 2, 3, 4, 5 \} \newline
@@ -1819,17 +1819,17 @@ G &amp; = \{ V, E \} \newline
 <p><img alt="链表、树、图之间的关系" src="../graph.assets/linkedlist_tree_graph.png" /></p>
 <p align="center"> Fig. 链表、树、图之间的关系 </p>
 
-<p>那么，图与其他数据结构的关系是什么？如果我们把「顶点」看作结点，把「边」看作连接各个结点的指针，则可将「图」看成一种从「链表」拓展而来的数据结构。<strong>相比线性关系（链表）和分治关系（树），网络关系（图）的自由度更高，也从而更为复杂</strong>。</p>
+<p>那么，图与其他数据结构的关系是什么？如果我们把「顶点」看作结点，把「边」看作连接各个结点的指针，则可将「图」看作是一种从「链表」拓展而来的数据结构。<strong>相较于线性关系（链表）和分治关系（树），网络关系（图）的自由度更高，从而更为复杂</strong>。</p>
 <h2 id="911">9.1.1. &nbsp; 图常见类型<a class="headerlink" href="#911" title="Permanent link">&para;</a></h2>
-<p>根据边是否有方向，分为「无向图 Undirected Graph」和「有向图 Directed Graph」。</p>
+<p>根据边是否具有方向，可分为「无向图 Undirected Graph」和「有向图 Directed Graph」。</p>
 <ul>
-<li>在无向图中，边表示两顶点之间“双向”的连接关系，例如微信或 QQ 中的“好友关系”；</li>
-<li>在有向图中，边是有方向的，即 <span class="arithmatex">\(A \rightarrow B\)</span> 和 <span class="arithmatex">\(A \leftarrow B\)</span> 两个方向的边是相互独立的，例如微博或抖音上的“关注”与“被关注”关系；</li>
+<li>在无向图中，边表示两顶点之间的“双向”连接关系，例如微信或 QQ 中的“好友关系”；</li>
+<li>在有向图中，边具有方向性，即 <span class="arithmatex">\(A \rightarrow B\)</span> 和 <span class="arithmatex">\(A \leftarrow B\)</span> 两个方向的边是相互独立的，例如微博或抖音上的“关注”与“被关注”关系；</li>
 </ul>
 <p><img alt="有向图与无向图" src="../graph.assets/directed_graph.png" /></p>
 <p align="center"> Fig. 有向图与无向图 </p>
 
-<p>根据所有顶点是否连通，分为「连通图 Connected Graph」和「非连通图 Disconnected Graph」。</p>
+<p>根据所有顶点是否连通，可分为「连通图 Connected Graph」和「非连通图 Disconnected Graph」。</p>
 <ul>
 <li>对于连通图，从某个顶点出发，可以到达其余任意顶点；</li>
 <li>对于非连通图，从某个顶点出发，至少有一个顶点无法到达；</li>
@@ -1837,40 +1837,40 @@ G &amp; = \{ V, E \} \newline
 <p><img alt="连通图与非连通图" src="../graph.assets/connected_graph.png" /></p>
 <p align="center"> Fig. 连通图与非连通图 </p>
 
-<p>我们可以给边添加“权重”变量，得到「有权图 Weighted Graph」。例如，在王者荣耀等游戏中，系统会根据共同游戏时间来计算玩家之间的“亲密度”，这种亲密度网络就可以使用有权图来表示。</p>
+<p>我们还可以为边添加“权重”变量，从而得到「有权图 Weighted Graph」。例如，在王者荣耀等手游中，系统会根据共同游戏时间来计算玩家之间的“亲密度”，这种亲密度网络就可以用有权图来表示。</p>
 <p><img alt="有权图与无权图" src="../graph.assets/weighted_graph.png" /></p>
 <p align="center"> Fig. 有权图与无权图 </p>
 
 <h2 id="912">9.1.2. &nbsp; 图常用术语<a class="headerlink" href="#912" title="Permanent link">&para;</a></h2>
 <ul>
-<li>「邻接 Adjacency」：当两顶点之间有边相连时，称此两顶点“邻接”。例如，上图中顶点 1 的邻接顶点为顶点 2, 3, 5 。</li>
-<li>「路径 Path」：从顶点 A 到顶点 B 走过的边构成的序列，被称为从 A 到 B 的“路径”。例如，上图中边序列 1-5-2-4 是顶点 1 到顶点 4 的一个路径。</li>
-<li>「度 Degree」表示一个顶点具有多少条边。对于有向图，「入度 In-Degree」表示有多少条边指向该顶点，「出度 Out-Degree」表示有多少条边从该顶点指出。</li>
+<li>「邻接 Adjacency」：当两顶点之间存在边相连时，称这两顶点“邻接”。在上图中，顶点 1 的邻接顶点为顶点 2、3、5。</li>
+<li>「路径 Path」：从顶点 A 到顶点 B 经过的边构成的序列被称为从 A 到 B 的“路径”。在上图中，边序列 1-5-2-4 是顶点 1 到顶点 4 的一条路径。</li>
+<li>「度 Degree」表示一个顶点拥有的边数。对于有向图，「入度 In-Degree」表示有多少条边指向该顶点，「出度 Out-Degree」表示有多少条边从该顶点指出。</li>
 </ul>
 <h2 id="913">9.1.3. &nbsp; 图的表示<a class="headerlink" href="#913" 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>设图的顶点数量为 <span class="arithmatex">\(n\)</span> ，「邻接矩阵 Adjacency Matrix」使用一个 <span class="arithmatex">\(n \times n\)</span> 大小的矩阵来表示图，每一行（列）代表一个顶点，矩阵元素代表边，使用 <span class="arithmatex">\(1\)</span> 或 <span class="arithmatex">\(0\)</span> 来表示两个顶点之间有边或无边。</p>
-<p>如下图所示，记邻接矩阵为 <span class="arithmatex">\(M\)</span> 、顶点列表为 <span class="arithmatex">\(V\)</span> ，则矩阵元素 <span class="arithmatex">\(M[i][j] = 1\)</span> 代表着顶点 <span class="arithmatex">\(V[i]\)</span> 到顶点 <span class="arithmatex">\(V[j]\)</span> 之间有边，相反地 <span class="arithmatex">\(M[i][j] = 0\)</span> 代表两顶点之间无边。</p>
+<p>设图的顶点数量为 <span class="arithmatex">\(n\)</span> ，「邻接矩阵 Adjacency Matrix」使用一个 <span class="arithmatex">\(n \times n\)</span> 大小的矩阵来表示图，每一行（列）代表一个顶点，矩阵元素代表边，用 <span class="arithmatex">\(1\)</span> 或 <span class="arithmatex">\(0\)</span> 表示两个顶点之间是否存在边。</p>
+<p>如下图所示，设邻接矩阵为 <span class="arithmatex">\(M\)</span> 、顶点列表为 <span class="arithmatex">\(V\)</span> ，那么矩阵元素 <span class="arithmatex">\(M[i][j] = 1\)</span> 表示顶点 <span class="arithmatex">\(V[i]\)</span> 到顶点 <span class="arithmatex">\(V[j]\)</span> 之间存在边，反之 <span class="arithmatex">\(M[i][j] = 0\)</span> 表示两顶点之间无边。</p>
 <p><img alt="图的邻接矩阵表示" src="../graph.assets/adjacency_matrix.png" /></p>
 <p align="center"> Fig. 图的邻接矩阵表示 </p>
 
-<p>邻接矩阵具有以下性质：</p>
+<p>邻接矩阵具有以下特性：</p>
 <ul>
-<li>顶点不能与自身相连，因而邻接矩阵主对角线元素没有意义。</li>
-<li>「无向图」两个方向的边等价，此时邻接矩阵关于主对角线对称。</li>
-<li>将邻接矩阵的元素从 <span class="arithmatex">\(1\)</span> , <span class="arithmatex">\(0\)</span> 替换为权重，则能够表示「有权图」。</li>
+<li>顶点不能与自身相连，因此邻接矩阵主对角线元素没有意义。</li>
+<li>对于无向图，两个方向的边等价，此时邻接矩阵关于主对角线对称。</li>
+<li>将邻接矩阵的元素从 <span class="arithmatex">\(1\)</span> , <span class="arithmatex">\(0\)</span> 替换为权重，则可表示有权图。</li>
 </ul>
-<p>使用邻接矩阵表示图时，我们可以直接通过访问矩阵元素来获取边，因此增删查操作的效率很高，时间复杂度均为 <span class="arithmatex">\(O(1)\)</span> 。然而，矩阵的空间复杂度为 <span class="arithmatex">\(O(n^2)\)</span> ，内存占用较大。</p>
+<p>使用邻接矩阵表示图时，我们可以直接访问矩阵元素以获取边，因此增删查操作的效率很高，时间复杂度均为 <span class="arithmatex">\(O(1)\)</span> 。然而，矩阵的空间复杂度为 <span class="arithmatex">\(O(n^2)\)</span> ，内存占用较多。</p>
 <h3 id="_2">邻接表<a class="headerlink" href="#_2" title="Permanent link">&para;</a></h3>
 <p>「邻接表 Adjacency List」使用 <span class="arithmatex">\(n\)</span> 个链表来表示图，链表结点表示顶点。第 <span class="arithmatex">\(i\)</span> 条链表对应顶点 <span class="arithmatex">\(i\)</span> ，其中存储了该顶点的所有邻接顶点（即与该顶点相连的顶点）。</p>
 <p><img alt="图的邻接表表示" src="../graph.assets/adjacency_list.png" /></p>
 <p align="center"> Fig. 图的邻接表表示 </p>
 
-<p>邻接表仅存储存在的边，而边的总数往往远小于 <span class="arithmatex">\(n^2\)</span> ，因此更加节省空间。但是，因为在邻接表中需要通过遍历链表来查找边，所以其时间效率不如邻接矩阵。</p>
-<p>观察上图发现，<strong>邻接表结构与哈希表「链地址法」非常相似，因此我们也可以用类似方法来优化效率</strong>。比如，当链表较长时，可以把链表转化为 AVL 树或红黑树，从而将时间效率从 <span class="arithmatex">\(O(n)\)</span> 优化至 <span class="arithmatex">\(O(\log n)\)</span> ，还可以通过中序遍历获取有序序列；还可以将链表转化为哈希表，将时间复杂度降低至 <span class="arithmatex">\(O(1)\)</span> 。</p>
+<p>邻接表仅存储实际存在的边，而边的总数通常远小于 <span class="arithmatex">\(n^2\)</span> ，因此它更加节省空间。然而，在邻接表中需要通过遍历链表来查找边，因此其时间效率不如邻接矩阵。</p>
+<p>观察上图可发现，<strong>邻接表结构与哈希表中的「链地址法」非常相似，因此我们也可以采用类似方法来优化效率</strong>。例如，当链表较长时，可以将链表转化为 AVL 树或红黑树，从而将时间效率从 <span class="arithmatex">\(O(n)\)</span> 优化至 <span class="arithmatex">\(O(\log n)\)</span> ，还可以通过中序遍历获取有序序列；此外，还可以将链表转换为哈希表，将时间复杂度降低至 <span class="arithmatex">\(O(1)\)</span> 。</p>
 <h2 id="914">9.1.4. &nbsp; 图常见应用<a class="headerlink" href="#914" title="Permanent link">&para;</a></h2>
-<p>现实中的许多系统都可以使用图来建模，对应的待求解问题也可以被约化为图计算问题。</p>
+<p>实际应用中，许多系统都可以用图来建模，相应的待求解问题也可以约化为图计算问题。</p>
 <div class="center-table">
 <table>
 <thead>

chapter_graph/graph_operations/index.html

@@ -1754,11 +1754,11 @@
 
 
 <h1 id="92">9.2. &nbsp; 图基础操作<a class="headerlink" href="#92" title="Permanent link">&para;</a></h1>
-<p>图的基础操作分为对「边」的操作和对「顶点」的操作，在「邻接矩阵」和「邻接表」这两种表示下的实现方式不同。</p>
+<p>图的基础操作可分为对「边」的操作和对「顶点」的操作。在「邻接矩阵」和「邻接表」两种表示方法下，实现方式有所不同。</p>
 <h2 id="921">9.2.1. &nbsp; 基于邻接矩阵的实现<a class="headerlink" href="#921" title="Permanent link">&para;</a></h2>
-<p>设图的顶点总数为 <span class="arithmatex">\(n\)</span> ，则有：</p>
+<p>给定一个顶点数量为 <span class="arithmatex">\(n\)</span> 的无向图，则有：</p>
 <ul>
-<li><strong>添加或删除边</strong>：直接在邻接矩阵中修改指定边的对应元素即可，使用 <span class="arithmatex">\(O(1)\)</span> 时间。而由于是无向图，因此需要同时更新两个方向的边。</li>
+<li><strong>添加或删除边</strong>：直接在邻接矩阵中修改指定的边即可，使用 <span class="arithmatex">\(O(1)\)</span> 时间。而由于是无向图，因此需要同时更新两个方向的边。</li>
 <li><strong>添加顶点</strong>：在邻接矩阵的尾部添加一行一列，并全部填 <span class="arithmatex">\(0\)</span> 即可，使用 <span class="arithmatex">\(O(n)\)</span> 时间。</li>
 <li><strong>删除顶点</strong>：在邻接矩阵中删除一行一列。当删除首行首列时达到最差情况，需要将 <span class="arithmatex">\((n-1)^2\)</span> 个元素“向左上移动”，从而使用 <span class="arithmatex">\(O(n^2)\)</span> 时间。</li>
 <li><strong>初始化</strong>：传入 <span class="arithmatex">\(n\)</span> 个顶点，初始化长度为 <span class="arithmatex">\(n\)</span> 的顶点列表 <code>vertices</code> ，使用 <span class="arithmatex">\(O(n)\)</span> 时间；初始化 <span class="arithmatex">\(n \times n\)</span> 大小的邻接矩阵 <code>adjMat</code> ，使用 <span class="arithmatex">\(O(n^2)\)</span> 时间。</li>
@@ -2510,13 +2510,13 @@
 </div>
 </div>
 <h2 id="922">9.2.2. &nbsp; 基于邻接表的实现<a class="headerlink" href="#922" title="Permanent link">&para;</a></h2>
-<p>设图的顶点总数为 <span class="arithmatex">\(n\)</span> 、边总数为 <span class="arithmatex">\(m\)</span> ，则有：</p>
+<p>设无向图的顶点总数为 <span class="arithmatex">\(n\)</span> 、边总数为 <span class="arithmatex">\(m\)</span> ，则有：</p>
 <ul>
-<li><strong>添加边</strong>：在顶点对应链表的尾部添加边即可，使用 <span class="arithmatex">\(O(1)\)</span> 时间。因为是无向图，所以需要同时添加两个方向的边。</li>
-<li><strong>删除边</strong>：在顶点对应链表中查询与删除指定边，使用 <span class="arithmatex">\(O(m)\)</span> 时间。与添加边一样，需要同时删除两个方向的边。</li>
-<li><strong>添加顶点</strong>：在邻接表中添加一个链表即可，并以新增顶点为链表头结点，使用 <span class="arithmatex">\(O(1)\)</span> 时间。</li>
-<li><strong>删除顶点</strong>：需要遍历整个邻接表，删除包含指定顶点的所有边，使用 <span class="arithmatex">\(O(n + m)\)</span> 时间。</li>
-<li><strong>初始化</strong>：需要在邻接表中建立 <span class="arithmatex">\(n\)</span> 个结点和 <span class="arithmatex">\(2m\)</span> 条边，使用 <span class="arithmatex">\(O(n + m)\)</span> 时间。</li>
+<li><strong>添加边</strong>：在顶点对应链表的末尾添加边即可，使用 <span class="arithmatex">\(O(1)\)</span> 时间。因为是无向图，所以需要同时添加两个方向的边。</li>
+<li><strong>删除边</strong>：在顶点对应链表中查找并删除指定边，使用 <span class="arithmatex">\(O(m)\)</span> 时间。在无向图中，需要同时删除两个方向的边。</li>
+<li><strong>添加顶点</strong>：在邻接表中添加一个链表，并将新增顶点作为链表头结点，使用 <span class="arithmatex">\(O(1)\)</span> 时间。</li>
+<li><strong>删除顶点</strong>：需遍历整个邻接表，删除包含指定顶点的所有边，使用 <span class="arithmatex">\(O(1)\)</span> 时间。</li>
+<li><strong>初始化</strong>：在邻接表中创建 <span class="arithmatex">\(n\)</span> 个顶点和 <span class="arithmatex">\(2m\)</span> 条边，使用 <span class="arithmatex">\(O(n + m)\)</span> 时间。</li>
 </ul>
 <div class="tabbed-set tabbed-alternate" data-tabs="3:5"><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" /><div class="tabbed-labels"><label for="__tabbed_3_1">初始化邻接表</label><label for="__tabbed_3_2">添加边</label><label for="__tabbed_3_3">删除边</label><label for="__tabbed_3_4">添加顶点</label><label for="__tabbed_3_5">删除顶点</label></div>
 <div class="tabbed-content">
@@ -2537,10 +2537,10 @@
 </div>
 </div>
 </div>
-<p>基于邻接表实现图的代码如下所示。细心的同学可能注意到，<strong>我们在邻接表中使用 <code>Vertex</code> 结点类来表示顶点</strong>，这样做的原因是：</p>
+<p>以下是基于邻接表实现图的代码示例。细心的同学可能注意到，<strong>我们在邻接表中使用 <code>Vertex</code> 结点类来表示顶点</strong>，这样做的原因有：</p>
 <ul>
 <li>如果我们选择通过顶点值来区分不同顶点，那么值重复的顶点将无法被区分。</li>
-<li>如果类似邻接矩阵那样，使用顶点列表索引来区分不同顶点。那么，假设我们想要删除索引为 <span class="arithmatex">\(i\)</span> 的顶点，则需要遍历整个邻接表，将其中 <span class="arithmatex">\(&gt; i\)</span> 的索引全部执行 <span class="arithmatex">\(-1\)</span> ，这样操作效率太低。</li>
+<li>如果类似邻接矩阵那样，使用顶点列表索引来区分不同顶点。那么，假设我们想要删除索引为 <span class="arithmatex">\(i\)</span> 的顶点，则需要遍历整个邻接表，将其中 <span class="arithmatex">\(&gt; i\)</span> 的索引全部减 <span class="arithmatex">\(1\)</span>，这样操作效率较低。</li>
 <li>因此我们考虑引入顶点类 <code>Vertex</code> ，使得每个顶点都是唯一的对象，此时删除顶点时就无需改动其余顶点了。</li>
 </ul>
 <div class="tabbed-set tabbed-alternate" data-tabs="4:10"><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" /><input id="__tabbed_4_6" name="__tabbed_4" type="radio" /><input id="__tabbed_4_7" name="__tabbed_4" type="radio" /><input id="__tabbed_4_8" name="__tabbed_4" type="radio" /><input id="__tabbed_4_9" name="__tabbed_4" type="radio" /><input id="__tabbed_4_10" name="__tabbed_4" type="radio" /><div class="tabbed-labels"><label for="__tabbed_4_1">Java</label><label for="__tabbed_4_2">C++</label><label for="__tabbed_4_3">Python</label><label for="__tabbed_4_4">Go</label><label for="__tabbed_4_5">JavaScript</label><label for="__tabbed_4_6">TypeScript</label><label for="__tabbed_4_7">C</label><label for="__tabbed_4_8">C#</label><label for="__tabbed_4_9">Swift</label><label for="__tabbed_4_10">Zig</label></div>
@@ -3228,7 +3228,7 @@
 </tbody>
 </table>
 </div>
-<p>观察上表，貌似邻接表（哈希表）的时间与空间效率最优。但实际上，在邻接矩阵中操作边的效率更高，只需要一次数组访问或赋值操作即可。总结以上，<strong>邻接矩阵体现“以空间换时间”，邻接表体现“以时间换空间”</strong>。</p>
+<p>观察上表，似乎邻接表（哈希表）的时间与空间效率最优。但实际上，在邻接矩阵中操作边的效率更高，只需要一次数组访问或赋值操作即可。综合来看，邻接矩阵体现了“以空间换时间”的原则，而邻接表体现了“以时间换空间”的原则。</p>
 
 
 

chapter_graph/graph_traversal/index.html

@@ -1822,21 +1822,21 @@
 <h1 id="93">9.3. &nbsp; 图的遍历<a class="headerlink" href="#93" title="Permanent link">&para;</a></h1>
 <div class="admonition note">
 <p class="admonition-title">图与树的关系</p>
-<p>树代表的是“一对多”的关系，而图则自由度更高，可以代表任意“多对多”关系。本质上，<strong>可以把树看作是图的一类特例</strong>。那么显然，树遍历操作也是图遍历操作的一个特例，两者的方法是非常类似的，建议你在学习本章节的过程中将两者融会贯通。</p>
+<p>树代表的是“一对多”的关系，而图则具有更高的自由度，可以表示任意的“多对多”关系。因此，我们可以把树看作是图的一种特例。显然，<strong>树的遍历操作也是图的遍历操作的一种特例</strong>，建议你在学习本章节时融会贯通两者的概念与实现方法。</p>
 </div>
-<p>「图」与「树」都是非线性数据结构，都需要使用「搜索算法」来实现遍历操作。</p>
-<p>类似地，图的遍历方式也分为两种，即「广度优先遍历 Breadth-First Traversal」和「深度优先遍历 Depth-First Travsersal」，也称「广度优先搜索 Breadth-First Search」和「深度优先搜索 Depth-First Search」，简称为 BFS 和 DFS 。</p>
+<p>「图」和「树」都是非线性数据结构，都需要使用「搜索算法」来实现遍历操作。</p>
+<p>与树类似，图的遍历方式也可分为两种，即「广度优先遍历 Breadth-First Traversal」和「深度优先遍历 Depth-First Traversal」，也称为「广度优先搜索 Breadth-First Search」和「深度优先搜索 Depth-First Search」，简称 BFS 和 DFS。</p>
 <h2 id="931">9.3.1. &nbsp; 广度优先遍历<a class="headerlink" href="#931" title="Permanent link">&para;</a></h2>
-<p><strong>广度优先遍历优是一种由近及远的遍历方式，从距离最近的顶点开始访问，并一层层向外扩张</strong>。具体地，从某个顶点出发，先遍历该顶点的所有邻接顶点，随后遍历下个顶点的所有邻接顶点，以此类推……</p>
+<p><strong>广度优先遍历是一种由近及远的遍历方式，从距离最近的顶点开始访问，并一层层向外扩张</strong>。具体来说，从某个顶点出发，先遍历该顶点的所有邻接顶点，然后遍历下一个顶点的所有邻接顶点，以此类推，直至所有顶点访问完毕。</p>
 <p><img alt="图的广度优先遍历" src="../graph_traversal.assets/graph_bfs.png" /></p>
 <p align="center"> Fig. 图的广度优先遍历 </p>
 
 <h3 id="_1">算法实现<a class="headerlink" href="#_1" title="Permanent link">&para;</a></h3>
-<p>BFS 常借助「队列」来实现。队列具有“先入先出”的性质，这与 BFS “由近及远”的思想是异曲同工的。</p>
+<p>BFS 通常借助「队列」来实现。队列具有“先入先出”的性质，这与 BFS 的“由近及远”的思想异曲同工。</p>
 <ol>
 <li>将遍历起始顶点 <code>startVet</code> 加入队列，并开启循环；</li>
-<li>在循环的每轮迭代中，弹出队首顶点弹出并记录访问，并将该顶点的所有邻接顶点加入到队列尾部；</li>
-<li>循环 <code>2.</code> ，直到所有顶点访问完成后结束；</li>
+<li>在循环的每轮迭代中，弹出队首顶点并记录访问，然后将该顶点的所有邻接顶点加入到队列尾部；</li>
+<li>循环步骤 <code>2.</code> ，直到所有顶点被访问完成后结束；</li>
 </ol>
 <p>为了防止重复遍历顶点，我们需要借助一个哈希表 <code>visited</code> 来记录哪些结点已被访问。</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>
@@ -2095,18 +2095,18 @@
 </div>
 <div class="admonition question">
 <p class="admonition-title">广度优先遍历的序列是否唯一？</p>
-<p>不唯一。广度优先遍历只要求“由近及远”，<strong>而多个相同距离的顶点的遍历顺序允许被任意打乱</strong>。以上图为例，顶点 <span class="arithmatex">\(1\)</span> , <span class="arithmatex">\(3\)</span> 的访问顺序可以交换、顶点 <span class="arithmatex">\(2\)</span> , <span class="arithmatex">\(4\)</span> , <span class="arithmatex">\(6\)</span> 的访问顺序也可以任意交换、以此类推……</p>
+<p>不唯一。广度优先遍历只要求按“由近及远”的顺序遍历，<strong>而多个相同距离的顶点的遍历顺序是允许被任意打乱的</strong>。以上图为例，顶点 <span class="arithmatex">\(1\)</span> , <span class="arithmatex">\(3\)</span> 的访问顺序可以交换、顶点 <span class="arithmatex">\(2\)</span> , <span class="arithmatex">\(4\)</span> , <span class="arithmatex">\(6\)</span> 的访问顺序也可以任意交换。</p>
 </div>
 <h3 id="_2">复杂度分析<a class="headerlink" href="#_2" title="Permanent link">&para;</a></h3>
-<p><strong>时间复杂度：</strong> 所有顶点都会入队、出队一次，使用 <span class="arithmatex">\(O(|V|)\)</span> 时间；在遍历邻接顶点的过程中，由于是无向图，因此所有边都会被访问 <span class="arithmatex">\(2\)</span> 次，使用 <span class="arithmatex">\(O(2|E|)\)</span> 时间；总体使用 <span class="arithmatex">\(O(|V| + |E|)\)</span> 时间。</p>
+<p><strong>时间复杂度：</strong> 所有顶点都会入队并出队一次，使用 <span class="arithmatex">\(O(|V|)\)</span> 时间；在遍历邻接顶点的过程中，由于是无向图，因此所有边都会被访问 <span class="arithmatex">\(2\)</span> 次，使用 <span class="arithmatex">\(O(2|E|)\)</span> 时间；总体使用 <span class="arithmatex">\(O(|V| + |E|)\)</span> 时间。</p>
 <p><strong>空间复杂度：</strong> 列表 <code>res</code> ，哈希表 <code>visited</code> ，队列 <code>que</code> 中的顶点数量最多为 <span class="arithmatex">\(|V|\)</span> ，使用 <span class="arithmatex">\(O(|V|)\)</span> 空间。</p>
 <h2 id="932">9.3.2. &nbsp; 深度优先遍历<a class="headerlink" href="#932" title="Permanent link">&para;</a></h2>
-<p><strong>深度优先遍历是一种优先走到底、无路可走再回头的遍历方式</strong>。具体地，从某个顶点出发，不断地访问当前结点的某个邻接顶点，直到走到尽头时回溯，再继续走到底 + 回溯，以此类推……直至所有顶点遍历完成时结束。</p>
+<p><strong>深度优先遍历是一种优先走到底、无路可走再回头的遍历方式</strong>。具体地，从某个顶点出发，访问当前顶点的某个邻接顶点，直到走到尽头时返回，再继续走到尽头并返回，以此类推，直至所有顶点遍历完成。</p>
 <p><img alt="图的深度优先遍历" src="../graph_traversal.assets/graph_dfs.png" /></p>
 <p align="center"> Fig. 图的深度优先遍历 </p>
 
 <h3 id="_3">算法实现<a class="headerlink" href="#_3" title="Permanent link">&para;</a></h3>
-<p>这种“走到头 + 回溯”的算法形式一般基于递归来实现。与 BFS 类似，在 DFS 中我们也需要借助一个哈希表 <code>visited</code> 来记录已被访问的顶点，以避免重复访问顶点。</p>
+<p>这种“走到尽头 + 回溯”的算法形式通常基于递归来实现。与 BFS 类似，在 DFS 中我们也需要借助一个哈希表 <code>visited</code> 来记录已被访问的顶点，以避免重复访问顶点。</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">
@@ -2314,12 +2314,12 @@
 </div>
 </div>
 </div>
-<p>深度优先遍历的算法流程如下图所示，其中</p>
+<p>深度优先遍历的算法流程如下图所示，其中：</p>
 <ul>
-<li><strong>直虚线代表向下递推</strong>，代表开启了一个新的递归方法来访问新顶点；</li>
-<li><strong>曲虚线代表向上回溯</strong>，代表此递归方法已经返回，回溯到了开启此递归方法的位置；</li>
+<li><strong>直虚线代表向下递推</strong>，表示开启了一个新的递归方法来访问新顶点；</li>
+<li><strong>曲虚线代表向上回溯</strong>，表示此递归方法已经返回，回溯到了开启此递归方法的位置；</li>
 </ul>
-<p>为了加深理解，请你将图示与代码结合起来，在脑中（或者用笔画下来）模拟整个 DFS 过程，包括每个递归方法何时开启、何时返回。</p>
+<p>为了加深理解，建议将图示与代码结合起来，在脑中（或者用笔画下来）模拟整个 DFS 过程，包括每个递归方法何时开启、何时返回。</p>
 <div class="tabbed-set tabbed-alternate" data-tabs="4:11"><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" /><input id="__tabbed_4_6" name="__tabbed_4" type="radio" /><input id="__tabbed_4_7" name="__tabbed_4" type="radio" /><input id="__tabbed_4_8" name="__tabbed_4" type="radio" /><input id="__tabbed_4_9" name="__tabbed_4" type="radio" /><input id="__tabbed_4_10" name="__tabbed_4" type="radio" /><input id="__tabbed_4_11" name="__tabbed_4" type="radio" /><div class="tabbed-labels"><label for="__tabbed_4_1">&lt;1&gt;</label><label for="__tabbed_4_2">&lt;2&gt;</label><label for="__tabbed_4_3">&lt;3&gt;</label><label for="__tabbed_4_4">&lt;4&gt;</label><label for="__tabbed_4_5">&lt;5&gt;</label><label for="__tabbed_4_6">&lt;6&gt;</label><label for="__tabbed_4_7">&lt;7&gt;</label><label for="__tabbed_4_8">&lt;8&gt;</label><label for="__tabbed_4_9">&lt;9&gt;</label><label for="__tabbed_4_10">&lt;10&gt;</label><label for="__tabbed_4_11">&lt;11&gt;</label></div>
 <div class="tabbed-content">
 <div class="tabbed-block">
@@ -2359,11 +2359,11 @@
 </div>
 <div class="admonition question">
 <p class="admonition-title">深度优先遍历的序列是否唯一？</p>
-<p>与广度优先遍历类似，深度优先遍历序列的顺序也不是唯一的。给定某顶点，先往哪个方向探索都行，都是深度优先遍历。</p>
-<p>以树的遍历为例，“根 <span class="arithmatex">\(\rightarrow\)</span> 左 <span class="arithmatex">\(\rightarrow\)</span> 右”、“左 <span class="arithmatex">\(\rightarrow\)</span> 根 <span class="arithmatex">\(\rightarrow\)</span> 右”、“左 <span class="arithmatex">\(\rightarrow\)</span> 右 <span class="arithmatex">\(\rightarrow\)</span> 根”分别对应前序、中序、后序遍历，体现三种不同的遍历优先级，而三者都属于深度优先遍历。</p>
+<p>与广度优先遍历类似，深度优先遍历序列的顺序也不是唯一的。给定某顶点，先往哪个方向探索都可以，即邻接顶点的顺序可以任意打乱，都是深度优先遍历。</p>
+<p>以树的遍历为例，“根 <span class="arithmatex">\(\rightarrow\)</span> 左 <span class="arithmatex">\(\rightarrow\)</span> 右”、“左 <span class="arithmatex">\(\rightarrow\)</span> 根 <span class="arithmatex">\(\rightarrow\)</span> 右”、“左 <span class="arithmatex">\(\rightarrow\)</span> 右 <span class="arithmatex">\(\rightarrow\)</span> 根”分别对应前序、中序、后序遍历，它们展示了三种不同的遍历优先级，然而这三者都属于深度优先遍历。</p>
 </div>
 <h3 id="_4">复杂度分析<a class="headerlink" href="#_4" title="Permanent link">&para;</a></h3>
-<p><strong>时间复杂度：</strong> 所有顶点都被访问一次；所有边都被访问了 <span class="arithmatex">\(2\)</span> 次，使用 <span class="arithmatex">\(O(2|E|)\)</span> 时间；总体使用 <span class="arithmatex">\(O(|V| + |E|)\)</span> 时间。</p>
+<p><strong>时间复杂度：</strong> 所有顶点都会被访问 <span class="arithmatex">\(1\)</span> 次，使用 <span class="arithmatex">\(O(|V|)\)</span> 时间；所有边都会被访问 <span class="arithmatex">\(2\)</span> 次，使用 <span class="arithmatex">\(O(2|E|)\)</span> 时间；总体使用 <span class="arithmatex">\(O(|V| + |E|)\)</span> 时间。</p>
 <p><strong>空间复杂度：</strong> 列表 <code>res</code> ，哈希表 <code>visited</code> 顶点数量最多为 <span class="arithmatex">\(|V|\)</span> ，递归深度最大为 <span class="arithmatex">\(|V|\)</span> ，因此使用 <span class="arithmatex">\(O(|V|)\)</span> 空间。</p>
 
 

chapter_graph/summary/index.html

@@ -1681,17 +1681,17 @@
 
 <h1 id="94">9.4. &nbsp; 小结<a class="headerlink" href="#94" title="Permanent link">&para;</a></h1>
 <ul>
-<li>图由顶点和边组成，可以表示为一组顶点和一组边构成的集合。</li>
-<li>相比线性关系（链表）和分治关系（树），网络关系（图）的自由度更高，也从而更为复杂。</li>
-<li>有向图的边存在方向，连通图中的任意顶点都可达，有权图的每条边都包含权重变量。</li>
-<li>邻接矩阵使用方阵来表示图，每一行（列）代表一个顶点，矩阵元素代表边，使用 <span class="arithmatex">\(1\)</span> 或 <span class="arithmatex">\(0\)</span> 来表示两个顶点之间有边或无边。邻接矩阵的增删查操作效率很高，但占用空间大。</li>
-<li>邻接表使用多个链表来表示图，第 <span class="arithmatex">\(i\)</span> 条链表对应顶点 <span class="arithmatex">\(i\)</span> ，其中存储了该顶点的所有邻接顶点。邻接表相对邻接矩阵更加节省空间，但由于需要通过遍历链表来查找边，因此时间效率较低。</li>
-<li>当邻接表中的链表过长时，可以将其转化为红黑树或哈希表，从而提升查询效率。</li>
-<li>从算法思想角度分析，邻接矩阵体现“以空间换时间”，邻接表体现“以时间换空间”</li>
-<li>图可以用于建模各类现实系统，例如社交网络、地铁线路等。</li>
+<li>图由顶点和边组成，可以被表示为一组顶点和一组边构成的集合。</li>
+<li>相较于线性关系（链表）和分治关系（树），网络关系（图）具有更高的自由度，因而更为复杂。</li>
+<li>有向图的边具有方向性，连通图中的任意顶点均可达，有权图的每条边都包含权重变量。</li>
+<li>邻接矩阵利用矩阵来表示图，每一行（列）代表一个顶点，矩阵元素代表边，用 <span class="arithmatex">\(1\)</span> 或 <span class="arithmatex">\(0\)</span> 表示两个顶点之间有边或无边。邻接矩阵在增删查操作上效率很高，但空间占用较多。</li>
+<li>邻接表使用多个链表来表示图，第 <span class="arithmatex">\(i\)</span> 条链表对应顶点 <span class="arithmatex">\(i\)</span> ，其中存储了该顶点的所有邻接顶点。邻接表相对于邻接矩阵更加节省空间，但由于需要遍历链表来查找边，时间效率较低。</li>
+<li>当邻接表中的链表过长时，可以将其转换为红黑树或哈希表，从而提升查询效率。</li>
+<li>从算法思想角度分析，邻接矩阵体现“以空间换时间”，邻接表体现“以时间换空间”。</li>
+<li>图可用于建模各类现实系统，如社交网络、地铁线路等。</li>
 <li>树是图的一种特例，树的遍历也是图的遍历的一种特例。</li>
-<li>图的广度优先遍历是一种由近及远、层层扩张的搜索方式，常借助队列实现。</li>
-<li>图的深度优先遍历是一种优先走到底、无路可走再回头的搜索方式，常基于递归来实现。</li>
+<li>图的广度优先遍历是一种由近及远、层层扩张的搜索方式，通常借助队列实现。</li>
+<li>图的深度优先遍历是一种优先走到底、无路可走时再回溯的搜索方式，常基于递归来实现。</li>
 </ul>