deploy

chapter_sorting/bubble_sort/index.html

@@ -3427,7 +3427,7 @@
 
 <h1 id="113">11.3 &nbsp; 冒泡排序<a class="headerlink" href="#113" title="Permanent link">&para;</a></h1>
 <p>「冒泡排序 bubble sort」通过连续地比较与交换相邻元素实现排序。这个过程就像气泡从底部升到顶部一样，因此得名冒泡排序。</p>
-<p>如下图所示，冒泡过程可以利用元素交换操作来模拟：从数组最左端开始向右遍历，依次比较相邻元素大小，如果“左元素 &gt; 右元素”就交换它俩。遍历完成后，最大的元素会被移动到数组的最右端。</p>
+<p>如图 11-4 所示，冒泡过程可以利用元素交换操作来模拟：从数组最左端开始向右遍历，依次比较相邻元素大小，如果“左元素 &gt; 右元素”就交换它俩。遍历完成后，最大的元素会被移动到数组的最右端。</p>
 <div class="tabbed-set tabbed-alternate" data-tabs="1:7"><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" /><div class="tabbed-labels"><label for="__tabbed_1_1">&lt;1&gt;</label><label for="__tabbed_1_2">&lt;2&gt;</label><label for="__tabbed_1_3">&lt;3&gt;</label><label for="__tabbed_1_4">&lt;4&gt;</label><label for="__tabbed_1_5">&lt;5&gt;</label><label for="__tabbed_1_6">&lt;6&gt;</label><label for="__tabbed_1_7">&lt;7&gt;</label></div>
 <div class="tabbed-content">
 <div class="tabbed-block">
@@ -3453,10 +3453,10 @@
 </div>
 </div>
 </div>
-<p align="center"> 图：利用元素交换操作模拟冒泡 </p>
+<p align="center"> 图 11-4 &nbsp; 利用元素交换操作模拟冒泡 </p>
 
 <h2 id="1131">11.3.1 &nbsp; 算法流程<a class="headerlink" href="#1131" title="Permanent link">&para;</a></h2>
-<p>设数组的长度为 <span class="arithmatex">\(n\)</span> ，冒泡排序的步骤如下图所示。</p>
+<p>设数组的长度为 <span class="arithmatex">\(n\)</span> ，冒泡排序的步骤如图 11-5 所示。</p>
 <ol>
 <li>首先，对 <span class="arithmatex">\(n\)</span> 个元素执行“冒泡”，<strong>将数组的最大元素交换至正确位置</strong>，</li>
 <li>接下来，对剩余 <span class="arithmatex">\(n - 1\)</span> 个元素执行“冒泡”，<strong>将第二大元素交换至正确位置</strong>。</li>
@@ -3464,7 +3464,7 @@
 <li>仅剩的一个元素必定是最小元素，无须排序，因此数组排序完成。</li>
 </ol>
 <p><img alt="冒泡排序流程" src="../bubble_sort.assets/bubble_sort_overview.png" /></p>
-<p align="center"> 图：冒泡排序流程 </p>
+<p align="center"> 图 11-5 &nbsp; 冒泡排序流程 </p>
 
 <div class="tabbed-set tabbed-alternate" data-tabs="2:12"><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" /><input id="__tabbed_2_6" name="__tabbed_2" type="radio" /><input id="__tabbed_2_7" name="__tabbed_2" type="radio" /><input id="__tabbed_2_8" name="__tabbed_2" type="radio" /><input id="__tabbed_2_9" name="__tabbed_2" type="radio" /><input id="__tabbed_2_10" name="__tabbed_2" type="radio" /><input id="__tabbed_2_11" name="__tabbed_2" type="radio" /><input id="__tabbed_2_12" name="__tabbed_2" type="radio" /><div class="tabbed-labels"><label for="__tabbed_2_1">Java</label><label for="__tabbed_2_2">C++</label><label for="__tabbed_2_3">Python</label><label for="__tabbed_2_4">Go</label><label for="__tabbed_2_5">JS</label><label for="__tabbed_2_6">TS</label><label for="__tabbed_2_7">C</label><label for="__tabbed_2_8">C#</label><label for="__tabbed_2_9">Swift</label><label for="__tabbed_2_10">Zig</label><label for="__tabbed_2_11">Dart</label><label for="__tabbed_2_12">Rust</label></div>
 <div class="tabbed-content">

