deploy

chapter_sorting/insertion_sort/index.html

@@ -1754,18 +1754,17 @@
 
 
 <h1 id="113">11.3. &nbsp; 插入排序<a class="headerlink" href="#113" title="Permanent link">&para;</a></h1>
-<p>「插入排序 Insertion Sort」是一种基于 <strong>数组插入操作</strong> 的排序算法。</p>
-<p>「插入操作」原理：选定某个待排序元素为基准数 <code>base</code>，将 <code>base</code> 与其左侧已排序区间元素依次对比大小，并插入到正确位置。</p>
-<p>回忆数组插入操作，我们需要将从目标索引到 <code>base</code> 之间的所有元素向右移动一位，然后再将 <code>base</code> 赋值给目标索引。</p>
+<p>「插入排序 Insertion Sort」是一种基于数组插入操作的排序算法。具体来说，选择一个待排序的元素作为基准值 <code>base</code> ，将 <code>base</code> 与其左侧已排序区间的元素逐一比较大小，并将其插入到正确的位置。</p>
+<p>回顾数组插入操作，我们需要将从目标索引到 <code>base</code> 之间的所有元素向右移动一位，然后再将 <code>base</code> 赋值给目标索引。</p>
 <p><img alt="单次插入操作" src="../insertion_sort.assets/insertion_operation.png" /></p>
 <p align="center"> Fig. 单次插入操作 </p>
 
 <h2 id="1131">11.3.1. &nbsp; 算法流程<a class="headerlink" href="#1131" title="Permanent link">&para;</a></h2>
-<p>循环执行插入操作：</p>
+<p>插入排序的整体流程如下：</p>
 <ol>
-<li>先选取数组的 <strong>第 2 个元素</strong> 为 <code>base</code> ，执行插入操作后，<strong>数组前 2 个元素已完成排序</strong>。</li>
-<li>选取 <strong>第 3 个元素</strong> 为 <code>base</code> ，执行插入操作后，<strong>数组前 3 个元素已完成排序</strong>。</li>
-<li>以此类推……最后一轮选取 <strong>数组尾元素</strong> 为 <code>base</code> ，执行插入操作后，<strong>所有元素已完成排序</strong>。</li>
+<li>首先，选取数组的第 2 个元素作为 <code>base</code> ，执行插入操作后，<strong>数组的前 2 个元素已排序</strong>。</li>
+<li>接着，选取第 3 个元素作为 <code>base</code> ，执行插入操作后，<strong>数组的前 3 个元素已排序</strong>。</li>
+<li>以此类推，在最后一轮中，选取数组尾元素作为 <code>base</code> ，执行插入操作后，<strong>所有元素均已排序</strong>。</li>
 </ol>
 <p><img alt="插入排序流程" src="../insertion_sort.assets/insertion_sort_overview.png" /></p>
 <p align="center"> Fig. 插入排序流程 </p>
@@ -1928,21 +1927,21 @@
 </div>
 </div>
 <h2 id="1132">11.3.2. &nbsp; 算法特性<a class="headerlink" href="#1132" title="Permanent link">&para;</a></h2>
