deploy

chapter_sorting/summary/index.html

@@ -3531,31 +3531,21 @@
 <p align="center"> 图 11-19 &nbsp; 排序算法对比 </p>
 
 <h3 id="2-q-a">2. &nbsp; Q &amp; A<a class="headerlink" href="#2-q-a" title="Permanent link">&para;</a></h3>
-<div class="admonition question">
-<p class="admonition-title">排序算法稳定性在什么情况下是必需的？</p>
+<p><strong>Q</strong>：排序算法稳定性在什么情况下是必需的？</p>
 <p>在现实中，我们有可能基于对象的某个属性进行排序。例如，学生有姓名和身高两个属性，我们希望实现一个多级排序：先按照姓名进行排序，得到 <code>(A, 180) (B, 185) (C, 170) (D, 170)</code> ；再对身高进行排序。由于排序算法不稳定，因此可能得到 <code>(D, 170) (C, 170) (A, 180) (B, 185)</code> 。</p>
 <p>可以发现，学生 D 和 C 的位置发生了交换，姓名的有序性被破坏了，而这是我们不希望看到的。</p>
-</div>
-<div class="admonition question">
-<p class="admonition-title">哨兵划分中“从右往左查找”与“从左往右查找”的顺序可以交换吗？</p>
+<p><strong>Q</strong>：哨兵划分中“从右往左查找”与“从左往右查找”的顺序可以交换吗？</p>
 <p>不行，当我们以最左端元素为基准数时，必须先“从右往左查找”再“从左往右查找”。这个结论有些反直觉，我们来剖析一下原因。</p>
 <p>哨兵划分 <code>partition()</code> 的最后一步是交换 <code>nums[left]</code> 和 <code>nums[i]</code> 。完成交换后，基准数左边的元素都 <code>&lt;=</code> 基准数，<strong>这就要求最后一步交换前 <code>nums[left] &gt;= nums[i]</code> 必须成立</strong>。假设我们先“从左往右查找”，那么如果找不到比基准数更大的元素，<strong>则会在 <code>i == j</code> 时跳出循环，此时可能 <code>nums[j] == nums[i] &gt; nums[left]</code></strong>。也就是说，此时最后一步交换操作会把一个比基准数更大的元素交换至数组最左端，导致哨兵划分失败。</p>
 <p>举个例子，给定数组 <code>[0, 0, 0, 0, 1]</code> ，如果先“从左向右查找”，哨兵划分后数组为 <code>[1, 0, 0, 0, 0]</code> ，这个结果是不正确的。</p>
 <p>再深入思考一下，如果我们选择 <code>nums[right]</code> 为基准数，那么正好反过来，必须先“从左往右查找”。</p>
-</div>
-<div class="admonition question">
-<p class="admonition-title">关于尾递归优化，为什么选短的数组能保证递归深度不超过 <span class="arithmatex">\(\log n\)</span> ？</p>
+<p><strong>Q</strong>：关于尾递归优化，为什么选短的数组能保证递归深度不超过 <span class="arithmatex">\(\log n\)</span> ？</p>
 <p>递归深度就是当前未返回的递归方法的数量。每轮哨兵划分我们将原数组划分为两个子数组。在尾递归优化后，向下递归的子数组长度最大为原数组长度的一半。假设最差情况，一直为一半长度，那么最终的递归深度就是 <span class="arithmatex">\(\log n\)</span> 。</p>
 <p>回顾原始的快速排序，我们有可能会连续地递归长度较大的数组，最差情况下为 <span class="arithmatex">\(n\)</span>、<span class="arithmatex">\(n - 1\)</span>、<span class="arithmatex">\(\dots\)</span>、<span class="arithmatex">\(2\)</span>、<span class="arithmatex">\(1\)</span> ，递归深度为 <span class="arithmatex">\(n\)</span> 。尾递归优化可以避免这种情况出现。</p>
-</div>
-<div class="admonition question">
-<p class="admonition-title">当数组中所有元素都相等时，快速排序的时间复杂度是 <span class="arithmatex">\(O(n^2)\)</span> 吗？该如何处理这种退化情况？</p>
+<p><strong>Q</strong>：当数组中所有元素都相等时，快速排序的时间复杂度是 <span class="arithmatex">\(O(n^2)\)</span> 吗？该如何处理这种退化情况？</p>
 <p>是的。对于这种情况，可以考虑通过哨兵划分将数组划分为三个部分：小于、等于、大于基准数。仅向下递归小于和大于的两部分。在该方法下，输入元素全部相等的数组，仅一轮哨兵划分即可完成排序。</p>
-</div>
-<div class="admonition question">
-<p class="admonition-title">桶排序的最差时间复杂度为什么是 <span class="arithmatex">\(O(n^2)\)</span> ？</p>
+<p><strong>Q</strong>：桶排序的最差时间复杂度为什么是 <span class="arithmatex">\(O(n^2)\)</span> ？</p>
 <p>最差情况下，所有元素被分至同一个桶中。如果我们采用一个 <span class="arithmatex">\(O(n^2)\)</span> 算法来排序这些元素，则时间复杂度为 <span class="arithmatex">\(O(n^2)\)</span> 。</p>
-</div>
 
 <!-- Source file information -->