chapter_sorting/bucket_sort/index.html

@@ -3429,14 +3429,14 @@
 <p>前述的几种排序算法都属于“基于比较的排序算法”，它们通过比较元素间的大小来实现排序。此类排序算法的时间复杂度无法超越 <span class="arithmatex">\(O(n \log n)\)</span> 。接下来，我们将探讨几种“非比较排序算法”，它们的时间复杂度可以达到线性阶。</p>
 <p>「桶排序 bucket sort」是分治策略的一个典型应用。它通过设置一些具有大小顺序的桶，每个桶对应一个数据范围，将数据平均分配到各个桶中；然后，在每个桶内部分别执行排序；最终按照桶的顺序将所有数据合并。</p>
 <h2 id="1181">11.8.1 &nbsp; 算法流程<a class="headerlink" href="#1181" title="Permanent link">&para;</a></h2>
-<p>考虑一个长度为 <span class="arithmatex">\(n\)</span> 的数组，元素是范围 <span class="arithmatex">\([0, 1)\)</span> 的浮点数。桶排序的流程如下图所示。</p>
+<p>考虑一个长度为 <span class="arithmatex">\(n\)</span> 的数组，元素是范围 <span class="arithmatex">\([0, 1)\)</span> 的浮点数。桶排序的流程如图 11-13 所示。</p>
 <ol>
 <li>初始化 <span class="arithmatex">\(k\)</span> 个桶，将 <span class="arithmatex">\(n\)</span> 个元素分配到 <span class="arithmatex">\(k\)</span> 个桶中。</li>
 <li>对每个桶分别执行排序（本文采用编程语言的内置排序函数）。</li>
 <li>按照桶的从小到大的顺序，合并结果。</li>
 </ol>
 <p><img alt="桶排序算法流程" src="../bucket_sort.assets/bucket_sort_overview.png" /></p>
-<p align="center"> 图：桶排序算法流程 </p>
+<p align="center"> 图 11-13 &nbsp; 桶排序算法流程 </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>
 <div class="tabbed-content">
@@ -3804,14 +3804,14 @@
 <h2 id="1183">11.8.3 &nbsp; 如何实现平均分配<a class="headerlink" href="#1183" title="Permanent link">&para;</a></h2>
 <p>桶排序的时间复杂度理论上可以达到 <span class="arithmatex">\(O(n)\)</span> ，<strong>关键在于将元素均匀分配到各个桶中</strong>，因为实际数据往往不是均匀分布的。例如，我们想要将淘宝上的所有商品按价格范围平均分配到 10 个桶中，但商品价格分布不均，低于 100 元的非常多，高于 1000 元的非常少。若将价格区间平均划分为 10 份，各个桶中的商品数量差距会非常大。</p>
 <p>为实现平均分配，我们可以先设定一个大致的分界线，将数据粗略地分到 3 个桶中。<strong>分配完毕后，再将商品较多的桶继续划分为 3 个桶，直至所有桶中的元素数量大致相等</strong>。</p>
-<p>如下图所示，这种方法本质上是创建一个递归树，目标是让叶节点的值尽可能平均。当然，不一定要每轮将数据划分为 3 个桶，具体划分方式可根据数据特点灵活选择。</p>
+<p>如图 11-14 所示，这种方法本质上是创建一个递归树，目标是让叶节点的值尽可能平均。当然，不一定要每轮将数据划分为 3 个桶，具体划分方式可根据数据特点灵活选择。</p>
 <p><img alt="递归划分桶" src="../bucket_sort.assets/scatter_in_buckets_recursively.png" /></p>
-<p align="center"> 图：递归划分桶 </p>
+<p align="center"> 图 11-14 &nbsp; 递归划分桶 </p>
 
 <p>如果我们提前知道商品价格的概率分布，<strong>则可以根据数据概率分布设置每个桶的价格分界线</strong>。值得注意的是，数据分布并不一定需要特意统计，也可以根据数据特点采用某种概率模型进行近似。</p>