-<p><strong>时间复杂度 <span class="arithmatex">\(O(n^2)\)</span></strong> ：最差情况下，各轮插入操作循环 <span class="arithmatex">\(n - 1\)</span> , <span class="arithmatex">\(n-2\)</span> , <span class="arithmatex">\(\cdots\)</span> , <span class="arithmatex">\(2\)</span> , <span class="arithmatex">\(1\)</span> 次，求和为 <span class="arithmatex">\(\frac{(n - 1) n}{2}\)</span> ，使用 <span class="arithmatex">\(O(n^2)\)</span> 时间。输入数组完全有序下，达到最佳时间复杂度 <span class="arithmatex">\(O(n)\)</span> ，因此是“自适应排序”。</p>
-<p><strong>空间复杂度 <span class="arithmatex">\(O(1)\)</span></strong> ：指针 <span class="arithmatex">\(i\)</span> , <span class="arithmatex">\(j\)</span> 使用常数大小的额外空间，因此是“原地排序”。</p>
-<p>在插入操作中，我们会将元素插入到相等元素的右边，不会改变它们的次序，因此是“稳定排序”。</p>
+<p><strong>时间复杂度 <span class="arithmatex">\(O(n^2)\)</span></strong> ：最差情况下，每次插入操作分别需要循环 <span class="arithmatex">\(n - 1\)</span> , <span class="arithmatex">\(n-2\)</span> , <span class="arithmatex">\(\cdots\)</span> , <span class="arithmatex">\(2\)</span> , <span class="arithmatex">\(1\)</span> 次，求和得到 <span class="arithmatex">\(\frac{(n - 1) n}{2}\)</span> ，因此时间复杂度为 <span class="arithmatex">\(O(n^2)\)</span> 。当输入数组完全有序时，插入排序达到最佳时间复杂度 <span class="arithmatex">\(O(n)\)</span> ，因此是“自适应排序”。</p>
+<p><strong>空间复杂度 <span class="arithmatex">\(O(1)\)</span></strong> ：指针 <span class="arithmatex">\(i\)</span> , <span class="arithmatex">\(j\)</span> 使用常数大小的额外空间，所以插入排序是“原地排序”。</p>
+<p>在插入操作过程中，我们会将元素插入到相等元素的右侧，不会改变它们的顺序，因此是“稳定排序”。</p>
 <h2 id="1133">11.3.3. &nbsp; 插入排序优势<a class="headerlink" href="#1133" title="Permanent link">&para;</a></h2>
-<p>回顾「冒泡排序」和「插入排序」的复杂度分析，两者的循环轮数都是 <span class="arithmatex">\(\frac{(n - 1) n}{2}\)</span> 。但不同的是：</p>
+<p>回顾冒泡排序和插入排序的复杂度分析，两者的循环轮数都是 <span class="arithmatex">\(\frac{(n - 1) n}{2}\)</span> 。然而，它们之间存在以下差异：</p>
 <ul>
-<li>冒泡操作基于 <strong>元素交换</strong> 实现，需要借助一个临时变量实现，共 3 个单元操作；</li>
-<li>插入操作基于 <strong>元素赋值</strong> 实现，只需 1 个单元操作；</li>
+<li>冒泡操作基于元素交换实现，需要借助一个临时变量，共涉及 3 个单元操作；</li>
+<li>插入操作基于元素赋值实现，仅需 1 个单元操作；</li>
 </ul>
-<p>粗略估计，冒泡排序的计算开销约为插入排序的 3 倍，因此插入排序更受欢迎，许多编程语言（例如 Java）的内置排序函数都使用到了插入排序，大致思路为：</p>
+<p>粗略估计下来，冒泡排序的计算开销约为插入排序的 3 倍，因此插入排序更受欢迎。实际上，许多编程语言（如 Java）的内置排序函数都采用了插入排序，大致思路为：</p>
 <ul>
-<li>对于 <strong>长数组</strong>，采用基于分治的排序算法，例如「快速排序」，时间复杂度为 <span class="arithmatex">\(O(n \log n)\)</span> ；</li>
-<li>对于 <strong>短数组</strong>，直接使用「插入排序」，时间复杂度为 <span class="arithmatex">\(O(n^2)\)</span> ；</li>
+<li>对于长数组，采用基于分治的排序算法，例如「快速排序」，时间复杂度为 <span class="arithmatex">\(O(n \log n)\)</span> ；</li>
+<li>对于短数组，直接使用「插入排序」，时间复杂度为 <span class="arithmatex">\(O(n^2)\)</span> ；</li>
 </ul>
-<p>虽然插入排序比快速排序的时间复杂度更高，<strong>但实际上在数据量较小时插入排序更快</strong>，这是因为复杂度中的常数项（即每轮中的单元操作数量）占主导作用。这个现象与「线性查找」和「二分查找」的情况类似。</p>
+<p>尽管插入排序的时间复杂度高于快速排序，<strong>但在数据量较小的情况下，插入排序实际上更快</strong>。这是因为在数据量较小时，复杂度中的常数项（即每轮中的单元操作数量）起主导作用。这个现象与「线性查找」和「二分查找」的情况相似。</p>