-<p>如下图所示，我们假设商品价格服从正态分布，这样就可以合理地设定价格区间，从而将商品平均分配到各个桶中。</p>
+<p>如图 11-15 所示，我们假设商品价格服从正态分布，这样就可以合理地设定价格区间，从而将商品平均分配到各个桶中。</p>
 <p><img alt="根据概率分布划分桶" src="../bucket_sort.assets/scatter_in_buckets_distribution.png" /></p>
-<p align="center"> 图：根据概率分布划分桶 </p>
+<p align="center"> 图 11-15 &nbsp; 根据概率分布划分桶 </p>
 
 
 

chapter_sorting/counting_sort/index.html

@@ -3442,14 +3442,14 @@
 <h1 id="119">11.9 &nbsp; 计数排序<a class="headerlink" href="#119" title="Permanent link">&para;</a></h1>
 <p>「计数排序 counting sort」通过统计元素数量来实现排序，通常应用于整数数组。</p>
 <h2 id="1191">11.9.1 &nbsp; 简单实现<a class="headerlink" href="#1191" title="Permanent link">&para;</a></h2>
-<p>先来看一个简单的例子。给定一个长度为 <span class="arithmatex">\(n\)</span> 的数组 <code>nums</code> ，其中的元素都是“非负整数”，计数排序的整体流程如下图所示。</p>
+<p>先来看一个简单的例子。给定一个长度为 <span class="arithmatex">\(n\)</span> 的数组 <code>nums</code> ，其中的元素都是“非负整数”，计数排序的整体流程如图 11-16 所示。</p>
 <ol>
 <li>遍历数组，找出数组中的最大数字，记为 <span class="arithmatex">\(m\)</span> ，然后创建一个长度为 <span class="arithmatex">\(m + 1\)</span> 的辅助数组 <code>counter</code> 。</li>
 <li><strong>借助 <code>counter</code> 统计 <code>nums</code> 中各数字的出现次数</strong>，其中 <code>counter[num]</code> 对应数字 <code>num</code> 的出现次数。统计方法很简单，只需遍历 <code>nums</code>（设当前数字为 <code>num</code>），每轮将 <code>counter[num]</code> 增加 <span class="arithmatex">\(1\)</span> 即可。</li>
 <li><strong>由于 <code>counter</code> 的各个索引天然有序，因此相当于所有数字已经被排序好了</strong>。接下来，我们遍历 <code>counter</code> ，根据各数字的出现次数，将它们按从小到大的顺序填入 <code>nums</code> 即可。</li>
 </ol>
 <p><img alt="计数排序流程" src="../counting_sort.assets/counting_sort_overview.png" /></p>
-<p align="center"> 图：计数排序流程 </p>
+<p align="center"> 图 11-16 &nbsp; 计数排序流程 </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>
 <div class="tabbed-content">
@@ -3745,7 +3745,7 @@
 <li>将 <code>num</code> 填入数组 <code>res</code> 的索引 <code>prefix[num] - 1</code> 处。</li>
 <li>令前缀和 <code>prefix[num]</code> 减小 <span class="arithmatex">\(1\)</span> ，从而得到下次放置 <code>num</code> 的索引。</li>
 </ol>
-<p>遍历完成后，数组 <code>res</code> 中就是排序好的结果，最后使用 <code>res</code> 覆盖原数组 <code>nums</code> 即可。下图展示了完整的计数排序流程。</p>
+<p>遍历完成后，数组 <code>res</code> 中就是排序好的结果，最后使用 <code>res</code> 覆盖原数组 <code>nums</code> 即可。图 11-17 展示了完整的计数排序流程。</p>
 <div class="tabbed-set tabbed-alternate" data-tabs="2:8"><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" /><input id="__tabbed_2_6" name="__tabbed_2" type="radio" /><input id="__tabbed_2_7" name="__tabbed_2" type="radio" /><input id="__tabbed_2_8" name="__tabbed_2" type="radio" /><div class="tabbed-labels"><label for="__tabbed_2_1">&lt;1&gt;</label><label for="__tabbed_2_2">&lt;2&gt;</label><label for="__tabbed_2_3">&lt;3&gt;</label><label for="__tabbed_2_4">&lt;4&gt;</label><label for="__tabbed_2_5">&lt;5&gt;</label><label for="__tabbed_2_6">&lt;6&gt;</label><label for="__tabbed_2_7">&lt;7&gt;</label><label for="__tabbed_2_8">&lt;8&gt;</label></div>
 <div class="tabbed-content">
 <div class="tabbed-block">
@@ -3774,7 +3774,7 @@
 </div>
 </div>
 </div>
-<p align="center"> 图：计数排序步骤 </p>
+<p align="center"> 图 11-17 &nbsp; 计数排序步骤 </p>
 
 <p>计数排序的实现代码如下所示。</p>
 <div class="tabbed-set tabbed-alternate" data-tabs="3:12"><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" /><input id="__tabbed_3_11" name="__tabbed_3" type="radio" /><input id="__tabbed_3_12" 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">JS</label><label for="__tabbed_3_6">TS</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><label for="__tabbed_3_11">Dart</label><label for="__tabbed_3_12">Rust</label></div>

chapter_sorting/heap_sort/index.html

@@ -3423,7 +3423,7 @@
 </ol>
 <p>以上方法虽然可行，但需要借助一个额外数组来保存弹出的元素，比较浪费空间。在实际中，我们通常使用一种更加优雅的实现方式。</p>
 <h2 id="1171">11.7.1 &nbsp; 算法流程<a class="headerlink" href="#1171" title="Permanent link">&para;</a></h2>
-<p>设数组的长度为 <span class="arithmatex">\(n\)</span> ，堆排序的流程如下图所示。</p>
+<p>设数组的长度为 <span class="arithmatex">\(n\)</span> ，堆排序的流程如图 11-12 所示。</p>
 <ol>
 <li>输入数组并建立大顶堆。完成后，最大元素位于堆顶。</li>
 <li>将堆顶元素（第一个元素）与堆底元素（最后一个元素）交换。完成交换后，堆的长度减 <span class="arithmatex">\(1\)</span> ，已排序元素数量加 <span class="arithmatex">\(1\)</span> 。</li>
@@ -3474,7 +3474,7 @@
 </div>
 </div>
 </div>
-<p align="center"> 图：堆排序步骤 </p>
+<p align="center"> 图 11-12 &nbsp; 堆排序步骤 </p>
 
 <p>在代码实现中，我们使用了与堆章节相同的从顶至底堆化 <code>sift_down()</code> 函数。值得注意的是，由于堆的长度会随着提取最大元素而减小，因此我们需要给 <code>sift_down()</code> 函数添加一个长度参数 <span class="arithmatex">\(n\)</span> ，用于指定堆的当前有效长度。</p>
 <div class="tabbed-set tabbed-alternate" data-tabs="2:12"><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" /><input id="__tabbed_2_6" name="__tabbed_2" type="radio" /><input id="__tabbed_2_7" name="__tabbed_2" type="radio" /><input id="__tabbed_2_8" name="__tabbed_2" type="radio" /><input id="__tabbed_2_9" name="__tabbed_2" type="radio" /><input id="__tabbed_2_10" name="__tabbed_2" type="radio" /><input id="__tabbed_2_11" name="__tabbed_2" type="radio" /><input id="__tabbed_2_12" name="__tabbed_2" type="radio" /><div class="tabbed-labels"><label for="__tabbed_2_1">Java</label><label for="__tabbed_2_2">C++</label><label for="__tabbed_2_3">Python</label><label for="__tabbed_2_4">Go</label><label for="__tabbed_2_5">JS</label><label for="__tabbed_2_6">TS</label><label for="__tabbed_2_7">C</label><label for="__tabbed_2_8">C#</label><label for="__tabbed_2_9">Swift</label><label for="__tabbed_2_10">Zig</label><label for="__tabbed_2_11">Dart</label><label for="__tabbed_2_12">Rust</label></div>

chapter_sorting/insertion_sort/index.html

@@ -3428,12 +3428,12 @@
 <h1 id="114">11.4 &nbsp; 插入排序<a class="headerlink" href="#114" title="Permanent link">&para;</a></h1>
 <p>「插入排序 insertion sort」是一种简单的排序算法，它的工作原理与手动整理一副牌的过程非常相似。</p>
 <p>具体来说，我们在未排序区间选择一个基准元素，将该元素与其左侧已排序区间的元素逐一比较大小，并将该元素插入到正确的位置。</p>
-<p>下图展示了数组插入元素的操作流程。设基准元素为 <code>base</code> ，我们需要将从目标索引到 <code>base</code> 之间的所有元素向右移动一位，然后再将 <code>base</code> 赋值给目标索引。</p>
+<p>图 11-6 展示了数组插入元素的操作流程。设基准元素为 <code>base</code> ，我们需要将从目标索引到 <code>base</code> 之间的所有元素向右移动一位，然后再将 <code>base</code> 赋值给目标索引。</p>
 <p><img alt="单次插入操作" src="../insertion_sort.assets/insertion_operation.png" /></p>
-<p align="center"> 图：单次插入操作 </p>
+<p align="center"> 图 11-6 &nbsp; 单次插入操作 </p>
 
 <h2 id="1141">11.4.1 &nbsp; 算法流程<a class="headerlink" href="#1141" title="Permanent link">&para;</a></h2>
-<p>插入排序的整体流程如下图所示。</p>
+<p>插入排序的整体流程如图 11-7 所示。</p>
 <ol>
 <li>初始状态下，数组的第 1 个元素已完成排序。</li>
 <li>选取数组的第 2 个元素作为 <code>base</code> ，将其插入到正确位置后，<strong>数组的前 2 个元素已排序</strong>。</li>
@@ -3441,7 +3441,7 @@
 <li>以此类推，在最后一轮中，选取最后一个元素作为 <code>base</code> ，将其插入到正确位置后，<strong>所有元素均已排序</strong>。</li>
 </ol>
 <p><img alt="插入排序流程" src="../insertion_sort.assets/insertion_sort_overview.png" /></p>
-<p align="center"> 图：插入排序流程 </p>
+<p align="center"> 图 11-7 &nbsp; 插入排序流程 </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>
 <div class="tabbed-content">

chapter_sorting/merge_sort/index.html

@@ -3426,16 +3426,16 @@
 
 
 <h1 id="116">11.6 &nbsp; 归并排序<a class="headerlink" href="#116" title="Permanent link">&para;</a></h1>
-<p>「归并排序 merge sort」是一种基于分治策略的排序算法，包含下图所示的“划分”和“合并”阶段：</p>
+<p>「归并排序 merge sort」是一种基于分治策略的排序算法，包含图 11-10 所示的“划分”和“合并”阶段：</p>
 <ol>
 <li><strong>划分阶段</strong>：通过递归不断地将数组从中点处分开，将长数组的排序问题转换为短数组的排序问题。</li>
 <li><strong>合并阶段</strong>：当子数组长度为 1 时终止划分，开始合并，持续地将左右两个较短的有序数组合并为一个较长的有序数组，直至结束。</li>
 </ol>
 <p><img alt="归并排序的划分与合并阶段" src="../merge_sort.assets/merge_sort_overview.png" /></p>
-<p align="center"> 图：归并排序的划分与合并阶段 </p>
+<p align="center"> 图 11-10 &nbsp; 归并排序的划分与合并阶段 </p>
 
 <h2 id="1161">11.6.1 &nbsp; 算法流程<a class="headerlink" href="#1161" title="Permanent link">&para;</a></h2>
-<p>如下图所示，“划分阶段”从顶至底递归地将数组从中点切为两个子数组：</p>
+<p>如图 11-11 所示，“划分阶段”从顶至底递归地将数组从中点切为两个子数组：</p>
 <ol>
 <li>计算数组中点 <code>mid</code> ，递归划分左子数组（区间 <code>[left, mid]</code> ）和右子数组（区间 <code>[mid + 1, right]</code> ）。</li>
 <li>递归执行步骤 <code>1.</code> ，直至子数组区间长度为 1 时，终止递归划分。</li>
@@ -3475,7 +3475,7 @@
 </div>
 </div>
 </div>
-<p align="center"> 图：归并排序步骤 </p>
+<p align="center"> 图 11-11 &nbsp; 归并排序步骤 </p>
 
 <p>观察发现，归并排序的递归顺序与二叉树的后序遍历相同，对比来看：</p>
 <ul>

chapter_sorting/quick_sort/index.html

@@ -3455,7 +3455,7 @@
 
 <h1 id="115">11.5 &nbsp; 快速排序<a class="headerlink" href="#115" title="Permanent link">&para;</a></h1>
 <p>「快速排序 quick sort」是一种基于分治策略的排序算法，运行高效，应用广泛。</p>
-<p>快速排序的核心操作是“哨兵划分”，其目标是：选择数组中的某个元素作为“基准数”，将所有小于基准数的元素移到其左侧，而大于基准数的元素移到其右侧。具体来说，哨兵划分的流程如下图所示。</p>
+<p>快速排序的核心操作是“哨兵划分”，其目标是：选择数组中的某个元素作为“基准数”，将所有小于基准数的元素移到其左侧，而大于基准数的元素移到其右侧。具体来说，哨兵划分的流程如图 11-8 所示。</p>
 <ol>
 <li>选取数组最左端元素作为基准数，初始化两个指针 <code>i</code> 和 <code>j</code> 分别指向数组的两端。</li>
 <li>设置一个循环，在每轮中使用 <code>i</code>（<code>j</code>）分别寻找第一个比基准数大（小）的元素，然后交换这两个元素。</li>
@@ -3492,7 +3492,7 @@
 </div>
 </div>
 </div>
-<p align="center"> 图：哨兵划分步骤 </p>
+<p align="center"> 图 11-8 &nbsp; 哨兵划分步骤 </p>
 
 <p>哨兵划分完成后，原数组被划分成三部分：左子数组、基准数、右子数组，且满足“左子数组任意元素 <span class="arithmatex">\(\leq\)</span> 基准数 <span class="arithmatex">\(\leq\)</span> 右子数组任意元素”。因此，我们接下来只需对这两个子数组进行排序。</p>
 <div class="admonition note">
@@ -3793,14 +3793,14 @@
 </div>
 </div>
 <h2 id="1151">11.5.1 &nbsp; 算法流程<a class="headerlink" href="#1151" title="Permanent link">&para;</a></h2>
-<p>快速排序的整体流程如下图所示。</p>
+<p>快速排序的整体流程如图 11-9 所示。</p>
 <ol>
 <li>首先，对原数组执行一次“哨兵划分”，得到未排序的左子数组和右子数组。</li>
 <li>然后，对左子数组和右子数组分别递归执行“哨兵划分”。</li>
 <li>持续递归，直至子数组长度为 1 时终止，从而完成整个数组的排序。</li>
 </ol>
 <p><img alt="快速排序流程" src="../quick_sort.assets/quick_sort_overview.png" /></p>
-<p align="center"> 图：快速排序流程 </p>
+<p align="center"> 图 11-9 &nbsp; 快速排序流程 </p>
 
 <div class="tabbed-set tabbed-alternate" data-tabs="3:12"><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" /><input id="__tabbed_3_11" name="__tabbed_3" type="radio" /><input id="__tabbed_3_12" 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">JS</label><label for="__tabbed_3_6">TS</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><label for="__tabbed_3_11">Dart</label><label for="__tabbed_3_12">Rust</label></div>
 <div class="tabbed-content">

chapter_sorting/radix_sort/index.html

@@ -3415,14 +3415,14 @@
 <p>上一节我们介绍了计数排序，它适用于数据量 <span class="arithmatex">\(n\)</span> 较大但数据范围 <span class="arithmatex">\(m\)</span> 较小的情况。假设我们需要对 <span class="arithmatex">\(n = 10^6\)</span> 个学号进行排序，而学号是一个 <span class="arithmatex">\(8\)</span> 位数字，这意味着数据范围 <span class="arithmatex">\(m = 10^8\)</span> 非常大，使用计数排序需要分配大量内存空间，而基数排序可以避免这种情况。</p>
 <p>「基数排序 radix sort」的核心思想与计数排序一致，也通过统计个数来实现排序。在此基础上，基数排序利用数字各位之间的递进关系，依次对每一位进行排序，从而得到最终的排序结果。</p>
 <h2 id="11101">11.10.1 &nbsp; 算法流程<a class="headerlink" href="#11101" title="Permanent link">&para;</a></h2>
-<p>以学号数据为例，假设数字的最低位是第 <span class="arithmatex">\(1\)</span> 位，最高位是第 <span class="arithmatex">\(8\)</span> 位，基数排序的流程如下图所示。</p>
+<p>以学号数据为例，假设数字的最低位是第 <span class="arithmatex">\(1\)</span> 位，最高位是第 <span class="arithmatex">\(8\)</span> 位，基数排序的流程如图 11-18 所示。</p>
 <ol>
 <li>初始化位数 <span class="arithmatex">\(k = 1\)</span> 。</li>
 <li>对学号的第 <span class="arithmatex">\(k\)</span> 位执行“计数排序”。完成后，数据会根据第 <span class="arithmatex">\(k\)</span> 位从小到大排序。</li>
 <li>将 <span class="arithmatex">\(k\)</span> 增加 <span class="arithmatex">\(1\)</span> ，然后返回步骤 <code>2.</code> 继续迭代，直到所有位都排序完成后结束。</li>
 </ol>
 <p><img alt="基数排序算法流程" src="../radix_sort.assets/radix_sort_overview.png" /></p>
-<p align="center"> 图：基数排序算法流程 </p>
+<p align="center"> 图 11-18 &nbsp; 基数排序算法流程 </p>
 
 <p>下面来剖析代码实现。对于一个 <span class="arithmatex">\(d\)</span> 进制的数字 <span class="arithmatex">\(x\)</span> ，要获取其第 <span class="arithmatex">\(k\)</span> 位 <span class="arithmatex">\(x_k\)</span> ，可以使用以下计算公式：</p>
 <div class="arithmatex">\[

chapter_sorting/selection_sort/index.html

@@ -3399,7 +3399,7 @@
 
 <h1 id="112">11.2 &nbsp; 选择排序<a class="headerlink" href="#112" title="Permanent link">&para;</a></h1>
 <p>「选择排序 selection sort」的工作原理非常直接：开启一个循环，每轮从未排序区间选择最小的元素，将其放到已排序区间的末尾。</p>
-<p>设数组的长度为 <span class="arithmatex">\(n\)</span> ，选择排序的算法流程如下图所示。</p>
+<p>设数组的长度为 <span class="arithmatex">\(n\)</span> ，选择排序的算法流程如图 11-2 所示。</p>
 <ol>
 <li>初始状态下，所有元素未排序，即未排序（索引）区间为 <span class="arithmatex">\([0, n-1]\)</span> 。</li>
 <li>选取区间 <span class="arithmatex">\([0, n-1]\)</span> 中的最小元素，将其与索引 <span class="arithmatex">\(0\)</span> 处元素交换。完成后，数组前 1 个元素已排序。</li>
@@ -3444,7 +3444,7 @@
 </div>
 </div>
 </div>
-<p align="center"> 图：选择排序步骤 </p>
+<p align="center"> 图 11-2 &nbsp; 选择排序步骤 </p>
 
 <p>在代码中，我们用 <span class="arithmatex">\(k\)</span> 来记录未排序区间内的最小元素。</p>
 <div class="tabbed-set tabbed-alternate" data-tabs="2:12"><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" /><input id="__tabbed_2_6" name="__tabbed_2" type="radio" /><input id="__tabbed_2_7" name="__tabbed_2" type="radio" /><input id="__tabbed_2_8" name="__tabbed_2" type="radio" /><input id="__tabbed_2_9" name="__tabbed_2" type="radio" /><input id="__tabbed_2_10" name="__tabbed_2" type="radio" /><input id="__tabbed_2_11" name="__tabbed_2" type="radio" /><input id="__tabbed_2_12" name="__tabbed_2" type="radio" /><div class="tabbed-labels"><label for="__tabbed_2_1">Java</label><label for="__tabbed_2_2">C++</label><label for="__tabbed_2_3">Python</label><label for="__tabbed_2_4">Go</label><label for="__tabbed_2_5">JS</label><label for="__tabbed_2_6">TS</label><label for="__tabbed_2_7">C</label><label for="__tabbed_2_8">C#</label><label for="__tabbed_2_9">Swift</label><label for="__tabbed_2_10">Zig</label><label for="__tabbed_2_11">Dart</label><label for="__tabbed_2_12">Rust</label></div>
@@ -3664,10 +3664,10 @@
 <ul>
 <li><strong>时间复杂度为 <span class="arithmatex">\(O(n^2)\)</span> 、非自适应排序</strong>：外循环共 <span class="arithmatex">\(n - 1\)</span> 轮，第一轮的未排序区间长度为 <span class="arithmatex">\(n\)</span> ，最后一轮的未排序区间长度为 <span class="arithmatex">\(2\)</span> ，即各轮外循环分别包含 <span class="arithmatex">\(n\)</span> , <span class="arithmatex">\(n - 1\)</span> , <span class="arithmatex">\(\dots\)</span> , <span class="arithmatex">\(2\)</span> 轮内循环，求和为 <span class="arithmatex">\(\frac{(n - 1)(n + 2)}{2}\)</span> 。</li>
 <li><strong>空间复杂度 <span class="arithmatex">\(O(1)\)</span> 、原地排序</strong>：指针 <span class="arithmatex">\(i\)</span> , <span class="arithmatex">\(j\)</span> 使用常数大小的额外空间。</li>
-<li><strong>非稳定排序</strong>：如下图所示，元素 <code>nums[i]</code> 有可能被交换至与其相等的元素的右边，导致两者相对顺序发生改变。</li>
+<li><strong>非稳定排序</strong>：如图 11-3 所示，元素 <code>nums[i]</code> 有可能被交换至与其相等的元素的右边，导致两者相对顺序发生改变。</li>
 </ul>
 <p><img alt="选择排序非稳定示例" src="../selection_sort.assets/selection_sort_instability.png" /></p>
-<p align="center"> 图：选择排序非稳定示例 </p>
+<p align="center"> 图 11-3 &nbsp; 选择排序非稳定示例 </p>
 
 
 

chapter_sorting/sorting_algorithm/index.html

@@ -3413,9 +3413,9 @@
 
 <h1 id="111">11.1 &nbsp; 排序算法<a class="headerlink" href="#111" title="Permanent link">&para;</a></h1>
 <p>「排序算法 sorting algorithm」用于对一组数据按照特定顺序进行排列。排序算法有着广泛的应用，因为有序数据通常能够被更有效地查找、分析和处理。</p>
-<p>如下图所示，排序算法中的数据类型可以是整数、浮点数、字符或字符串等。排序的判断规则可根据需求设定，如数字大小、字符 ASCII 码顺序或自定义规则。</p>
+<p>如图 11-1 所示，排序算法中的数据类型可以是整数、浮点数、字符或字符串等。排序的判断规则可根据需求设定，如数字大小、字符 ASCII 码顺序或自定义规则。</p>
 <p><img alt="数据类型和判断规则示例" src="../sorting_algorithm.assets/sorting_examples.png" /></p>
-<p align="center"> 图：数据类型和判断规则示例 </p>
+<p align="center"> 图 11-1 &nbsp; 数据类型和判断规则示例 </p>
 
 <h2 id="1111">11.1.1 &nbsp; 评价维度<a class="headerlink" href="#1111" title="Permanent link">&para;</a></h2>
 <p><strong>运行效率</strong>：我们期望排序算法的时间复杂度尽量低，且总体操作数量较少（即时间复杂度中的常数项降低）。对于大数据量情况，运行效率显得尤为重要。</p>

chapter_sorting/summary/index.html

@@ -3407,10 +3407,10 @@
 <li>计数排序是桶排序的一个特例，它通过统计数据出现的次数来实现排序。计数排序适用于数据量大但数据范围有限的情况，并且要求数据能够转换为正整数。</li>
 <li>基数排序通过逐位排序来实现数据排序，要求数据能够表示为固定位数的数字。</li>
 <li>总的来说，我们希望找到一种排序算法，具有高效率、稳定、原地以及正向自适应性等优点。然而，正如其他数据结构和算法一样，没有一种排序算法能够同时满足所有这些条件。在实际应用中，我们需要根据数据的特性来选择合适的排序算法。</li>
-<li>下图对比了主流排序算法的效率、稳定性、就地性和自适应性等。</li>
+<li>图 11-19 对比了主流排序算法的效率、稳定性、就地性和自适应性等。</li>
 </ul>
 <p><img alt="排序算法对比" src="../summary.assets/sorting_algorithms_comparison.png" /></p>
-<p align="center"> 图：排序算法对比 </p>
+<p align="center"> 图 11-19 &nbsp; 排序算法对比 </p>
 
 <h2 id="11111-q-a">11.11.1 &nbsp; Q &amp; A<a class="headerlink" href="#11111-q-a" title="Permanent link">&para;</a></h2>
 <div class="admonition question">