mirror of
https://github.com/krahets/hello-algo.git
synced 2026-07-10 06:26:08 +00:00
deploy
This commit is contained in:
krahets
@@ -5548,107 +5548,106 @@
|
||||
<a id="__codelineno-93-11" name="__codelineno-93-11" href="#__codelineno-93-11"></a><span class="k">impl</span><span class="w"> </span><span class="n">MyList</span><span class="w"> </span><span class="p">{</span>
|
||||
<a id="__codelineno-93-12" name="__codelineno-93-12" href="#__codelineno-93-12"></a><span class="w"> </span><span class="cm">/* 构造方法 */</span>
|
||||
<a id="__codelineno-93-13" name="__codelineno-93-13" href="#__codelineno-93-13"></a><span class="w"> </span><span class="k">pub</span><span class="w"> </span><span class="k">fn</span> <span class="nf">new</span><span class="p">(</span><span class="n">capacity</span>: <span class="kt">usize</span><span class="p">)</span><span class="w"> </span>-> <span class="nc">Self</span><span class="w"> </span><span class="p">{</span>
|
||||
<a id="__codelineno-93-14" name="__codelineno-93-14" href="#__codelineno-93-14"></a><span class="w"> </span><span class="kd">let</span><span class="w"> </span><span class="k">mut</span><span class="w"> </span><span class="n">vec</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="nb">Vec</span>::<span class="n">new</span><span class="p">();</span>
|
||||
<a id="__codelineno-93-15" name="__codelineno-93-15" href="#__codelineno-93-15"></a><span class="w"> </span><span class="n">vec</span><span class="p">.</span><span class="n">resize</span><span class="p">(</span><span class="n">capacity</span><span class="p">,</span><span class="w"> </span><span class="mi">0</span><span class="p">);</span>
|
||||
<a id="__codelineno-93-16" name="__codelineno-93-16" href="#__codelineno-93-16"></a><span class="w"> </span><span class="bp">Self</span><span class="w"> </span><span class="p">{</span>
|
||||
<a id="__codelineno-93-17" name="__codelineno-93-17" href="#__codelineno-93-17"></a><span class="w"> </span><span class="n">arr</span>: <span class="nc">vec</span><span class="p">,</span>
|
||||
<a id="__codelineno-93-18" name="__codelineno-93-18" href="#__codelineno-93-18"></a><span class="w"> </span><span class="n">capacity</span><span class="p">,</span>
|
||||
<a id="__codelineno-93-19" name="__codelineno-93-19" href="#__codelineno-93-19"></a><span class="w"> </span><span class="n">size</span>: <span class="mi">0</span><span class="p">,</span>
|
||||
<a id="__codelineno-93-20" name="__codelineno-93-20" href="#__codelineno-93-20"></a><span class="w"> </span><span class="n">extend_ratio</span>: <span class="mi">2</span><span class="p">,</span>
|
||||
<a id="__codelineno-93-21" name="__codelineno-93-21" href="#__codelineno-93-21"></a><span class="w"> </span><span class="p">}</span>
|
||||
<a id="__codelineno-93-22" name="__codelineno-93-22" href="#__codelineno-93-22"></a><span class="w"> </span><span class="p">}</span>
|
||||
<a id="__codelineno-93-23" name="__codelineno-93-23" href="#__codelineno-93-23"></a>
|
||||
<a id="__codelineno-93-24" name="__codelineno-93-24" href="#__codelineno-93-24"></a><span class="w"> </span><span class="cm">/* 获取列表长度（当前元素数量）*/</span>
|
||||
<a id="__codelineno-93-25" name="__codelineno-93-25" href="#__codelineno-93-25"></a><span class="w"> </span><span class="k">pub</span><span class="w"> </span><span class="k">fn</span> <span class="nf">size</span><span class="p">(</span><span class="o">&</span><span class="bp">self</span><span class="p">)</span><span class="w"> </span>-> <span class="kt">usize</span> <span class="p">{</span>
|
||||
<a id="__codelineno-93-26" name="__codelineno-93-26" href="#__codelineno-93-26"></a><span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="bp">self</span><span class="p">.</span><span class="n">size</span><span class="p">;</span>
|
||||
<a id="__codelineno-93-27" name="__codelineno-93-27" href="#__codelineno-93-27"></a><span class="w"> </span><span class="p">}</span>
|
||||
<a id="__codelineno-93-28" name="__codelineno-93-28" href="#__codelineno-93-28"></a>
|
||||
<a id="__codelineno-93-29" name="__codelineno-93-29" href="#__codelineno-93-29"></a><span class="w"> </span><span class="cm">/* 获取列表容量 */</span>
|
||||
<a id="__codelineno-93-30" name="__codelineno-93-30" href="#__codelineno-93-30"></a><span class="w"> </span><span class="k">pub</span><span class="w"> </span><span class="k">fn</span> <span class="nf">capacity</span><span class="p">(</span><span class="o">&</span><span class="bp">self</span><span class="p">)</span><span class="w"> </span>-> <span class="kt">usize</span> <span class="p">{</span>
|
||||
<a id="__codelineno-93-31" name="__codelineno-93-31" href="#__codelineno-93-31"></a><span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="bp">self</span><span class="p">.</span><span class="n">capacity</span><span class="p">;</span>
|
||||
<a id="__codelineno-93-32" name="__codelineno-93-32" href="#__codelineno-93-32"></a><span class="w"> </span><span class="p">}</span>
|
||||
<a id="__codelineno-93-33" name="__codelineno-93-33" href="#__codelineno-93-33"></a>
|
||||
<a id="__codelineno-93-34" name="__codelineno-93-34" href="#__codelineno-93-34"></a><span class="w"> </span><span class="cm">/* 访问元素 */</span>
|
||||
<a id="__codelineno-93-35" name="__codelineno-93-35" href="#__codelineno-93-35"></a><span class="w"> </span><span class="k">pub</span><span class="w"> </span><span class="k">fn</span> <span class="nf">get</span><span class="p">(</span><span class="o">&</span><span class="bp">self</span><span class="p">,</span><span class="w"> </span><span class="n">index</span>: <span class="kt">usize</span><span class="p">)</span><span class="w"> </span>-> <span class="kt">i32</span> <span class="p">{</span>
|
||||
<a id="__codelineno-93-36" name="__codelineno-93-36" href="#__codelineno-93-36"></a><span class="w"> </span><span class="c1">// 索引如果越界，则抛出异常，下同</span>
|
||||
<a id="__codelineno-93-37" name="__codelineno-93-37" href="#__codelineno-93-37"></a><span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="n">index</span><span class="w"> </span><span class="o">>=</span><span class="w"> </span><span class="bp">self</span><span class="p">.</span><span class="n">size</span><span class="w"> </span><span class="p">{</span>
|
||||
<a id="__codelineno-93-38" name="__codelineno-93-38" href="#__codelineno-93-38"></a><span class="w"> </span><span class="fm">panic!</span><span class="p">(</span><span class="s">"索引越界"</span><span class="p">)</span>
|
||||
<a id="__codelineno-93-39" name="__codelineno-93-39" href="#__codelineno-93-39"></a><span class="w"> </span><span class="p">};</span>
|
||||
<a id="__codelineno-93-40" name="__codelineno-93-40" href="#__codelineno-93-40"></a><span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="bp">self</span><span class="p">.</span><span class="n">arr</span><span class="p">[</span><span class="n">index</span><span class="p">];</span>
|
||||
<a id="__codelineno-93-41" name="__codelineno-93-41" href="#__codelineno-93-41"></a><span class="w"> </span><span class="p">}</span>
|
||||
<a id="__codelineno-93-42" name="__codelineno-93-42" href="#__codelineno-93-42"></a>
|
||||
<a id="__codelineno-93-43" name="__codelineno-93-43" href="#__codelineno-93-43"></a><span class="w"> </span><span class="cm">/* 更新元素 */</span>
|
||||
<a id="__codelineno-93-44" name="__codelineno-93-44" href="#__codelineno-93-44"></a><span class="w"> </span><span class="k">pub</span><span class="w"> </span><span class="k">fn</span> <span class="nf">set</span><span class="p">(</span><span class="o">&</span><span class="k">mut</span><span class="w"> </span><span class="bp">self</span><span class="p">,</span><span class="w"> </span><span class="n">index</span>: <span class="kt">usize</span><span class="p">,</span><span class="w"> </span><span class="n">num</span>: <span class="kt">i32</span><span class="p">)</span><span class="w"> </span><span class="p">{</span>
|
||||
<a id="__codelineno-93-45" name="__codelineno-93-45" href="#__codelineno-93-45"></a><span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="n">index</span><span class="w"> </span><span class="o">>=</span><span class="w"> </span><span class="bp">self</span><span class="p">.</span><span class="n">size</span><span class="w"> </span><span class="p">{</span>
|
||||
<a id="__codelineno-93-46" name="__codelineno-93-46" href="#__codelineno-93-46"></a><span class="w"> </span><span class="fm">panic!</span><span class="p">(</span><span class="s">"索引越界"</span><span class="p">)</span>
|
||||
<a id="__codelineno-93-47" name="__codelineno-93-47" href="#__codelineno-93-47"></a><span class="w"> </span><span class="p">};</span>
|
||||
<a id="__codelineno-93-48" name="__codelineno-93-48" href="#__codelineno-93-48"></a><span class="w"> </span><span class="bp">self</span><span class="p">.</span><span class="n">arr</span><span class="p">[</span><span class="n">index</span><span class="p">]</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">num</span><span class="p">;</span>
|
||||
<a id="__codelineno-93-49" name="__codelineno-93-49" href="#__codelineno-93-49"></a><span class="w"> </span><span class="p">}</span>
|
||||
<a id="__codelineno-93-50" name="__codelineno-93-50" href="#__codelineno-93-50"></a>
|
||||
<a id="__codelineno-93-51" name="__codelineno-93-51" href="#__codelineno-93-51"></a><span class="w"> </span><span class="cm">/* 在尾部添加元素 */</span>
|
||||
<a id="__codelineno-93-52" name="__codelineno-93-52" href="#__codelineno-93-52"></a><span class="w"> </span><span class="k">pub</span><span class="w"> </span><span class="k">fn</span> <span class="nf">add</span><span class="p">(</span><span class="o">&</span><span class="k">mut</span><span class="w"> </span><span class="bp">self</span><span class="p">,</span><span class="w"> </span><span class="n">num</span>: <span class="kt">i32</span><span class="p">)</span><span class="w"> </span><span class="p">{</span>
|
||||
<a id="__codelineno-93-53" name="__codelineno-93-53" href="#__codelineno-93-53"></a><span class="w"> </span><span class="c1">// 元素数量超出容量时，触发扩容机制</span>
|
||||
<a id="__codelineno-93-54" name="__codelineno-93-54" href="#__codelineno-93-54"></a><span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="bp">self</span><span class="p">.</span><span class="n">size</span><span class="w"> </span><span class="o">==</span><span class="w"> </span><span class="bp">self</span><span class="p">.</span><span class="n">capacity</span><span class="p">()</span><span class="w"> </span><span class="p">{</span>
|
||||
<a id="__codelineno-93-55" name="__codelineno-93-55" href="#__codelineno-93-55"></a><span class="w"> </span><span class="bp">self</span><span class="p">.</span><span class="n">extend_capacity</span><span class="p">();</span>
|
||||
<a id="__codelineno-93-56" name="__codelineno-93-56" href="#__codelineno-93-56"></a><span class="w"> </span><span class="p">}</span>
|
||||
<a id="__codelineno-93-57" name="__codelineno-93-57" href="#__codelineno-93-57"></a><span class="w"> </span><span class="bp">self</span><span class="p">.</span><span class="n">arr</span><span class="p">[</span><span class="bp">self</span><span class="p">.</span><span class="n">size</span><span class="p">]</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">num</span><span class="p">;</span>
|
||||
<a id="__codelineno-93-58" name="__codelineno-93-58" href="#__codelineno-93-58"></a><span class="w"> </span><span class="c1">// 更新元素数量</span>
|
||||
<a id="__codelineno-93-59" name="__codelineno-93-59" href="#__codelineno-93-59"></a><span class="w"> </span><span class="bp">self</span><span class="p">.</span><span class="n">size</span><span class="w"> </span><span class="o">+=</span><span class="w"> </span><span class="mi">1</span><span class="p">;</span>
|
||||
<a id="__codelineno-93-60" name="__codelineno-93-60" href="#__codelineno-93-60"></a><span class="w"> </span><span class="p">}</span>
|
||||
<a id="__codelineno-93-61" name="__codelineno-93-61" href="#__codelineno-93-61"></a>
|
||||
<a id="__codelineno-93-62" name="__codelineno-93-62" href="#__codelineno-93-62"></a><span class="w"> </span><span class="cm">/* 在中间插入元素 */</span>
|
||||
<a id="__codelineno-93-63" name="__codelineno-93-63" href="#__codelineno-93-63"></a><span class="w"> </span><span class="k">pub</span><span class="w"> </span><span class="k">fn</span> <span class="nf">insert</span><span class="p">(</span><span class="o">&</span><span class="k">mut</span><span class="w"> </span><span class="bp">self</span><span class="p">,</span><span class="w"> </span><span class="n">index</span>: <span class="kt">usize</span><span class="p">,</span><span class="w"> </span><span class="n">num</span>: <span class="kt">i32</span><span class="p">)</span><span class="w"> </span><span class="p">{</span>
|
||||
<a id="__codelineno-93-64" name="__codelineno-93-64" href="#__codelineno-93-64"></a><span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="n">index</span><span class="w"> </span><span class="o">>=</span><span class="w"> </span><span class="bp">self</span><span class="p">.</span><span class="n">size</span><span class="p">()</span><span class="w"> </span><span class="p">{</span>
|
||||
<a id="__codelineno-93-65" name="__codelineno-93-65" href="#__codelineno-93-65"></a><span class="w"> </span><span class="fm">panic!</span><span class="p">(</span><span class="s">"索引越界"</span><span class="p">)</span>
|
||||
<a id="__codelineno-93-66" name="__codelineno-93-66" href="#__codelineno-93-66"></a><span class="w"> </span><span class="p">};</span>
|
||||
<a id="__codelineno-93-67" name="__codelineno-93-67" href="#__codelineno-93-67"></a><span class="w"> </span><span class="c1">// 元素数量超出容量时，触发扩容机制</span>
|
||||
<a id="__codelineno-93-68" name="__codelineno-93-68" href="#__codelineno-93-68"></a><span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="bp">self</span><span class="p">.</span><span class="n">size</span><span class="w"> </span><span class="o">==</span><span class="w"> </span><span class="bp">self</span><span class="p">.</span><span class="n">capacity</span><span class="p">()</span><span class="w"> </span><span class="p">{</span>
|
||||
<a id="__codelineno-93-69" name="__codelineno-93-69" href="#__codelineno-93-69"></a><span class="w"> </span><span class="bp">self</span><span class="p">.</span><span class="n">extend_capacity</span><span class="p">();</span>
|
||||
<a id="__codelineno-93-70" name="__codelineno-93-70" href="#__codelineno-93-70"></a><span class="w"> </span><span class="p">}</span>
|
||||
<a id="__codelineno-93-71" name="__codelineno-93-71" href="#__codelineno-93-71"></a><span class="w"> </span><span class="c1">// 将索引 index 以及之后的元素都向后移动一位</span>
|
||||
<a id="__codelineno-93-72" name="__codelineno-93-72" href="#__codelineno-93-72"></a><span class="w"> </span><span class="k">for</span><span class="w"> </span><span class="n">j</span><span class="w"> </span><span class="k">in</span><span class="w"> </span><span class="p">(</span><span class="n">index</span><span class="o">..</span><span class="bp">self</span><span class="p">.</span><span class="n">size</span><span class="p">).</span><span class="n">rev</span><span class="p">()</span><span class="w"> </span><span class="p">{</span>
|
||||
<a id="__codelineno-93-73" name="__codelineno-93-73" href="#__codelineno-93-73"></a><span class="w"> </span><span class="bp">self</span><span class="p">.</span><span class="n">arr</span><span class="p">[</span><span class="n">j</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="mi">1</span><span class="p">]</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="bp">self</span><span class="p">.</span><span class="n">arr</span><span class="p">[</span><span class="n">j</span><span class="p">];</span>
|
||||
<a id="__codelineno-93-74" name="__codelineno-93-74" href="#__codelineno-93-74"></a><span class="w"> </span><span class="p">}</span>
|
||||
<a id="__codelineno-93-75" name="__codelineno-93-75" href="#__codelineno-93-75"></a><span class="w"> </span><span class="bp">self</span><span class="p">.</span><span class="n">arr</span><span class="p">[</span><span class="n">index</span><span class="p">]</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">num</span><span class="p">;</span>
|
||||
<a id="__codelineno-93-76" name="__codelineno-93-76" href="#__codelineno-93-76"></a><span class="w"> </span><span class="c1">// 更新元素数量</span>
|
||||
<a id="__codelineno-93-77" name="__codelineno-93-77" href="#__codelineno-93-77"></a><span class="w"> </span><span class="bp">self</span><span class="p">.</span><span class="n">size</span><span class="w"> </span><span class="o">+=</span><span class="w"> </span><span class="mi">1</span><span class="p">;</span>
|
||||
<a id="__codelineno-93-78" name="__codelineno-93-78" href="#__codelineno-93-78"></a><span class="w"> </span><span class="p">}</span>
|
||||
<a id="__codelineno-93-79" name="__codelineno-93-79" href="#__codelineno-93-79"></a>
|
||||
<a id="__codelineno-93-80" name="__codelineno-93-80" href="#__codelineno-93-80"></a><span class="w"> </span><span class="cm">/* 删除元素 */</span>
|
||||
<a id="__codelineno-93-81" name="__codelineno-93-81" href="#__codelineno-93-81"></a><span class="w"> </span><span class="k">pub</span><span class="w"> </span><span class="k">fn</span> <span class="nf">remove</span><span class="p">(</span><span class="o">&</span><span class="k">mut</span><span class="w"> </span><span class="bp">self</span><span class="p">,</span><span class="w"> </span><span class="n">index</span>: <span class="kt">usize</span><span class="p">)</span><span class="w"> </span>-> <span class="kt">i32</span> <span class="p">{</span>
|
||||
<a id="__codelineno-93-82" name="__codelineno-93-82" href="#__codelineno-93-82"></a><span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="n">index</span><span class="w"> </span><span class="o">>=</span><span class="w"> </span><span class="bp">self</span><span class="p">.</span><span class="n">size</span><span class="p">()</span><span class="w"> </span><span class="p">{</span>
|
||||
<a id="__codelineno-93-83" name="__codelineno-93-83" href="#__codelineno-93-83"></a><span class="w"> </span><span class="fm">panic!</span><span class="p">(</span><span class="s">"索引越界"</span><span class="p">)</span>
|
||||
<a id="__codelineno-93-84" name="__codelineno-93-84" href="#__codelineno-93-84"></a><span class="w"> </span><span class="p">};</span>
|
||||
<a id="__codelineno-93-85" name="__codelineno-93-85" href="#__codelineno-93-85"></a><span class="w"> </span><span class="kd">let</span><span class="w"> </span><span class="n">num</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="bp">self</span><span class="p">.</span><span class="n">arr</span><span class="p">[</span><span class="n">index</span><span class="p">];</span>
|
||||
<a id="__codelineno-93-86" name="__codelineno-93-86" href="#__codelineno-93-86"></a><span class="w"> </span><span class="c1">// 将将索引 index 之后的元素都向前移动一位</span>
|
||||
<a id="__codelineno-93-87" name="__codelineno-93-87" href="#__codelineno-93-87"></a><span class="w"> </span><span class="k">for</span><span class="w"> </span><span class="n">j</span><span class="w"> </span><span class="k">in</span><span class="w"> </span><span class="p">(</span><span class="n">index</span><span class="o">..</span><span class="bp">self</span><span class="p">.</span><span class="n">size</span><span class="w"> </span><span class="o">-</span><span class="w"> </span><span class="mi">1</span><span class="p">)</span><span class="w"> </span><span class="p">{</span>
|
||||
<a id="__codelineno-93-88" name="__codelineno-93-88" href="#__codelineno-93-88"></a><span class="w"> </span><span class="bp">self</span><span class="p">.</span><span class="n">arr</span><span class="p">[</span><span class="n">j</span><span class="p">]</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="bp">self</span><span class="p">.</span><span class="n">arr</span><span class="p">[</span><span class="n">j</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="mi">1</span><span class="p">];</span>
|
||||
<a id="__codelineno-93-89" name="__codelineno-93-89" href="#__codelineno-93-89"></a><span class="w"> </span><span class="p">}</span>
|
||||
<a id="__codelineno-93-90" name="__codelineno-93-90" href="#__codelineno-93-90"></a><span class="w"> </span><span class="c1">// 更新元素数量</span>
|
||||
<a id="__codelineno-93-91" name="__codelineno-93-91" href="#__codelineno-93-91"></a><span class="w"> </span><span class="bp">self</span><span class="p">.</span><span class="n">size</span><span class="w"> </span><span class="o">-=</span><span class="w"> </span><span class="mi">1</span><span class="p">;</span>
|
||||
<a id="__codelineno-93-92" name="__codelineno-93-92" href="#__codelineno-93-92"></a><span class="w"> </span><span class="c1">// 返回被删除的元素</span>
|
||||
<a id="__codelineno-93-93" name="__codelineno-93-93" href="#__codelineno-93-93"></a><span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="n">num</span><span class="p">;</span>
|
||||
<a id="__codelineno-93-94" name="__codelineno-93-94" href="#__codelineno-93-94"></a><span class="w"> </span><span class="p">}</span>
|
||||
<a id="__codelineno-93-95" name="__codelineno-93-95" href="#__codelineno-93-95"></a>
|
||||
<a id="__codelineno-93-96" name="__codelineno-93-96" href="#__codelineno-93-96"></a><span class="w"> </span><span class="cm">/* 列表扩容 */</span>
|
||||
<a id="__codelineno-93-97" name="__codelineno-93-97" href="#__codelineno-93-97"></a><span class="w"> </span><span class="k">pub</span><span class="w"> </span><span class="k">fn</span> <span class="nf">extend_capacity</span><span class="p">(</span><span class="o">&</span><span class="k">mut</span><span class="w"> </span><span class="bp">self</span><span class="p">)</span><span class="w"> </span><span class="p">{</span>
|
||||
<a id="__codelineno-93-98" name="__codelineno-93-98" href="#__codelineno-93-98"></a><span class="w"> </span><span class="c1">// 新建一个长度为原数组 extend_ratio 倍的新数组，并将原数组复制到新数组</span>
|
||||
<a id="__codelineno-93-99" name="__codelineno-93-99" href="#__codelineno-93-99"></a><span class="w"> </span><span class="kd">let</span><span class="w"> </span><span class="n">new_capacity</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="bp">self</span><span class="p">.</span><span class="n">capacity</span><span class="w"> </span><span class="o">*</span><span class="w"> </span><span class="bp">self</span><span class="p">.</span><span class="n">extend_ratio</span><span class="p">;</span>
|
||||
<a id="__codelineno-93-100" name="__codelineno-93-100" href="#__codelineno-93-100"></a><span class="w"> </span><span class="bp">self</span><span class="p">.</span><span class="n">arr</span><span class="p">.</span><span class="n">resize</span><span class="p">(</span><span class="n">new_capacity</span><span class="p">,</span><span class="w"> </span><span class="mi">0</span><span class="p">);</span>
|
||||
<a id="__codelineno-93-101" name="__codelineno-93-101" href="#__codelineno-93-101"></a><span class="w"> </span><span class="c1">// 更新列表容量</span>
|
||||
<a id="__codelineno-93-102" name="__codelineno-93-102" href="#__codelineno-93-102"></a><span class="w"> </span><span class="bp">self</span><span class="p">.</span><span class="n">capacity</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">new_capacity</span><span class="p">;</span>
|
||||
<a id="__codelineno-93-103" name="__codelineno-93-103" href="#__codelineno-93-103"></a><span class="w"> </span><span class="p">}</span>
|
||||
<a id="__codelineno-93-104" name="__codelineno-93-104" href="#__codelineno-93-104"></a>
|
||||
<a id="__codelineno-93-105" name="__codelineno-93-105" href="#__codelineno-93-105"></a><span class="w"> </span><span class="cm">/* 将列表转换为数组 */</span>
|
||||
<a id="__codelineno-93-106" name="__codelineno-93-106" href="#__codelineno-93-106"></a><span class="w"> </span><span class="k">pub</span><span class="w"> </span><span class="k">fn</span> <span class="nf">to_array</span><span class="p">(</span><span class="o">&</span><span class="k">mut</span><span class="w"> </span><span class="bp">self</span><span class="p">)</span><span class="w"> </span>-> <span class="nb">Vec</span><span class="o"><</span><span class="kt">i32</span><span class="o">></span><span class="w"> </span><span class="p">{</span>
|
||||
<a id="__codelineno-93-107" name="__codelineno-93-107" href="#__codelineno-93-107"></a><span class="w"> </span><span class="c1">// 仅转换有效长度范围内的列表元素</span>
|
||||
<a id="__codelineno-93-108" name="__codelineno-93-108" href="#__codelineno-93-108"></a><span class="w"> </span><span class="kd">let</span><span class="w"> </span><span class="k">mut</span><span class="w"> </span><span class="n">arr</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="nb">Vec</span>::<span class="n">new</span><span class="p">();</span>
|
||||
<a id="__codelineno-93-109" name="__codelineno-93-109" href="#__codelineno-93-109"></a><span class="w"> </span><span class="k">for</span><span class="w"> </span><span class="n">i</span><span class="w"> </span><span class="k">in</span><span class="w"> </span><span class="mi">0</span><span class="o">..</span><span class="bp">self</span><span class="p">.</span><span class="n">size</span><span class="w"> </span><span class="p">{</span>
|
||||
<a id="__codelineno-93-110" name="__codelineno-93-110" href="#__codelineno-93-110"></a><span class="w"> </span><span class="n">arr</span><span class="p">.</span><span class="n">push</span><span class="p">(</span><span class="bp">self</span><span class="p">.</span><span class="n">get</span><span class="p">(</span><span class="n">i</span><span class="p">));</span>
|
||||
<a id="__codelineno-93-111" name="__codelineno-93-111" href="#__codelineno-93-111"></a><span class="w"> </span><span class="p">}</span>
|
||||
<a id="__codelineno-93-112" name="__codelineno-93-112" href="#__codelineno-93-112"></a><span class="w"> </span><span class="n">arr</span>
|
||||
<a id="__codelineno-93-113" name="__codelineno-93-113" href="#__codelineno-93-113"></a><span class="w"> </span><span class="p">}</span>
|
||||
<a id="__codelineno-93-114" name="__codelineno-93-114" href="#__codelineno-93-114"></a><span class="p">}</span>
|
||||
<a id="__codelineno-93-14" name="__codelineno-93-14" href="#__codelineno-93-14"></a><span class="w"> </span><span class="kd">let</span><span class="w"> </span><span class="k">mut</span><span class="w"> </span><span class="n">vec</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="fm">vec!</span><span class="p">[</span><span class="mi">0</span><span class="p">;</span><span class="w"> </span><span class="n">capacity</span><span class="p">];</span>
|
||||
<a id="__codelineno-93-15" name="__codelineno-93-15" href="#__codelineno-93-15"></a><span class="w"> </span><span class="bp">Self</span><span class="w"> </span><span class="p">{</span>
|
||||
<a id="__codelineno-93-16" name="__codelineno-93-16" href="#__codelineno-93-16"></a><span class="w"> </span><span class="n">arr</span>: <span class="nc">vec</span><span class="p">,</span>
|
||||
<a id="__codelineno-93-17" name="__codelineno-93-17" href="#__codelineno-93-17"></a><span class="w"> </span><span class="n">capacity</span><span class="p">,</span>
|
||||
<a id="__codelineno-93-18" name="__codelineno-93-18" href="#__codelineno-93-18"></a><span class="w"> </span><span class="n">size</span>: <span class="mi">0</span><span class="p">,</span>
|
||||
<a id="__codelineno-93-19" name="__codelineno-93-19" href="#__codelineno-93-19"></a><span class="w"> </span><span class="n">extend_ratio</span>: <span class="mi">2</span><span class="p">,</span>
|
||||
<a id="__codelineno-93-20" name="__codelineno-93-20" href="#__codelineno-93-20"></a><span class="w"> </span><span class="p">}</span>
|
||||
<a id="__codelineno-93-21" name="__codelineno-93-21" href="#__codelineno-93-21"></a><span class="w"> </span><span class="p">}</span>
|
||||
<a id="__codelineno-93-22" name="__codelineno-93-22" href="#__codelineno-93-22"></a>
|
||||
<a id="__codelineno-93-23" name="__codelineno-93-23" href="#__codelineno-93-23"></a><span class="w"> </span><span class="cm">/* 获取列表长度（当前元素数量）*/</span>
|
||||
<a id="__codelineno-93-24" name="__codelineno-93-24" href="#__codelineno-93-24"></a><span class="w"> </span><span class="k">pub</span><span class="w"> </span><span class="k">fn</span> <span class="nf">size</span><span class="p">(</span><span class="o">&</span><span class="bp">self</span><span class="p">)</span><span class="w"> </span>-> <span class="kt">usize</span> <span class="p">{</span>
|
||||
<a id="__codelineno-93-25" name="__codelineno-93-25" href="#__codelineno-93-25"></a><span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="bp">self</span><span class="p">.</span><span class="n">size</span><span class="p">;</span>
|
||||
<a id="__codelineno-93-26" name="__codelineno-93-26" href="#__codelineno-93-26"></a><span class="w"> </span><span class="p">}</span>
|
||||
<a id="__codelineno-93-27" name="__codelineno-93-27" href="#__codelineno-93-27"></a>
|
||||
<a id="__codelineno-93-28" name="__codelineno-93-28" href="#__codelineno-93-28"></a><span class="w"> </span><span class="cm">/* 获取列表容量 */</span>
|
||||
<a id="__codelineno-93-29" name="__codelineno-93-29" href="#__codelineno-93-29"></a><span class="w"> </span><span class="k">pub</span><span class="w"> </span><span class="k">fn</span> <span class="nf">capacity</span><span class="p">(</span><span class="o">&</span><span class="bp">self</span><span class="p">)</span><span class="w"> </span>-> <span class="kt">usize</span> <span class="p">{</span>
|
||||
<a id="__codelineno-93-30" name="__codelineno-93-30" href="#__codelineno-93-30"></a><span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="bp">self</span><span class="p">.</span><span class="n">capacity</span><span class="p">;</span>
|
||||
<a id="__codelineno-93-31" name="__codelineno-93-31" href="#__codelineno-93-31"></a><span class="w"> </span><span class="p">}</span>
|
||||
<a id="__codelineno-93-32" name="__codelineno-93-32" href="#__codelineno-93-32"></a>
|
||||
<a id="__codelineno-93-33" name="__codelineno-93-33" href="#__codelineno-93-33"></a><span class="w"> </span><span class="cm">/* 访问元素 */</span>
|
||||
<a id="__codelineno-93-34" name="__codelineno-93-34" href="#__codelineno-93-34"></a><span class="w"> </span><span class="k">pub</span><span class="w"> </span><span class="k">fn</span> <span class="nf">get</span><span class="p">(</span><span class="o">&</span><span class="bp">self</span><span class="p">,</span><span class="w"> </span><span class="n">index</span>: <span class="kt">usize</span><span class="p">)</span><span class="w"> </span>-> <span class="kt">i32</span> <span class="p">{</span>
|
||||
<a id="__codelineno-93-35" name="__codelineno-93-35" href="#__codelineno-93-35"></a><span class="w"> </span><span class="c1">// 索引如果越界，则抛出异常，下同</span>
|
||||
<a id="__codelineno-93-36" name="__codelineno-93-36" href="#__codelineno-93-36"></a><span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="n">index</span><span class="w"> </span><span class="o">>=</span><span class="w"> </span><span class="bp">self</span><span class="p">.</span><span class="n">size</span><span class="w"> </span><span class="p">{</span>
|
||||
<a id="__codelineno-93-37" name="__codelineno-93-37" href="#__codelineno-93-37"></a><span class="w"> </span><span class="fm">panic!</span><span class="p">(</span><span class="s">"索引越界"</span><span class="p">)</span>
|
||||
<a id="__codelineno-93-38" name="__codelineno-93-38" href="#__codelineno-93-38"></a><span class="w"> </span><span class="p">};</span>
|
||||
<a id="__codelineno-93-39" name="__codelineno-93-39" href="#__codelineno-93-39"></a><span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="bp">self</span><span class="p">.</span><span class="n">arr</span><span class="p">[</span><span class="n">index</span><span class="p">];</span>
|
||||
<a id="__codelineno-93-40" name="__codelineno-93-40" href="#__codelineno-93-40"></a><span class="w"> </span><span class="p">}</span>
|
||||
<a id="__codelineno-93-41" name="__codelineno-93-41" href="#__codelineno-93-41"></a>
|
||||
<a id="__codelineno-93-42" name="__codelineno-93-42" href="#__codelineno-93-42"></a><span class="w"> </span><span class="cm">/* 更新元素 */</span>
|
||||
<a id="__codelineno-93-43" name="__codelineno-93-43" href="#__codelineno-93-43"></a><span class="w"> </span><span class="k">pub</span><span class="w"> </span><span class="k">fn</span> <span class="nf">set</span><span class="p">(</span><span class="o">&</span><span class="k">mut</span><span class="w"> </span><span class="bp">self</span><span class="p">,</span><span class="w"> </span><span class="n">index</span>: <span class="kt">usize</span><span class="p">,</span><span class="w"> </span><span class="n">num</span>: <span class="kt">i32</span><span class="p">)</span><span class="w"> </span><span class="p">{</span>
|
||||
<a id="__codelineno-93-44" name="__codelineno-93-44" href="#__codelineno-93-44"></a><span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="n">index</span><span class="w"> </span><span class="o">>=</span><span class="w"> </span><span class="bp">self</span><span class="p">.</span><span class="n">size</span><span class="w"> </span><span class="p">{</span>
|
||||
<a id="__codelineno-93-45" name="__codelineno-93-45" href="#__codelineno-93-45"></a><span class="w"> </span><span class="fm">panic!</span><span class="p">(</span><span class="s">"索引越界"</span><span class="p">)</span>
|
||||
<a id="__codelineno-93-46" name="__codelineno-93-46" href="#__codelineno-93-46"></a><span class="w"> </span><span class="p">};</span>
|
||||
<a id="__codelineno-93-47" name="__codelineno-93-47" href="#__codelineno-93-47"></a><span class="w"> </span><span class="bp">self</span><span class="p">.</span><span class="n">arr</span><span class="p">[</span><span class="n">index</span><span class="p">]</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">num</span><span class="p">;</span>
|
||||
<a id="__codelineno-93-48" name="__codelineno-93-48" href="#__codelineno-93-48"></a><span class="w"> </span><span class="p">}</span>
|
||||
<a id="__codelineno-93-49" name="__codelineno-93-49" href="#__codelineno-93-49"></a>
|
||||
<a id="__codelineno-93-50" name="__codelineno-93-50" href="#__codelineno-93-50"></a><span class="w"> </span><span class="cm">/* 在尾部添加元素 */</span>
|
||||
<a id="__codelineno-93-51" name="__codelineno-93-51" href="#__codelineno-93-51"></a><span class="w"> </span><span class="k">pub</span><span class="w"> </span><span class="k">fn</span> <span class="nf">add</span><span class="p">(</span><span class="o">&</span><span class="k">mut</span><span class="w"> </span><span class="bp">self</span><span class="p">,</span><span class="w"> </span><span class="n">num</span>: <span class="kt">i32</span><span class="p">)</span><span class="w"> </span><span class="p">{</span>
|
||||
<a id="__codelineno-93-52" name="__codelineno-93-52" href="#__codelineno-93-52"></a><span class="w"> </span><span class="c1">// 元素数量超出容量时，触发扩容机制</span>
|
||||
<a id="__codelineno-93-53" name="__codelineno-93-53" href="#__codelineno-93-53"></a><span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="bp">self</span><span class="p">.</span><span class="n">size</span><span class="w"> </span><span class="o">==</span><span class="w"> </span><span class="bp">self</span><span class="p">.</span><span class="n">capacity</span><span class="p">()</span><span class="w"> </span><span class="p">{</span>
|
||||
<a id="__codelineno-93-54" name="__codelineno-93-54" href="#__codelineno-93-54"></a><span class="w"> </span><span class="bp">self</span><span class="p">.</span><span class="n">extend_capacity</span><span class="p">();</span>
|
||||
<a id="__codelineno-93-55" name="__codelineno-93-55" href="#__codelineno-93-55"></a><span class="w"> </span><span class="p">}</span>
|
||||
<a id="__codelineno-93-56" name="__codelineno-93-56" href="#__codelineno-93-56"></a><span class="w"> </span><span class="bp">self</span><span class="p">.</span><span class="n">arr</span><span class="p">[</span><span class="bp">self</span><span class="p">.</span><span class="n">size</span><span class="p">]</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">num</span><span class="p">;</span>
|
||||
<a id="__codelineno-93-57" name="__codelineno-93-57" href="#__codelineno-93-57"></a><span class="w"> </span><span class="c1">// 更新元素数量</span>
|
||||
<a id="__codelineno-93-58" name="__codelineno-93-58" href="#__codelineno-93-58"></a><span class="w"> </span><span class="bp">self</span><span class="p">.</span><span class="n">size</span><span class="w"> </span><span class="o">+=</span><span class="w"> </span><span class="mi">1</span><span class="p">;</span>
|
||||
<a id="__codelineno-93-59" name="__codelineno-93-59" href="#__codelineno-93-59"></a><span class="w"> </span><span class="p">}</span>
|
||||
<a id="__codelineno-93-60" name="__codelineno-93-60" href="#__codelineno-93-60"></a>
|
||||
<a id="__codelineno-93-61" name="__codelineno-93-61" href="#__codelineno-93-61"></a><span class="w"> </span><span class="cm">/* 在中间插入元素 */</span>
|
||||
<a id="__codelineno-93-62" name="__codelineno-93-62" href="#__codelineno-93-62"></a><span class="w"> </span><span class="k">pub</span><span class="w"> </span><span class="k">fn</span> <span class="nf">insert</span><span class="p">(</span><span class="o">&</span><span class="k">mut</span><span class="w"> </span><span class="bp">self</span><span class="p">,</span><span class="w"> </span><span class="n">index</span>: <span class="kt">usize</span><span class="p">,</span><span class="w"> </span><span class="n">num</span>: <span class="kt">i32</span><span class="p">)</span><span class="w"> </span><span class="p">{</span>
|
||||
<a id="__codelineno-93-63" name="__codelineno-93-63" href="#__codelineno-93-63"></a><span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="n">index</span><span class="w"> </span><span class="o">>=</span><span class="w"> </span><span class="bp">self</span><span class="p">.</span><span class="n">size</span><span class="p">()</span><span class="w"> </span><span class="p">{</span>
|
||||
<a id="__codelineno-93-64" name="__codelineno-93-64" href="#__codelineno-93-64"></a><span class="w"> </span><span class="fm">panic!</span><span class="p">(</span><span class="s">"索引越界"</span><span class="p">)</span>
|
||||
<a id="__codelineno-93-65" name="__codelineno-93-65" href="#__codelineno-93-65"></a><span class="w"> </span><span class="p">};</span>
|
||||
<a id="__codelineno-93-66" name="__codelineno-93-66" href="#__codelineno-93-66"></a><span class="w"> </span><span class="c1">// 元素数量超出容量时，触发扩容机制</span>
|
||||
<a id="__codelineno-93-67" name="__codelineno-93-67" href="#__codelineno-93-67"></a><span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="bp">self</span><span class="p">.</span><span class="n">size</span><span class="w"> </span><span class="o">==</span><span class="w"> </span><span class="bp">self</span><span class="p">.</span><span class="n">capacity</span><span class="p">()</span><span class="w"> </span><span class="p">{</span>
|
||||
<a id="__codelineno-93-68" name="__codelineno-93-68" href="#__codelineno-93-68"></a><span class="w"> </span><span class="bp">self</span><span class="p">.</span><span class="n">extend_capacity</span><span class="p">();</span>
|
||||
<a id="__codelineno-93-69" name="__codelineno-93-69" href="#__codelineno-93-69"></a><span class="w"> </span><span class="p">}</span>
|
||||
<a id="__codelineno-93-70" name="__codelineno-93-70" href="#__codelineno-93-70"></a><span class="w"> </span><span class="c1">// 将索引 index 以及之后的元素都向后移动一位</span>
|
||||
<a id="__codelineno-93-71" name="__codelineno-93-71" href="#__codelineno-93-71"></a><span class="w"> </span><span class="k">for</span><span class="w"> </span><span class="n">j</span><span class="w"> </span><span class="k">in</span><span class="w"> </span><span class="p">(</span><span class="n">index</span><span class="o">..</span><span class="bp">self</span><span class="p">.</span><span class="n">size</span><span class="p">).</span><span class="n">rev</span><span class="p">()</span><span class="w"> </span><span class="p">{</span>
|
||||
<a id="__codelineno-93-72" name="__codelineno-93-72" href="#__codelineno-93-72"></a><span class="w"> </span><span class="bp">self</span><span class="p">.</span><span class="n">arr</span><span class="p">[</span><span class="n">j</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="mi">1</span><span class="p">]</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="bp">self</span><span class="p">.</span><span class="n">arr</span><span class="p">[</span><span class="n">j</span><span class="p">];</span>
|
||||
<a id="__codelineno-93-73" name="__codelineno-93-73" href="#__codelineno-93-73"></a><span class="w"> </span><span class="p">}</span>
|
||||
<a id="__codelineno-93-74" name="__codelineno-93-74" href="#__codelineno-93-74"></a><span class="w"> </span><span class="bp">self</span><span class="p">.</span><span class="n">arr</span><span class="p">[</span><span class="n">index</span><span class="p">]</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">num</span><span class="p">;</span>
|
||||
<a id="__codelineno-93-75" name="__codelineno-93-75" href="#__codelineno-93-75"></a><span class="w"> </span><span class="c1">// 更新元素数量</span>
|
||||
<a id="__codelineno-93-76" name="__codelineno-93-76" href="#__codelineno-93-76"></a><span class="w"> </span><span class="bp">self</span><span class="p">.</span><span class="n">size</span><span class="w"> </span><span class="o">+=</span><span class="w"> </span><span class="mi">1</span><span class="p">;</span>
|
||||
<a id="__codelineno-93-77" name="__codelineno-93-77" href="#__codelineno-93-77"></a><span class="w"> </span><span class="p">}</span>
|
||||
<a id="__codelineno-93-78" name="__codelineno-93-78" href="#__codelineno-93-78"></a>
|
||||
<a id="__codelineno-93-79" name="__codelineno-93-79" href="#__codelineno-93-79"></a><span class="w"> </span><span class="cm">/* 删除元素 */</span>
|
||||
<a id="__codelineno-93-80" name="__codelineno-93-80" href="#__codelineno-93-80"></a><span class="w"> </span><span class="k">pub</span><span class="w"> </span><span class="k">fn</span> <span class="nf">remove</span><span class="p">(</span><span class="o">&</span><span class="k">mut</span><span class="w"> </span><span class="bp">self</span><span class="p">,</span><span class="w"> </span><span class="n">index</span>: <span class="kt">usize</span><span class="p">)</span><span class="w"> </span>-> <span class="kt">i32</span> <span class="p">{</span>
|
||||
<a id="__codelineno-93-81" name="__codelineno-93-81" href="#__codelineno-93-81"></a><span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="n">index</span><span class="w"> </span><span class="o">>=</span><span class="w"> </span><span class="bp">self</span><span class="p">.</span><span class="n">size</span><span class="p">()</span><span class="w"> </span><span class="p">{</span>
|
||||
<a id="__codelineno-93-82" name="__codelineno-93-82" href="#__codelineno-93-82"></a><span class="w"> </span><span class="fm">panic!</span><span class="p">(</span><span class="s">"索引越界"</span><span class="p">)</span>
|
||||
<a id="__codelineno-93-83" name="__codelineno-93-83" href="#__codelineno-93-83"></a><span class="w"> </span><span class="p">};</span>
|
||||
<a id="__codelineno-93-84" name="__codelineno-93-84" href="#__codelineno-93-84"></a><span class="w"> </span><span class="kd">let</span><span class="w"> </span><span class="n">num</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="bp">self</span><span class="p">.</span><span class="n">arr</span><span class="p">[</span><span class="n">index</span><span class="p">];</span>
|
||||
<a id="__codelineno-93-85" name="__codelineno-93-85" href="#__codelineno-93-85"></a><span class="w"> </span><span class="c1">// 将将索引 index 之后的元素都向前移动一位</span>
|
||||
<a id="__codelineno-93-86" name="__codelineno-93-86" href="#__codelineno-93-86"></a><span class="w"> </span><span class="k">for</span><span class="w"> </span><span class="n">j</span><span class="w"> </span><span class="k">in</span><span class="w"> </span><span class="n">index</span><span class="o">..</span><span class="bp">self</span><span class="p">.</span><span class="n">size</span><span class="w"> </span><span class="o">-</span><span class="w"> </span><span class="mi">1</span><span class="w"> </span><span class="p">{</span>
|
||||
<a id="__codelineno-93-87" name="__codelineno-93-87" href="#__codelineno-93-87"></a><span class="w"> </span><span class="bp">self</span><span class="p">.</span><span class="n">arr</span><span class="p">[</span><span class="n">j</span><span class="p">]</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="bp">self</span><span class="p">.</span><span class="n">arr</span><span class="p">[</span><span class="n">j</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="mi">1</span><span class="p">];</span>
|
||||
<a id="__codelineno-93-88" name="__codelineno-93-88" href="#__codelineno-93-88"></a><span class="w"> </span><span class="p">}</span>
|
||||
<a id="__codelineno-93-89" name="__codelineno-93-89" href="#__codelineno-93-89"></a><span class="w"> </span><span class="c1">// 更新元素数量</span>
|
||||
<a id="__codelineno-93-90" name="__codelineno-93-90" href="#__codelineno-93-90"></a><span class="w"> </span><span class="bp">self</span><span class="p">.</span><span class="n">size</span><span class="w"> </span><span class="o">-=</span><span class="w"> </span><span class="mi">1</span><span class="p">;</span>
|
||||
<a id="__codelineno-93-91" name="__codelineno-93-91" href="#__codelineno-93-91"></a><span class="w"> </span><span class="c1">// 返回被删除的元素</span>
|
||||
<a id="__codelineno-93-92" name="__codelineno-93-92" href="#__codelineno-93-92"></a><span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="n">num</span><span class="p">;</span>
|
||||
<a id="__codelineno-93-93" name="__codelineno-93-93" href="#__codelineno-93-93"></a><span class="w"> </span><span class="p">}</span>
|
||||
<a id="__codelineno-93-94" name="__codelineno-93-94" href="#__codelineno-93-94"></a>
|
||||
<a id="__codelineno-93-95" name="__codelineno-93-95" href="#__codelineno-93-95"></a><span class="w"> </span><span class="cm">/* 列表扩容 */</span>
|
||||
<a id="__codelineno-93-96" name="__codelineno-93-96" href="#__codelineno-93-96"></a><span class="w"> </span><span class="k">pub</span><span class="w"> </span><span class="k">fn</span> <span class="nf">extend_capacity</span><span class="p">(</span><span class="o">&</span><span class="k">mut</span><span class="w"> </span><span class="bp">self</span><span class="p">)</span><span class="w"> </span><span class="p">{</span>
|
||||
<a id="__codelineno-93-97" name="__codelineno-93-97" href="#__codelineno-93-97"></a><span class="w"> </span><span class="c1">// 新建一个长度为原数组 extend_ratio 倍的新数组，并将原数组复制到新数组</span>
|
||||
<a id="__codelineno-93-98" name="__codelineno-93-98" href="#__codelineno-93-98"></a><span class="w"> </span><span class="kd">let</span><span class="w"> </span><span class="n">new_capacity</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="bp">self</span><span class="p">.</span><span class="n">capacity</span><span class="w"> </span><span class="o">*</span><span class="w"> </span><span class="bp">self</span><span class="p">.</span><span class="n">extend_ratio</span><span class="p">;</span>
|
||||
<a id="__codelineno-93-99" name="__codelineno-93-99" href="#__codelineno-93-99"></a><span class="w"> </span><span class="bp">self</span><span class="p">.</span><span class="n">arr</span><span class="p">.</span><span class="n">resize</span><span class="p">(</span><span class="n">new_capacity</span><span class="p">,</span><span class="w"> </span><span class="mi">0</span><span class="p">);</span>
|
||||
<a id="__codelineno-93-100" name="__codelineno-93-100" href="#__codelineno-93-100"></a><span class="w"> </span><span class="c1">// 更新列表容量</span>
|
||||
<a id="__codelineno-93-101" name="__codelineno-93-101" href="#__codelineno-93-101"></a><span class="w"> </span><span class="bp">self</span><span class="p">.</span><span class="n">capacity</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">new_capacity</span><span class="p">;</span>
|
||||
<a id="__codelineno-93-102" name="__codelineno-93-102" href="#__codelineno-93-102"></a><span class="w"> </span><span class="p">}</span>
|
||||
<a id="__codelineno-93-103" name="__codelineno-93-103" href="#__codelineno-93-103"></a>
|
||||
<a id="__codelineno-93-104" name="__codelineno-93-104" href="#__codelineno-93-104"></a><span class="w"> </span><span class="cm">/* 将列表转换为数组 */</span>
|
||||
<a id="__codelineno-93-105" name="__codelineno-93-105" href="#__codelineno-93-105"></a><span class="w"> </span><span class="k">pub</span><span class="w"> </span><span class="k">fn</span> <span class="nf">to_array</span><span class="p">(</span><span class="o">&</span><span class="bp">self</span><span class="p">)</span><span class="w"> </span>-> <span class="nb">Vec</span><span class="o"><</span><span class="kt">i32</span><span class="o">></span><span class="w"> </span><span class="p">{</span>
|
||||
<a id="__codelineno-93-106" name="__codelineno-93-106" href="#__codelineno-93-106"></a><span class="w"> </span><span class="c1">// 仅转换有效长度范围内的列表元素</span>
|
||||
<a id="__codelineno-93-107" name="__codelineno-93-107" href="#__codelineno-93-107"></a><span class="w"> </span><span class="kd">let</span><span class="w"> </span><span class="k">mut</span><span class="w"> </span><span class="n">arr</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="nb">Vec</span>::<span class="n">new</span><span class="p">();</span>
|
||||
<a id="__codelineno-93-108" name="__codelineno-93-108" href="#__codelineno-93-108"></a><span class="w"> </span><span class="k">for</span><span class="w"> </span><span class="n">i</span><span class="w"> </span><span class="k">in</span><span class="w"> </span><span class="mi">0</span><span class="o">..</span><span class="bp">self</span><span class="p">.</span><span class="n">size</span><span class="w"> </span><span class="p">{</span>
|
||||
<a id="__codelineno-93-109" name="__codelineno-93-109" href="#__codelineno-93-109"></a><span class="w"> </span><span class="n">arr</span><span class="p">.</span><span class="n">push</span><span class="p">(</span><span class="bp">self</span><span class="p">.</span><span class="n">get</span><span class="p">(</span><span class="n">i</span><span class="p">));</span>
|
||||
<a id="__codelineno-93-110" name="__codelineno-93-110" href="#__codelineno-93-110"></a><span class="w"> </span><span class="p">}</span>
|
||||
<a id="__codelineno-93-111" name="__codelineno-93-111" href="#__codelineno-93-111"></a><span class="w"> </span><span class="n">arr</span>
|
||||
<a id="__codelineno-93-112" name="__codelineno-93-112" href="#__codelineno-93-112"></a><span class="w"> </span><span class="p">}</span>
|
||||
<a id="__codelineno-93-113" name="__codelineno-93-113" href="#__codelineno-93-113"></a><span class="p">}</span>
|
||||
</code></pre></div>
|
||||
</div>
|
||||
<div class="tabbed-block">
|
||||
|
||||
@@ -3660,7 +3660,7 @@
|
||||
<li>子集和问题的目标是在给定集合中找到和为目标值的所有子集。集合不区分元素顺序，而搜索过程会输出所有顺序的结果，产生重复子集。我们在回溯前将数据进行排序，并设置一个变量来指示每一轮的遍历起始点，从而将生成重复子集的搜索分支进行剪枝。</li>
|
||||
<li>对于子集和问题，数组中的相等元素会产生重复集合。我们利用数组已排序的前置条件，通过判断相邻元素是否相等实现剪枝，从而确保相等元素在每轮中只能被选中一次。</li>
|
||||
<li><span class="arithmatex">\(n\)</span> 皇后问题旨在寻找将 <span class="arithmatex">\(n\)</span> 个皇后放置到 <span class="arithmatex">\(n \times n\)</span> 尺寸棋盘上的方案，要求所有皇后两两之间无法攻击对方。该问题的约束条件有行约束、列约束、主对角线和次对角线约束。为满足行约束，我们采用按行放置的策略，保证每一行放置一个皇后。</li>
|
||||
<li>列约束和对角线约束的处理方式类似。对于列约束，我们利用一个数组来记录每一列是否有皇后，从而指示选中的格子是否合法。对于对角线约束，我们借助两个数组来分别记录该主、次对角线上是否存在皇后；难点在于找处在到同一主（副）对角线上格子满足的行列索引规律。</li>
|
||||
<li>列约束和对角线约束的处理方式类似。对于列约束，我们利用一个数组来记录每一列是否有皇后，从而指示选中的格子是否合法。对于对角线约束，我们借助两个数组来分别记录该主、次对角线上是否存在皇后；难点在于找出处在同一主（副）对角线上的格子所满足的行列索引规律。</li>
|
||||
</ul>
|
||||
<h3 id="2-q-a">2. Q & A<a class="headerlink" href="#2-q-a" title="Permanent link">¶</a></h3>
|
||||
<p><strong>Q</strong>：怎么理解回溯和递归的关系？</p>
|
||||
|
||||
@@ -4012,7 +4012,7 @@
|
||||
<a id="__codelineno-7-25" name="__codelineno-7-25" href="#__codelineno-7-25"></a><span class="w"> </span><span class="k">for</span><span class="w"> </span><span class="p">(</span><span class="kd">const</span><span class="w"> </span><span class="nx">c</span><span class="w"> </span><span class="k">of</span><span class="w"> </span><span class="nx">key</span><span class="p">)</span><span class="w"> </span><span class="p">{</span>
|
||||
<a id="__codelineno-7-26" name="__codelineno-7-26" href="#__codelineno-7-26"></a><span class="w"> </span><span class="nx">hash</span><span class="w"> </span><span class="o">^=</span><span class="w"> </span><span class="nx">c</span><span class="p">.</span><span class="nx">charCodeAt</span><span class="p">(</span><span class="mf">0</span><span class="p">);</span>
|
||||
<a id="__codelineno-7-27" name="__codelineno-7-27" href="#__codelineno-7-27"></a><span class="w"> </span><span class="p">}</span>
|
||||
<a id="__codelineno-7-28" name="__codelineno-7-28" href="#__codelineno-7-28"></a><span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="nx">hash</span><span class="w"> </span><span class="o">&</span><span class="w"> </span><span class="nx">MODULUS</span><span class="p">;</span>
|
||||
<a id="__codelineno-7-28" name="__codelineno-7-28" href="#__codelineno-7-28"></a><span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="nx">hash</span><span class="w"> </span><span class="o">%</span><span class="w"> </span><span class="nx">MODULUS</span><span class="p">;</span>
|
||||
<a id="__codelineno-7-29" name="__codelineno-7-29" href="#__codelineno-7-29"></a><span class="p">}</span>
|
||||
<a id="__codelineno-7-30" name="__codelineno-7-30" href="#__codelineno-7-30"></a>
|
||||
<a id="__codelineno-7-31" name="__codelineno-7-31" href="#__codelineno-7-31"></a><span class="cm">/* 旋转哈希 */</span>
|
||||
@@ -4054,7 +4054,7 @@
|
||||
<a id="__codelineno-8-25" name="__codelineno-8-25" href="#__codelineno-8-25"></a><span class="w"> </span><span class="k">for</span><span class="w"> </span><span class="p">(</span><span class="kd">const</span><span class="w"> </span><span class="nx">c</span><span class="w"> </span><span class="k">of</span><span class="w"> </span><span class="nx">key</span><span class="p">)</span><span class="w"> </span><span class="p">{</span>
|
||||
<a id="__codelineno-8-26" name="__codelineno-8-26" href="#__codelineno-8-26"></a><span class="w"> </span><span class="nx">hash</span><span class="w"> </span><span class="o">^=</span><span class="w"> </span><span class="nx">c</span><span class="p">.</span><span class="nx">charCodeAt</span><span class="p">(</span><span class="mf">0</span><span class="p">);</span>
|
||||
<a id="__codelineno-8-27" name="__codelineno-8-27" href="#__codelineno-8-27"></a><span class="w"> </span><span class="p">}</span>
|
||||
<a id="__codelineno-8-28" name="__codelineno-8-28" href="#__codelineno-8-28"></a><span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="nx">hash</span><span class="w"> </span><span class="o">&</span><span class="w"> </span><span class="nx">MODULUS</span><span class="p">;</span>
|
||||
<a id="__codelineno-8-28" name="__codelineno-8-28" href="#__codelineno-8-28"></a><span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="nx">hash</span><span class="w"> </span><span class="o">%</span><span class="w"> </span><span class="nx">MODULUS</span><span class="p">;</span>
|
||||
<a id="__codelineno-8-29" name="__codelineno-8-29" href="#__codelineno-8-29"></a><span class="p">}</span>
|
||||
<a id="__codelineno-8-30" name="__codelineno-8-30" href="#__codelineno-8-30"></a>
|
||||
<a id="__codelineno-8-31" name="__codelineno-8-31" href="#__codelineno-8-31"></a><span class="cm">/* 旋转哈希 */</span>
|
||||
|
||||
@@ -4731,10 +4731,10 @@
|
||||
<div class="tabbed-block">
|
||||
<div class="highlight"><span class="filename">hash_map_chaining.rs</span><pre><span></span><code><a id="__codelineno-9-1" name="__codelineno-9-1" href="#__codelineno-9-1"></a><span class="cm">/* 链式地址哈希表 */</span>
|
||||
<a id="__codelineno-9-2" name="__codelineno-9-2" href="#__codelineno-9-2"></a><span class="k">struct</span> <span class="nc">HashMapChaining</span><span class="w"> </span><span class="p">{</span>
|
||||
<a id="__codelineno-9-3" name="__codelineno-9-3" href="#__codelineno-9-3"></a><span class="w"> </span><span class="n">size</span>: <span class="kt">i32</span><span class="p">,</span>
|
||||
<a id="__codelineno-9-4" name="__codelineno-9-4" href="#__codelineno-9-4"></a><span class="w"> </span><span class="n">capacity</span>: <span class="kt">i32</span><span class="p">,</span>
|
||||
<a id="__codelineno-9-3" name="__codelineno-9-3" href="#__codelineno-9-3"></a><span class="w"> </span><span class="n">size</span>: <span class="kt">usize</span><span class="p">,</span>
|
||||
<a id="__codelineno-9-4" name="__codelineno-9-4" href="#__codelineno-9-4"></a><span class="w"> </span><span class="n">capacity</span>: <span class="kt">usize</span><span class="p">,</span>
|
||||
<a id="__codelineno-9-5" name="__codelineno-9-5" href="#__codelineno-9-5"></a><span class="w"> </span><span class="n">load_thres</span>: <span class="kt">f32</span><span class="p">,</span>
|
||||
<a id="__codelineno-9-6" name="__codelineno-9-6" href="#__codelineno-9-6"></a><span class="w"> </span><span class="n">extend_ratio</span>: <span class="kt">i32</span><span class="p">,</span>
|
||||
<a id="__codelineno-9-6" name="__codelineno-9-6" href="#__codelineno-9-6"></a><span class="w"> </span><span class="n">extend_ratio</span>: <span class="kt">usize</span><span class="p">,</span>
|
||||
<a id="__codelineno-9-7" name="__codelineno-9-7" href="#__codelineno-9-7"></a><span class="w"> </span><span class="n">buckets</span>: <span class="nb">Vec</span><span class="o"><</span><span class="nb">Vec</span><span class="o"><</span><span class="n">Pair</span><span class="o">>></span><span class="p">,</span>
|
||||
<a id="__codelineno-9-8" name="__codelineno-9-8" href="#__codelineno-9-8"></a><span class="p">}</span>
|
||||
<a id="__codelineno-9-9" name="__codelineno-9-9" href="#__codelineno-9-9"></a>
|
||||
@@ -4752,7 +4752,7 @@
|
||||
<a id="__codelineno-9-21" name="__codelineno-9-21" href="#__codelineno-9-21"></a>
|
||||
<a id="__codelineno-9-22" name="__codelineno-9-22" href="#__codelineno-9-22"></a><span class="w"> </span><span class="cm">/* 哈希函数 */</span>
|
||||
<a id="__codelineno-9-23" name="__codelineno-9-23" href="#__codelineno-9-23"></a><span class="w"> </span><span class="k">fn</span> <span class="nf">hash_func</span><span class="p">(</span><span class="o">&</span><span class="bp">self</span><span class="p">,</span><span class="w"> </span><span class="n">key</span>: <span class="kt">i32</span><span class="p">)</span><span class="w"> </span>-> <span class="kt">usize</span> <span class="p">{</span>
|
||||
<a id="__codelineno-9-24" name="__codelineno-9-24" href="#__codelineno-9-24"></a><span class="w"> </span><span class="n">key</span><span class="w"> </span><span class="k">as</span><span class="w"> </span><span class="kt">usize</span><span class="w"> </span><span class="o">%</span><span class="w"> </span><span class="bp">self</span><span class="p">.</span><span class="n">capacity</span><span class="w"> </span><span class="k">as</span><span class="w"> </span><span class="kt">usize</span>
|
||||
<a id="__codelineno-9-24" name="__codelineno-9-24" href="#__codelineno-9-24"></a><span class="w"> </span><span class="n">key</span><span class="w"> </span><span class="k">as</span><span class="w"> </span><span class="kt">usize</span><span class="w"> </span><span class="o">%</span><span class="w"> </span><span class="bp">self</span><span class="p">.</span><span class="n">capacity</span>
|
||||
<a id="__codelineno-9-25" name="__codelineno-9-25" href="#__codelineno-9-25"></a><span class="w"> </span><span class="p">}</span>
|
||||
<a id="__codelineno-9-26" name="__codelineno-9-26" href="#__codelineno-9-26"></a>
|
||||
<a id="__codelineno-9-27" name="__codelineno-9-27" href="#__codelineno-9-27"></a><span class="w"> </span><span class="cm">/* 负载因子 */</span>
|
||||
@@ -4763,91 +4763,87 @@
|
||||
<a id="__codelineno-9-32" name="__codelineno-9-32" href="#__codelineno-9-32"></a><span class="w"> </span><span class="cm">/* 删除操作 */</span>
|
||||
<a id="__codelineno-9-33" name="__codelineno-9-33" href="#__codelineno-9-33"></a><span class="w"> </span><span class="k">fn</span> <span class="nf">remove</span><span class="p">(</span><span class="o">&</span><span class="k">mut</span><span class="w"> </span><span class="bp">self</span><span class="p">,</span><span class="w"> </span><span class="n">key</span>: <span class="kt">i32</span><span class="p">)</span><span class="w"> </span>-> <span class="nb">Option</span><span class="o"><</span><span class="nb">String</span><span class="o">></span><span class="w"> </span><span class="p">{</span>
|
||||
<a id="__codelineno-9-34" name="__codelineno-9-34" href="#__codelineno-9-34"></a><span class="w"> </span><span class="kd">let</span><span class="w"> </span><span class="n">index</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="bp">self</span><span class="p">.</span><span class="n">hash_func</span><span class="p">(</span><span class="n">key</span><span class="p">);</span>
|
||||
<a id="__codelineno-9-35" name="__codelineno-9-35" href="#__codelineno-9-35"></a><span class="w"> </span><span class="kd">let</span><span class="w"> </span><span class="n">bucket</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="o">&</span><span class="k">mut</span><span class="w"> </span><span class="bp">self</span><span class="p">.</span><span class="n">buckets</span><span class="p">[</span><span class="n">index</span><span class="p">];</span>
|
||||
<a id="__codelineno-9-36" name="__codelineno-9-36" href="#__codelineno-9-36"></a>
|
||||
<a id="__codelineno-9-37" name="__codelineno-9-37" href="#__codelineno-9-37"></a><span class="w"> </span><span class="c1">// 遍历桶，从中删除键值对</span>
|
||||
<a id="__codelineno-9-38" name="__codelineno-9-38" href="#__codelineno-9-38"></a><span class="w"> </span><span class="k">for</span><span class="w"> </span><span class="n">i</span><span class="w"> </span><span class="k">in</span><span class="w"> </span><span class="mi">0</span><span class="o">..</span><span class="n">bucket</span><span class="p">.</span><span class="n">len</span><span class="p">()</span><span class="w"> </span><span class="p">{</span>
|
||||
<a id="__codelineno-9-39" name="__codelineno-9-39" href="#__codelineno-9-39"></a><span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="n">bucket</span><span class="p">[</span><span class="n">i</span><span class="p">].</span><span class="n">key</span><span class="w"> </span><span class="o">==</span><span class="w"> </span><span class="n">key</span><span class="w"> </span><span class="p">{</span>
|
||||
<a id="__codelineno-9-40" name="__codelineno-9-40" href="#__codelineno-9-40"></a><span class="w"> </span><span class="kd">let</span><span class="w"> </span><span class="n">pair</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">bucket</span><span class="p">.</span><span class="n">remove</span><span class="p">(</span><span class="n">i</span><span class="p">);</span>
|
||||
<a id="__codelineno-9-41" name="__codelineno-9-41" href="#__codelineno-9-41"></a><span class="w"> </span><span class="bp">self</span><span class="p">.</span><span class="n">size</span><span class="w"> </span><span class="o">-=</span><span class="w"> </span><span class="mi">1</span><span class="p">;</span>
|
||||
<a id="__codelineno-9-42" name="__codelineno-9-42" href="#__codelineno-9-42"></a><span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="nb">Some</span><span class="p">(</span><span class="n">pair</span><span class="p">.</span><span class="n">val</span><span class="p">);</span>
|
||||
<a id="__codelineno-9-43" name="__codelineno-9-43" href="#__codelineno-9-43"></a><span class="w"> </span><span class="p">}</span>
|
||||
<a id="__codelineno-9-44" name="__codelineno-9-44" href="#__codelineno-9-44"></a><span class="w"> </span><span class="p">}</span>
|
||||
<a id="__codelineno-9-45" name="__codelineno-9-45" href="#__codelineno-9-45"></a>
|
||||
<a id="__codelineno-9-46" name="__codelineno-9-46" href="#__codelineno-9-46"></a><span class="w"> </span><span class="c1">// 若未找到 key ，则返回 None</span>
|
||||
<a id="__codelineno-9-47" name="__codelineno-9-47" href="#__codelineno-9-47"></a><span class="w"> </span><span class="nb">None</span>
|
||||
<a id="__codelineno-9-48" name="__codelineno-9-48" href="#__codelineno-9-48"></a><span class="w"> </span><span class="p">}</span>
|
||||
<a id="__codelineno-9-49" name="__codelineno-9-49" href="#__codelineno-9-49"></a>
|
||||
<a id="__codelineno-9-50" name="__codelineno-9-50" href="#__codelineno-9-50"></a><span class="w"> </span><span class="cm">/* 扩容哈希表 */</span>
|
||||
<a id="__codelineno-9-51" name="__codelineno-9-51" href="#__codelineno-9-51"></a><span class="w"> </span><span class="k">fn</span> <span class="nf">extend</span><span class="p">(</span><span class="o">&</span><span class="k">mut</span><span class="w"> </span><span class="bp">self</span><span class="p">)</span><span class="w"> </span><span class="p">{</span>
|
||||
<a id="__codelineno-9-52" name="__codelineno-9-52" href="#__codelineno-9-52"></a><span class="w"> </span><span class="c1">// 暂存原哈希表</span>
|
||||
<a id="__codelineno-9-53" name="__codelineno-9-53" href="#__codelineno-9-53"></a><span class="w"> </span><span class="kd">let</span><span class="w"> </span><span class="n">buckets_tmp</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">std</span>::<span class="n">mem</span>::<span class="n">replace</span><span class="p">(</span><span class="o">&</span><span class="k">mut</span><span class="w"> </span><span class="bp">self</span><span class="p">.</span><span class="n">buckets</span><span class="p">,</span><span class="w"> </span><span class="fm">vec!</span><span class="p">[]);</span>
|
||||
<a id="__codelineno-9-54" name="__codelineno-9-54" href="#__codelineno-9-54"></a>
|
||||
<a id="__codelineno-9-55" name="__codelineno-9-55" href="#__codelineno-9-55"></a><span class="w"> </span><span class="c1">// 初始化扩容后的新哈希表</span>
|
||||
<a id="__codelineno-9-56" name="__codelineno-9-56" href="#__codelineno-9-56"></a><span class="w"> </span><span class="bp">self</span><span class="p">.</span><span class="n">capacity</span><span class="w"> </span><span class="o">*=</span><span class="w"> </span><span class="bp">self</span><span class="p">.</span><span class="n">extend_ratio</span><span class="p">;</span>
|
||||
<a id="__codelineno-9-57" name="__codelineno-9-57" href="#__codelineno-9-57"></a><span class="w"> </span><span class="bp">self</span><span class="p">.</span><span class="n">buckets</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="fm">vec!</span><span class="p">[</span><span class="nb">Vec</span>::<span class="n">new</span><span class="p">();</span><span class="w"> </span><span class="bp">self</span><span class="p">.</span><span class="n">capacity</span><span class="w"> </span><span class="k">as</span><span class="w"> </span><span class="kt">usize</span><span class="p">];</span>
|
||||
<a id="__codelineno-9-58" name="__codelineno-9-58" href="#__codelineno-9-58"></a><span class="w"> </span><span class="bp">self</span><span class="p">.</span><span class="n">size</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mi">0</span><span class="p">;</span>
|
||||
<a id="__codelineno-9-59" name="__codelineno-9-59" href="#__codelineno-9-59"></a>
|
||||
<a id="__codelineno-9-60" name="__codelineno-9-60" href="#__codelineno-9-60"></a><span class="w"> </span><span class="c1">// 将键值对从原哈希表搬运至新哈希表</span>
|
||||
<a id="__codelineno-9-61" name="__codelineno-9-61" href="#__codelineno-9-61"></a><span class="w"> </span><span class="k">for</span><span class="w"> </span><span class="n">bucket</span><span class="w"> </span><span class="k">in</span><span class="w"> </span><span class="n">buckets_tmp</span><span class="w"> </span><span class="p">{</span>
|
||||
<a id="__codelineno-9-62" name="__codelineno-9-62" href="#__codelineno-9-62"></a><span class="w"> </span><span class="k">for</span><span class="w"> </span><span class="n">pair</span><span class="w"> </span><span class="k">in</span><span class="w"> </span><span class="n">bucket</span><span class="w"> </span><span class="p">{</span>
|
||||
<a id="__codelineno-9-63" name="__codelineno-9-63" href="#__codelineno-9-63"></a><span class="w"> </span><span class="bp">self</span><span class="p">.</span><span class="n">put</span><span class="p">(</span><span class="n">pair</span><span class="p">.</span><span class="n">key</span><span class="p">,</span><span class="w"> </span><span class="n">pair</span><span class="p">.</span><span class="n">val</span><span class="p">);</span>
|
||||
<a id="__codelineno-9-64" name="__codelineno-9-64" href="#__codelineno-9-64"></a><span class="w"> </span><span class="p">}</span>
|
||||
<a id="__codelineno-9-65" name="__codelineno-9-65" href="#__codelineno-9-65"></a><span class="w"> </span><span class="p">}</span>
|
||||
<a id="__codelineno-9-66" name="__codelineno-9-66" href="#__codelineno-9-66"></a><span class="w"> </span><span class="p">}</span>
|
||||
<a id="__codelineno-9-67" name="__codelineno-9-67" href="#__codelineno-9-67"></a>
|
||||
<a id="__codelineno-9-68" name="__codelineno-9-68" href="#__codelineno-9-68"></a><span class="w"> </span><span class="cm">/* 打印哈希表 */</span>
|
||||
<a id="__codelineno-9-69" name="__codelineno-9-69" href="#__codelineno-9-69"></a><span class="w"> </span><span class="k">fn</span> <span class="nf">print</span><span class="p">(</span><span class="o">&</span><span class="bp">self</span><span class="p">)</span><span class="w"> </span><span class="p">{</span>
|
||||
<a id="__codelineno-9-70" name="__codelineno-9-70" href="#__codelineno-9-70"></a><span class="w"> </span><span class="k">for</span><span class="w"> </span><span class="n">bucket</span><span class="w"> </span><span class="k">in</span><span class="w"> </span><span class="o">&</span><span class="bp">self</span><span class="p">.</span><span class="n">buckets</span><span class="w"> </span><span class="p">{</span>
|
||||
<a id="__codelineno-9-71" name="__codelineno-9-71" href="#__codelineno-9-71"></a><span class="w"> </span><span class="kd">let</span><span class="w"> </span><span class="k">mut</span><span class="w"> </span><span class="n">res</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="nb">Vec</span>::<span class="n">new</span><span class="p">();</span>
|
||||
<a id="__codelineno-9-72" name="__codelineno-9-72" href="#__codelineno-9-72"></a><span class="w"> </span><span class="k">for</span><span class="w"> </span><span class="n">pair</span><span class="w"> </span><span class="k">in</span><span class="w"> </span><span class="n">bucket</span><span class="w"> </span><span class="p">{</span>
|
||||
<a id="__codelineno-9-73" name="__codelineno-9-73" href="#__codelineno-9-73"></a><span class="w"> </span><span class="n">res</span><span class="p">.</span><span class="n">push</span><span class="p">(</span><span class="fm">format!</span><span class="p">(</span><span class="s">"{} -> {}"</span><span class="p">,</span><span class="w"> </span><span class="n">pair</span><span class="p">.</span><span class="n">key</span><span class="p">,</span><span class="w"> </span><span class="n">pair</span><span class="p">.</span><span class="n">val</span><span class="p">));</span>
|
||||
<a id="__codelineno-9-74" name="__codelineno-9-74" href="#__codelineno-9-74"></a><span class="w"> </span><span class="p">}</span>
|
||||
<a id="__codelineno-9-75" name="__codelineno-9-75" href="#__codelineno-9-75"></a><span class="w"> </span><span class="fm">println!</span><span class="p">(</span><span class="s">"{:?}"</span><span class="p">,</span><span class="w"> </span><span class="n">res</span><span class="p">);</span>
|
||||
<a id="__codelineno-9-76" name="__codelineno-9-76" href="#__codelineno-9-76"></a><span class="w"> </span><span class="p">}</span>
|
||||
<a id="__codelineno-9-77" name="__codelineno-9-77" href="#__codelineno-9-77"></a><span class="w"> </span><span class="p">}</span>
|
||||
<a id="__codelineno-9-78" name="__codelineno-9-78" href="#__codelineno-9-78"></a>
|
||||
<a id="__codelineno-9-79" name="__codelineno-9-79" href="#__codelineno-9-79"></a><span class="w"> </span><span class="cm">/* 添加操作 */</span>
|
||||
<a id="__codelineno-9-80" name="__codelineno-9-80" href="#__codelineno-9-80"></a><span class="w"> </span><span class="k">fn</span> <span class="nf">put</span><span class="p">(</span><span class="o">&</span><span class="k">mut</span><span class="w"> </span><span class="bp">self</span><span class="p">,</span><span class="w"> </span><span class="n">key</span>: <span class="kt">i32</span><span class="p">,</span><span class="w"> </span><span class="n">val</span>: <span class="nb">String</span><span class="p">)</span><span class="w"> </span><span class="p">{</span>
|
||||
<a id="__codelineno-9-81" name="__codelineno-9-81" href="#__codelineno-9-81"></a><span class="w"> </span><span class="c1">// 当负载因子超过阈值时，执行扩容</span>
|
||||
<a id="__codelineno-9-82" name="__codelineno-9-82" href="#__codelineno-9-82"></a><span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="bp">self</span><span class="p">.</span><span class="n">load_factor</span><span class="p">()</span><span class="w"> </span><span class="o">></span><span class="w"> </span><span class="bp">self</span><span class="p">.</span><span class="n">load_thres</span><span class="w"> </span><span class="p">{</span>
|
||||
<a id="__codelineno-9-83" name="__codelineno-9-83" href="#__codelineno-9-83"></a><span class="w"> </span><span class="bp">self</span><span class="p">.</span><span class="n">extend</span><span class="p">();</span>
|
||||
<a id="__codelineno-9-84" name="__codelineno-9-84" href="#__codelineno-9-84"></a><span class="w"> </span><span class="p">}</span>
|
||||
<a id="__codelineno-9-85" name="__codelineno-9-85" href="#__codelineno-9-85"></a>
|
||||
<a id="__codelineno-9-86" name="__codelineno-9-86" href="#__codelineno-9-86"></a><span class="w"> </span><span class="kd">let</span><span class="w"> </span><span class="n">index</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="bp">self</span><span class="p">.</span><span class="n">hash_func</span><span class="p">(</span><span class="n">key</span><span class="p">);</span>
|
||||
<a id="__codelineno-9-87" name="__codelineno-9-87" href="#__codelineno-9-87"></a><span class="w"> </span><span class="kd">let</span><span class="w"> </span><span class="n">bucket</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="o">&</span><span class="k">mut</span><span class="w"> </span><span class="bp">self</span><span class="p">.</span><span class="n">buckets</span><span class="p">[</span><span class="n">index</span><span class="p">];</span>
|
||||
<a id="__codelineno-9-88" name="__codelineno-9-88" href="#__codelineno-9-88"></a>
|
||||
<a id="__codelineno-9-89" name="__codelineno-9-89" href="#__codelineno-9-89"></a><span class="w"> </span><span class="c1">// 遍历桶，若遇到指定 key ，则更新对应 val 并返回</span>
|
||||
<a id="__codelineno-9-90" name="__codelineno-9-90" href="#__codelineno-9-90"></a><span class="w"> </span><span class="k">for</span><span class="w"> </span><span class="n">pair</span><span class="w"> </span><span class="k">in</span><span class="w"> </span><span class="n">bucket</span><span class="w"> </span><span class="p">{</span>
|
||||
<a id="__codelineno-9-91" name="__codelineno-9-91" href="#__codelineno-9-91"></a><span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="n">pair</span><span class="p">.</span><span class="n">key</span><span class="w"> </span><span class="o">==</span><span class="w"> </span><span class="n">key</span><span class="w"> </span><span class="p">{</span>
|
||||
<a id="__codelineno-9-92" name="__codelineno-9-92" href="#__codelineno-9-92"></a><span class="w"> </span><span class="n">pair</span><span class="p">.</span><span class="n">val</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">val</span><span class="p">;</span>
|
||||
<a id="__codelineno-9-93" name="__codelineno-9-93" href="#__codelineno-9-93"></a><span class="w"> </span><span class="k">return</span><span class="p">;</span>
|
||||
<a id="__codelineno-9-94" name="__codelineno-9-94" href="#__codelineno-9-94"></a><span class="w"> </span><span class="p">}</span>
|
||||
<a id="__codelineno-9-95" name="__codelineno-9-95" href="#__codelineno-9-95"></a><span class="w"> </span><span class="p">}</span>
|
||||
<a id="__codelineno-9-96" name="__codelineno-9-96" href="#__codelineno-9-96"></a><span class="w"> </span><span class="kd">let</span><span class="w"> </span><span class="n">bucket</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="o">&</span><span class="k">mut</span><span class="w"> </span><span class="bp">self</span><span class="p">.</span><span class="n">buckets</span><span class="p">[</span><span class="n">index</span><span class="p">];</span>
|
||||
<a id="__codelineno-9-97" name="__codelineno-9-97" href="#__codelineno-9-97"></a>
|
||||
<a id="__codelineno-9-98" name="__codelineno-9-98" href="#__codelineno-9-98"></a><span class="w"> </span><span class="c1">// 若无该 key ，则将键值对添加至尾部</span>
|
||||
<a id="__codelineno-9-99" name="__codelineno-9-99" href="#__codelineno-9-99"></a><span class="w"> </span><span class="kd">let</span><span class="w"> </span><span class="n">pair</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">Pair</span><span class="w"> </span><span class="p">{</span><span class="w"> </span><span class="n">key</span><span class="p">,</span><span class="w"> </span><span class="n">val</span><span class="w"> </span><span class="p">};</span>
|
||||
<a id="__codelineno-9-100" name="__codelineno-9-100" href="#__codelineno-9-100"></a><span class="w"> </span><span class="n">bucket</span><span class="p">.</span><span class="n">push</span><span class="p">(</span><span class="n">pair</span><span class="p">);</span>
|
||||
<a id="__codelineno-9-101" name="__codelineno-9-101" href="#__codelineno-9-101"></a><span class="w"> </span><span class="bp">self</span><span class="p">.</span><span class="n">size</span><span class="w"> </span><span class="o">+=</span><span class="w"> </span><span class="mi">1</span><span class="p">;</span>
|
||||
<a id="__codelineno-9-102" name="__codelineno-9-102" href="#__codelineno-9-102"></a><span class="w"> </span><span class="p">}</span>
|
||||
<a id="__codelineno-9-103" name="__codelineno-9-103" href="#__codelineno-9-103"></a>
|
||||
<a id="__codelineno-9-104" name="__codelineno-9-104" href="#__codelineno-9-104"></a><span class="w"> </span><span class="cm">/* 查询操作 */</span>
|
||||
<a id="__codelineno-9-105" name="__codelineno-9-105" href="#__codelineno-9-105"></a><span class="w"> </span><span class="k">fn</span> <span class="nf">get</span><span class="p">(</span><span class="o">&</span><span class="bp">self</span><span class="p">,</span><span class="w"> </span><span class="n">key</span>: <span class="kt">i32</span><span class="p">)</span><span class="w"> </span>-> <span class="nb">Option</span><span class="o"><&</span><span class="kt">str</span><span class="o">></span><span class="w"> </span><span class="p">{</span>
|
||||
<a id="__codelineno-9-106" name="__codelineno-9-106" href="#__codelineno-9-106"></a><span class="w"> </span><span class="kd">let</span><span class="w"> </span><span class="n">index</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="bp">self</span><span class="p">.</span><span class="n">hash_func</span><span class="p">(</span><span class="n">key</span><span class="p">);</span>
|
||||
<a id="__codelineno-9-107" name="__codelineno-9-107" href="#__codelineno-9-107"></a><span class="w"> </span><span class="kd">let</span><span class="w"> </span><span class="n">bucket</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="o">&</span><span class="bp">self</span><span class="p">.</span><span class="n">buckets</span><span class="p">[</span><span class="n">index</span><span class="p">];</span>
|
||||
<a id="__codelineno-9-108" name="__codelineno-9-108" href="#__codelineno-9-108"></a>
|
||||
<a id="__codelineno-9-109" name="__codelineno-9-109" href="#__codelineno-9-109"></a><span class="w"> </span><span class="c1">// 遍历桶，若找到 key ，则返回对应 val</span>
|
||||
<a id="__codelineno-9-110" name="__codelineno-9-110" href="#__codelineno-9-110"></a><span class="w"> </span><span class="k">for</span><span class="w"> </span><span class="n">pair</span><span class="w"> </span><span class="k">in</span><span class="w"> </span><span class="n">bucket</span><span class="w"> </span><span class="p">{</span>
|
||||
<a id="__codelineno-9-111" name="__codelineno-9-111" href="#__codelineno-9-111"></a><span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="n">pair</span><span class="p">.</span><span class="n">key</span><span class="w"> </span><span class="o">==</span><span class="w"> </span><span class="n">key</span><span class="w"> </span><span class="p">{</span>
|
||||
<a id="__codelineno-9-112" name="__codelineno-9-112" href="#__codelineno-9-112"></a><span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="nb">Some</span><span class="p">(</span><span class="o">&</span><span class="n">pair</span><span class="p">.</span><span class="n">val</span><span class="p">);</span>
|
||||
<a id="__codelineno-9-113" name="__codelineno-9-113" href="#__codelineno-9-113"></a><span class="w"> </span><span class="p">}</span>
|
||||
<a id="__codelineno-9-114" name="__codelineno-9-114" href="#__codelineno-9-114"></a><span class="w"> </span><span class="p">}</span>
|
||||
<a id="__codelineno-9-115" name="__codelineno-9-115" href="#__codelineno-9-115"></a>
|
||||
<a id="__codelineno-9-116" name="__codelineno-9-116" href="#__codelineno-9-116"></a><span class="w"> </span><span class="c1">// 若未找到 key ，则返回 None</span>
|
||||
<a id="__codelineno-9-117" name="__codelineno-9-117" href="#__codelineno-9-117"></a><span class="w"> </span><span class="nb">None</span>
|
||||
<a id="__codelineno-9-118" name="__codelineno-9-118" href="#__codelineno-9-118"></a><span class="w"> </span><span class="p">}</span>
|
||||
<a id="__codelineno-9-119" name="__codelineno-9-119" href="#__codelineno-9-119"></a><span class="p">}</span>
|
||||
<a id="__codelineno-9-35" name="__codelineno-9-35" href="#__codelineno-9-35"></a>
|
||||
<a id="__codelineno-9-36" name="__codelineno-9-36" href="#__codelineno-9-36"></a><span class="w"> </span><span class="c1">// 遍历桶，从中删除键值对</span>
|
||||
<a id="__codelineno-9-37" name="__codelineno-9-37" href="#__codelineno-9-37"></a><span class="w"> </span><span class="k">for</span><span class="w"> </span><span class="p">(</span><span class="n">i</span><span class="p">,</span><span class="w"> </span><span class="n">p</span><span class="p">)</span><span class="w"> </span><span class="k">in</span><span class="w"> </span><span class="bp">self</span><span class="p">.</span><span class="n">buckets</span><span class="p">[</span><span class="n">index</span><span class="p">].</span><span class="n">iter_mut</span><span class="p">().</span><span class="n">enumerate</span><span class="p">()</span><span class="w"> </span><span class="p">{</span>
|
||||
<a id="__codelineno-9-38" name="__codelineno-9-38" href="#__codelineno-9-38"></a><span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="n">p</span><span class="p">.</span><span class="n">key</span><span class="w"> </span><span class="o">==</span><span class="w"> </span><span class="n">key</span><span class="w"> </span><span class="p">{</span>
|
||||
<a id="__codelineno-9-39" name="__codelineno-9-39" href="#__codelineno-9-39"></a><span class="w"> </span><span class="kd">let</span><span class="w"> </span><span class="n">pair</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="bp">self</span><span class="p">.</span><span class="n">buckets</span><span class="p">[</span><span class="n">index</span><span class="p">].</span><span class="n">remove</span><span class="p">(</span><span class="n">i</span><span class="p">);</span>
|
||||
<a id="__codelineno-9-40" name="__codelineno-9-40" href="#__codelineno-9-40"></a><span class="w"> </span><span class="bp">self</span><span class="p">.</span><span class="n">size</span><span class="w"> </span><span class="o">-=</span><span class="w"> </span><span class="mi">1</span><span class="p">;</span>
|
||||
<a id="__codelineno-9-41" name="__codelineno-9-41" href="#__codelineno-9-41"></a><span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="nb">Some</span><span class="p">(</span><span class="n">pair</span><span class="p">.</span><span class="n">val</span><span class="p">);</span>
|
||||
<a id="__codelineno-9-42" name="__codelineno-9-42" href="#__codelineno-9-42"></a><span class="w"> </span><span class="p">}</span>
|
||||
<a id="__codelineno-9-43" name="__codelineno-9-43" href="#__codelineno-9-43"></a><span class="w"> </span><span class="p">}</span>
|
||||
<a id="__codelineno-9-44" name="__codelineno-9-44" href="#__codelineno-9-44"></a>
|
||||
<a id="__codelineno-9-45" name="__codelineno-9-45" href="#__codelineno-9-45"></a><span class="w"> </span><span class="c1">// 若未找到 key ，则返回 None</span>
|
||||
<a id="__codelineno-9-46" name="__codelineno-9-46" href="#__codelineno-9-46"></a><span class="w"> </span><span class="nb">None</span>
|
||||
<a id="__codelineno-9-47" name="__codelineno-9-47" href="#__codelineno-9-47"></a><span class="w"> </span><span class="p">}</span>
|
||||
<a id="__codelineno-9-48" name="__codelineno-9-48" href="#__codelineno-9-48"></a>
|
||||
<a id="__codelineno-9-49" name="__codelineno-9-49" href="#__codelineno-9-49"></a><span class="w"> </span><span class="cm">/* 扩容哈希表 */</span>
|
||||
<a id="__codelineno-9-50" name="__codelineno-9-50" href="#__codelineno-9-50"></a><span class="w"> </span><span class="k">fn</span> <span class="nf">extend</span><span class="p">(</span><span class="o">&</span><span class="k">mut</span><span class="w"> </span><span class="bp">self</span><span class="p">)</span><span class="w"> </span><span class="p">{</span>
|
||||
<a id="__codelineno-9-51" name="__codelineno-9-51" href="#__codelineno-9-51"></a><span class="w"> </span><span class="c1">// 暂存原哈希表</span>
|
||||
<a id="__codelineno-9-52" name="__codelineno-9-52" href="#__codelineno-9-52"></a><span class="w"> </span><span class="kd">let</span><span class="w"> </span><span class="n">buckets_tmp</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">std</span>::<span class="n">mem</span>::<span class="n">take</span><span class="p">(</span><span class="o">&</span><span class="k">mut</span><span class="w"> </span><span class="bp">self</span><span class="p">.</span><span class="n">buckets</span><span class="p">);</span>
|
||||
<a id="__codelineno-9-53" name="__codelineno-9-53" href="#__codelineno-9-53"></a>
|
||||
<a id="__codelineno-9-54" name="__codelineno-9-54" href="#__codelineno-9-54"></a><span class="w"> </span><span class="c1">// 初始化扩容后的新哈希表</span>
|
||||
<a id="__codelineno-9-55" name="__codelineno-9-55" href="#__codelineno-9-55"></a><span class="w"> </span><span class="bp">self</span><span class="p">.</span><span class="n">capacity</span><span class="w"> </span><span class="o">*=</span><span class="w"> </span><span class="bp">self</span><span class="p">.</span><span class="n">extend_ratio</span><span class="p">;</span>
|
||||
<a id="__codelineno-9-56" name="__codelineno-9-56" href="#__codelineno-9-56"></a><span class="w"> </span><span class="bp">self</span><span class="p">.</span><span class="n">buckets</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="fm">vec!</span><span class="p">[</span><span class="nb">Vec</span>::<span class="n">new</span><span class="p">();</span><span class="w"> </span><span class="bp">self</span><span class="p">.</span><span class="n">capacity</span><span class="w"> </span><span class="k">as</span><span class="w"> </span><span class="kt">usize</span><span class="p">];</span>
|
||||
<a id="__codelineno-9-57" name="__codelineno-9-57" href="#__codelineno-9-57"></a><span class="w"> </span><span class="bp">self</span><span class="p">.</span><span class="n">size</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mi">0</span><span class="p">;</span>
|
||||
<a id="__codelineno-9-58" name="__codelineno-9-58" href="#__codelineno-9-58"></a>
|
||||
<a id="__codelineno-9-59" name="__codelineno-9-59" href="#__codelineno-9-59"></a><span class="w"> </span><span class="c1">// 将键值对从原哈希表搬运至新哈希表</span>
|
||||
<a id="__codelineno-9-60" name="__codelineno-9-60" href="#__codelineno-9-60"></a><span class="w"> </span><span class="k">for</span><span class="w"> </span><span class="n">bucket</span><span class="w"> </span><span class="k">in</span><span class="w"> </span><span class="n">buckets_tmp</span><span class="w"> </span><span class="p">{</span>
|
||||
<a id="__codelineno-9-61" name="__codelineno-9-61" href="#__codelineno-9-61"></a><span class="w"> </span><span class="k">for</span><span class="w"> </span><span class="n">pair</span><span class="w"> </span><span class="k">in</span><span class="w"> </span><span class="n">bucket</span><span class="w"> </span><span class="p">{</span>
|
||||
<a id="__codelineno-9-62" name="__codelineno-9-62" href="#__codelineno-9-62"></a><span class="w"> </span><span class="bp">self</span><span class="p">.</span><span class="n">put</span><span class="p">(</span><span class="n">pair</span><span class="p">.</span><span class="n">key</span><span class="p">,</span><span class="w"> </span><span class="n">pair</span><span class="p">.</span><span class="n">val</span><span class="p">);</span>
|
||||
<a id="__codelineno-9-63" name="__codelineno-9-63" href="#__codelineno-9-63"></a><span class="w"> </span><span class="p">}</span>
|
||||
<a id="__codelineno-9-64" name="__codelineno-9-64" href="#__codelineno-9-64"></a><span class="w"> </span><span class="p">}</span>
|
||||
<a id="__codelineno-9-65" name="__codelineno-9-65" href="#__codelineno-9-65"></a><span class="w"> </span><span class="p">}</span>
|
||||
<a id="__codelineno-9-66" name="__codelineno-9-66" href="#__codelineno-9-66"></a>
|
||||
<a id="__codelineno-9-67" name="__codelineno-9-67" href="#__codelineno-9-67"></a><span class="w"> </span><span class="cm">/* 打印哈希表 */</span>
|
||||
<a id="__codelineno-9-68" name="__codelineno-9-68" href="#__codelineno-9-68"></a><span class="w"> </span><span class="k">fn</span> <span class="nf">print</span><span class="p">(</span><span class="o">&</span><span class="bp">self</span><span class="p">)</span><span class="w"> </span><span class="p">{</span>
|
||||
<a id="__codelineno-9-69" name="__codelineno-9-69" href="#__codelineno-9-69"></a><span class="w"> </span><span class="k">for</span><span class="w"> </span><span class="n">bucket</span><span class="w"> </span><span class="k">in</span><span class="w"> </span><span class="o">&</span><span class="bp">self</span><span class="p">.</span><span class="n">buckets</span><span class="w"> </span><span class="p">{</span>
|
||||
<a id="__codelineno-9-70" name="__codelineno-9-70" href="#__codelineno-9-70"></a><span class="w"> </span><span class="kd">let</span><span class="w"> </span><span class="k">mut</span><span class="w"> </span><span class="n">res</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="nb">Vec</span>::<span class="n">new</span><span class="p">();</span>
|
||||
<a id="__codelineno-9-71" name="__codelineno-9-71" href="#__codelineno-9-71"></a><span class="w"> </span><span class="k">for</span><span class="w"> </span><span class="n">pair</span><span class="w"> </span><span class="k">in</span><span class="w"> </span><span class="n">bucket</span><span class="w"> </span><span class="p">{</span>
|
||||
<a id="__codelineno-9-72" name="__codelineno-9-72" href="#__codelineno-9-72"></a><span class="w"> </span><span class="n">res</span><span class="p">.</span><span class="n">push</span><span class="p">(</span><span class="fm">format!</span><span class="p">(</span><span class="s">"{} -> {}"</span><span class="p">,</span><span class="w"> </span><span class="n">pair</span><span class="p">.</span><span class="n">key</span><span class="p">,</span><span class="w"> </span><span class="n">pair</span><span class="p">.</span><span class="n">val</span><span class="p">));</span>
|
||||
<a id="__codelineno-9-73" name="__codelineno-9-73" href="#__codelineno-9-73"></a><span class="w"> </span><span class="p">}</span>
|
||||
<a id="__codelineno-9-74" name="__codelineno-9-74" href="#__codelineno-9-74"></a><span class="w"> </span><span class="fm">println!</span><span class="p">(</span><span class="s">"{:?}"</span><span class="p">,</span><span class="w"> </span><span class="n">res</span><span class="p">);</span>
|
||||
<a id="__codelineno-9-75" name="__codelineno-9-75" href="#__codelineno-9-75"></a><span class="w"> </span><span class="p">}</span>
|
||||
<a id="__codelineno-9-76" name="__codelineno-9-76" href="#__codelineno-9-76"></a><span class="w"> </span><span class="p">}</span>
|
||||
<a id="__codelineno-9-77" name="__codelineno-9-77" href="#__codelineno-9-77"></a>
|
||||
<a id="__codelineno-9-78" name="__codelineno-9-78" href="#__codelineno-9-78"></a><span class="w"> </span><span class="cm">/* 添加操作 */</span>
|
||||
<a id="__codelineno-9-79" name="__codelineno-9-79" href="#__codelineno-9-79"></a><span class="w"> </span><span class="k">fn</span> <span class="nf">put</span><span class="p">(</span><span class="o">&</span><span class="k">mut</span><span class="w"> </span><span class="bp">self</span><span class="p">,</span><span class="w"> </span><span class="n">key</span>: <span class="kt">i32</span><span class="p">,</span><span class="w"> </span><span class="n">val</span>: <span class="nb">String</span><span class="p">)</span><span class="w"> </span><span class="p">{</span>
|
||||
<a id="__codelineno-9-80" name="__codelineno-9-80" href="#__codelineno-9-80"></a><span class="w"> </span><span class="c1">// 当负载因子超过阈值时，执行扩容</span>
|
||||
<a id="__codelineno-9-81" name="__codelineno-9-81" href="#__codelineno-9-81"></a><span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="bp">self</span><span class="p">.</span><span class="n">load_factor</span><span class="p">()</span><span class="w"> </span><span class="o">></span><span class="w"> </span><span class="bp">self</span><span class="p">.</span><span class="n">load_thres</span><span class="w"> </span><span class="p">{</span>
|
||||
<a id="__codelineno-9-82" name="__codelineno-9-82" href="#__codelineno-9-82"></a><span class="w"> </span><span class="bp">self</span><span class="p">.</span><span class="n">extend</span><span class="p">();</span>
|
||||
<a id="__codelineno-9-83" name="__codelineno-9-83" href="#__codelineno-9-83"></a><span class="w"> </span><span class="p">}</span>
|
||||
<a id="__codelineno-9-84" name="__codelineno-9-84" href="#__codelineno-9-84"></a>
|
||||
<a id="__codelineno-9-85" name="__codelineno-9-85" href="#__codelineno-9-85"></a><span class="w"> </span><span class="kd">let</span><span class="w"> </span><span class="n">index</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="bp">self</span><span class="p">.</span><span class="n">hash_func</span><span class="p">(</span><span class="n">key</span><span class="p">);</span>
|
||||
<a id="__codelineno-9-86" name="__codelineno-9-86" href="#__codelineno-9-86"></a>
|
||||
<a id="__codelineno-9-87" name="__codelineno-9-87" href="#__codelineno-9-87"></a><span class="w"> </span><span class="c1">// 遍历桶，若遇到指定 key ，则更新对应 val 并返回</span>
|
||||
<a id="__codelineno-9-88" name="__codelineno-9-88" href="#__codelineno-9-88"></a><span class="w"> </span><span class="k">for</span><span class="w"> </span><span class="n">pair</span><span class="w"> </span><span class="k">in</span><span class="w"> </span><span class="bp">self</span><span class="p">.</span><span class="n">buckets</span><span class="p">[</span><span class="n">index</span><span class="p">].</span><span class="n">iter_mut</span><span class="p">()</span><span class="w"> </span><span class="p">{</span>
|
||||
<a id="__codelineno-9-89" name="__codelineno-9-89" href="#__codelineno-9-89"></a><span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="n">pair</span><span class="p">.</span><span class="n">key</span><span class="w"> </span><span class="o">==</span><span class="w"> </span><span class="n">key</span><span class="w"> </span><span class="p">{</span>
|
||||
<a id="__codelineno-9-90" name="__codelineno-9-90" href="#__codelineno-9-90"></a><span class="w"> </span><span class="n">pair</span><span class="p">.</span><span class="n">val</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">val</span><span class="p">;</span>
|
||||
<a id="__codelineno-9-91" name="__codelineno-9-91" href="#__codelineno-9-91"></a><span class="w"> </span><span class="k">return</span><span class="p">;</span>
|
||||
<a id="__codelineno-9-92" name="__codelineno-9-92" href="#__codelineno-9-92"></a><span class="w"> </span><span class="p">}</span>
|
||||
<a id="__codelineno-9-93" name="__codelineno-9-93" href="#__codelineno-9-93"></a><span class="w"> </span><span class="p">}</span>
|
||||
<a id="__codelineno-9-94" name="__codelineno-9-94" href="#__codelineno-9-94"></a>
|
||||
<a id="__codelineno-9-95" name="__codelineno-9-95" href="#__codelineno-9-95"></a><span class="w"> </span><span class="c1">// 若无该 key ，则将键值对添加至尾部</span>
|
||||
<a id="__codelineno-9-96" name="__codelineno-9-96" href="#__codelineno-9-96"></a><span class="w"> </span><span class="kd">let</span><span class="w"> </span><span class="n">pair</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">Pair</span><span class="w"> </span><span class="p">{</span><span class="w"> </span><span class="n">key</span><span class="p">,</span><span class="w"> </span><span class="n">val</span><span class="w"> </span><span class="p">};</span>
|
||||
<a id="__codelineno-9-97" name="__codelineno-9-97" href="#__codelineno-9-97"></a><span class="w"> </span><span class="bp">self</span><span class="p">.</span><span class="n">buckets</span><span class="p">[</span><span class="n">index</span><span class="p">].</span><span class="n">push</span><span class="p">(</span><span class="n">pair</span><span class="p">);</span>
|
||||
<a id="__codelineno-9-98" name="__codelineno-9-98" href="#__codelineno-9-98"></a><span class="w"> </span><span class="bp">self</span><span class="p">.</span><span class="n">size</span><span class="w"> </span><span class="o">+=</span><span class="w"> </span><span class="mi">1</span><span class="p">;</span>
|
||||
<a id="__codelineno-9-99" name="__codelineno-9-99" href="#__codelineno-9-99"></a><span class="w"> </span><span class="p">}</span>
|
||||
<a id="__codelineno-9-100" name="__codelineno-9-100" href="#__codelineno-9-100"></a>
|
||||
<a id="__codelineno-9-101" name="__codelineno-9-101" href="#__codelineno-9-101"></a><span class="w"> </span><span class="cm">/* 查询操作 */</span>
|
||||
<a id="__codelineno-9-102" name="__codelineno-9-102" href="#__codelineno-9-102"></a><span class="w"> </span><span class="k">fn</span> <span class="nf">get</span><span class="p">(</span><span class="o">&</span><span class="bp">self</span><span class="p">,</span><span class="w"> </span><span class="n">key</span>: <span class="kt">i32</span><span class="p">)</span><span class="w"> </span>-> <span class="nb">Option</span><span class="o"><&</span><span class="kt">str</span><span class="o">></span><span class="w"> </span><span class="p">{</span>
|
||||
<a id="__codelineno-9-103" name="__codelineno-9-103" href="#__codelineno-9-103"></a><span class="w"> </span><span class="kd">let</span><span class="w"> </span><span class="n">index</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="bp">self</span><span class="p">.</span><span class="n">hash_func</span><span class="p">(</span><span class="n">key</span><span class="p">);</span>
|
||||
<a id="__codelineno-9-104" name="__codelineno-9-104" href="#__codelineno-9-104"></a>
|
||||
<a id="__codelineno-9-105" name="__codelineno-9-105" href="#__codelineno-9-105"></a><span class="w"> </span><span class="c1">// 遍历桶，若找到 key ，则返回对应 val</span>
|
||||
<a id="__codelineno-9-106" name="__codelineno-9-106" href="#__codelineno-9-106"></a><span class="w"> </span><span class="k">for</span><span class="w"> </span><span class="n">pair</span><span class="w"> </span><span class="k">in</span><span class="w"> </span><span class="bp">self</span><span class="p">.</span><span class="n">buckets</span><span class="p">[</span><span class="n">index</span><span class="p">].</span><span class="n">iter</span><span class="p">()</span><span class="w"> </span><span class="p">{</span>
|
||||
<a id="__codelineno-9-107" name="__codelineno-9-107" href="#__codelineno-9-107"></a><span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="n">pair</span><span class="p">.</span><span class="n">key</span><span class="w"> </span><span class="o">==</span><span class="w"> </span><span class="n">key</span><span class="w"> </span><span class="p">{</span>
|
||||
<a id="__codelineno-9-108" name="__codelineno-9-108" href="#__codelineno-9-108"></a><span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="nb">Some</span><span class="p">(</span><span class="o">&</span><span class="n">pair</span><span class="p">.</span><span class="n">val</span><span class="p">);</span>
|
||||
<a id="__codelineno-9-109" name="__codelineno-9-109" href="#__codelineno-9-109"></a><span class="w"> </span><span class="p">}</span>
|
||||
<a id="__codelineno-9-110" name="__codelineno-9-110" href="#__codelineno-9-110"></a><span class="w"> </span><span class="p">}</span>
|
||||
<a id="__codelineno-9-111" name="__codelineno-9-111" href="#__codelineno-9-111"></a>
|
||||
<a id="__codelineno-9-112" name="__codelineno-9-112" href="#__codelineno-9-112"></a><span class="w"> </span><span class="c1">// 若未找到 key ，则返回 None</span>
|
||||
<a id="__codelineno-9-113" name="__codelineno-9-113" href="#__codelineno-9-113"></a><span class="w"> </span><span class="nb">None</span>
|
||||
<a id="__codelineno-9-114" name="__codelineno-9-114" href="#__codelineno-9-114"></a><span class="w"> </span><span class="p">}</span>
|
||||
<a id="__codelineno-9-115" name="__codelineno-9-115" href="#__codelineno-9-115"></a><span class="p">}</span>
|
||||
</code></pre></div>
|
||||
</div>
|
||||
<div class="tabbed-block">
|
||||
|
||||
@@ -3704,20 +3704,18 @@
|
||||
<a id="__codelineno-0-2" name="__codelineno-0-2" href="#__codelineno-0-2"></a><span class="w"> </span><span class="sd">"""计数排序"""</span>
|
||||
<a id="__codelineno-0-3" name="__codelineno-0-3" href="#__codelineno-0-3"></a> <span class="c1"># 简单实现，无法用于排序对象</span>
|
||||
<a id="__codelineno-0-4" name="__codelineno-0-4" href="#__codelineno-0-4"></a> <span class="c1"># 1. 统计数组最大元素 m</span>
|
||||
<a id="__codelineno-0-5" name="__codelineno-0-5" href="#__codelineno-0-5"></a> <span class="n">m</span> <span class="o">=</span> <span class="mi">0</span>
|
||||
<a id="__codelineno-0-6" name="__codelineno-0-6" href="#__codelineno-0-6"></a> <span class="k">for</span> <span class="n">num</span> <span class="ow">in</span> <span class="n">nums</span><span class="p">:</span>
|
||||
<a id="__codelineno-0-7" name="__codelineno-0-7" href="#__codelineno-0-7"></a> <span class="n">m</span> <span class="o">=</span> <span class="nb">max</span><span class="p">(</span><span class="n">m</span><span class="p">,</span> <span class="n">num</span><span class="p">)</span>
|
||||
<a id="__codelineno-0-8" name="__codelineno-0-8" href="#__codelineno-0-8"></a> <span class="c1"># 2. 统计各数字的出现次数</span>
|
||||
<a id="__codelineno-0-9" name="__codelineno-0-9" href="#__codelineno-0-9"></a> <span class="c1"># counter[num] 代表 num 的出现次数</span>
|
||||
<a id="__codelineno-0-10" name="__codelineno-0-10" href="#__codelineno-0-10"></a> <span class="n">counter</span> <span class="o">=</span> <span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">*</span> <span class="p">(</span><span class="n">m</span> <span class="o">+</span> <span class="mi">1</span><span class="p">)</span>
|
||||
<a id="__codelineno-0-11" name="__codelineno-0-11" href="#__codelineno-0-11"></a> <span class="k">for</span> <span class="n">num</span> <span class="ow">in</span> <span class="n">nums</span><span class="p">:</span>
|
||||
<a id="__codelineno-0-12" name="__codelineno-0-12" href="#__codelineno-0-12"></a> <span class="n">counter</span><span class="p">[</span><span class="n">num</span><span class="p">]</span> <span class="o">+=</span> <span class="mi">1</span>
|
||||
<a id="__codelineno-0-13" name="__codelineno-0-13" href="#__codelineno-0-13"></a> <span class="c1"># 3. 遍历 counter ，将各元素填入原数组 nums</span>
|
||||
<a id="__codelineno-0-14" name="__codelineno-0-14" href="#__codelineno-0-14"></a> <span class="n">i</span> <span class="o">=</span> <span class="mi">0</span>
|
||||
<a id="__codelineno-0-15" name="__codelineno-0-15" href="#__codelineno-0-15"></a> <span class="k">for</span> <span class="n">num</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="n">m</span> <span class="o">+</span> <span class="mi">1</span><span class="p">):</span>
|
||||
<a id="__codelineno-0-16" name="__codelineno-0-16" href="#__codelineno-0-16"></a> <span class="k">for</span> <span class="n">_</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="n">counter</span><span class="p">[</span><span class="n">num</span><span class="p">]):</span>
|
||||
<a id="__codelineno-0-17" name="__codelineno-0-17" href="#__codelineno-0-17"></a> <span class="n">nums</span><span class="p">[</span><span class="n">i</span><span class="p">]</span> <span class="o">=</span> <span class="n">num</span>
|
||||
<a id="__codelineno-0-18" name="__codelineno-0-18" href="#__codelineno-0-18"></a> <span class="n">i</span> <span class="o">+=</span> <span class="mi">1</span>
|
||||
<a id="__codelineno-0-5" name="__codelineno-0-5" href="#__codelineno-0-5"></a> <span class="n">m</span> <span class="o">=</span> <span class="nb">max</span><span class="p">(</span><span class="n">nums</span><span class="p">)</span>
|
||||
<a id="__codelineno-0-6" name="__codelineno-0-6" href="#__codelineno-0-6"></a> <span class="c1"># 2. 统计各数字的出现次数</span>
|
||||
<a id="__codelineno-0-7" name="__codelineno-0-7" href="#__codelineno-0-7"></a> <span class="c1"># counter[num] 代表 num 的出现次数</span>
|
||||
<a id="__codelineno-0-8" name="__codelineno-0-8" href="#__codelineno-0-8"></a> <span class="n">counter</span> <span class="o">=</span> <span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">*</span> <span class="p">(</span><span class="n">m</span> <span class="o">+</span> <span class="mi">1</span><span class="p">)</span>
|
||||
<a id="__codelineno-0-9" name="__codelineno-0-9" href="#__codelineno-0-9"></a> <span class="k">for</span> <span class="n">num</span> <span class="ow">in</span> <span class="n">nums</span><span class="p">:</span>
|
||||
<a id="__codelineno-0-10" name="__codelineno-0-10" href="#__codelineno-0-10"></a> <span class="n">counter</span><span class="p">[</span><span class="n">num</span><span class="p">]</span> <span class="o">+=</span> <span class="mi">1</span>
|
||||
<a id="__codelineno-0-11" name="__codelineno-0-11" href="#__codelineno-0-11"></a> <span class="c1"># 3. 遍历 counter ，将各元素填入原数组 nums</span>
|
||||
<a id="__codelineno-0-12" name="__codelineno-0-12" href="#__codelineno-0-12"></a> <span class="n">i</span> <span class="o">=</span> <span class="mi">0</span>
|
||||
<a id="__codelineno-0-13" name="__codelineno-0-13" href="#__codelineno-0-13"></a> <span class="k">for</span> <span class="n">num</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="n">m</span> <span class="o">+</span> <span class="mi">1</span><span class="p">):</span>
|
||||
<a id="__codelineno-0-14" name="__codelineno-0-14" href="#__codelineno-0-14"></a> <span class="k">for</span> <span class="n">_</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="n">counter</span><span class="p">[</span><span class="n">num</span><span class="p">]):</span>
|
||||
<a id="__codelineno-0-15" name="__codelineno-0-15" href="#__codelineno-0-15"></a> <span class="n">nums</span><span class="p">[</span><span class="n">i</span><span class="p">]</span> <span class="o">=</span> <span class="n">num</span>
|
||||
<a id="__codelineno-0-16" name="__codelineno-0-16" href="#__codelineno-0-16"></a> <span class="n">i</span> <span class="o">+=</span> <span class="mi">1</span>
|
||||
</code></pre></div>
|
||||
</div>
|
||||
<div class="tabbed-block">
|
||||
|
||||
@@ -5370,7 +5370,7 @@
|
||||
<a id="__codelineno-23-109" name="__codelineno-23-109" href="#__codelineno-23-109"></a><span class="w"> </span><span class="p">}</span>
|
||||
<a id="__codelineno-23-110" name="__codelineno-23-110" href="#__codelineno-23-110"></a><span class="w"> </span><span class="p">}</span>
|
||||
<a id="__codelineno-23-111" name="__codelineno-23-111" href="#__codelineno-23-111"></a><span class="w"> </span><span class="bp">self</span><span class="p">.</span><span class="n">que_size</span><span class="w"> </span><span class="o">-=</span><span class="w"> </span><span class="mi">1</span><span class="p">;</span><span class="w"> </span><span class="c1">// 更新队列长度</span>
|
||||
<a id="__codelineno-23-112" name="__codelineno-23-112" href="#__codelineno-23-112"></a><span class="w"> </span><span class="n">Rc</span>::<span class="n">try_unwrap</span><span class="p">(</span><span class="n">old_front</span><span class="p">).</span><span class="n">ok</span><span class="p">().</span><span class="n">unwrap</span><span class="p">().</span><span class="n">into_inner</span><span class="p">().</span><span class="n">val</span>
|
||||
<a id="__codelineno-23-112" name="__codelineno-23-112" href="#__codelineno-23-112"></a><span class="w"> </span><span class="n">old_front</span><span class="p">.</span><span class="n">borrow</span><span class="p">().</span><span class="n">val</span>
|
||||
<a id="__codelineno-23-113" name="__codelineno-23-113" href="#__codelineno-23-113"></a><span class="w"> </span><span class="p">})</span>
|
||||
<a id="__codelineno-23-114" name="__codelineno-23-114" href="#__codelineno-23-114"></a><span class="w"> </span><span class="p">}</span>
|
||||
<a id="__codelineno-23-115" name="__codelineno-23-115" href="#__codelineno-23-115"></a><span class="w"> </span><span class="c1">// 队尾出队操作</span>
|
||||
@@ -5386,7 +5386,7 @@
|
||||
<a id="__codelineno-23-125" name="__codelineno-23-125" href="#__codelineno-23-125"></a><span class="w"> </span><span class="p">}</span>
|
||||
<a id="__codelineno-23-126" name="__codelineno-23-126" href="#__codelineno-23-126"></a><span class="w"> </span><span class="p">}</span>
|
||||
<a id="__codelineno-23-127" name="__codelineno-23-127" href="#__codelineno-23-127"></a><span class="w"> </span><span class="bp">self</span><span class="p">.</span><span class="n">que_size</span><span class="w"> </span><span class="o">-=</span><span class="w"> </span><span class="mi">1</span><span class="p">;</span><span class="w"> </span><span class="c1">// 更新队列长度</span>
|
||||
<a id="__codelineno-23-128" name="__codelineno-23-128" href="#__codelineno-23-128"></a><span class="w"> </span><span class="n">Rc</span>::<span class="n">try_unwrap</span><span class="p">(</span><span class="n">old_rear</span><span class="p">).</span><span class="n">ok</span><span class="p">().</span><span class="n">unwrap</span><span class="p">().</span><span class="n">into_inner</span><span class="p">().</span><span class="n">val</span>
|
||||
<a id="__codelineno-23-128" name="__codelineno-23-128" href="#__codelineno-23-128"></a><span class="w"> </span><span class="n">old_rear</span><span class="p">.</span><span class="n">borrow</span><span class="p">().</span><span class="n">val</span>
|
||||
<a id="__codelineno-23-129" name="__codelineno-23-129" href="#__codelineno-23-129"></a><span class="w"> </span><span class="p">})</span>
|
||||
<a id="__codelineno-23-130" name="__codelineno-23-130" href="#__codelineno-23-130"></a><span class="w"> </span><span class="p">}</span>
|
||||
<a id="__codelineno-23-131" name="__codelineno-23-131" href="#__codelineno-23-131"></a><span class="w"> </span><span class="p">}</span>
|
||||
@@ -5413,14 +5413,18 @@
|
||||
<a id="__codelineno-23-152" name="__codelineno-23-152" href="#__codelineno-23-152"></a>
|
||||
<a id="__codelineno-23-153" name="__codelineno-23-153" href="#__codelineno-23-153"></a><span class="w"> </span><span class="cm">/* 返回数组用于打印 */</span>
|
||||
<a id="__codelineno-23-154" name="__codelineno-23-154" href="#__codelineno-23-154"></a><span class="w"> </span><span class="k">pub</span><span class="w"> </span><span class="k">fn</span> <span class="nf">to_array</span><span class="p">(</span><span class="o">&</span><span class="bp">self</span><span class="p">,</span><span class="w"> </span><span class="n">head</span>: <span class="nb">Option</span><span class="o"><&</span><span class="n">Rc</span><span class="o"><</span><span class="n">RefCell</span><span class="o"><</span><span class="n">ListNode</span><span class="o"><</span><span class="n">T</span><span class="o">>>>></span><span class="p">)</span><span class="w"> </span>-> <span class="nb">Vec</span><span class="o"><</span><span class="n">T</span><span class="o">></span><span class="w"> </span><span class="p">{</span>
|
||||
<a id="__codelineno-23-155" name="__codelineno-23-155" href="#__codelineno-23-155"></a><span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="kd">let</span><span class="w"> </span><span class="nb">Some</span><span class="p">(</span><span class="n">node</span><span class="p">)</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">head</span><span class="w"> </span><span class="p">{</span>
|
||||
<a id="__codelineno-23-156" name="__codelineno-23-156" href="#__codelineno-23-156"></a><span class="w"> </span><span class="kd">let</span><span class="w"> </span><span class="k">mut</span><span class="w"> </span><span class="n">nums</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="bp">self</span><span class="p">.</span><span class="n">to_array</span><span class="p">(</span><span class="n">node</span><span class="p">.</span><span class="n">borrow</span><span class="p">().</span><span class="n">next</span><span class="p">.</span><span class="n">as_ref</span><span class="p">());</span>
|
||||
<a id="__codelineno-23-157" name="__codelineno-23-157" href="#__codelineno-23-157"></a><span class="w"> </span><span class="n">nums</span><span class="p">.</span><span class="n">insert</span><span class="p">(</span><span class="mi">0</span><span class="p">,</span><span class="w"> </span><span class="n">node</span><span class="p">.</span><span class="n">borrow</span><span class="p">().</span><span class="n">val</span><span class="p">);</span>
|
||||
<a id="__codelineno-23-158" name="__codelineno-23-158" href="#__codelineno-23-158"></a><span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="n">nums</span><span class="p">;</span>
|
||||
<a id="__codelineno-23-159" name="__codelineno-23-159" href="#__codelineno-23-159"></a><span class="w"> </span><span class="p">}</span>
|
||||
<a id="__codelineno-23-160" name="__codelineno-23-160" href="#__codelineno-23-160"></a><span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="nb">Vec</span>::<span class="n">new</span><span class="p">();</span>
|
||||
<a id="__codelineno-23-161" name="__codelineno-23-161" href="#__codelineno-23-161"></a><span class="w"> </span><span class="p">}</span>
|
||||
<a id="__codelineno-23-162" name="__codelineno-23-162" href="#__codelineno-23-162"></a><span class="p">}</span>
|
||||
<a id="__codelineno-23-155" name="__codelineno-23-155" href="#__codelineno-23-155"></a><span class="w"> </span><span class="kd">let</span><span class="w"> </span><span class="k">mut</span><span class="w"> </span><span class="n">res</span>: <span class="nb">Vec</span><span class="o"><</span><span class="n">T</span><span class="o">></span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="nb">Vec</span>::<span class="n">new</span><span class="p">();</span>
|
||||
<a id="__codelineno-23-156" name="__codelineno-23-156" href="#__codelineno-23-156"></a><span class="w"> </span><span class="k">fn</span> <span class="nf">recur</span><span class="o"><</span><span class="n">T</span>: <span class="nb">Copy</span><span class="o">></span><span class="p">(</span><span class="n">cur</span>: <span class="nb">Option</span><span class="o"><&</span><span class="n">Rc</span><span class="o"><</span><span class="n">RefCell</span><span class="o"><</span><span class="n">ListNode</span><span class="o"><</span><span class="n">T</span><span class="o">>>>></span><span class="p">,</span><span class="w"> </span><span class="n">res</span>: <span class="kp">&</span><span class="nc">mut</span><span class="w"> </span><span class="nb">Vec</span><span class="o"><</span><span class="n">T</span><span class="o">></span><span class="p">)</span><span class="w"> </span><span class="p">{</span>
|
||||
<a id="__codelineno-23-157" name="__codelineno-23-157" href="#__codelineno-23-157"></a><span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="kd">let</span><span class="w"> </span><span class="nb">Some</span><span class="p">(</span><span class="n">cur</span><span class="p">)</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">cur</span><span class="w"> </span><span class="p">{</span>
|
||||
<a id="__codelineno-23-158" name="__codelineno-23-158" href="#__codelineno-23-158"></a><span class="w"> </span><span class="n">res</span><span class="p">.</span><span class="n">push</span><span class="p">(</span><span class="n">cur</span><span class="p">.</span><span class="n">borrow</span><span class="p">().</span><span class="n">val</span><span class="p">);</span>
|
||||
<a id="__codelineno-23-159" name="__codelineno-23-159" href="#__codelineno-23-159"></a><span class="w"> </span><span class="n">recur</span><span class="p">(</span><span class="n">cur</span><span class="p">.</span><span class="n">borrow</span><span class="p">().</span><span class="n">next</span><span class="p">.</span><span class="n">as_ref</span><span class="p">(),</span><span class="w"> </span><span class="n">res</span><span class="p">);</span>
|
||||
<a id="__codelineno-23-160" name="__codelineno-23-160" href="#__codelineno-23-160"></a><span class="w"> </span><span class="p">}</span>
|
||||
<a id="__codelineno-23-161" name="__codelineno-23-161" href="#__codelineno-23-161"></a><span class="w"> </span><span class="p">}</span>
|
||||
<a id="__codelineno-23-162" name="__codelineno-23-162" href="#__codelineno-23-162"></a>
|
||||
<a id="__codelineno-23-163" name="__codelineno-23-163" href="#__codelineno-23-163"></a><span class="w"> </span><span class="n">recur</span><span class="p">(</span><span class="n">head</span><span class="p">,</span><span class="w"> </span><span class="o">&</span><span class="k">mut</span><span class="w"> </span><span class="n">res</span><span class="p">);</span>
|
||||
<a id="__codelineno-23-164" name="__codelineno-23-164" href="#__codelineno-23-164"></a><span class="w"> </span><span class="n">res</span>
|
||||
<a id="__codelineno-23-165" name="__codelineno-23-165" href="#__codelineno-23-165"></a><span class="w"> </span><span class="p">}</span>
|
||||
<a id="__codelineno-23-166" name="__codelineno-23-166" href="#__codelineno-23-166"></a><span class="p">}</span>
|
||||
</code></pre></div>
|
||||
</div>
|
||||
<div class="tabbed-block">
|
||||
|
||||
@@ -4750,7 +4750,7 @@
|
||||
<a id="__codelineno-23-56" name="__codelineno-23-56" href="#__codelineno-23-56"></a><span class="w"> </span><span class="p">}</span>
|
||||
<a id="__codelineno-23-57" name="__codelineno-23-57" href="#__codelineno-23-57"></a><span class="w"> </span><span class="p">}</span>
|
||||
<a id="__codelineno-23-58" name="__codelineno-23-58" href="#__codelineno-23-58"></a><span class="w"> </span><span class="bp">self</span><span class="p">.</span><span class="n">que_size</span><span class="w"> </span><span class="o">-=</span><span class="w"> </span><span class="mi">1</span><span class="p">;</span>
|
||||
<a id="__codelineno-23-59" name="__codelineno-23-59" href="#__codelineno-23-59"></a><span class="w"> </span><span class="n">Rc</span>::<span class="n">try_unwrap</span><span class="p">(</span><span class="n">old_front</span><span class="p">).</span><span class="n">ok</span><span class="p">().</span><span class="n">unwrap</span><span class="p">().</span><span class="n">into_inner</span><span class="p">().</span><span class="n">val</span>
|
||||
<a id="__codelineno-23-59" name="__codelineno-23-59" href="#__codelineno-23-59"></a><span class="w"> </span><span class="n">old_front</span><span class="p">.</span><span class="n">borrow</span><span class="p">().</span><span class="n">val</span>
|
||||
<a id="__codelineno-23-60" name="__codelineno-23-60" href="#__codelineno-23-60"></a><span class="w"> </span><span class="p">})</span>
|
||||
<a id="__codelineno-23-61" name="__codelineno-23-61" href="#__codelineno-23-61"></a><span class="w"> </span><span class="p">}</span>
|
||||
<a id="__codelineno-23-62" name="__codelineno-23-62" href="#__codelineno-23-62"></a>
|
||||
@@ -4761,14 +4761,20 @@
|
||||
<a id="__codelineno-23-67" name="__codelineno-23-67" href="#__codelineno-23-67"></a>
|
||||
<a id="__codelineno-23-68" name="__codelineno-23-68" href="#__codelineno-23-68"></a><span class="w"> </span><span class="cm">/* 将链表转化为 Array 并返回 */</span>
|
||||
<a id="__codelineno-23-69" name="__codelineno-23-69" href="#__codelineno-23-69"></a><span class="w"> </span><span class="k">pub</span><span class="w"> </span><span class="k">fn</span> <span class="nf">to_array</span><span class="p">(</span><span class="o">&</span><span class="bp">self</span><span class="p">,</span><span class="w"> </span><span class="n">head</span>: <span class="nb">Option</span><span class="o"><&</span><span class="n">Rc</span><span class="o"><</span><span class="n">RefCell</span><span class="o"><</span><span class="n">ListNode</span><span class="o"><</span><span class="n">T</span><span class="o">>>>></span><span class="p">)</span><span class="w"> </span>-> <span class="nb">Vec</span><span class="o"><</span><span class="n">T</span><span class="o">></span><span class="w"> </span><span class="p">{</span>
|
||||
<a id="__codelineno-23-70" name="__codelineno-23-70" href="#__codelineno-23-70"></a><span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="kd">let</span><span class="w"> </span><span class="nb">Some</span><span class="p">(</span><span class="n">node</span><span class="p">)</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">head</span><span class="w"> </span><span class="p">{</span>
|
||||
<a id="__codelineno-23-71" name="__codelineno-23-71" href="#__codelineno-23-71"></a><span class="w"> </span><span class="kd">let</span><span class="w"> </span><span class="k">mut</span><span class="w"> </span><span class="n">nums</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="bp">self</span><span class="p">.</span><span class="n">to_array</span><span class="p">(</span><span class="n">node</span><span class="p">.</span><span class="n">borrow</span><span class="p">().</span><span class="n">next</span><span class="p">.</span><span class="n">as_ref</span><span class="p">());</span>
|
||||
<a id="__codelineno-23-72" name="__codelineno-23-72" href="#__codelineno-23-72"></a><span class="w"> </span><span class="n">nums</span><span class="p">.</span><span class="n">insert</span><span class="p">(</span><span class="mi">0</span><span class="p">,</span><span class="w"> </span><span class="n">node</span><span class="p">.</span><span class="n">borrow</span><span class="p">().</span><span class="n">val</span><span class="p">);</span>
|
||||
<a id="__codelineno-23-73" name="__codelineno-23-73" href="#__codelineno-23-73"></a><span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="n">nums</span><span class="p">;</span>
|
||||
<a id="__codelineno-23-74" name="__codelineno-23-74" href="#__codelineno-23-74"></a><span class="w"> </span><span class="p">}</span>
|
||||
<a id="__codelineno-23-75" name="__codelineno-23-75" href="#__codelineno-23-75"></a><span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="nb">Vec</span>::<span class="n">new</span><span class="p">();</span>
|
||||
<a id="__codelineno-23-76" name="__codelineno-23-76" href="#__codelineno-23-76"></a><span class="w"> </span><span class="p">}</span>
|
||||
<a id="__codelineno-23-77" name="__codelineno-23-77" href="#__codelineno-23-77"></a><span class="p">}</span>
|
||||
<a id="__codelineno-23-70" name="__codelineno-23-70" href="#__codelineno-23-70"></a><span class="w"> </span><span class="kd">let</span><span class="w"> </span><span class="k">mut</span><span class="w"> </span><span class="n">res</span>: <span class="nb">Vec</span><span class="o"><</span><span class="n">T</span><span class="o">></span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="nb">Vec</span>::<span class="n">new</span><span class="p">();</span>
|
||||
<a id="__codelineno-23-71" name="__codelineno-23-71" href="#__codelineno-23-71"></a>
|
||||
<a id="__codelineno-23-72" name="__codelineno-23-72" href="#__codelineno-23-72"></a><span class="w"> </span><span class="k">fn</span> <span class="nf">recur</span><span class="o"><</span><span class="n">T</span>: <span class="nb">Copy</span><span class="o">></span><span class="p">(</span><span class="n">cur</span>: <span class="nb">Option</span><span class="o"><&</span><span class="n">Rc</span><span class="o"><</span><span class="n">RefCell</span><span class="o"><</span><span class="n">ListNode</span><span class="o"><</span><span class="n">T</span><span class="o">>>>></span><span class="p">,</span><span class="w"> </span><span class="n">res</span>: <span class="kp">&</span><span class="nc">mut</span><span class="w"> </span><span class="nb">Vec</span><span class="o"><</span><span class="n">T</span><span class="o">></span><span class="p">)</span><span class="w"> </span><span class="p">{</span>
|
||||
<a id="__codelineno-23-73" name="__codelineno-23-73" href="#__codelineno-23-73"></a><span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="kd">let</span><span class="w"> </span><span class="nb">Some</span><span class="p">(</span><span class="n">cur</span><span class="p">)</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">cur</span><span class="w"> </span><span class="p">{</span>
|
||||
<a id="__codelineno-23-74" name="__codelineno-23-74" href="#__codelineno-23-74"></a><span class="w"> </span><span class="n">res</span><span class="p">.</span><span class="n">push</span><span class="p">(</span><span class="n">cur</span><span class="p">.</span><span class="n">borrow</span><span class="p">().</span><span class="n">val</span><span class="p">);</span>
|
||||
<a id="__codelineno-23-75" name="__codelineno-23-75" href="#__codelineno-23-75"></a><span class="w"> </span><span class="n">recur</span><span class="p">(</span><span class="n">cur</span><span class="p">.</span><span class="n">borrow</span><span class="p">().</span><span class="n">next</span><span class="p">.</span><span class="n">as_ref</span><span class="p">(),</span><span class="w"> </span><span class="n">res</span><span class="p">);</span>
|
||||
<a id="__codelineno-23-76" name="__codelineno-23-76" href="#__codelineno-23-76"></a><span class="w"> </span><span class="p">}</span>
|
||||
<a id="__codelineno-23-77" name="__codelineno-23-77" href="#__codelineno-23-77"></a><span class="w"> </span><span class="p">}</span>
|
||||
<a id="__codelineno-23-78" name="__codelineno-23-78" href="#__codelineno-23-78"></a>
|
||||
<a id="__codelineno-23-79" name="__codelineno-23-79" href="#__codelineno-23-79"></a><span class="w"> </span><span class="n">recur</span><span class="p">(</span><span class="n">head</span><span class="p">,</span><span class="w"> </span><span class="o">&</span><span class="k">mut</span><span class="w"> </span><span class="n">res</span><span class="p">);</span>
|
||||
<a id="__codelineno-23-80" name="__codelineno-23-80" href="#__codelineno-23-80"></a>
|
||||
<a id="__codelineno-23-81" name="__codelineno-23-81" href="#__codelineno-23-81"></a><span class="w"> </span><span class="n">res</span>
|
||||
<a id="__codelineno-23-82" name="__codelineno-23-82" href="#__codelineno-23-82"></a><span class="w"> </span><span class="p">}</span>
|
||||
<a id="__codelineno-23-83" name="__codelineno-23-83" href="#__codelineno-23-83"></a><span class="p">}</span>
|
||||
</code></pre></div>
|
||||
</div>
|
||||
<div class="tabbed-block">
|
||||
|
||||
@@ -4659,34 +4659,28 @@
|
||||
<a id="__codelineno-23-34" name="__codelineno-23-34" href="#__codelineno-23-34"></a><span class="w"> </span><span class="cm">/* 出栈 */</span>
|
||||
<a id="__codelineno-23-35" name="__codelineno-23-35" href="#__codelineno-23-35"></a><span class="w"> </span><span class="k">pub</span><span class="w"> </span><span class="k">fn</span> <span class="nf">pop</span><span class="p">(</span><span class="o">&</span><span class="k">mut</span><span class="w"> </span><span class="bp">self</span><span class="p">)</span><span class="w"> </span>-> <span class="nb">Option</span><span class="o"><</span><span class="n">T</span><span class="o">></span><span class="w"> </span><span class="p">{</span>
|
||||
<a id="__codelineno-23-36" name="__codelineno-23-36" href="#__codelineno-23-36"></a><span class="w"> </span><span class="bp">self</span><span class="p">.</span><span class="n">stack_peek</span><span class="p">.</span><span class="n">take</span><span class="p">().</span><span class="n">map</span><span class="p">(</span><span class="o">|</span><span class="n">old_head</span><span class="o">|</span><span class="w"> </span><span class="p">{</span>
|
||||
<a id="__codelineno-23-37" name="__codelineno-23-37" href="#__codelineno-23-37"></a><span class="w"> </span><span class="k">match</span><span class="w"> </span><span class="n">old_head</span><span class="p">.</span><span class="n">borrow_mut</span><span class="p">().</span><span class="n">next</span><span class="p">.</span><span class="n">take</span><span class="p">()</span><span class="w"> </span><span class="p">{</span>
|
||||
<a id="__codelineno-23-38" name="__codelineno-23-38" href="#__codelineno-23-38"></a><span class="w"> </span><span class="nb">Some</span><span class="p">(</span><span class="n">new_head</span><span class="p">)</span><span class="w"> </span><span class="o">=></span><span class="w"> </span><span class="p">{</span>
|
||||
<a id="__codelineno-23-39" name="__codelineno-23-39" href="#__codelineno-23-39"></a><span class="w"> </span><span class="bp">self</span><span class="p">.</span><span class="n">stack_peek</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="nb">Some</span><span class="p">(</span><span class="n">new_head</span><span class="p">);</span>
|
||||
<a id="__codelineno-23-40" name="__codelineno-23-40" href="#__codelineno-23-40"></a><span class="w"> </span><span class="p">}</span>
|
||||
<a id="__codelineno-23-41" name="__codelineno-23-41" href="#__codelineno-23-41"></a><span class="w"> </span><span class="nb">None</span><span class="w"> </span><span class="o">=></span><span class="w"> </span><span class="p">{</span>
|
||||
<a id="__codelineno-23-42" name="__codelineno-23-42" href="#__codelineno-23-42"></a><span class="w"> </span><span class="bp">self</span><span class="p">.</span><span class="n">stack_peek</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="nb">None</span><span class="p">;</span>
|
||||
<a id="__codelineno-23-43" name="__codelineno-23-43" href="#__codelineno-23-43"></a><span class="w"> </span><span class="p">}</span>
|
||||
<a id="__codelineno-23-44" name="__codelineno-23-44" href="#__codelineno-23-44"></a><span class="w"> </span><span class="p">}</span>
|
||||
<a id="__codelineno-23-45" name="__codelineno-23-45" href="#__codelineno-23-45"></a><span class="w"> </span><span class="bp">self</span><span class="p">.</span><span class="n">stk_size</span><span class="w"> </span><span class="o">-=</span><span class="w"> </span><span class="mi">1</span><span class="p">;</span>
|
||||
<a id="__codelineno-23-46" name="__codelineno-23-46" href="#__codelineno-23-46"></a><span class="w"> </span><span class="n">Rc</span>::<span class="n">try_unwrap</span><span class="p">(</span><span class="n">old_head</span><span class="p">).</span><span class="n">ok</span><span class="p">().</span><span class="n">unwrap</span><span class="p">().</span><span class="n">into_inner</span><span class="p">().</span><span class="n">val</span>
|
||||
<a id="__codelineno-23-47" name="__codelineno-23-47" href="#__codelineno-23-47"></a><span class="w"> </span><span class="p">})</span>
|
||||
<a id="__codelineno-23-48" name="__codelineno-23-48" href="#__codelineno-23-48"></a><span class="w"> </span><span class="p">}</span>
|
||||
<a id="__codelineno-23-49" name="__codelineno-23-49" href="#__codelineno-23-49"></a>
|
||||
<a id="__codelineno-23-50" name="__codelineno-23-50" href="#__codelineno-23-50"></a><span class="w"> </span><span class="cm">/* 访问栈顶元素 */</span>
|
||||
<a id="__codelineno-23-51" name="__codelineno-23-51" href="#__codelineno-23-51"></a><span class="w"> </span><span class="k">pub</span><span class="w"> </span><span class="k">fn</span> <span class="nf">peek</span><span class="p">(</span><span class="o">&</span><span class="bp">self</span><span class="p">)</span><span class="w"> </span>-> <span class="nb">Option</span><span class="o"><&</span><span class="n">Rc</span><span class="o"><</span><span class="n">RefCell</span><span class="o"><</span><span class="n">ListNode</span><span class="o"><</span><span class="n">T</span><span class="o">>>>></span><span class="w"> </span><span class="p">{</span>
|
||||
<a id="__codelineno-23-52" name="__codelineno-23-52" href="#__codelineno-23-52"></a><span class="w"> </span><span class="bp">self</span><span class="p">.</span><span class="n">stack_peek</span><span class="p">.</span><span class="n">as_ref</span><span class="p">()</span>
|
||||
<a id="__codelineno-23-53" name="__codelineno-23-53" href="#__codelineno-23-53"></a><span class="w"> </span><span class="p">}</span>
|
||||
<a id="__codelineno-23-54" name="__codelineno-23-54" href="#__codelineno-23-54"></a>
|
||||
<a id="__codelineno-23-55" name="__codelineno-23-55" href="#__codelineno-23-55"></a><span class="w"> </span><span class="cm">/* 将 List 转化为 Array 并返回 */</span>
|
||||
<a id="__codelineno-23-56" name="__codelineno-23-56" href="#__codelineno-23-56"></a><span class="w"> </span><span class="k">pub</span><span class="w"> </span><span class="k">fn</span> <span class="nf">to_array</span><span class="p">(</span><span class="o">&</span><span class="bp">self</span><span class="p">,</span><span class="w"> </span><span class="n">head</span>: <span class="nb">Option</span><span class="o"><&</span><span class="n">Rc</span><span class="o"><</span><span class="n">RefCell</span><span class="o"><</span><span class="n">ListNode</span><span class="o"><</span><span class="n">T</span><span class="o">>>>></span><span class="p">)</span><span class="w"> </span>-> <span class="nb">Vec</span><span class="o"><</span><span class="n">T</span><span class="o">></span><span class="w"> </span><span class="p">{</span>
|
||||
<a id="__codelineno-23-57" name="__codelineno-23-57" href="#__codelineno-23-57"></a><span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="kd">let</span><span class="w"> </span><span class="nb">Some</span><span class="p">(</span><span class="n">node</span><span class="p">)</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">head</span><span class="w"> </span><span class="p">{</span>
|
||||
<a id="__codelineno-23-58" name="__codelineno-23-58" href="#__codelineno-23-58"></a><span class="w"> </span><span class="kd">let</span><span class="w"> </span><span class="k">mut</span><span class="w"> </span><span class="n">nums</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="bp">self</span><span class="p">.</span><span class="n">to_array</span><span class="p">(</span><span class="n">node</span><span class="p">.</span><span class="n">borrow</span><span class="p">().</span><span class="n">next</span><span class="p">.</span><span class="n">as_ref</span><span class="p">());</span>
|
||||
<a id="__codelineno-23-59" name="__codelineno-23-59" href="#__codelineno-23-59"></a><span class="w"> </span><span class="n">nums</span><span class="p">.</span><span class="n">push</span><span class="p">(</span><span class="n">node</span><span class="p">.</span><span class="n">borrow</span><span class="p">().</span><span class="n">val</span><span class="p">);</span>
|
||||
<a id="__codelineno-23-60" name="__codelineno-23-60" href="#__codelineno-23-60"></a><span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="n">nums</span><span class="p">;</span>
|
||||
<a id="__codelineno-23-61" name="__codelineno-23-61" href="#__codelineno-23-61"></a><span class="w"> </span><span class="p">}</span>
|
||||
<a id="__codelineno-23-62" name="__codelineno-23-62" href="#__codelineno-23-62"></a><span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="nb">Vec</span>::<span class="n">new</span><span class="p">();</span>
|
||||
<a id="__codelineno-23-63" name="__codelineno-23-63" href="#__codelineno-23-63"></a><span class="w"> </span><span class="p">}</span>
|
||||
<a id="__codelineno-23-64" name="__codelineno-23-64" href="#__codelineno-23-64"></a><span class="p">}</span>
|
||||
<a id="__codelineno-23-37" name="__codelineno-23-37" href="#__codelineno-23-37"></a><span class="w"> </span><span class="bp">self</span><span class="p">.</span><span class="n">stack_peek</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">old_head</span><span class="p">.</span><span class="n">borrow_mut</span><span class="p">().</span><span class="n">next</span><span class="p">.</span><span class="n">take</span><span class="p">();</span>
|
||||
<a id="__codelineno-23-38" name="__codelineno-23-38" href="#__codelineno-23-38"></a><span class="w"> </span><span class="bp">self</span><span class="p">.</span><span class="n">stk_size</span><span class="w"> </span><span class="o">-=</span><span class="w"> </span><span class="mi">1</span><span class="p">;</span>
|
||||
<a id="__codelineno-23-39" name="__codelineno-23-39" href="#__codelineno-23-39"></a>
|
||||
<a id="__codelineno-23-40" name="__codelineno-23-40" href="#__codelineno-23-40"></a><span class="w"> </span><span class="n">old_head</span><span class="p">.</span><span class="n">borrow</span><span class="p">().</span><span class="n">val</span>
|
||||
<a id="__codelineno-23-41" name="__codelineno-23-41" href="#__codelineno-23-41"></a><span class="w"> </span><span class="p">})</span>
|
||||
<a id="__codelineno-23-42" name="__codelineno-23-42" href="#__codelineno-23-42"></a><span class="w"> </span><span class="p">}</span>
|
||||
<a id="__codelineno-23-43" name="__codelineno-23-43" href="#__codelineno-23-43"></a>
|
||||
<a id="__codelineno-23-44" name="__codelineno-23-44" href="#__codelineno-23-44"></a><span class="w"> </span><span class="cm">/* 访问栈顶元素 */</span>
|
||||
<a id="__codelineno-23-45" name="__codelineno-23-45" href="#__codelineno-23-45"></a><span class="w"> </span><span class="k">pub</span><span class="w"> </span><span class="k">fn</span> <span class="nf">peek</span><span class="p">(</span><span class="o">&</span><span class="bp">self</span><span class="p">)</span><span class="w"> </span>-> <span class="nb">Option</span><span class="o"><&</span><span class="n">Rc</span><span class="o"><</span><span class="n">RefCell</span><span class="o"><</span><span class="n">ListNode</span><span class="o"><</span><span class="n">T</span><span class="o">>>>></span><span class="w"> </span><span class="p">{</span>
|
||||
<a id="__codelineno-23-46" name="__codelineno-23-46" href="#__codelineno-23-46"></a><span class="w"> </span><span class="bp">self</span><span class="p">.</span><span class="n">stack_peek</span><span class="p">.</span><span class="n">as_ref</span><span class="p">()</span>
|
||||
<a id="__codelineno-23-47" name="__codelineno-23-47" href="#__codelineno-23-47"></a><span class="w"> </span><span class="p">}</span>
|
||||
<a id="__codelineno-23-48" name="__codelineno-23-48" href="#__codelineno-23-48"></a>
|
||||
<a id="__codelineno-23-49" name="__codelineno-23-49" href="#__codelineno-23-49"></a><span class="w"> </span><span class="cm">/* 将 List 转化为 Array 并返回 */</span>
|
||||
<a id="__codelineno-23-50" name="__codelineno-23-50" href="#__codelineno-23-50"></a><span class="w"> </span><span class="k">pub</span><span class="w"> </span><span class="k">fn</span> <span class="nf">to_array</span><span class="p">(</span><span class="o">&</span><span class="bp">self</span><span class="p">,</span><span class="w"> </span><span class="n">head</span>: <span class="nb">Option</span><span class="o"><&</span><span class="n">Rc</span><span class="o"><</span><span class="n">RefCell</span><span class="o"><</span><span class="n">ListNode</span><span class="o"><</span><span class="n">T</span><span class="o">>>>></span><span class="p">)</span><span class="w"> </span>-> <span class="nb">Vec</span><span class="o"><</span><span class="n">T</span><span class="o">></span><span class="w"> </span><span class="p">{</span>
|
||||
<a id="__codelineno-23-51" name="__codelineno-23-51" href="#__codelineno-23-51"></a><span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="kd">let</span><span class="w"> </span><span class="nb">Some</span><span class="p">(</span><span class="n">node</span><span class="p">)</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">head</span><span class="w"> </span><span class="p">{</span>
|
||||
<a id="__codelineno-23-52" name="__codelineno-23-52" href="#__codelineno-23-52"></a><span class="w"> </span><span class="kd">let</span><span class="w"> </span><span class="k">mut</span><span class="w"> </span><span class="n">nums</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="bp">self</span><span class="p">.</span><span class="n">to_array</span><span class="p">(</span><span class="n">node</span><span class="p">.</span><span class="n">borrow</span><span class="p">().</span><span class="n">next</span><span class="p">.</span><span class="n">as_ref</span><span class="p">());</span>
|
||||
<a id="__codelineno-23-53" name="__codelineno-23-53" href="#__codelineno-23-53"></a><span class="w"> </span><span class="n">nums</span><span class="p">.</span><span class="n">push</span><span class="p">(</span><span class="n">node</span><span class="p">.</span><span class="n">borrow</span><span class="p">().</span><span class="n">val</span><span class="p">);</span>
|
||||
<a id="__codelineno-23-54" name="__codelineno-23-54" href="#__codelineno-23-54"></a><span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="n">nums</span><span class="p">;</span>
|
||||
<a id="__codelineno-23-55" name="__codelineno-23-55" href="#__codelineno-23-55"></a><span class="w"> </span><span class="p">}</span>
|
||||
<a id="__codelineno-23-56" name="__codelineno-23-56" href="#__codelineno-23-56"></a><span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="nb">Vec</span>::<span class="n">new</span><span class="p">();</span>
|
||||
<a id="__codelineno-23-57" name="__codelineno-23-57" href="#__codelineno-23-57"></a><span class="w"> </span><span class="p">}</span>
|
||||
<a id="__codelineno-23-58" name="__codelineno-23-58" href="#__codelineno-23-58"></a><span class="p">}</span>
|
||||
</code></pre></div>
|
||||
</div>
|
||||
<div class="tabbed-block">
|
||||
|
||||
@@ -3520,8 +3520,8 @@
|
||||
<p><a class="glightbox" href="../assets/covers/chapter_backtracking.jpg" data-type="image" data-width="100%" data-height="auto" data-desc-position="bottom"><img alt="Backtracking" class="cover-image" src="../assets/covers/chapter_backtracking.jpg" /></a></p>
|
||||
<div class="admonition abstract">
|
||||
<p class="admonition-title">Abstract</p>
|
||||
<p>Like explorers in a maze, we may encounter difficulties on our path forward.</p>
|
||||
<p>The power of backtracking allows us to start over, keep trying, and eventually find the exit to the light.</p>
|
||||
<p>Like explorers in a maze, we may encounter obstacles on our path forward.</p>
|
||||
<p>The power of backtracking lets us begin anew, keep trying, and eventually find the exit leading to the light.</p>
|
||||
</div>
|
||||
<h2 id="chapter-contents">Chapter contents<a class="headerlink" href="#chapter-contents" title="Permanent link">¶</a></h2>
|
||||
<ul>
|
||||
|
||||
@@ -3521,7 +3521,7 @@
|
||||
<div class="admonition abstract">
|
||||
<p class="admonition-title">Abstract</p>
|
||||
<p>Complexity analysis is like a space-time navigator in the vast universe of algorithms.</p>
|
||||
<p>It guides us in exploring deeper within the the dimensions of time and space, seeking more elegant solutions.</p>
|
||||
<p>It guides us in exploring deeper within the dimensions of time and space, seeking more elegant solutions.</p>
|
||||
</div>
|
||||
<h2 id="chapter-contents">Chapter contents<a class="headerlink" href="#chapter-contents" title="Permanent link">¶</a></h2>
|
||||
<ul>
|
||||
|
||||
@@ -91,7 +91,7 @@
|
||||
<div data-md-component="skip">
|
||||
|
||||
|
||||
<a href="#123-building-binary-tree-problem" class="md-skip">
|
||||
<a href="#123-building-a-binary-tree-problem" class="md-skip">
|
||||
Skip to content
|
||||
</a>
|
||||
|
||||
@@ -2665,7 +2665,7 @@
|
||||
<li class="md-nav__item">
|
||||
<a href="#1-determining-if-it-is-a-divide-and-conquer-problem" class="md-nav__link">
|
||||
<span class="md-ellipsis">
|
||||
1. Determining if it is a divide and conquer problem
|
||||
1. Determining if it is a divide-and-conquer problem
|
||||
</span>
|
||||
</a>
|
||||
|
||||
@@ -2681,9 +2681,9 @@
|
||||
</li>
|
||||
|
||||
<li class="md-nav__item">
|
||||
<a href="#3-describing-subtree-intervals-based-on-variables" class="md-nav__link">
|
||||
<a href="#3-describing-subtree-ranges-based-on-variables" class="md-nav__link">
|
||||
<span class="md-ellipsis">
|
||||
3. Describing subtree intervals based on variables
|
||||
3. Describing subtree ranges based on variables
|
||||
</span>
|
||||
</a>
|
||||
|
||||
@@ -3550,7 +3550,7 @@
|
||||
<li class="md-nav__item">
|
||||
<a href="#1-determining-if-it-is-a-divide-and-conquer-problem" class="md-nav__link">
|
||||
<span class="md-ellipsis">
|
||||
1. Determining if it is a divide and conquer problem
|
||||
1. Determining if it is a divide-and-conquer problem
|
||||
</span>
|
||||
</a>
|
||||
|
||||
@@ -3566,9 +3566,9 @@
|
||||
</li>
|
||||
|
||||
<li class="md-nav__item">
|
||||
<a href="#3-describing-subtree-intervals-based-on-variables" class="md-nav__link">
|
||||
<a href="#3-describing-subtree-ranges-based-on-variables" class="md-nav__link">
|
||||
<span class="md-ellipsis">
|
||||
3. Describing subtree intervals based on variables
|
||||
3. Describing subtree ranges based on variables
|
||||
</span>
|
||||
</a>
|
||||
|
||||
@@ -3619,45 +3619,45 @@
|
||||
|
||||
|
||||
<!-- Page content -->
|
||||
<h1 id="123-building-binary-tree-problem">12.3 Building binary tree problem<a class="headerlink" href="#123-building-binary-tree-problem" title="Permanent link">¶</a></h1>
|
||||
<h1 id="123-building-a-binary-tree-problem">12.3 Building a binary tree problem<a class="headerlink" href="#123-building-a-binary-tree-problem" title="Permanent link">¶</a></h1>
|
||||
<div class="admonition question">
|
||||
<p class="admonition-title">Question</p>
|
||||
<p>Given the pre-order traversal <code>preorder</code> and in-order traversal <code>inorder</code> of a binary tree, construct the binary tree and return the root node of the binary tree. Assume that there are no duplicate values in the nodes of the binary tree (as shown in Figure 12-5).</p>
|
||||
<p>Given the pre-order traversal <code>preorder</code> sequence and the in-order traversal <code>inorder</code> sequence of a binary tree, construct the binary tree and return its root node. Assume there are no duplicate node values in the binary tree (as shown in Figure 12-5).</p>
|
||||
</div>
|
||||
<p><a class="glightbox" href="../build_binary_tree_problem.assets/build_tree_example.png" data-type="image" data-width="100%" data-height="auto" data-desc-position="bottom"><img alt="Example data for building a binary tree" class="animation-figure" src="../build_binary_tree_problem.assets/build_tree_example.png" /></a></p>
|
||||
<p align="center"> Figure 12-5 Example data for building a binary tree </p>
|
||||
|
||||
<h3 id="1-determining-if-it-is-a-divide-and-conquer-problem">1. Determining if it is a divide and conquer problem<a class="headerlink" href="#1-determining-if-it-is-a-divide-and-conquer-problem" title="Permanent link">¶</a></h3>
|
||||
<p>The original problem of constructing a binary tree from <code>preorder</code> and <code>inorder</code> is a typical divide and conquer problem.</p>
|
||||
<h3 id="1-determining-if-it-is-a-divide-and-conquer-problem">1. Determining if it is a divide-and-conquer problem<a class="headerlink" href="#1-determining-if-it-is-a-divide-and-conquer-problem" title="Permanent link">¶</a></h3>
|
||||
<p>The original problem of building a binary tree from the <code>preorder</code> and the <code>inorder</code> sequences is a typical divide-and-conquer problem.</p>
|
||||
<ul>
|
||||
<li><strong>The problem can be decomposed</strong>: From the perspective of divide and conquer, we can divide the original problem into two subproblems: building the left subtree and building the right subtree, plus one operation: initializing the root node. For each subtree (subproblem), we can still use the above division method, dividing it into smaller subtrees (subproblems), until the smallest subproblem (empty subtree) is reached.</li>
|
||||
<li><strong>The subproblems are independent</strong>: The left and right subtrees are independent of each other, with no overlap. When building the left subtree, we only need to focus on the parts of the in-order and pre-order traversals that correspond to the left subtree. The same applies to the right subtree.</li>
|
||||
<li><strong>Solutions to subproblems can be combined</strong>: Once the solutions for the left and right subtrees (solutions to subproblems) are obtained, we can link them to the root node to obtain the solution to the original problem.</li>
|
||||
<li><strong>The problem can be decomposed</strong>: From the perspective of divide-and-conquer, we can divide the original problem into two subproblems—building the left subtree and building the right subtree—plus one operation of initializing the root node. For each subtree (subproblem), we continue applying the same approach, partitioning it into smaller subtrees (subproblems), until reaching the smallest subproblem (an empty subtree).</li>
|
||||
<li><strong>The subproblems are independent</strong>: The left and right subtrees do not overlap. When building the left subtree, we only need the segments of the in-order and pre-order traversals that correspond to the left subtree. The same approach applies to the right subtree.</li>
|
||||
<li><strong>Solutions to subproblems can be combined</strong>: Once we have constructed the left and right subtrees (the subproblem solutions), we can attach them to the root node to obtain the solution to the original problem.</li>
|
||||
</ul>
|
||||
<h3 id="2-how-to-divide-the-subtrees">2. How to divide the subtrees<a class="headerlink" href="#2-how-to-divide-the-subtrees" title="Permanent link">¶</a></h3>
|
||||
<p>Based on the above analysis, this problem can be solved using divide and conquer, <strong>but how do we use the pre-order traversal <code>preorder</code> and in-order traversal <code>inorder</code> to divide the left and right subtrees?</strong></p>
|
||||
<p>By definition, <code>preorder</code> and <code>inorder</code> can be divided into three parts.</p>
|
||||
<p>Based on the above analysis, this problem can be solved using divide-and-conquer. <strong>However, how do we use the pre-order traversal <code>preorder</code> sequence and the in-order traversal <code>inorder</code> sequence to divide the left and right subtrees?</strong></p>
|
||||
<p>By definition, both the <code>preorder</code> and <code>inorder</code> sequences can be divided into three parts:</p>
|
||||
<ul>
|
||||
<li>Pre-order traversal: <code>[ Root | Left Subtree | Right Subtree ]</code>, for example, the tree in the figure corresponds to <code>[ 3 | 9 | 2 1 7 ]</code>.</li>
|
||||
<li>In-order traversal: <code>[ Left Subtree | Root | Right Subtree ]</code>, for example, the tree in the figure corresponds to <code>[ 9 | 3 | 1 2 7 ]</code>.</li>
|
||||
<li>Pre-order traversal: <code>[ Root | Left Subtree | Right Subtree ]</code>. For example, in the figure, the tree corresponds to <code>[ 3 | 9 | 2 1 7 ]</code>.</li>
|
||||
<li>In-order traversal: <code>[ Left Subtree | Root | Right Subtree ]</code>. For example, in the figure, the tree corresponds to <code>[ 9 | 3 | 1 2 7 ]</code>.</li>
|
||||
</ul>
|
||||
<p>Using the data in the figure above, we can obtain the division results as shown in Figure 12-6.</p>
|
||||
<p>Using the data from the preceding figure, we can follow the steps shown in the next figure to obtain the division results:</p>
|
||||
<ol>
|
||||
<li>The first element 3 in the pre-order traversal is the value of the root node.</li>
|
||||
<li>Find the index of the root node 3 in <code>inorder</code>, and use this index to divide <code>inorder</code> into <code>[ 9 | 3 ｜ 1 2 7 ]</code>.</li>
|
||||
<li>Based on the division results of <code>inorder</code>, it is easy to determine the number of nodes in the left and right subtrees as 1 and 3, respectively, thus dividing <code>preorder</code> into <code>[ 3 | 9 | 2 1 7 ]</code>.</li>
|
||||
<li>Find the index of the root node 3 in the <code>inorder</code> sequence, and use this index to split <code>inorder</code> into <code>[ 9 | 3 ｜ 1 2 7 ]</code>.</li>
|
||||
<li>According to the split of the <code>inorder</code> sequence, it is straightforward to determine that the left and right subtrees contain 1 and 3 nodes, respectively, so we can split the <code>preorder</code> sequence into <code>[ 3 | 9 | 2 1 7 ]</code> accordingly.</li>
|
||||
</ol>
|
||||
<p><a class="glightbox" href="../build_binary_tree_problem.assets/build_tree_preorder_inorder_division.png" data-type="image" data-width="100%" data-height="auto" data-desc-position="bottom"><img alt="Dividing the subtrees in pre-order and in-order traversals" class="animation-figure" src="../build_binary_tree_problem.assets/build_tree_preorder_inorder_division.png" /></a></p>
|
||||
<p><a class="glightbox" href="build_binary_tree_problem.assets/build_tree_pre-order_in-order_division.png" data-type="image" data-width="100%" data-height="auto" data-desc-position="bottom"><img alt="Dividing the subtrees in pre-order and in-order traversals" class="animation-figure" src="build_binary_tree_problem.assets/build_tree_pre-order_in-order_division.png" /></a></p>
|
||||
<p align="center"> Figure 12-6 Dividing the subtrees in pre-order and in-order traversals </p>
|
||||
|
||||
<h3 id="3-describing-subtree-intervals-based-on-variables">3. Describing subtree intervals based on variables<a class="headerlink" href="#3-describing-subtree-intervals-based-on-variables" title="Permanent link">¶</a></h3>
|
||||
<p>Based on the above division method, <strong>we have now obtained the index intervals of the root, left subtree, and right subtree in <code>preorder</code> and <code>inorder</code></strong>. To describe these index intervals, we need the help of several pointer variables.</p>
|
||||
<h3 id="3-describing-subtree-ranges-based-on-variables">3. Describing subtree ranges based on variables<a class="headerlink" href="#3-describing-subtree-ranges-based-on-variables" title="Permanent link">¶</a></h3>
|
||||
<p>Based on the above division method, <strong>we have now obtained the index ranges of the root, left subtree, and right subtree in the <code>preorder</code> and <code>inorder</code> sequences</strong>. To describe these index ranges, we use several pointer variables.</p>
|
||||
<ul>
|
||||
<li>Let the index of the current tree's root node in <code>preorder</code> be denoted as <span class="arithmatex">\(i\)</span>.</li>
|
||||
<li>Let the index of the current tree's root node in <code>inorder</code> be denoted as <span class="arithmatex">\(m\)</span>.</li>
|
||||
<li>Let the index interval of the current tree in <code>inorder</code> be denoted as <span class="arithmatex">\([l, r]\)</span>.</li>
|
||||
<li>Let the index of the current tree's root node in the <code>preorder</code> sequence be denoted as <span class="arithmatex">\(i\)</span>.</li>
|
||||
<li>Let the index of the current tree's root node in the <code>inorder</code> sequence be denoted as <span class="arithmatex">\(m\)</span>.</li>
|
||||
<li>Let the index range of the current tree in the <code>inorder</code> sequence be denoted as <span class="arithmatex">\([l, r]\)</span>.</li>
|
||||
</ul>
|
||||
<p>As shown in Table 12-1, the above variables can represent the index of the root node in <code>preorder</code> as well as the index intervals of the subtrees in <code>inorder</code>.</p>
|
||||
<p>As shown in Table 12-1, these variables represent the root node’s index in the <code>preorder</code> sequence and the index ranges of the subtrees in the <code>inorder</code> sequence.</p>
|
||||
<p align="center"> Table 12-1 Indexes of the root node and subtrees in pre-order and in-order traversals </p>
|
||||
|
||||
<div class="center-table">
|
||||
@@ -3666,7 +3666,7 @@
|
||||
<tr>
|
||||
<th></th>
|
||||
<th>Root node index in <code>preorder</code></th>
|
||||
<th>Subtree index interval in <code>inorder</code></th>
|
||||
<th>Subtree index range in <code>inorder</code></th>
|
||||
</tr>
|
||||
</thead>
|
||||
<tbody>
|
||||
@@ -3688,12 +3688,12 @@
|
||||
</tbody>
|
||||
</table>
|
||||
</div>
|
||||
<p>Please note, the meaning of <span class="arithmatex">\((m-l)\)</span> in the right subtree root index is "the number of nodes in the left subtree", which is suggested to be understood in conjunction with Figure 12-7.</p>
|
||||
<p>Please note that <span class="arithmatex">\((m-l)\)</span> in the right subtree root index represents "the number of nodes in the left subtree." It may help to consult Figure 12-7 for a clearer understanding.</p>
|
||||
<p><a class="glightbox" href="../build_binary_tree_problem.assets/build_tree_division_pointers.png" data-type="image" data-width="100%" data-height="auto" data-desc-position="bottom"><img alt="Indexes of the root node and left and right subtrees" class="animation-figure" src="../build_binary_tree_problem.assets/build_tree_division_pointers.png" /></a></p>
|
||||
<p align="center"> Figure 12-7 Indexes of the root node and left and right subtrees </p>
|
||||
|
||||
<h3 id="4-code-implementation">4. Code implementation<a class="headerlink" href="#4-code-implementation" title="Permanent link">¶</a></h3>
|
||||
<p>To improve the efficiency of querying <span class="arithmatex">\(m\)</span>, we use a hash table <code>hmap</code> to store the mapping of elements in <code>inorder</code> to their indexes:</p>
|
||||
<p>To improve the efficiency of querying <span class="arithmatex">\(m\)</span>, we use a hash table <code>hmap</code> to store the mapping from elements in the <code>inorder</code> sequence to their indexes:</p>
|
||||
<div class="tabbed-set tabbed-alternate" data-tabs="1:14"><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" /><input id="__tabbed_1_13" name="__tabbed_1" type="radio" /><input id="__tabbed_1_14" name="__tabbed_1" type="radio" /><div class="tabbed-labels"><label for="__tabbed_1_1">Python</label><label for="__tabbed_1_2">C++</label><label for="__tabbed_1_3">Java</label><label for="__tabbed_1_4">C#</label><label for="__tabbed_1_5">Go</label><label for="__tabbed_1_6">Swift</label><label for="__tabbed_1_7">JS</label><label for="__tabbed_1_8">TS</label><label for="__tabbed_1_9">Dart</label><label for="__tabbed_1_10">Rust</label><label for="__tabbed_1_11">C</label><label for="__tabbed_1_12">Kotlin</label><label for="__tabbed_1_13">Ruby</label><label for="__tabbed_1_14">Zig</label></div>
|
||||
<div class="tabbed-content">
|
||||
<div class="tabbed-block">
|
||||
@@ -3855,7 +3855,7 @@
|
||||
</div>
|
||||
</div>
|
||||
</div>
|
||||
<p>Figure 12-8 shows the recursive process of building the binary tree, where each node is established during the "descending" process, and each edge (reference) is established during the "ascending" process.</p>
|
||||
<p>Figure 12-8 shows the recursive process of building the binary tree. Each node is created during the "descending" phase of the recursion, and each edge (reference) is formed during the "ascending" phase.</p>
|
||||
<div class="tabbed-set tabbed-alternate" data-tabs="2:9"><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" /><div class="tabbed-labels"><label for="__tabbed_2_1"><1></label><label for="__tabbed_2_2"><2></label><label for="__tabbed_2_3"><3></label><label for="__tabbed_2_4"><4></label><label for="__tabbed_2_5"><5></label><label for="__tabbed_2_6"><6></label><label for="__tabbed_2_7"><7></label><label for="__tabbed_2_8"><8></label><label for="__tabbed_2_9"><9></label></div>
|
||||
<div class="tabbed-content">
|
||||
<div class="tabbed-block">
|
||||
@@ -3889,12 +3889,12 @@
|
||||
</div>
|
||||
<p align="center"> Figure 12-8 Recursive process of building a binary tree </p>
|
||||
|
||||
<p>Each recursive function's division results of <code>preorder</code> and <code>inorder</code> are shown in Figure 12-9.</p>
|
||||
<p><a class="glightbox" href="../build_binary_tree_problem.assets/built_tree_overall.png" data-type="image" data-width="100%" data-height="auto" data-desc-position="bottom"><img alt="Division results in each recursive function" class="animation-figure" src="../build_binary_tree_problem.assets/built_tree_overall.png" /></a></p>
|
||||
<p align="center"> Figure 12-9 Division results in each recursive function </p>
|
||||
<p>Each recursive function's division of the <code>preorder</code> and <code>inorder</code> sequences is illustrated in Figure 12-9.</p>
|
||||
<p><a class="glightbox" href="../build_binary_tree_problem.assets/built_tree_overall.png" data-type="image" data-width="100%" data-height="auto" data-desc-position="bottom"><img alt="Division in each recursive function" class="animation-figure" src="../build_binary_tree_problem.assets/built_tree_overall.png" /></a></p>
|
||||
<p align="center"> Figure 12-9 Division in each recursive function </p>
|
||||
|
||||
<p>Assuming the number of nodes in the tree is <span class="arithmatex">\(n\)</span>, initializing each node (executing a recursive function <code>dfs()</code>) takes <span class="arithmatex">\(O(1)\)</span> time. <strong>Thus, the overall time complexity is <span class="arithmatex">\(O(n)\)</span></strong>.</p>
|
||||
<p>The hash table stores the mapping of <code>inorder</code> elements to their indexes, with a space complexity of <span class="arithmatex">\(O(n)\)</span>. In the worst case, when the binary tree degenerates into a linked list, the recursive depth reaches <span class="arithmatex">\(n\)</span>, using <span class="arithmatex">\(O(n)\)</span> stack frame space. <strong>Therefore, the overall space complexity is <span class="arithmatex">\(O(n)\)</span></strong>.</p>
|
||||
<p>Assuming the binary tree has <span class="arithmatex">\(n\)</span> nodes, initializing each node (calling the recursive function <code>dfs()</code>) takes <span class="arithmatex">\(O(1)\)</span> time. <strong>Therefore, the overall time complexity is <span class="arithmatex">\(O(n)\)</span></strong>.</p>
|
||||
<p>Because the hash table stores the mapping from <code>inorder</code> elements to their indexes, it requires <span class="arithmatex">\(O(n)\)</span> space. In the worst case, if the binary tree degenerates into a linked list, the recursive depth can reach <span class="arithmatex">\(n\)</span>, consuming <span class="arithmatex">\(O(n)\)</span> stack space. <strong>Hence, the overall space complexity is <span class="arithmatex">\(O(n)\)</span></strong>.</p>
|
||||
|
||||
<!-- Source file information -->
|
||||
|
||||
|
||||
@@ -2630,13 +2630,13 @@
|
||||
</li>
|
||||
|
||||
<li class="md-nav__item">
|
||||
<a href="#1212-improving-efficiency-through-divide-and-conquer" class="md-nav__link">
|
||||
<a href="#1212-improve-efficiency-through-divide-and-conquer" class="md-nav__link">
|
||||
<span class="md-ellipsis">
|
||||
12.1.2 Improving efficiency through divide and conquer
|
||||
12.1.2 Improve efficiency through divide and conquer
|
||||
</span>
|
||||
</a>
|
||||
|
||||
<nav class="md-nav" aria-label="12.1.2 Improving efficiency through divide and conquer">
|
||||
<nav class="md-nav" aria-label="12.1.2 Improve efficiency through divide and conquer">
|
||||
<ul class="md-nav__list">
|
||||
|
||||
<li class="md-nav__item">
|
||||
@@ -3572,13 +3572,13 @@
|
||||
</li>
|
||||
|
||||
<li class="md-nav__item">
|
||||
<a href="#1212-improving-efficiency-through-divide-and-conquer" class="md-nav__link">
|
||||
<a href="#1212-improve-efficiency-through-divide-and-conquer" class="md-nav__link">
|
||||
<span class="md-ellipsis">
|
||||
12.1.2 Improving efficiency through divide and conquer
|
||||
12.1.2 Improve efficiency through divide and conquer
|
||||
</span>
|
||||
</a>
|
||||
|
||||
<nav class="md-nav" aria-label="12.1.2 Improving efficiency through divide and conquer">
|
||||
<nav class="md-nav" aria-label="12.1.2 Improve efficiency through divide and conquer">
|
||||
<ul class="md-nav__list">
|
||||
|
||||
<li class="md-nav__item">
|
||||
@@ -3650,10 +3650,10 @@
|
||||
|
||||
<!-- Page content -->
|
||||
<h1 id="121-divide-and-conquer-algorithms">12.1 Divide and conquer algorithms<a class="headerlink" href="#121-divide-and-conquer-algorithms" title="Permanent link">¶</a></h1>
|
||||
<p><u>Divide and conquer</u>, fully referred to as "divide and rule", is an extremely important and common algorithm strategy. Divide and conquer is usually based on recursion and includes two steps: "divide" and "conquer".</p>
|
||||
<p><u>Divide and conquer</u> is an important and popular algorithm strategy. As the name suggests, the algorithm is typically implemented recursively and consists of two steps: "divide" and "conquer".</p>
|
||||
<ol>
|
||||
<li><strong>Divide (partition phase)</strong>: Recursively decompose the original problem into two or more sub-problems until the smallest sub-problem is reached and the process terminates.</li>
|
||||
<li><strong>Conquer (merge phase)</strong>: Starting from the smallest sub-problem with a known solution, merge the solutions of the sub-problems from bottom to top to construct the solution to the original problem.</li>
|
||||
<li><strong>Divide (partition phase)</strong>: Recursively break down the original problem into two or more smaller sub-problems until the smallest sub-problem is reached.</li>
|
||||
<li><strong>Conquer (merge phase)</strong>: Starting from the smallest sub-problem with known solution, we construct the solution to the original problem by merging the solutions of sub-problems in a bottom-up manner.</li>
|
||||
</ol>
|
||||
<p>As shown in Figure 12-1, "merge sort" is one of the typical applications of the divide and conquer strategy.</p>
|
||||
<ol>
|
||||
@@ -3664,30 +3664,30 @@
|
||||
<p align="center"> Figure 12-1 Merge sort's divide and conquer strategy </p>
|
||||
|
||||
<h2 id="1211-how-to-identify-divide-and-conquer-problems">12.1.1 How to identify divide and conquer problems<a class="headerlink" href="#1211-how-to-identify-divide-and-conquer-problems" title="Permanent link">¶</a></h2>
|
||||
<p>Whether a problem is suitable for a divide and conquer solution can usually be judged based on the following criteria.</p>
|
||||
<p>Whether a problem is suitable for a divide-and-conquer solution can usually be decided based on the following criteria.</p>
|
||||
<ol>
|
||||
<li><strong>The problem can be decomposed</strong>: The original problem can be decomposed into smaller, similar sub-problems and can be recursively divided in the same manner.</li>
|
||||
<li><strong>The problem can be broken down into smaller ones</strong>: The original problem can be divided into smaller, similar sub-problems and such process can be recursively done in the same manner.</li>
|
||||
<li><strong>Sub-problems are independent</strong>: There is no overlap between sub-problems, and they are independent and can be solved separately.</li>
|
||||
<li><strong>Solutions to sub-problems can be merged</strong>: The solution to the original problem is obtained by merging the solutions of the sub-problems.</li>
|
||||
<li><strong>Solutions to sub-problems can be merged</strong>: The solution to the original problem is derived by combining the solutions of the sub-problems.</li>
|
||||
</ol>
|
||||
<p>Clearly, merge sort meets these three criteria.</p>
|
||||
<ol>
|
||||
<li><strong>The problem can be decomposed</strong>: Recursively divide the array (original problem) into two sub-arrays (sub-problems).</li>
|
||||
<li><strong>The problem can be broken down into smaller ones</strong>: Recursively divide the array (original problem) into two sub-arrays (sub-problems).</li>
|
||||
<li><strong>Sub-problems are independent</strong>: Each sub-array can be sorted independently (sub-problems can be solved independently).</li>
|
||||
<li><strong>Solutions to sub-problems can be merged</strong>: Two ordered sub-arrays (solutions to the sub-problems) can be merged into one ordered array (solution to the original problem).</li>
|
||||
</ol>
|
||||
<h2 id="1212-improving-efficiency-through-divide-and-conquer">12.1.2 Improving efficiency through divide and conquer<a class="headerlink" href="#1212-improving-efficiency-through-divide-and-conquer" title="Permanent link">¶</a></h2>
|
||||
<p><strong>Divide and conquer can not only effectively solve algorithm problems but often also improve algorithm efficiency</strong>. In sorting algorithms, quicksort, merge sort, and heap sort are faster than selection, bubble, and insertion sorts because they apply the divide and conquer strategy.</p>
|
||||
<p>Then, we may ask: <strong>Why can divide and conquer improve algorithm efficiency, and what is the underlying logic?</strong> In other words, why are the steps of decomposing a large problem into multiple sub-problems, solving the sub-problems, and merging the solutions of the sub-problems into the solution of the original problem more efficient than directly solving the original problem? This question can be discussed from the aspects of the number of operations and parallel computation.</p>
|
||||
<h2 id="1212-improve-efficiency-through-divide-and-conquer">12.1.2 Improve efficiency through divide and conquer<a class="headerlink" href="#1212-improve-efficiency-through-divide-and-conquer" title="Permanent link">¶</a></h2>
|
||||
<p>The <strong>divide-and-conquer strategy not only effectively solves algorithm problems but also often enhances efficiency</strong>. In sorting algorithms, quick sort, merge sort, and heap sort are faster than selection sort, bubble sort, and insertion sort because they apply the divide-and-conquer strategy.</p>
|
||||
<p>We may have a question in mind: <strong>Why can divide and conquer improve algorithm efficiency, and what is the underlying logic?</strong> In other words, why is breaking a problem into sub-problems, solving them, and combining their solutions to address the original problem offer more efficiency than directly solving the original problem? This question can be analyzed from two aspects: operation count and parallel computation.</p>
|
||||
<h3 id="1-optimization-of-operation-count">1. Optimization of operation count<a class="headerlink" href="#1-optimization-of-operation-count" title="Permanent link">¶</a></h3>
|
||||
<p>Taking "bubble sort" as an example, it requires <span class="arithmatex">\(O(n^2)\)</span> time to process an array of length <span class="arithmatex">\(n\)</span>. Suppose we divide the array from the midpoint into two sub-arrays as shown in Figure 12-2, then the division requires <span class="arithmatex">\(O(n)\)</span> time, sorting each sub-array requires <span class="arithmatex">\(O((n / 2)^2)\)</span> time, and merging the two sub-arrays requires <span class="arithmatex">\(O(n)\)</span> time, with the total time complexity being:</p>
|
||||
<p>Taking "bubble sort" as an example, it requires <span class="arithmatex">\(O(n^2)\)</span> time to process an array of length <span class="arithmatex">\(n\)</span>. Suppose we divide the array from the midpoint into two sub-arrays as shown in Figure 12-2, such division requires <span class="arithmatex">\(O(n)\)</span> time. Sorting each sub-array requires <span class="arithmatex">\(O((n / 2)^2)\)</span> time. And merging the two sub-arrays requires <span class="arithmatex">\(O(n)\)</span> time. Thus, the overall time complexity is:</p>
|
||||
<div class="arithmatex">\[
|
||||
O(n + (\frac{n}{2})^2 \times 2 + n) = O(\frac{n^2}{2} + 2n)
|
||||
\]</div>
|
||||
<p><a class="glightbox" href="../divide_and_conquer.assets/divide_and_conquer_bubble_sort.png" data-type="image" data-width="100%" data-height="auto" data-desc-position="bottom"><img alt="Bubble sort before and after array partition" class="animation-figure" src="../divide_and_conquer.assets/divide_and_conquer_bubble_sort.png" /></a></p>
|
||||
<p align="center"> Figure 12-2 Bubble sort before and after array partition </p>
|
||||
|
||||
<p>Next, we calculate the following inequality, where the left and right sides are the total number of operations before and after the partition, respectively:</p>
|
||||
<p>Let's calculate the following inequality, where the left side represents the total number of operations before division and the right side represents the total number of operations after division, respectively:</p>
|
||||
<div class="arithmatex">\[
|
||||
\begin{aligned}
|
||||
n^2 & > \frac{n^2}{2} + 2n \newline
|
||||
@@ -3695,34 +3695,34 @@ n^2 - \frac{n^2}{2} - 2n & > 0 \newline
|
||||
n(n - 4) & > 0
|
||||
\end{aligned}
|
||||
\]</div>
|
||||
<p><strong>This means that when <span class="arithmatex">\(n > 4\)</span>, the number of operations after partitioning is fewer, and the sorting efficiency should be higher</strong>. Please note that the time complexity after partitioning is still quadratic <span class="arithmatex">\(O(n^2)\)</span>, but the constant factor in the complexity has decreased.</p>
|
||||
<p>Further, <strong>what if we keep dividing the sub-arrays from their midpoints into two sub-arrays</strong> until the sub-arrays have only one element left? This idea is actually "merge sort," with a time complexity of <span class="arithmatex">\(O(n \log n)\)</span>.</p>
|
||||
<p>Furthermore, <strong>what if we set several more partition points</strong> and evenly divide the original array into <span class="arithmatex">\(k\)</span> sub-arrays? This situation is very similar to "bucket sort," which is very suitable for sorting massive data, and theoretically, the time complexity can reach <span class="arithmatex">\(O(n + k)\)</span>.</p>
|
||||
<p><strong>This means that when <span class="arithmatex">\(n > 4\)</span>, the number of operations after partitioning is fewer, leading to better performance</strong>. Please note that the time complexity after partitioning is still quadratic <span class="arithmatex">\(O(n^2)\)</span>, but the constant factor in the complexity has decreased.</p>
|
||||
<p>We can go even further. <strong>How about keeping dividing the sub-arrays from their midpoints into two sub-arrays</strong> until the sub-arrays have only one element left? This idea is actually "merge sort," with a time complexity of <span class="arithmatex">\(O(n \log n)\)</span>.</p>
|
||||
<p>Let's try something a bit different again. <strong>How about splitting into more partitions instead of just two?</strong> For example, we evenly divide the original array into <span class="arithmatex">\(k\)</span> sub-arrays? This approach is very similar to "bucket sort," which is very suitable for sorting massive data. Theoretically, the time complexity can reach <span class="arithmatex">\(O(n + k)\)</span>.</p>
|
||||
<h3 id="2-optimization-through-parallel-computation">2. Optimization through parallel computation<a class="headerlink" href="#2-optimization-through-parallel-computation" title="Permanent link">¶</a></h3>
|
||||
<p>We know that the sub-problems generated by divide and conquer are independent of each other, <strong>thus they can usually be solved in parallel</strong>. This means that divide and conquer can not only reduce the algorithm's time complexity, <strong>but also facilitate parallel optimization by the operating system</strong>.</p>
|
||||
<p>Parallel optimization is especially effective in environments with multiple cores or processors, as the system can process multiple sub-problems simultaneously, making fuller use of computing resources and significantly reducing the overall runtime.</p>
|
||||
<p>For example, in the "bucket sort" shown in Figure 12-3, we distribute massive data evenly across various buckets, then the sorting tasks of all buckets can be distributed to different computing units, and the results are merged after completion.</p>
|
||||
<p>We know that the sub-problems generated by divide and conquer are independent of each other, <strong>which means that they can be solved in parallel.</strong> As a result, divide and conquer not only reduces the algorithm's time complexity, <strong>but also facilitates parallel optimization by modern operating systems.</strong></p>
|
||||
<p>Parallel optimization is particularly effective in environments with multiple cores or processors. As the system can process multiple sub-problems simultaneously, fully utilizing computing resources, the overall runtime is significantly reduced.</p>
|
||||
<p>For example, in the "bucket sort" shown in Figure 12-3, we break massive data evenly into various buckets. The jobs of sorting each bucket can be allocated to available computing units. Once all jobs are done, all sorted buckets are merged to produce the final result.</p>
|
||||
<p><a class="glightbox" href="../divide_and_conquer.assets/divide_and_conquer_parallel_computing.png" data-type="image" data-width="100%" data-height="auto" data-desc-position="bottom"><img alt="Bucket sort's parallel computation" class="animation-figure" src="../divide_and_conquer.assets/divide_and_conquer_parallel_computing.png" /></a></p>
|
||||
<p align="center"> Figure 12-3 Bucket sort's parallel computation </p>
|
||||
|
||||
<h2 id="1213-common-applications-of-divide-and-conquer">12.1.3 Common applications of divide and conquer<a class="headerlink" href="#1213-common-applications-of-divide-and-conquer" title="Permanent link">¶</a></h2>
|
||||
<p>On one hand, divide and conquer can be used to solve many classic algorithm problems.</p>
|
||||
<p>Divide and conquer can be used to solve many classic algorithm problems.</p>
|
||||
<ul>
|
||||
<li><strong>Finding the closest point pair</strong>: This algorithm first divides the set of points into two parts, then finds the closest point pair in each part, and finally finds the closest point pair that spans the two parts.</li>
|
||||
<li><strong>Large integer multiplication</strong>: For example, the Karatsuba algorithm, which breaks down large integer multiplication into several smaller integer multiplications and additions.</li>
|
||||
<li><strong>Matrix multiplication</strong>: For example, the Strassen algorithm, which decomposes large matrix multiplication into multiple small matrix multiplications and additions.</li>
|
||||
<li><strong>Tower of Hanoi problem</strong>: The Tower of Hanoi problem can be solved recursively, a typical application of the divide and conquer strategy.</li>
|
||||
<li><strong>Solving inverse pairs</strong>: In a sequence, if a number in front is greater than a number behind, these two numbers form an inverse pair. Solving the inverse pair problem can utilize the idea of divide and conquer, with the aid of merge sort.</li>
|
||||
<li><strong>Finding the closest pair of points</strong>: This algorithm works by dividing the set of points into two halves. Then it recursively finds the closest pair in each half. Finally it considers pairs that span the two halves to find the overall closest pair.</li>
|
||||
<li><strong>Large integer multiplication</strong>: One algorithm is called Karatsuba. It breaks down large integer multiplication into several smaller integer multiplications and additions.</li>
|
||||
<li><strong>Matrix multiplication</strong>: One example is the Strassen algorithm. It breaks down a large matrix multiplication into multiple small matrix multiplications and additions.</li>
|
||||
<li><strong>Tower of Hanoi problem</strong>: The Tower of Hanoi problem can be solved recursively, a typical application of the divide-and-conquer strategy.</li>
|
||||
<li><strong>Solving inversion pairs</strong>: In a sequence, if a preceding number is greater than a following number, then these two numbers constitute an inversion pair. Solving inversion pair problem can utilize the idea of divide and conquer, with the aid of merge sort.</li>
|
||||
</ul>
|
||||
<p>On the other hand, divide and conquer is very widely applied in the design of algorithms and data structures.</p>
|
||||
<p>Divide and conquer is also widely applied in the design of algorithms and data structures.</p>
|
||||
<ul>
|
||||
<li><strong>Binary search</strong>: Binary search divides an ordered array from the midpoint index into two parts, then decides which half to exclude based on the comparison result between the target value and the middle element value, and performs the same binary operation in the remaining interval.</li>
|
||||
<li><strong>Binary search</strong>: Binary search divides a sorted array into two halves from the midpoint index. And then based on the comparison result between the target value and the middle element value, one half is discarded. The search continues on the remaining half with the same process until the target is found or there is no remaining element.</li>
|
||||
<li><strong>Merge sort</strong>: Already introduced at the beginning of this section, no further elaboration is needed.</li>
|
||||
<li><strong>Quicksort</strong>: Quicksort selects a pivot value, then divides the array into two sub-arrays, one with elements smaller than the pivot and the other with elements larger than the pivot, and then performs the same partitioning operation on these two parts until the sub-array has only one element.</li>
|
||||
<li><strong>Bucket sort</strong>: The basic idea of bucket sort is to distribute data to multiple buckets, then sort the elements within each bucket, and finally retrieve the elements from the buckets in order to obtain an ordered array.</li>
|
||||
<li><strong>Trees</strong>: For example, binary search trees, AVL trees, red-black trees, B-trees, B+ trees, etc., their operations such as search, insertion, and deletion can all be considered applications of the divide and conquer strategy.</li>
|
||||
<li><strong>Heap</strong>: A heap is a special type of complete binary tree, whose various operations, such as insertion, deletion, and heapification, actually imply the idea of divide and conquer.</li>
|
||||
<li><strong>Hash table</strong>: Although hash tables do not directly apply divide and conquer, some hash collision resolution solutions indirectly apply the divide and conquer strategy, for example, long lists in chained addressing being converted to red-black trees to improve query efficiency.</li>
|
||||
<li><strong>Quicksort</strong>: Quicksort picks a pivot value to divide the array into two sub-arrays, one with elements smaller than the pivot and the other with elements larger than the pivot. Such process goes on against each of these two sub-arrays until they hold only one element.</li>
|
||||
<li><strong>Bucket sort</strong>: The basic idea of bucket sort is to distribute data to multiple buckets. After sorting the elements within each bucket, retrieve the elements from the buckets in order to obtain an ordered array.</li>
|
||||
<li><strong>Trees</strong>: For example, binary search trees, AVL trees, red-black trees, B-trees, and B+ trees, etc. Their operations, such as search, insertion, and deletion, can all be regarded as applications of the divide-and-conquer strategy.</li>
|
||||
<li><strong>Heap</strong>: A heap is a special type of complete binary tree. Its various operations, such as insertion, deletion, and heapify, actually imply the idea of divide and conquer.</li>
|
||||
<li><strong>Hash table</strong>: Although hash tables do not directly apply divide and conquer, some hash collision resolution solutions indirectly apply the strategy. For example, long lists in chained addressing may be converted to red-black trees to improve query efficiency.</li>
|
||||
</ul>
|
||||
<p>It can be seen that <strong>divide and conquer is a subtly pervasive algorithmic idea</strong>, embedded within various algorithms and data structures.</p>
|
||||
|
||||
|
||||
@@ -2684,9 +2684,9 @@
|
||||
<ul class="md-nav__list" data-md-component="toc" data-md-scrollfix>
|
||||
|
||||
<li class="md-nav__item">
|
||||
<a href="#1-consider-the-base-case" class="md-nav__link">
|
||||
<a href="#1-consider-the-base-cases" class="md-nav__link">
|
||||
<span class="md-ellipsis">
|
||||
1. Consider the base case
|
||||
1. Consider the base cases
|
||||
</span>
|
||||
</a>
|
||||
|
||||
@@ -3539,9 +3539,9 @@
|
||||
<ul class="md-nav__list" data-md-component="toc" data-md-scrollfix>
|
||||
|
||||
<li class="md-nav__item">
|
||||
<a href="#1-consider-the-base-case" class="md-nav__link">
|
||||
<a href="#1-consider-the-base-cases" class="md-nav__link">
|
||||
<span class="md-ellipsis">
|
||||
1. Consider the base case
|
||||
1. Consider the base cases
|
||||
</span>
|
||||
</a>
|
||||
|
||||
@@ -3602,12 +3602,12 @@
|
||||
|
||||
<!-- Page content -->
|
||||
<h1 id="124-tower-of-hanoi-problem">12.4 Tower of Hanoi Problem<a class="headerlink" href="#124-tower-of-hanoi-problem" title="Permanent link">¶</a></h1>
|
||||
<p>In both merge sorting and building binary trees, we decompose the original problem into two subproblems, each half the size of the original problem. However, for the Tower of Hanoi, we adopt a different decomposition strategy.</p>
|
||||
<p>In both merge sort and binary tree construction, we break the original problem into two subproblems, each half the size of the original problem. However, for the Tower of Hanoi, we adopt a different decomposition strategy.</p>
|
||||
<div class="admonition question">
|
||||
<p class="admonition-title">Question</p>
|
||||
<p>Given three pillars, denoted as <code>A</code>, <code>B</code>, and <code>C</code>. Initially, pillar <code>A</code> is stacked with <span class="arithmatex">\(n\)</span> discs, arranged in order from top to bottom from smallest to largest. Our task is to move these <span class="arithmatex">\(n\)</span> discs to pillar <code>C</code>, maintaining their original order (as shown in Figure 12-10). The following rules must be followed during the disc movement process:</p>
|
||||
<p>We are given three pillars, denoted as <code>A</code>, <code>B</code>, and <code>C</code>. Initially, pillar <code>A</code> has <span class="arithmatex">\(n\)</span> discs, arranged from top to bottom in ascending size. Our task is to move these <span class="arithmatex">\(n\)</span> discs to pillar <code>C</code>, maintaining their original order (as shown in Figure 12-10). The following rules apply during the movement:</p>
|
||||
<ol>
|
||||
<li>A disc can only be picked up from the top of a pillar and placed on top of another pillar.</li>
|
||||
<li>A disc can be removed only from the top of a pillar and must be placed on the top of another pillar.</li>
|
||||
<li>Only one disc can be moved at a time.</li>
|
||||
<li>A smaller disc must always be on top of a larger disc.</li>
|
||||
</ol>
|
||||
@@ -3615,9 +3615,9 @@
|
||||
<p><a class="glightbox" href="../hanota_problem.assets/hanota_example.png" data-type="image" data-width="100%" data-height="auto" data-desc-position="bottom"><img alt="Example of the Tower of Hanoi" class="animation-figure" src="../hanota_problem.assets/hanota_example.png" /></a></p>
|
||||
<p align="center"> Figure 12-10 Example of the Tower of Hanoi </p>
|
||||
|
||||
<p><strong>We denote the Tower of Hanoi of size <span class="arithmatex">\(i\)</span> as <span class="arithmatex">\(f(i)\)</span></strong>. For example, <span class="arithmatex">\(f(3)\)</span> represents the Tower of Hanoi of moving <span class="arithmatex">\(3\)</span> discs from <code>A</code> to <code>C</code>.</p>
|
||||
<h3 id="1-consider-the-base-case">1. Consider the base case<a class="headerlink" href="#1-consider-the-base-case" title="Permanent link">¶</a></h3>
|
||||
<p>As shown in Figure 12-11, for the problem <span class="arithmatex">\(f(1)\)</span>, i.e., when there is only one disc, we can directly move it from <code>A</code> to <code>C</code>.</p>
|
||||
<p><strong>We denote the Tower of Hanoi problem of size <span class="arithmatex">\(i\)</span> as <span class="arithmatex">\(f(i)\)</span></strong>. For example, <span class="arithmatex">\(f(3)\)</span> represents moving <span class="arithmatex">\(3\)</span> discs from pillar <code>A</code> to pillar <code>C</code>.</p>
|
||||
<h3 id="1-consider-the-base-cases">1. Consider the base cases<a class="headerlink" href="#1-consider-the-base-cases" title="Permanent link">¶</a></h3>
|
||||
<p>As shown in Figure 12-11, for the problem <span class="arithmatex">\(f(1)\)</span>—which has only one disc—we can directly move it from <code>A</code> to <code>C</code>.</p>
|
||||
<div class="tabbed-set tabbed-alternate" data-tabs="1:2"><input checked="checked" id="__tabbed_1_1" name="__tabbed_1" type="radio" /><input id="__tabbed_1_2" name="__tabbed_1" type="radio" /><div class="tabbed-labels"><label for="__tabbed_1_1"><1></label><label for="__tabbed_1_2"><2></label></div>
|
||||
<div class="tabbed-content">
|
||||
<div class="tabbed-block">
|
||||
@@ -3630,7 +3630,7 @@
|
||||
</div>
|
||||
<p align="center"> Figure 12-11 Solution for a problem of size 1 </p>
|
||||
|
||||
<p>As shown in Figure 12-12, for the problem <span class="arithmatex">\(f(2)\)</span>, i.e., when there are two discs, <strong>since the smaller disc must always be above the larger disc, <code>B</code> is needed to assist in the movement</strong>.</p>
|
||||
<p>For <span class="arithmatex">\(f(2)\)</span>—which has two discs—<strong>we rely on pillar <code>B</code> to help keep the smaller disc above the larger disc</strong>, as illustrated in the following figure:</p>
|
||||
<ol>
|
||||
<li>First, move the smaller disc from <code>A</code> to <code>B</code>.</li>
|
||||
<li>Then move the larger disc from <code>A</code> to <code>C</code>.</li>
|
||||
@@ -3654,14 +3654,14 @@
|
||||
</div>
|
||||
<p align="center"> Figure 12-12 Solution for a problem of size 2 </p>
|
||||
|
||||
<p>The process of solving the problem <span class="arithmatex">\(f(2)\)</span> can be summarized as: <strong>moving two discs from <code>A</code> to <code>C</code> with the help of <code>B</code></strong>. Here, <code>C</code> is called the target pillar, and <code>B</code> is called the buffer pillar.</p>
|
||||
<p>The process of solving <span class="arithmatex">\(f(2)\)</span> can be summarized as: <strong>moving two discs from <code>A</code> to <code>C</code> with the help of <code>B</code></strong>. Here, <code>C</code> is called the target pillar, and <code>B</code> is called the buffer pillar.</p>
|
||||
<h3 id="2-decomposition-of-subproblems">2. Decomposition of subproblems<a class="headerlink" href="#2-decomposition-of-subproblems" title="Permanent link">¶</a></h3>
|
||||
<p>For the problem <span class="arithmatex">\(f(3)\)</span>, i.e., when there are three discs, the situation becomes slightly more complicated.</p>
|
||||
<p>Since we already know the solutions to <span class="arithmatex">\(f(1)\)</span> and <span class="arithmatex">\(f(2)\)</span>, we can think from a divide-and-conquer perspective and <strong>consider the two top discs on <code>A</code> as a unit</strong>, performing the steps shown in Figure 12-13. This way, the three discs are successfully moved from <code>A</code> to <code>C</code>.</p>
|
||||
<p>For the problem <span class="arithmatex">\(f(3)\)</span>—that is, when there are three discs—the situation becomes slightly more complicated.</p>
|
||||
<p>Since we already know the solutions to <span class="arithmatex">\(f(1)\)</span> and <span class="arithmatex">\(f(2)\)</span>, we can adopt a divide-and-conquer perspective and <strong>treat the top two discs on <code>A</code> as a single unit</strong>, performing the steps shown in Figure 12-13. This allows the three discs to be successfully moved from <code>A</code> to <code>C</code>.</p>
|
||||
<ol>
|
||||
<li>Let <code>B</code> be the target pillar and <code>C</code> the buffer pillar, and move the two discs from <code>A</code> to <code>B</code>.</li>
|
||||
<li>Let <code>B</code> be the target pillar and <code>C</code> the buffer pillar, then move the two discs from <code>A</code> to <code>B</code>.</li>
|
||||
<li>Move the remaining disc from <code>A</code> directly to <code>C</code>.</li>
|
||||
<li>Let <code>C</code> be the target pillar and <code>A</code> the buffer pillar, and move the two discs from <code>B</code> to <code>C</code>.</li>
|
||||
<li>Let <code>C</code> be the target pillar and <code>A</code> the buffer pillar, then move the two discs from <code>B</code> to <code>C</code>.</li>
|
||||
</ol>
|
||||
<div class="tabbed-set tabbed-alternate" data-tabs="3:4"><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" /><div class="tabbed-labels"><label for="__tabbed_3_1"><1></label><label for="__tabbed_3_2"><2></label><label for="__tabbed_3_3"><3></label><label for="__tabbed_3_4"><4></label></div>
|
||||
<div class="tabbed-content">
|
||||
@@ -3681,19 +3681,19 @@
|
||||
</div>
|
||||
<p align="center"> Figure 12-13 Solution for a problem of size 3 </p>
|
||||
|
||||
<p>Essentially, <strong>we divide the problem <span class="arithmatex">\(f(3)\)</span> into two subproblems <span class="arithmatex">\(f(2)\)</span> and one subproblem <span class="arithmatex">\(f(1)\)</span></strong>. By solving these three subproblems in order, the original problem is resolved. This indicates that the subproblems are independent, and their solutions can be merged.</p>
|
||||
<p>From this, we can summarize the divide-and-conquer strategy for solving the Tower of Hanoi shown in Figure 12-14: divide the original problem <span class="arithmatex">\(f(n)\)</span> into two subproblems <span class="arithmatex">\(f(n-1)\)</span> and one subproblem <span class="arithmatex">\(f(1)\)</span>, and solve these three subproblems in the following order.</p>
|
||||
<p>Essentially, <strong>we decompose <span class="arithmatex">\(f(3)\)</span> into two <span class="arithmatex">\(f(2)\)</span> subproblems and one <span class="arithmatex">\(f(1)\)</span> subproblem</strong>. By solving these three subproblems in sequence, the original problem is solved, indicating that the subproblems are independent and their solutions can be merged.</p>
|
||||
<p>From this, we can summarize the divide-and-conquer strategy for the Tower of Hanoi, illustrated in Figure 12-14. We divide the original problem <span class="arithmatex">\(f(n)\)</span> into two subproblems <span class="arithmatex">\(f(n-1)\)</span> and one subproblem <span class="arithmatex">\(f(1)\)</span>, and solve these three subproblems in the following order:</p>
|
||||
<ol>
|
||||
<li>Move <span class="arithmatex">\(n-1\)</span> discs with the help of <code>C</code> from <code>A</code> to <code>B</code>.</li>
|
||||
<li>Move the remaining one disc directly from <code>A</code> to <code>C</code>.</li>
|
||||
<li>Move <span class="arithmatex">\(n-1\)</span> discs with the help of <code>A</code> from <code>B</code> to <code>C</code>.</li>
|
||||
<li>Move <span class="arithmatex">\(n-1\)</span> discs from <code>A</code> to <code>B</code>, using <code>C</code> as a buffer. </li>
|
||||
<li>Move the remaining disc directly from <code>A</code> to <code>C</code>.</li>
|
||||
<li>Move <span class="arithmatex">\(n-1\)</span> discs from <code>B</code> to <code>C</code>, using <code>A</code> as a buffer. </li>
|
||||
</ol>
|
||||
<p>For these two subproblems <span class="arithmatex">\(f(n-1)\)</span>, <strong>they can be recursively divided in the same manner</strong> until the smallest subproblem <span class="arithmatex">\(f(1)\)</span> is reached. The solution to <span class="arithmatex">\(f(1)\)</span> is already known and requires only one move.</p>
|
||||
<p><a class="glightbox" href="../hanota_problem.assets/hanota_divide_and_conquer.png" data-type="image" data-width="100%" data-height="auto" data-desc-position="bottom"><img alt="Divide and conquer strategy for solving the Tower of Hanoi" class="animation-figure" src="../hanota_problem.assets/hanota_divide_and_conquer.png" /></a></p>
|
||||
<p align="center"> Figure 12-14 Divide and conquer strategy for solving the Tower of Hanoi </p>
|
||||
<p>For each <span class="arithmatex">\(f(n-1)\)</span> subproblem, <strong>we can apply the same recursive partition</strong> until we reach the smallest subproblem <span class="arithmatex">\(f(1)\)</span>. Because <span class="arithmatex">\(f(1)\)</span> is already known to require just a single move, it is trivial to solve.</p>
|
||||
<p><a class="glightbox" href="../hanota_problem.assets/hanota_divide_and_conquer.png" data-type="image" data-width="100%" data-height="auto" data-desc-position="bottom"><img alt="Divide-and-conquer strategy for solving the Tower of Hanoi" class="animation-figure" src="../hanota_problem.assets/hanota_divide_and_conquer.png" /></a></p>
|
||||
<p align="center"> Figure 12-14 Divide-and-conquer strategy for solving the Tower of Hanoi </p>
|
||||
|
||||
<h3 id="3-code-implementation">3. Code implementation<a class="headerlink" href="#3-code-implementation" title="Permanent link">¶</a></h3>
|
||||
<p>In the code, we declare a recursive function <code>dfs(i, src, buf, tar)</code> whose role is to move the <span class="arithmatex">\(i\)</span> discs on top of pillar <code>src</code> with the help of buffer pillar <code>buf</code> to the target pillar <code>tar</code>:</p>
|
||||
<p>In the code, we define a recursive function <code>dfs(i, src, buf, tar)</code> which moves the top <span class="arithmatex">\(i\)</span> discs from pillar <code>src</code> to pillar <code>tar</code>, using pillar <code>buf</code> as a buffer:</p>
|
||||
<div class="tabbed-set tabbed-alternate" data-tabs="4:14"><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" /><input id="__tabbed_4_12" name="__tabbed_4" type="radio" /><input id="__tabbed_4_13" name="__tabbed_4" type="radio" /><input id="__tabbed_4_14" name="__tabbed_4" type="radio" /><div class="tabbed-labels"><label for="__tabbed_4_1">Python</label><label for="__tabbed_4_2">C++</label><label for="__tabbed_4_3">Java</label><label for="__tabbed_4_4">C#</label><label for="__tabbed_4_5">Go</label><label for="__tabbed_4_6">Swift</label><label for="__tabbed_4_7">JS</label><label for="__tabbed_4_8">TS</label><label for="__tabbed_4_9">Dart</label><label for="__tabbed_4_10">Rust</label><label for="__tabbed_4_11">C</label><label for="__tabbed_4_12">Kotlin</label><label for="__tabbed_4_13">Ruby</label><label for="__tabbed_4_14">Zig</label></div>
|
||||
<div class="tabbed-content">
|
||||
<div class="tabbed-block">
|
||||
@@ -3879,14 +3879,14 @@
|
||||
</div>
|
||||
</div>
|
||||
</div>
|
||||
<p>As shown in Figure 12-15, the Tower of Hanoi forms a recursive tree with a height of <span class="arithmatex">\(n\)</span>, each node representing a subproblem, corresponding to an open <code>dfs()</code> function, <strong>thus the time complexity is <span class="arithmatex">\(O(2^n)\)</span>, and the space complexity is <span class="arithmatex">\(O(n)\)</span></strong>.</p>
|
||||
<p>As shown in Figure 12-15, the Tower of Hanoi problem can be visualized as a recursive tree of height <span class="arithmatex">\(n\)</span>. Each node represents a subproblem, corresponding to a call to <code>dfs()</code>, <strong>Hence, the time complexity is <span class="arithmatex">\(O(2^n)\)</span>, and the space complexity is <span class="arithmatex">\(O(n)\)</span>.</strong></p>
|
||||
<p><a class="glightbox" href="../hanota_problem.assets/hanota_recursive_tree.png" data-type="image" data-width="100%" data-height="auto" data-desc-position="bottom"><img alt="Recursive tree of the Tower of Hanoi" class="animation-figure" src="../hanota_problem.assets/hanota_recursive_tree.png" /></a></p>
|
||||
<p align="center"> Figure 12-15 Recursive tree of the Tower of Hanoi </p>
|
||||
|
||||
<div class="admonition quote">
|
||||
<p class="admonition-title">Quote</p>
|
||||
<p>The Tower of Hanoi originates from an ancient legend. In a temple in ancient India, monks had three tall diamond pillars and <span class="arithmatex">\(64\)</span> differently sized golden discs. The monks continuously moved the discs, believing that when the last disc is correctly placed, the world would end.</p>
|
||||
<p>However, even if the monks moved a disc every second, it would take about <span class="arithmatex">\(2^{64} \approx 1.84×10^{19}\)</span> seconds, approximately 585 billion years, far exceeding current estimates of the age of the universe. Thus, if the legend is true, we probably do not need to worry about the world ending.</p>
|
||||
<p>The Tower of Hanoi originates from an ancient legend. In a temple in ancient India, monks had three tall diamond pillars and <span class="arithmatex">\(64\)</span> differently sized golden discs. They believed that when the last disc was correctly placed, the world would end.</p>
|
||||
<p>However, even if the monks moved one disc every second, it would take about <span class="arithmatex">\(2^{64} \approx 1.84×10^{19}\)</span> —approximately 585 billion years—far exceeding current estimates of the age of the universe. Thus, if the legend is true, we probably do not need to worry about the world ending.</p>
|
||||
</div>
|
||||
|
||||
<!-- Source file information -->
|
||||
|
||||
@@ -3520,8 +3520,8 @@
|
||||
<p><a class="glightbox" href="../assets/covers/chapter_divide_and_conquer.jpg" data-type="image" data-width="100%" data-height="auto" data-desc-position="bottom"><img alt="Divide and Conquer" class="cover-image" src="../assets/covers/chapter_divide_and_conquer.jpg" /></a></p>
|
||||
<div class="admonition abstract">
|
||||
<p class="admonition-title">Abstract</p>
|
||||
<p>Difficult problems are decomposed layer by layer, each decomposition making them simpler.</p>
|
||||
<p>Divide and conquer reveals an important truth: start with simplicity, and nothing is complex anymore.</p>
|
||||
<p>Difficult problems are decomposed layer by layer, with each decomposition making them simpler.</p>
|
||||
<p>Divide and conquer unveils a profound truth: begin with simplicity, and complexity dissolves.</p>
|
||||
</div>
|
||||
<h2 id="chapter-contents">Chapter contents<a class="headerlink" href="#chapter-contents" title="Permanent link">¶</a></h2>
|
||||
<ul>
|
||||
|
||||
@@ -3511,15 +3511,15 @@
|
||||
<!-- Page content -->
|
||||
<h1 id="125-summary">12.5 Summary<a class="headerlink" href="#125-summary" title="Permanent link">¶</a></h1>
|
||||
<ul>
|
||||
<li>Divide and conquer is a common algorithm design strategy, which includes dividing (partitioning) and conquering (merging) two stages, usually implemented based on recursion.</li>
|
||||
<li>The basis for judging whether it is a divide and conquer algorithm problem includes: whether the problem can be decomposed, whether the subproblems are independent, and whether the subproblems can be merged.</li>
|
||||
<li>Merge sort is a typical application of the divide and conquer strategy, which recursively divides the array into two equal-length subarrays until only one element remains, and then starts merging layer by layer to complete the sorting.</li>
|
||||
<li>Introducing the divide and conquer strategy can often improve algorithm efficiency. On one hand, the divide and conquer strategy reduces the number of operations; on the other hand, it is conducive to parallel optimization of the system after division.</li>
|
||||
<li>Divide and conquer can solve many algorithm problems and is widely used in data structure and algorithm design, where its presence is ubiquitous.</li>
|
||||
<li>Compared to brute force search, adaptive search is more efficient. Search algorithms with a time complexity of <span class="arithmatex">\(O(\log n)\)</span> are usually based on the divide and conquer strategy.</li>
|
||||
<li>Binary search is another typical application of the divide and conquer strategy, which does not include the step of merging the solutions of subproblems. We can implement binary search through recursive divide and conquer.</li>
|
||||
<li>In the problem of constructing binary trees, building the tree (original problem) can be divided into building the left and right subtree (subproblems), which can be achieved by partitioning the index intervals of the pre-order and in-order traversals.</li>
|
||||
<li>In the Tower of Hanoi problem, a problem of size <span class="arithmatex">\(n\)</span> can be divided into two subproblems of size <span class="arithmatex">\(n-1\)</span> and one subproblem of size <span class="arithmatex">\(1\)</span>. By solving these three subproblems in sequence, the original problem is consequently resolved.</li>
|
||||
<li>Divide and conquer is a common algorithm design strategy that consists of two stages—divide (partition) and conquer (merge)—and is generally implemented using recursion.</li>
|
||||
<li>To determine whether a problem is suited for a divide and conquer approach, we check if the problem can be decomposed, whether the subproblems are independent, and whether the subproblems can be merged.</li>
|
||||
<li>Merge sort is a typical example of the divide and conquer strategy. It recursively splits an array into two equal-length subarrays until only one element remains, and then merges these subarrays layer by layer to complete the sorting.</li>
|
||||
<li>Introducing the divide and conquer strategy often improves algorithm efficiency. On one hand, it reduces the number of operations; on the other hand, it facilitates parallel optimization of the system after division.</li>
|
||||
<li>Divide and conquer can be applied to numerous algorithmic problems and is widely used in data structures and algorithm design, appearing in many scenarios.</li>
|
||||
<li>Compared to brute force search, adaptive search is more efficient. Search algorithms with a time complexity of <span class="arithmatex">\(O(\log n)\)</span> are typically based on the divide and conquer strategy.</li>
|
||||
<li>Binary search is another classic application of the divide-and-conquer strategy. It does not involve merging subproblem solutions and can be implemented via a recursive divide-and-conquer approach.</li>
|
||||
<li>In the problem of constructing binary trees, building the tree (the original problem) can be divided into building the left subtree and right subtree (the subproblems). This can be achieved by partitioning the index ranges of the preorder and inorder traversals.</li>
|
||||
<li>In the Tower of Hanoi problem, a problem of size <span class="arithmatex">\(n\)</span> can be broken down into two subproblems of size <span class="arithmatex">\(n-1\)</span> and one subproblem of size <span class="arithmatex">\(1\)</span>. By solving these three subproblems in sequence, the original problem is resolved.</li>
|
||||
</ul>
|
||||
|
||||
<!-- Source file information -->
|
||||
|
||||
@@ -3521,7 +3521,7 @@
|
||||
<div class="admonition abstract">
|
||||
<p class="admonition-title">Abstract</p>
|
||||
<p>Streams merge into rivers, and rivers merge into the sea.</p>
|
||||
<p>Dynamic programming combines the solutions of small problems to solve bigger problems, step by step leading us to the solution.</p>
|
||||
<p>Dynamic programming weaves smaller problems’ solutions into larger ones, guiding us step by step toward the far shore—where the ultimate answer awaits.</p>
|
||||
</div>
|
||||
<h2 id="chapter-contents">Chapter contents<a class="headerlink" href="#chapter-contents" title="Permanent link">¶</a></h2>
|
||||
<ul>
|
||||
|
||||
+133
-133
@@ -1796,28 +1796,28 @@
|
||||
<ul class="md-nav__list" data-md-component="toc" data-md-scrollfix>
|
||||
|
||||
<li class="md-nav__item">
|
||||
<a href="#811-common-operations-on-heaps" class="md-nav__link">
|
||||
<a href="#811-common-heap-operations" class="md-nav__link">
|
||||
<span class="md-ellipsis">
|
||||
8.1.1 Common operations on heaps
|
||||
8.1.1 Common heap operations
|
||||
</span>
|
||||
</a>
|
||||
|
||||
</li>
|
||||
|
||||
<li class="md-nav__item">
|
||||
<a href="#812-implementation-of-heaps" class="md-nav__link">
|
||||
<a href="#812-implementation-of-the-heap" class="md-nav__link">
|
||||
<span class="md-ellipsis">
|
||||
8.1.2 Implementation of heaps
|
||||
8.1.2 Implementation of the heap
|
||||
</span>
|
||||
</a>
|
||||
|
||||
<nav class="md-nav" aria-label="8.1.2 Implementation of heaps">
|
||||
<nav class="md-nav" aria-label="8.1.2 Implementation of the heap">
|
||||
<ul class="md-nav__list">
|
||||
|
||||
<li class="md-nav__item">
|
||||
<a href="#1-storage-and-representation-of-heaps" class="md-nav__link">
|
||||
<a href="#1-heap-storage-and-representation" class="md-nav__link">
|
||||
<span class="md-ellipsis">
|
||||
1. Storage and representation of heaps
|
||||
1. Heap storage and representation
|
||||
</span>
|
||||
</a>
|
||||
|
||||
@@ -3581,28 +3581,28 @@
|
||||
<ul class="md-nav__list" data-md-component="toc" data-md-scrollfix>
|
||||
|
||||
<li class="md-nav__item">
|
||||
<a href="#811-common-operations-on-heaps" class="md-nav__link">
|
||||
<a href="#811-common-heap-operations" class="md-nav__link">
|
||||
<span class="md-ellipsis">
|
||||
8.1.1 Common operations on heaps
|
||||
8.1.1 Common heap operations
|
||||
</span>
|
||||
</a>
|
||||
|
||||
</li>
|
||||
|
||||
<li class="md-nav__item">
|
||||
<a href="#812-implementation-of-heaps" class="md-nav__link">
|
||||
<a href="#812-implementation-of-the-heap" class="md-nav__link">
|
||||
<span class="md-ellipsis">
|
||||
8.1.2 Implementation of heaps
|
||||
8.1.2 Implementation of the heap
|
||||
</span>
|
||||
</a>
|
||||
|
||||
<nav class="md-nav" aria-label="8.1.2 Implementation of heaps">
|
||||
<nav class="md-nav" aria-label="8.1.2 Implementation of the heap">
|
||||
<ul class="md-nav__list">
|
||||
|
||||
<li class="md-nav__item">
|
||||
<a href="#1-storage-and-representation-of-heaps" class="md-nav__link">
|
||||
<a href="#1-heap-storage-and-representation" class="md-nav__link">
|
||||
<span class="md-ellipsis">
|
||||
1. Storage and representation of heaps
|
||||
1. Heap storage and representation
|
||||
</span>
|
||||
</a>
|
||||
|
||||
@@ -3686,24 +3686,24 @@
|
||||
|
||||
<!-- Page content -->
|
||||
<h1 id="81-heap">8.1 Heap<a class="headerlink" href="#81-heap" title="Permanent link">¶</a></h1>
|
||||
<p>A <u>heap</u> is a complete binary tree that satisfies specific conditions and can be mainly divided into two types, as shown in Figure 8-1.</p>
|
||||
<p>A <u>heap</u> is a complete binary tree that satisfies specific conditions and can be mainly categorized into two types, as shown in Figure 8-1.</p>
|
||||
<ul>
|
||||
<li><u>Min heap</u>: The value of any node <span class="arithmatex">\(\leq\)</span> the values of its child nodes.</li>
|
||||
<li><u>Max heap</u>: The value of any node <span class="arithmatex">\(\geq\)</span> the values of its child nodes.</li>
|
||||
<li><u>min heap</u>: The value of any node <span class="arithmatex">\(\leq\)</span> the values of its child nodes.</li>
|
||||
<li><u>max heap</u>: The value of any node <span class="arithmatex">\(\geq\)</span> the values of its child nodes.</li>
|
||||
</ul>
|
||||
<p><a class="glightbox" href="../heap.assets/min_heap_and_max_heap.png" data-type="image" data-width="100%" data-height="auto" data-desc-position="bottom"><img alt="Min heap and max heap" class="animation-figure" src="../heap.assets/min_heap_and_max_heap.png" /></a></p>
|
||||
<p align="center"> Figure 8-1 Min heap and max heap </p>
|
||||
|
||||
<p>As a special case of a complete binary tree, heaps have the following characteristics:</p>
|
||||
<p>As a special case of a complete binary tree, a heap has the following characteristics:</p>
|
||||
<ul>
|
||||
<li>The bottom layer nodes are filled from left to right, and nodes in other layers are fully filled.</li>
|
||||
<li>The root node of the binary tree is called the "heap top," and the bottom-rightmost node is called the "heap bottom."</li>
|
||||
<li>For max heaps (min heaps), the value of the heap top element (root node) is the largest (smallest).</li>
|
||||
<li>The root node of the binary tree is called the "top" of the heap, and the bottom-rightmost node is called the "bottom" of the heap.</li>
|
||||
<li>For max heaps (min heaps), the value of the top element (root) is the largest (smallest) among all elements.</li>
|
||||
</ul>
|
||||
<h2 id="811-common-operations-on-heaps">8.1.1 Common operations on heaps<a class="headerlink" href="#811-common-operations-on-heaps" title="Permanent link">¶</a></h2>
|
||||
<h2 id="811-common-heap-operations">8.1.1 Common heap operations<a class="headerlink" href="#811-common-heap-operations" title="Permanent link">¶</a></h2>
|
||||
<p>It should be noted that many programming languages provide a <u>priority queue</u>, which is an abstract data structure defined as a queue with priority sorting.</p>
|
||||
<p>In fact, <strong>heaps are often used to implement priority queues, with max heaps equivalent to priority queues where elements are dequeued in descending order</strong>. From a usage perspective, we can consider "priority queue" and "heap" as equivalent data structures. Therefore, this book does not make a special distinction between the two, uniformly referring to them as "heap."</p>
|
||||
<p>Common operations on heaps are shown in Table 8-1, and the method names depend on the programming language.</p>
|
||||
<p>In practice, <strong>heaps are often used to implement priority queues. A max heap corresponds to a priority queue where elements are dequeued in descending order</strong>. From a usage perspective, we can consider "priority queue" and "heap" as equivalent data structures. Therefore, this book does not make a special distinction between the two, uniformly referring to them as "heap."</p>
|
||||
<p>Common operations on heaps are shown in Table 8-1, and the method names may vary based on the programming language.</p>
|
||||
<p align="center"> Table 8-1 Efficiency of Heap Operations </p>
|
||||
|
||||
<div class="center-table">
|
||||
@@ -3745,349 +3745,349 @@
|
||||
</table>
|
||||
</div>
|
||||
<p>In practice, we can directly use the heap class (or priority queue class) provided by programming languages.</p>
|
||||
<p>Similar to sorting algorithms where we have "ascending order" and "descending order," we can switch between "min heap" and "max heap" by setting a <code>flag</code> or modifying the <code>Comparator</code>. The code is as follows:</p>
|
||||
<p>Similar to sorting algorithms where we have "ascending order" and "descending order", we can switch between "min heap" and "max heap" by setting a <code>flag</code> or modifying the <code>Comparator</code>. The code is as follows:</p>
|
||||
<div class="tabbed-set tabbed-alternate" data-tabs="1:14"><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" /><input id="__tabbed_1_13" name="__tabbed_1" type="radio" /><input id="__tabbed_1_14" name="__tabbed_1" type="radio" /><div class="tabbed-labels"><label for="__tabbed_1_1">Python</label><label for="__tabbed_1_2">C++</label><label for="__tabbed_1_3">Java</label><label for="__tabbed_1_4">C#</label><label for="__tabbed_1_5">Go</label><label for="__tabbed_1_6">Swift</label><label for="__tabbed_1_7">JS</label><label for="__tabbed_1_8">TS</label><label for="__tabbed_1_9">Dart</label><label for="__tabbed_1_10">Rust</label><label for="__tabbed_1_11">C</label><label for="__tabbed_1_12">Kotlin</label><label for="__tabbed_1_13">Ruby</label><label for="__tabbed_1_14">Zig</label></div>
|
||||
<div class="tabbed-content">
|
||||
<div class="tabbed-block">
|
||||
<div class="highlight"><span class="filename">heap.py</span><pre><span></span><code><a id="__codelineno-0-1" name="__codelineno-0-1" href="#__codelineno-0-1"></a><span class="c1"># 初始化小顶堆</span>
|
||||
<div class="highlight"><span class="filename">heap.py</span><pre><span></span><code><a id="__codelineno-0-1" name="__codelineno-0-1" href="#__codelineno-0-1"></a><span class="c1"># Initialize a min heap</span>
|
||||
<a id="__codelineno-0-2" name="__codelineno-0-2" href="#__codelineno-0-2"></a><span class="n">min_heap</span><span class="p">,</span> <span class="n">flag</span> <span class="o">=</span> <span class="p">[],</span> <span class="mi">1</span>
|
||||
<a id="__codelineno-0-3" name="__codelineno-0-3" href="#__codelineno-0-3"></a><span class="c1"># 初始化大顶堆</span>
|
||||
<a id="__codelineno-0-3" name="__codelineno-0-3" href="#__codelineno-0-3"></a><span class="c1"># Initialize a max heap</span>
|
||||
<a id="__codelineno-0-4" name="__codelineno-0-4" href="#__codelineno-0-4"></a><span class="n">max_heap</span><span class="p">,</span> <span class="n">flag</span> <span class="o">=</span> <span class="p">[],</span> <span class="o">-</span><span class="mi">1</span>
|
||||
<a id="__codelineno-0-5" name="__codelineno-0-5" href="#__codelineno-0-5"></a>
|
||||
<a id="__codelineno-0-6" name="__codelineno-0-6" href="#__codelineno-0-6"></a><span class="c1"># Python 的 heapq 模块默认实现小顶堆</span>
|
||||
<a id="__codelineno-0-7" name="__codelineno-0-7" href="#__codelineno-0-7"></a><span class="c1"># 考虑将“元素取负”后再入堆，这样就可以将大小关系颠倒，从而实现大顶堆</span>
|
||||
<a id="__codelineno-0-8" name="__codelineno-0-8" href="#__codelineno-0-8"></a><span class="c1"># 在本示例中，flag = 1 时对应小顶堆，flag = -1 时对应大顶堆</span>
|
||||
<a id="__codelineno-0-6" name="__codelineno-0-6" href="#__codelineno-0-6"></a><span class="c1"># Python's heapq module implements a min heap by default</span>
|
||||
<a id="__codelineno-0-7" name="__codelineno-0-7" href="#__codelineno-0-7"></a><span class="c1"># By negating the elements before pushing them to the heap, we invert the order and thus implement a max heap</span>
|
||||
<a id="__codelineno-0-8" name="__codelineno-0-8" href="#__codelineno-0-8"></a><span class="c1"># In this example, flag = 1 corresponds to a min heap, while flag = -1 corresponds to a max heap</span>
|
||||
<a id="__codelineno-0-9" name="__codelineno-0-9" href="#__codelineno-0-9"></a>
|
||||
<a id="__codelineno-0-10" name="__codelineno-0-10" href="#__codelineno-0-10"></a><span class="c1"># 元素入堆</span>
|
||||
<a id="__codelineno-0-10" name="__codelineno-0-10" href="#__codelineno-0-10"></a><span class="c1"># Push elements into the heap</span>
|
||||
<a id="__codelineno-0-11" name="__codelineno-0-11" href="#__codelineno-0-11"></a><span class="n">heapq</span><span class="o">.</span><span class="n">heappush</span><span class="p">(</span><span class="n">max_heap</span><span class="p">,</span> <span class="n">flag</span> <span class="o">*</span> <span class="mi">1</span><span class="p">)</span>
|
||||
<a id="__codelineno-0-12" name="__codelineno-0-12" href="#__codelineno-0-12"></a><span class="n">heapq</span><span class="o">.</span><span class="n">heappush</span><span class="p">(</span><span class="n">max_heap</span><span class="p">,</span> <span class="n">flag</span> <span class="o">*</span> <span class="mi">3</span><span class="p">)</span>
|
||||
<a id="__codelineno-0-13" name="__codelineno-0-13" href="#__codelineno-0-13"></a><span class="n">heapq</span><span class="o">.</span><span class="n">heappush</span><span class="p">(</span><span class="n">max_heap</span><span class="p">,</span> <span class="n">flag</span> <span class="o">*</span> <span class="mi">2</span><span class="p">)</span>
|
||||
<a id="__codelineno-0-14" name="__codelineno-0-14" href="#__codelineno-0-14"></a><span class="n">heapq</span><span class="o">.</span><span class="n">heappush</span><span class="p">(</span><span class="n">max_heap</span><span class="p">,</span> <span class="n">flag</span> <span class="o">*</span> <span class="mi">5</span><span class="p">)</span>
|
||||
<a id="__codelineno-0-15" name="__codelineno-0-15" href="#__codelineno-0-15"></a><span class="n">heapq</span><span class="o">.</span><span class="n">heappush</span><span class="p">(</span><span class="n">max_heap</span><span class="p">,</span> <span class="n">flag</span> <span class="o">*</span> <span class="mi">4</span><span class="p">)</span>
|
||||
<a id="__codelineno-0-16" name="__codelineno-0-16" href="#__codelineno-0-16"></a>
|
||||
<a id="__codelineno-0-17" name="__codelineno-0-17" href="#__codelineno-0-17"></a><span class="c1"># 获取堆顶元素</span>
|
||||
<a id="__codelineno-0-17" name="__codelineno-0-17" href="#__codelineno-0-17"></a><span class="c1"># Retrieve the top element of the heap</span>
|
||||
<a id="__codelineno-0-18" name="__codelineno-0-18" href="#__codelineno-0-18"></a><span class="n">peek</span><span class="p">:</span> <span class="nb">int</span> <span class="o">=</span> <span class="n">flag</span> <span class="o">*</span> <span class="n">max_heap</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="c1"># 5</span>
|
||||
<a id="__codelineno-0-19" name="__codelineno-0-19" href="#__codelineno-0-19"></a>
|
||||
<a id="__codelineno-0-20" name="__codelineno-0-20" href="#__codelineno-0-20"></a><span class="c1"># 堆顶元素出堆</span>
|
||||
<a id="__codelineno-0-21" name="__codelineno-0-21" href="#__codelineno-0-21"></a><span class="c1"># 出堆元素会形成一个从大到小的序列</span>
|
||||
<a id="__codelineno-0-20" name="__codelineno-0-20" href="#__codelineno-0-20"></a><span class="c1"># Pop the top element of the heap</span>
|
||||
<a id="__codelineno-0-21" name="__codelineno-0-21" href="#__codelineno-0-21"></a><span class="c1"># The popped elements will form a sequence in descending order</span>
|
||||
<a id="__codelineno-0-22" name="__codelineno-0-22" href="#__codelineno-0-22"></a><span class="n">val</span> <span class="o">=</span> <span class="n">flag</span> <span class="o">*</span> <span class="n">heapq</span><span class="o">.</span><span class="n">heappop</span><span class="p">(</span><span class="n">max_heap</span><span class="p">)</span> <span class="c1"># 5</span>
|
||||
<a id="__codelineno-0-23" name="__codelineno-0-23" href="#__codelineno-0-23"></a><span class="n">val</span> <span class="o">=</span> <span class="n">flag</span> <span class="o">*</span> <span class="n">heapq</span><span class="o">.</span><span class="n">heappop</span><span class="p">(</span><span class="n">max_heap</span><span class="p">)</span> <span class="c1"># 4</span>
|
||||
<a id="__codelineno-0-24" name="__codelineno-0-24" href="#__codelineno-0-24"></a><span class="n">val</span> <span class="o">=</span> <span class="n">flag</span> <span class="o">*</span> <span class="n">heapq</span><span class="o">.</span><span class="n">heappop</span><span class="p">(</span><span class="n">max_heap</span><span class="p">)</span> <span class="c1"># 3</span>
|
||||
<a id="__codelineno-0-25" name="__codelineno-0-25" href="#__codelineno-0-25"></a><span class="n">val</span> <span class="o">=</span> <span class="n">flag</span> <span class="o">*</span> <span class="n">heapq</span><span class="o">.</span><span class="n">heappop</span><span class="p">(</span><span class="n">max_heap</span><span class="p">)</span> <span class="c1"># 2</span>
|
||||
<a id="__codelineno-0-26" name="__codelineno-0-26" href="#__codelineno-0-26"></a><span class="n">val</span> <span class="o">=</span> <span class="n">flag</span> <span class="o">*</span> <span class="n">heapq</span><span class="o">.</span><span class="n">heappop</span><span class="p">(</span><span class="n">max_heap</span><span class="p">)</span> <span class="c1"># 1</span>
|
||||
<a id="__codelineno-0-27" name="__codelineno-0-27" href="#__codelineno-0-27"></a>
|
||||
<a id="__codelineno-0-28" name="__codelineno-0-28" href="#__codelineno-0-28"></a><span class="c1"># 获取堆大小</span>
|
||||
<a id="__codelineno-0-28" name="__codelineno-0-28" href="#__codelineno-0-28"></a><span class="c1"># Get the size of the heap</span>
|
||||
<a id="__codelineno-0-29" name="__codelineno-0-29" href="#__codelineno-0-29"></a><span class="n">size</span><span class="p">:</span> <span class="nb">int</span> <span class="o">=</span> <span class="nb">len</span><span class="p">(</span><span class="n">max_heap</span><span class="p">)</span>
|
||||
<a id="__codelineno-0-30" name="__codelineno-0-30" href="#__codelineno-0-30"></a>
|
||||
<a id="__codelineno-0-31" name="__codelineno-0-31" href="#__codelineno-0-31"></a><span class="c1"># 判断堆是否为空</span>
|
||||
<a id="__codelineno-0-31" name="__codelineno-0-31" href="#__codelineno-0-31"></a><span class="c1"># Check if the heap is empty</span>
|
||||
<a id="__codelineno-0-32" name="__codelineno-0-32" href="#__codelineno-0-32"></a><span class="n">is_empty</span><span class="p">:</span> <span class="nb">bool</span> <span class="o">=</span> <span class="ow">not</span> <span class="n">max_heap</span>
|
||||
<a id="__codelineno-0-33" name="__codelineno-0-33" href="#__codelineno-0-33"></a>
|
||||
<a id="__codelineno-0-34" name="__codelineno-0-34" href="#__codelineno-0-34"></a><span class="c1"># 输入列表并建堆</span>
|
||||
<a id="__codelineno-0-34" name="__codelineno-0-34" href="#__codelineno-0-34"></a><span class="c1"># Create a heap from a list</span>
|
||||
<a id="__codelineno-0-35" name="__codelineno-0-35" href="#__codelineno-0-35"></a><span class="n">min_heap</span><span class="p">:</span> <span class="nb">list</span><span class="p">[</span><span class="nb">int</span><span class="p">]</span> <span class="o">=</span> <span class="p">[</span><span class="mi">1</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">5</span><span class="p">,</span> <span class="mi">4</span><span class="p">]</span>
|
||||
<a id="__codelineno-0-36" name="__codelineno-0-36" href="#__codelineno-0-36"></a><span class="n">heapq</span><span class="o">.</span><span class="n">heapify</span><span class="p">(</span><span class="n">min_heap</span><span class="p">)</span>
|
||||
</code></pre></div>
|
||||
</div>
|
||||
<div class="tabbed-block">
|
||||
<div class="highlight"><span class="filename">heap.cpp</span><pre><span></span><code><a id="__codelineno-1-1" name="__codelineno-1-1" href="#__codelineno-1-1"></a><span class="cm">/* 初始化堆 */</span>
|
||||
<a id="__codelineno-1-2" name="__codelineno-1-2" href="#__codelineno-1-2"></a><span class="c1">// 初始化小顶堆</span>
|
||||
<div class="highlight"><span class="filename">heap.cpp</span><pre><span></span><code><a id="__codelineno-1-1" name="__codelineno-1-1" href="#__codelineno-1-1"></a><span class="cm">/* Initialize a heap */</span>
|
||||
<a id="__codelineno-1-2" name="__codelineno-1-2" href="#__codelineno-1-2"></a><span class="c1">// Initialize a min heap</span>
|
||||
<a id="__codelineno-1-3" name="__codelineno-1-3" href="#__codelineno-1-3"></a><span class="n">priority_queue</span><span class="o"><</span><span class="kt">int</span><span class="p">,</span><span class="w"> </span><span class="n">vector</span><span class="o"><</span><span class="kt">int</span><span class="o">></span><span class="p">,</span><span class="w"> </span><span class="n">greater</span><span class="o"><</span><span class="kt">int</span><span class="o">>></span><span class="w"> </span><span class="n">minHeap</span><span class="p">;</span>
|
||||
<a id="__codelineno-1-4" name="__codelineno-1-4" href="#__codelineno-1-4"></a><span class="c1">// 初始化大顶堆</span>
|
||||
<a id="__codelineno-1-4" name="__codelineno-1-4" href="#__codelineno-1-4"></a><span class="c1">// Initialize a max heap</span>
|
||||
<a id="__codelineno-1-5" name="__codelineno-1-5" href="#__codelineno-1-5"></a><span class="n">priority_queue</span><span class="o"><</span><span class="kt">int</span><span class="p">,</span><span class="w"> </span><span class="n">vector</span><span class="o"><</span><span class="kt">int</span><span class="o">></span><span class="p">,</span><span class="w"> </span><span class="n">less</span><span class="o"><</span><span class="kt">int</span><span class="o">>></span><span class="w"> </span><span class="n">maxHeap</span><span class="p">;</span>
|
||||
<a id="__codelineno-1-6" name="__codelineno-1-6" href="#__codelineno-1-6"></a>
|
||||
<a id="__codelineno-1-7" name="__codelineno-1-7" href="#__codelineno-1-7"></a><span class="cm">/* 元素入堆 */</span>
|
||||
<a id="__codelineno-1-7" name="__codelineno-1-7" href="#__codelineno-1-7"></a><span class="cm">/* Push elements into the heap */</span>
|
||||
<a id="__codelineno-1-8" name="__codelineno-1-8" href="#__codelineno-1-8"></a><span class="n">maxHeap</span><span class="p">.</span><span class="n">push</span><span class="p">(</span><span class="mi">1</span><span class="p">);</span>
|
||||
<a id="__codelineno-1-9" name="__codelineno-1-9" href="#__codelineno-1-9"></a><span class="n">maxHeap</span><span class="p">.</span><span class="n">push</span><span class="p">(</span><span class="mi">3</span><span class="p">);</span>
|
||||
<a id="__codelineno-1-10" name="__codelineno-1-10" href="#__codelineno-1-10"></a><span class="n">maxHeap</span><span class="p">.</span><span class="n">push</span><span class="p">(</span><span class="mi">2</span><span class="p">);</span>
|
||||
<a id="__codelineno-1-11" name="__codelineno-1-11" href="#__codelineno-1-11"></a><span class="n">maxHeap</span><span class="p">.</span><span class="n">push</span><span class="p">(</span><span class="mi">5</span><span class="p">);</span>
|
||||
<a id="__codelineno-1-12" name="__codelineno-1-12" href="#__codelineno-1-12"></a><span class="n">maxHeap</span><span class="p">.</span><span class="n">push</span><span class="p">(</span><span class="mi">4</span><span class="p">);</span>
|
||||
<a id="__codelineno-1-13" name="__codelineno-1-13" href="#__codelineno-1-13"></a>
|
||||
<a id="__codelineno-1-14" name="__codelineno-1-14" href="#__codelineno-1-14"></a><span class="cm">/* 获取堆顶元素 */</span>
|
||||
<a id="__codelineno-1-14" name="__codelineno-1-14" href="#__codelineno-1-14"></a><span class="cm">/* Retrieve the top element of the heap */</span>
|
||||
<a id="__codelineno-1-15" name="__codelineno-1-15" href="#__codelineno-1-15"></a><span class="kt">int</span><span class="w"> </span><span class="n">peek</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">maxHeap</span><span class="p">.</span><span class="n">top</span><span class="p">();</span><span class="w"> </span><span class="c1">// 5</span>
|
||||
<a id="__codelineno-1-16" name="__codelineno-1-16" href="#__codelineno-1-16"></a>
|
||||
<a id="__codelineno-1-17" name="__codelineno-1-17" href="#__codelineno-1-17"></a><span class="cm">/* 堆顶元素出堆 */</span>
|
||||
<a id="__codelineno-1-18" name="__codelineno-1-18" href="#__codelineno-1-18"></a><span class="c1">// 出堆元素会形成一个从大到小的序列</span>
|
||||
<a id="__codelineno-1-17" name="__codelineno-1-17" href="#__codelineno-1-17"></a><span class="cm">/* Pop the top element of the heap */</span>
|
||||
<a id="__codelineno-1-18" name="__codelineno-1-18" href="#__codelineno-1-18"></a><span class="c1">// The popped elements will form a sequence in descending order</span>
|
||||
<a id="__codelineno-1-19" name="__codelineno-1-19" href="#__codelineno-1-19"></a><span class="n">maxHeap</span><span class="p">.</span><span class="n">pop</span><span class="p">();</span><span class="w"> </span><span class="c1">// 5</span>
|
||||
<a id="__codelineno-1-20" name="__codelineno-1-20" href="#__codelineno-1-20"></a><span class="n">maxHeap</span><span class="p">.</span><span class="n">pop</span><span class="p">();</span><span class="w"> </span><span class="c1">// 4</span>
|
||||
<a id="__codelineno-1-21" name="__codelineno-1-21" href="#__codelineno-1-21"></a><span class="n">maxHeap</span><span class="p">.</span><span class="n">pop</span><span class="p">();</span><span class="w"> </span><span class="c1">// 3</span>
|
||||
<a id="__codelineno-1-22" name="__codelineno-1-22" href="#__codelineno-1-22"></a><span class="n">maxHeap</span><span class="p">.</span><span class="n">pop</span><span class="p">();</span><span class="w"> </span><span class="c1">// 2</span>
|
||||
<a id="__codelineno-1-23" name="__codelineno-1-23" href="#__codelineno-1-23"></a><span class="n">maxHeap</span><span class="p">.</span><span class="n">pop</span><span class="p">();</span><span class="w"> </span><span class="c1">// 1</span>
|
||||
<a id="__codelineno-1-24" name="__codelineno-1-24" href="#__codelineno-1-24"></a>
|
||||
<a id="__codelineno-1-25" name="__codelineno-1-25" href="#__codelineno-1-25"></a><span class="cm">/* 获取堆大小 */</span>
|
||||
<a id="__codelineno-1-25" name="__codelineno-1-25" href="#__codelineno-1-25"></a><span class="cm">/* Get the size of the heap */</span>
|
||||
<a id="__codelineno-1-26" name="__codelineno-1-26" href="#__codelineno-1-26"></a><span class="kt">int</span><span class="w"> </span><span class="n">size</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">maxHeap</span><span class="p">.</span><span class="n">size</span><span class="p">();</span>
|
||||
<a id="__codelineno-1-27" name="__codelineno-1-27" href="#__codelineno-1-27"></a>
|
||||
<a id="__codelineno-1-28" name="__codelineno-1-28" href="#__codelineno-1-28"></a><span class="cm">/* 判断堆是否为空 */</span>
|
||||
<a id="__codelineno-1-28" name="__codelineno-1-28" href="#__codelineno-1-28"></a><span class="cm">/* Check if the heap is empty */</span>
|
||||
<a id="__codelineno-1-29" name="__codelineno-1-29" href="#__codelineno-1-29"></a><span class="kt">bool</span><span class="w"> </span><span class="n">isEmpty</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">maxHeap</span><span class="p">.</span><span class="n">empty</span><span class="p">();</span>
|
||||
<a id="__codelineno-1-30" name="__codelineno-1-30" href="#__codelineno-1-30"></a>
|
||||
<a id="__codelineno-1-31" name="__codelineno-1-31" href="#__codelineno-1-31"></a><span class="cm">/* 输入列表并建堆 */</span>
|
||||
<a id="__codelineno-1-31" name="__codelineno-1-31" href="#__codelineno-1-31"></a><span class="cm">/* Create a heap from a list */</span>
|
||||
<a id="__codelineno-1-32" name="__codelineno-1-32" href="#__codelineno-1-32"></a><span class="n">vector</span><span class="o"><</span><span class="kt">int</span><span class="o">></span><span class="w"> </span><span class="n">input</span><span class="p">{</span><span class="mi">1</span><span class="p">,</span><span class="w"> </span><span class="mi">3</span><span class="p">,</span><span class="w"> </span><span class="mi">2</span><span class="p">,</span><span class="w"> </span><span class="mi">5</span><span class="p">,</span><span class="w"> </span><span class="mi">4</span><span class="p">};</span>
|
||||
<a id="__codelineno-1-33" name="__codelineno-1-33" href="#__codelineno-1-33"></a><span class="n">priority_queue</span><span class="o"><</span><span class="kt">int</span><span class="p">,</span><span class="w"> </span><span class="n">vector</span><span class="o"><</span><span class="kt">int</span><span class="o">></span><span class="p">,</span><span class="w"> </span><span class="n">greater</span><span class="o"><</span><span class="kt">int</span><span class="o">>></span><span class="w"> </span><span class="n">minHeap</span><span class="p">(</span><span class="n">input</span><span class="p">.</span><span class="n">begin</span><span class="p">(),</span><span class="w"> </span><span class="n">input</span><span class="p">.</span><span class="n">end</span><span class="p">());</span>
|
||||
</code></pre></div>
|
||||
</div>
|
||||
<div class="tabbed-block">
|
||||
<div class="highlight"><span class="filename">heap.java</span><pre><span></span><code><a id="__codelineno-2-1" name="__codelineno-2-1" href="#__codelineno-2-1"></a><span class="cm">/* 初始化堆 */</span>
|
||||
<a id="__codelineno-2-2" name="__codelineno-2-2" href="#__codelineno-2-2"></a><span class="c1">// 初始化小顶堆</span>
|
||||
<div class="highlight"><span class="filename">heap.java</span><pre><span></span><code><a id="__codelineno-2-1" name="__codelineno-2-1" href="#__codelineno-2-1"></a><span class="cm">/* Initialize a heap */</span>
|
||||
<a id="__codelineno-2-2" name="__codelineno-2-2" href="#__codelineno-2-2"></a><span class="c1">// Initialize a min heap</span>
|
||||
<a id="__codelineno-2-3" name="__codelineno-2-3" href="#__codelineno-2-3"></a><span class="n">Queue</span><span class="o"><</span><span class="n">Integer</span><span class="o">></span><span class="w"> </span><span class="n">minHeap</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">PriorityQueue</span><span class="o"><></span><span class="p">();</span>
|
||||
<a id="__codelineno-2-4" name="__codelineno-2-4" href="#__codelineno-2-4"></a><span class="c1">// 初始化大顶堆（使用 lambda 表达式修改 Comparator 即可）</span>
|
||||
<a id="__codelineno-2-4" name="__codelineno-2-4" href="#__codelineno-2-4"></a><span class="c1">// Initialize a max heap (Simply modify the Comparator using a lambda expression）</span>
|
||||
<a id="__codelineno-2-5" name="__codelineno-2-5" href="#__codelineno-2-5"></a><span class="n">Queue</span><span class="o"><</span><span class="n">Integer</span><span class="o">></span><span class="w"> </span><span class="n">maxHeap</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">PriorityQueue</span><span class="o"><></span><span class="p">((</span><span class="n">a</span><span class="p">,</span><span class="w"> </span><span class="n">b</span><span class="p">)</span><span class="w"> </span><span class="o">-></span><span class="w"> </span><span class="n">b</span><span class="w"> </span><span class="o">-</span><span class="w"> </span><span class="n">a</span><span class="p">);</span>
|
||||
<a id="__codelineno-2-6" name="__codelineno-2-6" href="#__codelineno-2-6"></a>
|
||||
<a id="__codelineno-2-7" name="__codelineno-2-7" href="#__codelineno-2-7"></a><span class="cm">/* 元素入堆 */</span>
|
||||
<a id="__codelineno-2-7" name="__codelineno-2-7" href="#__codelineno-2-7"></a><span class="cm">/* Push elements into the heap */</span>
|
||||
<a id="__codelineno-2-8" name="__codelineno-2-8" href="#__codelineno-2-8"></a><span class="n">maxHeap</span><span class="p">.</span><span class="na">offer</span><span class="p">(</span><span class="mi">1</span><span class="p">);</span>
|
||||
<a id="__codelineno-2-9" name="__codelineno-2-9" href="#__codelineno-2-9"></a><span class="n">maxHeap</span><span class="p">.</span><span class="na">offer</span><span class="p">(</span><span class="mi">3</span><span class="p">);</span>
|
||||
<a id="__codelineno-2-10" name="__codelineno-2-10" href="#__codelineno-2-10"></a><span class="n">maxHeap</span><span class="p">.</span><span class="na">offer</span><span class="p">(</span><span class="mi">2</span><span class="p">);</span>
|
||||
<a id="__codelineno-2-11" name="__codelineno-2-11" href="#__codelineno-2-11"></a><span class="n">maxHeap</span><span class="p">.</span><span class="na">offer</span><span class="p">(</span><span class="mi">5</span><span class="p">);</span>
|
||||
<a id="__codelineno-2-12" name="__codelineno-2-12" href="#__codelineno-2-12"></a><span class="n">maxHeap</span><span class="p">.</span><span class="na">offer</span><span class="p">(</span><span class="mi">4</span><span class="p">);</span>
|
||||
<a id="__codelineno-2-13" name="__codelineno-2-13" href="#__codelineno-2-13"></a>
|
||||
<a id="__codelineno-2-14" name="__codelineno-2-14" href="#__codelineno-2-14"></a><span class="cm">/* 获取堆顶元素 */</span>
|
||||
<a id="__codelineno-2-14" name="__codelineno-2-14" href="#__codelineno-2-14"></a><span class="cm">/* Retrieve the top element of the heap */</span>
|
||||
<a id="__codelineno-2-15" name="__codelineno-2-15" href="#__codelineno-2-15"></a><span class="kt">int</span><span class="w"> </span><span class="n">peek</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">maxHeap</span><span class="p">.</span><span class="na">peek</span><span class="p">();</span><span class="w"> </span><span class="c1">// 5</span>
|
||||
<a id="__codelineno-2-16" name="__codelineno-2-16" href="#__codelineno-2-16"></a>
|
||||
<a id="__codelineno-2-17" name="__codelineno-2-17" href="#__codelineno-2-17"></a><span class="cm">/* 堆顶元素出堆 */</span>
|
||||
<a id="__codelineno-2-18" name="__codelineno-2-18" href="#__codelineno-2-18"></a><span class="c1">// 出堆元素会形成一个从大到小的序列</span>
|
||||
<a id="__codelineno-2-17" name="__codelineno-2-17" href="#__codelineno-2-17"></a><span class="cm">/* Pop the top element of the heap */</span>
|
||||
<a id="__codelineno-2-18" name="__codelineno-2-18" href="#__codelineno-2-18"></a><span class="c1">// The popped elements will form a sequence in descending order</span>
|
||||
<a id="__codelineno-2-19" name="__codelineno-2-19" href="#__codelineno-2-19"></a><span class="n">peek</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">maxHeap</span><span class="p">.</span><span class="na">poll</span><span class="p">();</span><span class="w"> </span><span class="c1">// 5</span>
|
||||
<a id="__codelineno-2-20" name="__codelineno-2-20" href="#__codelineno-2-20"></a><span class="n">peek</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">maxHeap</span><span class="p">.</span><span class="na">poll</span><span class="p">();</span><span class="w"> </span><span class="c1">// 4</span>
|
||||
<a id="__codelineno-2-21" name="__codelineno-2-21" href="#__codelineno-2-21"></a><span class="n">peek</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">maxHeap</span><span class="p">.</span><span class="na">poll</span><span class="p">();</span><span class="w"> </span><span class="c1">// 3</span>
|
||||
<a id="__codelineno-2-22" name="__codelineno-2-22" href="#__codelineno-2-22"></a><span class="n">peek</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">maxHeap</span><span class="p">.</span><span class="na">poll</span><span class="p">();</span><span class="w"> </span><span class="c1">// 2</span>
|
||||
<a id="__codelineno-2-23" name="__codelineno-2-23" href="#__codelineno-2-23"></a><span class="n">peek</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">maxHeap</span><span class="p">.</span><span class="na">poll</span><span class="p">();</span><span class="w"> </span><span class="c1">// 1</span>
|
||||
<a id="__codelineno-2-24" name="__codelineno-2-24" href="#__codelineno-2-24"></a>
|
||||
<a id="__codelineno-2-25" name="__codelineno-2-25" href="#__codelineno-2-25"></a><span class="cm">/* 获取堆大小 */</span>
|
||||
<a id="__codelineno-2-25" name="__codelineno-2-25" href="#__codelineno-2-25"></a><span class="cm">/* Get the size of the heap */</span>
|
||||
<a id="__codelineno-2-26" name="__codelineno-2-26" href="#__codelineno-2-26"></a><span class="kt">int</span><span class="w"> </span><span class="n">size</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">maxHeap</span><span class="p">.</span><span class="na">size</span><span class="p">();</span>
|
||||
<a id="__codelineno-2-27" name="__codelineno-2-27" href="#__codelineno-2-27"></a>
|
||||
<a id="__codelineno-2-28" name="__codelineno-2-28" href="#__codelineno-2-28"></a><span class="cm">/* 判断堆是否为空 */</span>
|
||||
<a id="__codelineno-2-28" name="__codelineno-2-28" href="#__codelineno-2-28"></a><span class="cm">/* Check if the heap is empty */</span>
|
||||
<a id="__codelineno-2-29" name="__codelineno-2-29" href="#__codelineno-2-29"></a><span class="kt">boolean</span><span class="w"> </span><span class="n">isEmpty</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">maxHeap</span><span class="p">.</span><span class="na">isEmpty</span><span class="p">();</span>
|
||||
<a id="__codelineno-2-30" name="__codelineno-2-30" href="#__codelineno-2-30"></a>
|
||||
<a id="__codelineno-2-31" name="__codelineno-2-31" href="#__codelineno-2-31"></a><span class="cm">/* 输入列表并建堆 */</span>
|
||||
<a id="__codelineno-2-31" name="__codelineno-2-31" href="#__codelineno-2-31"></a><span class="cm">/* Create a heap from a list */</span>
|
||||
<a id="__codelineno-2-32" name="__codelineno-2-32" href="#__codelineno-2-32"></a><span class="n">minHeap</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">PriorityQueue</span><span class="o"><></span><span class="p">(</span><span class="n">Arrays</span><span class="p">.</span><span class="na">asList</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span><span class="w"> </span><span class="mi">3</span><span class="p">,</span><span class="w"> </span><span class="mi">2</span><span class="p">,</span><span class="w"> </span><span class="mi">5</span><span class="p">,</span><span class="w"> </span><span class="mi">4</span><span class="p">));</span>
|
||||
</code></pre></div>
|
||||
</div>
|
||||
<div class="tabbed-block">
|
||||
<div class="highlight"><span class="filename">heap.cs</span><pre><span></span><code><a id="__codelineno-3-1" name="__codelineno-3-1" href="#__codelineno-3-1"></a><span class="cm">/* 初始化堆 */</span>
|
||||
<a id="__codelineno-3-2" name="__codelineno-3-2" href="#__codelineno-3-2"></a><span class="c1">// 初始化小顶堆</span>
|
||||
<div class="highlight"><span class="filename">heap.cs</span><pre><span></span><code><a id="__codelineno-3-1" name="__codelineno-3-1" href="#__codelineno-3-1"></a><span class="cm">/* Initialize a heap */</span>
|
||||
<a id="__codelineno-3-2" name="__codelineno-3-2" href="#__codelineno-3-2"></a><span class="c1">// Initialize a min heap</span>
|
||||
<a id="__codelineno-3-3" name="__codelineno-3-3" href="#__codelineno-3-3"></a><span class="n">PriorityQueue</span><span class="o"><</span><span class="kt">int</span><span class="p">,</span><span class="w"> </span><span class="kt">int</span><span class="o">></span><span class="w"> </span><span class="n">minHeap</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">new</span><span class="p">();</span>
|
||||
<a id="__codelineno-3-4" name="__codelineno-3-4" href="#__codelineno-3-4"></a><span class="c1">// 初始化大顶堆（使用 lambda 表达式修改 Comparator 即可）</span>
|
||||
<a id="__codelineno-3-4" name="__codelineno-3-4" href="#__codelineno-3-4"></a><span class="c1">// Initialize a max heap (Simply modify the Comparator using a lambda expression)</span>
|
||||
<a id="__codelineno-3-5" name="__codelineno-3-5" href="#__codelineno-3-5"></a><span class="n">PriorityQueue</span><span class="o"><</span><span class="kt">int</span><span class="p">,</span><span class="w"> </span><span class="kt">int</span><span class="o">></span><span class="w"> </span><span class="n">maxHeap</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">new</span><span class="p">(</span><span class="n">Comparer</span><span class="o"><</span><span class="kt">int</span><span class="o">></span><span class="p">.</span><span class="n">Create</span><span class="p">((</span><span class="n">x</span><span class="p">,</span><span class="w"> </span><span class="n">y</span><span class="p">)</span><span class="w"> </span><span class="o">=></span><span class="w"> </span><span class="n">y</span><span class="w"> </span><span class="o">-</span><span class="w"> </span><span class="n">x</span><span class="p">));</span>
|
||||
<a id="__codelineno-3-6" name="__codelineno-3-6" href="#__codelineno-3-6"></a>
|
||||
<a id="__codelineno-3-7" name="__codelineno-3-7" href="#__codelineno-3-7"></a><span class="cm">/* 元素入堆 */</span>
|
||||
<a id="__codelineno-3-7" name="__codelineno-3-7" href="#__codelineno-3-7"></a><span class="cm">/* Push elements into the heap */</span>
|
||||
<a id="__codelineno-3-8" name="__codelineno-3-8" href="#__codelineno-3-8"></a><span class="n">maxHeap</span><span class="p">.</span><span class="n">Enqueue</span><span class="p">(</span><span class="m">1</span><span class="p">,</span><span class="w"> </span><span class="m">1</span><span class="p">);</span>
|
||||
<a id="__codelineno-3-9" name="__codelineno-3-9" href="#__codelineno-3-9"></a><span class="n">maxHeap</span><span class="p">.</span><span class="n">Enqueue</span><span class="p">(</span><span class="m">3</span><span class="p">,</span><span class="w"> </span><span class="m">3</span><span class="p">);</span>
|
||||
<a id="__codelineno-3-10" name="__codelineno-3-10" href="#__codelineno-3-10"></a><span class="n">maxHeap</span><span class="p">.</span><span class="n">Enqueue</span><span class="p">(</span><span class="m">2</span><span class="p">,</span><span class="w"> </span><span class="m">2</span><span class="p">);</span>
|
||||
<a id="__codelineno-3-11" name="__codelineno-3-11" href="#__codelineno-3-11"></a><span class="n">maxHeap</span><span class="p">.</span><span class="n">Enqueue</span><span class="p">(</span><span class="m">5</span><span class="p">,</span><span class="w"> </span><span class="m">5</span><span class="p">);</span>
|
||||
<a id="__codelineno-3-12" name="__codelineno-3-12" href="#__codelineno-3-12"></a><span class="n">maxHeap</span><span class="p">.</span><span class="n">Enqueue</span><span class="p">(</span><span class="m">4</span><span class="p">,</span><span class="w"> </span><span class="m">4</span><span class="p">);</span>
|
||||
<a id="__codelineno-3-13" name="__codelineno-3-13" href="#__codelineno-3-13"></a>
|
||||
<a id="__codelineno-3-14" name="__codelineno-3-14" href="#__codelineno-3-14"></a><span class="cm">/* 获取堆顶元素 */</span>
|
||||
<a id="__codelineno-3-14" name="__codelineno-3-14" href="#__codelineno-3-14"></a><span class="cm">/* Retrieve the top element of the heap */</span>
|
||||
<a id="__codelineno-3-15" name="__codelineno-3-15" href="#__codelineno-3-15"></a><span class="kt">int</span><span class="w"> </span><span class="n">peek</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">maxHeap</span><span class="p">.</span><span class="n">Peek</span><span class="p">();</span><span class="c1">//5</span>
|
||||
<a id="__codelineno-3-16" name="__codelineno-3-16" href="#__codelineno-3-16"></a>
|
||||
<a id="__codelineno-3-17" name="__codelineno-3-17" href="#__codelineno-3-17"></a><span class="cm">/* 堆顶元素出堆 */</span>
|
||||
<a id="__codelineno-3-18" name="__codelineno-3-18" href="#__codelineno-3-18"></a><span class="c1">// 出堆元素会形成一个从大到小的序列</span>
|
||||
<a id="__codelineno-3-17" name="__codelineno-3-17" href="#__codelineno-3-17"></a><span class="cm">/* Pop the top element of the heap */</span>
|
||||
<a id="__codelineno-3-18" name="__codelineno-3-18" href="#__codelineno-3-18"></a><span class="c1">// The popped elements will form a sequence in descending order</span>
|
||||
<a id="__codelineno-3-19" name="__codelineno-3-19" href="#__codelineno-3-19"></a><span class="n">peek</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">maxHeap</span><span class="p">.</span><span class="n">Dequeue</span><span class="p">();</span><span class="w"> </span><span class="c1">// 5</span>
|
||||
<a id="__codelineno-3-20" name="__codelineno-3-20" href="#__codelineno-3-20"></a><span class="n">peek</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">maxHeap</span><span class="p">.</span><span class="n">Dequeue</span><span class="p">();</span><span class="w"> </span><span class="c1">// 4</span>
|
||||
<a id="__codelineno-3-21" name="__codelineno-3-21" href="#__codelineno-3-21"></a><span class="n">peek</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">maxHeap</span><span class="p">.</span><span class="n">Dequeue</span><span class="p">();</span><span class="w"> </span><span class="c1">// 3</span>
|
||||
<a id="__codelineno-3-22" name="__codelineno-3-22" href="#__codelineno-3-22"></a><span class="n">peek</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">maxHeap</span><span class="p">.</span><span class="n">Dequeue</span><span class="p">();</span><span class="w"> </span><span class="c1">// 2</span>
|
||||
<a id="__codelineno-3-23" name="__codelineno-3-23" href="#__codelineno-3-23"></a><span class="n">peek</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">maxHeap</span><span class="p">.</span><span class="n">Dequeue</span><span class="p">();</span><span class="w"> </span><span class="c1">// 1</span>
|
||||
<a id="__codelineno-3-24" name="__codelineno-3-24" href="#__codelineno-3-24"></a>
|
||||
<a id="__codelineno-3-25" name="__codelineno-3-25" href="#__codelineno-3-25"></a><span class="cm">/* 获取堆大小 */</span>
|
||||
<a id="__codelineno-3-25" name="__codelineno-3-25" href="#__codelineno-3-25"></a><span class="cm">/* Get the size of the heap */</span>
|
||||
<a id="__codelineno-3-26" name="__codelineno-3-26" href="#__codelineno-3-26"></a><span class="kt">int</span><span class="w"> </span><span class="n">size</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">maxHeap</span><span class="p">.</span><span class="n">Count</span><span class="p">;</span>
|
||||
<a id="__codelineno-3-27" name="__codelineno-3-27" href="#__codelineno-3-27"></a>
|
||||
<a id="__codelineno-3-28" name="__codelineno-3-28" href="#__codelineno-3-28"></a><span class="cm">/* 判断堆是否为空 */</span>
|
||||
<a id="__codelineno-3-28" name="__codelineno-3-28" href="#__codelineno-3-28"></a><span class="cm">/* Check if the heap is empty */</span>
|
||||
<a id="__codelineno-3-29" name="__codelineno-3-29" href="#__codelineno-3-29"></a><span class="kt">bool</span><span class="w"> </span><span class="n">isEmpty</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">maxHeap</span><span class="p">.</span><span class="n">Count</span><span class="w"> </span><span class="o">==</span><span class="w"> </span><span class="m">0</span><span class="p">;</span>
|
||||
<a id="__codelineno-3-30" name="__codelineno-3-30" href="#__codelineno-3-30"></a>
|
||||
<a id="__codelineno-3-31" name="__codelineno-3-31" href="#__codelineno-3-31"></a><span class="cm">/* 输入列表并建堆 */</span>
|
||||
<a id="__codelineno-3-31" name="__codelineno-3-31" href="#__codelineno-3-31"></a><span class="cm">/* Create a heap from a list */</span>
|
||||
<a id="__codelineno-3-32" name="__codelineno-3-32" href="#__codelineno-3-32"></a><span class="n">minHeap</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">PriorityQueue</span><span class="o"><</span><span class="kt">int</span><span class="p">,</span><span class="w"> </span><span class="kt">int</span><span class="o">></span><span class="p">([(</span><span class="m">1</span><span class="p">,</span><span class="w"> </span><span class="m">1</span><span class="p">),</span><span class="w"> </span><span class="p">(</span><span class="m">3</span><span class="p">,</span><span class="w"> </span><span class="m">3</span><span class="p">),</span><span class="w"> </span><span class="p">(</span><span class="m">2</span><span class="p">,</span><span class="w"> </span><span class="m">2</span><span class="p">),</span><span class="w"> </span><span class="p">(</span><span class="m">5</span><span class="p">,</span><span class="w"> </span><span class="m">5</span><span class="p">),</span><span class="w"> </span><span class="p">(</span><span class="m">4</span><span class="p">,</span><span class="w"> </span><span class="m">4</span><span class="p">)]);</span>
|
||||
</code></pre></div>
|
||||
</div>
|
||||
<div class="tabbed-block">
|
||||
<div class="highlight"><span class="filename">heap.go</span><pre><span></span><code><a id="__codelineno-4-1" name="__codelineno-4-1" href="#__codelineno-4-1"></a><span class="c1">// Go 语言中可以通过实现 heap.Interface 来构建整数大顶堆</span>
|
||||
<a id="__codelineno-4-2" name="__codelineno-4-2" href="#__codelineno-4-2"></a><span class="c1">// 实现 heap.Interface 需要同时实现 sort.Interface</span>
|
||||
<div class="highlight"><span class="filename">heap.go</span><pre><span></span><code><a id="__codelineno-4-1" name="__codelineno-4-1" href="#__codelineno-4-1"></a><span class="c1">// In Go, we can construct a max heap of integers by implementing heap.Interface</span>
|
||||
<a id="__codelineno-4-2" name="__codelineno-4-2" href="#__codelineno-4-2"></a><span class="c1">// Note that implementing heap.Interface requires also implementing sort.Interface</span>
|
||||
<a id="__codelineno-4-3" name="__codelineno-4-3" href="#__codelineno-4-3"></a><span class="kd">type</span><span class="w"> </span><span class="nx">intHeap</span><span class="w"> </span><span class="p">[]</span><span class="kt">any</span>
|
||||
<a id="__codelineno-4-4" name="__codelineno-4-4" href="#__codelineno-4-4"></a>
|
||||
<a id="__codelineno-4-5" name="__codelineno-4-5" href="#__codelineno-4-5"></a><span class="c1">// Push heap.Interface 的方法，实现推入元素到堆</span>
|
||||
<a id="__codelineno-4-5" name="__codelineno-4-5" href="#__codelineno-4-5"></a><span class="c1">// Push method of heap.Interface, which pushes an element into the heap</span>
|
||||
<a id="__codelineno-4-6" name="__codelineno-4-6" href="#__codelineno-4-6"></a><span class="kd">func</span><span class="w"> </span><span class="p">(</span><span class="nx">h</span><span class="w"> </span><span class="o">*</span><span class="nx">intHeap</span><span class="p">)</span><span class="w"> </span><span class="nx">Push</span><span class="p">(</span><span class="nx">x</span><span class="w"> </span><span class="kt">any</span><span class="p">)</span><span class="w"> </span><span class="p">{</span>
|
||||
<a id="__codelineno-4-7" name="__codelineno-4-7" href="#__codelineno-4-7"></a><span class="w"> </span><span class="c1">// Push 和 Pop 使用 pointer receiver 作为参数</span>
|
||||
<a id="__codelineno-4-8" name="__codelineno-4-8" href="#__codelineno-4-8"></a><span class="w"> </span><span class="c1">// 因为它们不仅会对切片的内容进行调整，还会修改切片的长度。</span>
|
||||
<a id="__codelineno-4-7" name="__codelineno-4-7" href="#__codelineno-4-7"></a><span class="w"> </span><span class="c1">// Both Push and Pop use a pointer receiver</span>
|
||||
<a id="__codelineno-4-8" name="__codelineno-4-8" href="#__codelineno-4-8"></a><span class="w"> </span><span class="c1">// because they not only adjust the elements of the slice but also change its length</span>
|
||||
<a id="__codelineno-4-9" name="__codelineno-4-9" href="#__codelineno-4-9"></a><span class="w"> </span><span class="o">*</span><span class="nx">h</span><span class="w"> </span><span class="p">=</span><span class="w"> </span><span class="nb">append</span><span class="p">(</span><span class="o">*</span><span class="nx">h</span><span class="p">,</span><span class="w"> </span><span class="nx">x</span><span class="p">.(</span><span class="kt">int</span><span class="p">))</span>
|
||||
<a id="__codelineno-4-10" name="__codelineno-4-10" href="#__codelineno-4-10"></a><span class="p">}</span>
|
||||
<a id="__codelineno-4-11" name="__codelineno-4-11" href="#__codelineno-4-11"></a>
|
||||
<a id="__codelineno-4-12" name="__codelineno-4-12" href="#__codelineno-4-12"></a><span class="c1">// Pop heap.Interface 的方法，实现弹出堆顶元素</span>
|
||||
<a id="__codelineno-4-12" name="__codelineno-4-12" href="#__codelineno-4-12"></a><span class="c1">// Pop method of heap.Interface, which removes the top element of the heap</span>
|
||||
<a id="__codelineno-4-13" name="__codelineno-4-13" href="#__codelineno-4-13"></a><span class="kd">func</span><span class="w"> </span><span class="p">(</span><span class="nx">h</span><span class="w"> </span><span class="o">*</span><span class="nx">intHeap</span><span class="p">)</span><span class="w"> </span><span class="nx">Pop</span><span class="p">()</span><span class="w"> </span><span class="kt">any</span><span class="w"> </span><span class="p">{</span>
|
||||
<a id="__codelineno-4-14" name="__codelineno-4-14" href="#__codelineno-4-14"></a><span class="w"> </span><span class="c1">// 待出堆元素存放在最后</span>
|
||||
<a id="__codelineno-4-14" name="__codelineno-4-14" href="#__codelineno-4-14"></a><span class="w"> </span><span class="c1">// The element to pop from the heap is stored at the end</span>
|
||||
<a id="__codelineno-4-15" name="__codelineno-4-15" href="#__codelineno-4-15"></a><span class="w"> </span><span class="nx">last</span><span class="w"> </span><span class="o">:=</span><span class="w"> </span><span class="p">(</span><span class="o">*</span><span class="nx">h</span><span class="p">)[</span><span class="nb">len</span><span class="p">(</span><span class="o">*</span><span class="nx">h</span><span class="p">)</span><span class="o">-</span><span class="mi">1</span><span class="p">]</span>
|
||||
<a id="__codelineno-4-16" name="__codelineno-4-16" href="#__codelineno-4-16"></a><span class="w"> </span><span class="o">*</span><span class="nx">h</span><span class="w"> </span><span class="p">=</span><span class="w"> </span><span class="p">(</span><span class="o">*</span><span class="nx">h</span><span class="p">)[:</span><span class="nb">len</span><span class="p">(</span><span class="o">*</span><span class="nx">h</span><span class="p">)</span><span class="o">-</span><span class="mi">1</span><span class="p">]</span>
|
||||
<a id="__codelineno-4-17" name="__codelineno-4-17" href="#__codelineno-4-17"></a><span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="nx">last</span>
|
||||
<a id="__codelineno-4-18" name="__codelineno-4-18" href="#__codelineno-4-18"></a><span class="p">}</span>
|
||||
<a id="__codelineno-4-19" name="__codelineno-4-19" href="#__codelineno-4-19"></a>
|
||||
<a id="__codelineno-4-20" name="__codelineno-4-20" href="#__codelineno-4-20"></a><span class="c1">// Len sort.Interface 的方法</span>
|
||||
<a id="__codelineno-4-20" name="__codelineno-4-20" href="#__codelineno-4-20"></a><span class="c1">// Len method of sort.Interface</span>
|
||||
<a id="__codelineno-4-21" name="__codelineno-4-21" href="#__codelineno-4-21"></a><span class="kd">func</span><span class="w"> </span><span class="p">(</span><span class="nx">h</span><span class="w"> </span><span class="o">*</span><span class="nx">intHeap</span><span class="p">)</span><span class="w"> </span><span class="nx">Len</span><span class="p">()</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="p">{</span>
|
||||
<a id="__codelineno-4-22" name="__codelineno-4-22" href="#__codelineno-4-22"></a><span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="nb">len</span><span class="p">(</span><span class="o">*</span><span class="nx">h</span><span class="p">)</span>
|
||||
<a id="__codelineno-4-23" name="__codelineno-4-23" href="#__codelineno-4-23"></a><span class="p">}</span>
|
||||
<a id="__codelineno-4-24" name="__codelineno-4-24" href="#__codelineno-4-24"></a>
|
||||
<a id="__codelineno-4-25" name="__codelineno-4-25" href="#__codelineno-4-25"></a><span class="c1">// Less sort.Interface 的方法</span>
|
||||
<a id="__codelineno-4-25" name="__codelineno-4-25" href="#__codelineno-4-25"></a><span class="c1">// Less method of sort.Interface</span>
|
||||
<a id="__codelineno-4-26" name="__codelineno-4-26" href="#__codelineno-4-26"></a><span class="kd">func</span><span class="w"> </span><span class="p">(</span><span class="nx">h</span><span class="w"> </span><span class="o">*</span><span class="nx">intHeap</span><span class="p">)</span><span class="w"> </span><span class="nx">Less</span><span class="p">(</span><span class="nx">i</span><span class="p">,</span><span class="w"> </span><span class="nx">j</span><span class="w"> </span><span class="kt">int</span><span class="p">)</span><span class="w"> </span><span class="kt">bool</span><span class="w"> </span><span class="p">{</span>
|
||||
<a id="__codelineno-4-27" name="__codelineno-4-27" href="#__codelineno-4-27"></a><span class="w"> </span><span class="c1">// 如果实现小顶堆，则需要调整为小于号</span>
|
||||
<a id="__codelineno-4-27" name="__codelineno-4-27" href="#__codelineno-4-27"></a><span class="w"> </span><span class="c1">// If you want to implement a min heap, you would change this to a less-than comparison</span>
|
||||
<a id="__codelineno-4-28" name="__codelineno-4-28" href="#__codelineno-4-28"></a><span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="p">(</span><span class="o">*</span><span class="nx">h</span><span class="p">)[</span><span class="nx">i</span><span class="p">].(</span><span class="kt">int</span><span class="p">)</span><span class="w"> </span><span class="p">></span><span class="w"> </span><span class="p">(</span><span class="o">*</span><span class="nx">h</span><span class="p">)[</span><span class="nx">j</span><span class="p">].(</span><span class="kt">int</span><span class="p">)</span>
|
||||
<a id="__codelineno-4-29" name="__codelineno-4-29" href="#__codelineno-4-29"></a><span class="p">}</span>
|
||||
<a id="__codelineno-4-30" name="__codelineno-4-30" href="#__codelineno-4-30"></a>
|
||||
<a id="__codelineno-4-31" name="__codelineno-4-31" href="#__codelineno-4-31"></a><span class="c1">// Swap sort.Interface 的方法</span>
|
||||
<a id="__codelineno-4-31" name="__codelineno-4-31" href="#__codelineno-4-31"></a><span class="c1">// Swap method of sort.Interface</span>
|
||||
<a id="__codelineno-4-32" name="__codelineno-4-32" href="#__codelineno-4-32"></a><span class="kd">func</span><span class="w"> </span><span class="p">(</span><span class="nx">h</span><span class="w"> </span><span class="o">*</span><span class="nx">intHeap</span><span class="p">)</span><span class="w"> </span><span class="nx">Swap</span><span class="p">(</span><span class="nx">i</span><span class="p">,</span><span class="w"> </span><span class="nx">j</span><span class="w"> </span><span class="kt">int</span><span class="p">)</span><span class="w"> </span><span class="p">{</span>
|
||||
<a id="__codelineno-4-33" name="__codelineno-4-33" href="#__codelineno-4-33"></a><span class="w"> </span><span class="p">(</span><span class="o">*</span><span class="nx">h</span><span class="p">)[</span><span class="nx">i</span><span class="p">],</span><span class="w"> </span><span class="p">(</span><span class="o">*</span><span class="nx">h</span><span class="p">)[</span><span class="nx">j</span><span class="p">]</span><span class="w"> </span><span class="p">=</span><span class="w"> </span><span class="p">(</span><span class="o">*</span><span class="nx">h</span><span class="p">)[</span><span class="nx">j</span><span class="p">],</span><span class="w"> </span><span class="p">(</span><span class="o">*</span><span class="nx">h</span><span class="p">)[</span><span class="nx">i</span><span class="p">]</span>
|
||||
<a id="__codelineno-4-34" name="__codelineno-4-34" href="#__codelineno-4-34"></a><span class="p">}</span>
|
||||
<a id="__codelineno-4-35" name="__codelineno-4-35" href="#__codelineno-4-35"></a>
|
||||
<a id="__codelineno-4-36" name="__codelineno-4-36" href="#__codelineno-4-36"></a><span class="c1">// Top 获取堆顶元素</span>
|
||||
<a id="__codelineno-4-36" name="__codelineno-4-36" href="#__codelineno-4-36"></a><span class="c1">// Top Retrieve the top element of the heap</span>
|
||||
<a id="__codelineno-4-37" name="__codelineno-4-37" href="#__codelineno-4-37"></a><span class="kd">func</span><span class="w"> </span><span class="p">(</span><span class="nx">h</span><span class="w"> </span><span class="o">*</span><span class="nx">intHeap</span><span class="p">)</span><span class="w"> </span><span class="nx">Top</span><span class="p">()</span><span class="w"> </span><span class="kt">any</span><span class="w"> </span><span class="p">{</span>
|
||||
<a id="__codelineno-4-38" name="__codelineno-4-38" href="#__codelineno-4-38"></a><span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="p">(</span><span class="o">*</span><span class="nx">h</span><span class="p">)[</span><span class="mi">0</span><span class="p">]</span>
|
||||
<a id="__codelineno-4-39" name="__codelineno-4-39" href="#__codelineno-4-39"></a><span class="p">}</span>
|
||||
<a id="__codelineno-4-40" name="__codelineno-4-40" href="#__codelineno-4-40"></a>
|
||||
<a id="__codelineno-4-41" name="__codelineno-4-41" href="#__codelineno-4-41"></a><span class="cm">/* Driver Code */</span>
|
||||
<a id="__codelineno-4-42" name="__codelineno-4-42" href="#__codelineno-4-42"></a><span class="kd">func</span><span class="w"> </span><span class="nx">TestHeap</span><span class="p">(</span><span class="nx">t</span><span class="w"> </span><span class="o">*</span><span class="nx">testing</span><span class="p">.</span><span class="nx">T</span><span class="p">)</span><span class="w"> </span><span class="p">{</span>
|
||||
<a id="__codelineno-4-43" name="__codelineno-4-43" href="#__codelineno-4-43"></a><span class="w"> </span><span class="cm">/* 初始化堆 */</span>
|
||||
<a id="__codelineno-4-44" name="__codelineno-4-44" href="#__codelineno-4-44"></a><span class="w"> </span><span class="c1">// 初始化大顶堆</span>
|
||||
<a id="__codelineno-4-43" name="__codelineno-4-43" href="#__codelineno-4-43"></a><span class="w"> </span><span class="cm">/* Initialize a heap */</span>
|
||||
<a id="__codelineno-4-44" name="__codelineno-4-44" href="#__codelineno-4-44"></a><span class="w"> </span><span class="c1">// Initialize a max heap</span>
|
||||
<a id="__codelineno-4-45" name="__codelineno-4-45" href="#__codelineno-4-45"></a><span class="w"> </span><span class="nx">maxHeap</span><span class="w"> </span><span class="o">:=</span><span class="w"> </span><span class="o">&</span><span class="nx">intHeap</span><span class="p">{}</span>
|
||||
<a id="__codelineno-4-46" name="__codelineno-4-46" href="#__codelineno-4-46"></a><span class="w"> </span><span class="nx">heap</span><span class="p">.</span><span class="nx">Init</span><span class="p">(</span><span class="nx">maxHeap</span><span class="p">)</span>
|
||||
<a id="__codelineno-4-47" name="__codelineno-4-47" href="#__codelineno-4-47"></a><span class="w"> </span><span class="cm">/* 元素入堆 */</span>
|
||||
<a id="__codelineno-4-48" name="__codelineno-4-48" href="#__codelineno-4-48"></a><span class="w"> </span><span class="c1">// 调用 heap.Interface 的方法，来添加元素</span>
|
||||
<a id="__codelineno-4-47" name="__codelineno-4-47" href="#__codelineno-4-47"></a><span class="w"> </span><span class="cm">/* Push elements into the heap */</span>
|
||||
<a id="__codelineno-4-48" name="__codelineno-4-48" href="#__codelineno-4-48"></a><span class="w"> </span><span class="c1">// Call the methods of heap.Interface to add elements</span>
|
||||
<a id="__codelineno-4-49" name="__codelineno-4-49" href="#__codelineno-4-49"></a><span class="w"> </span><span class="nx">heap</span><span class="p">.</span><span class="nx">Push</span><span class="p">(</span><span class="nx">maxHeap</span><span class="p">,</span><span class="w"> </span><span class="mi">1</span><span class="p">)</span>
|
||||
<a id="__codelineno-4-50" name="__codelineno-4-50" href="#__codelineno-4-50"></a><span class="w"> </span><span class="nx">heap</span><span class="p">.</span><span class="nx">Push</span><span class="p">(</span><span class="nx">maxHeap</span><span class="p">,</span><span class="w"> </span><span class="mi">3</span><span class="p">)</span>
|
||||
<a id="__codelineno-4-51" name="__codelineno-4-51" href="#__codelineno-4-51"></a><span class="w"> </span><span class="nx">heap</span><span class="p">.</span><span class="nx">Push</span><span class="p">(</span><span class="nx">maxHeap</span><span class="p">,</span><span class="w"> </span><span class="mi">2</span><span class="p">)</span>
|
||||
<a id="__codelineno-4-52" name="__codelineno-4-52" href="#__codelineno-4-52"></a><span class="w"> </span><span class="nx">heap</span><span class="p">.</span><span class="nx">Push</span><span class="p">(</span><span class="nx">maxHeap</span><span class="p">,</span><span class="w"> </span><span class="mi">4</span><span class="p">)</span>
|
||||
<a id="__codelineno-4-53" name="__codelineno-4-53" href="#__codelineno-4-53"></a><span class="w"> </span><span class="nx">heap</span><span class="p">.</span><span class="nx">Push</span><span class="p">(</span><span class="nx">maxHeap</span><span class="p">,</span><span class="w"> </span><span class="mi">5</span><span class="p">)</span>
|
||||
<a id="__codelineno-4-54" name="__codelineno-4-54" href="#__codelineno-4-54"></a>
|
||||
<a id="__codelineno-4-55" name="__codelineno-4-55" href="#__codelineno-4-55"></a><span class="w"> </span><span class="cm">/* 获取堆顶元素 */</span>
|
||||
<a id="__codelineno-4-55" name="__codelineno-4-55" href="#__codelineno-4-55"></a><span class="w"> </span><span class="cm">/* Retrieve the top element of the heap */</span>
|
||||
<a id="__codelineno-4-56" name="__codelineno-4-56" href="#__codelineno-4-56"></a><span class="w"> </span><span class="nx">top</span><span class="w"> </span><span class="o">:=</span><span class="w"> </span><span class="nx">maxHeap</span><span class="p">.</span><span class="nx">Top</span><span class="p">()</span>
|
||||
<a id="__codelineno-4-57" name="__codelineno-4-57" href="#__codelineno-4-57"></a><span class="w"> </span><span class="nx">fmt</span><span class="p">.</span><span class="nx">Printf</span><span class="p">(</span><span class="s">"堆顶元素为 %d\n"</span><span class="p">,</span><span class="w"> </span><span class="nx">top</span><span class="p">)</span>
|
||||
<a id="__codelineno-4-57" name="__codelineno-4-57" href="#__codelineno-4-57"></a><span class="w"> </span><span class="nx">fmt</span><span class="p">.</span><span class="nx">Printf</span><span class="p">(</span><span class="s">"The top element of the heap is %d\n"</span><span class="p">,</span><span class="w"> </span><span class="nx">top</span><span class="p">)</span>
|
||||
<a id="__codelineno-4-58" name="__codelineno-4-58" href="#__codelineno-4-58"></a>
|
||||
<a id="__codelineno-4-59" name="__codelineno-4-59" href="#__codelineno-4-59"></a><span class="w"> </span><span class="cm">/* 堆顶元素出堆 */</span>
|
||||
<a id="__codelineno-4-60" name="__codelineno-4-60" href="#__codelineno-4-60"></a><span class="w"> </span><span class="c1">// 调用 heap.Interface 的方法，来移除元素</span>
|
||||
<a id="__codelineno-4-59" name="__codelineno-4-59" href="#__codelineno-4-59"></a><span class="w"> </span><span class="cm">/* Pop the top element of the heap */</span>
|
||||
<a id="__codelineno-4-60" name="__codelineno-4-60" href="#__codelineno-4-60"></a><span class="w"> </span><span class="c1">// Call the methods of heap.Interface to remove elements</span>
|
||||
<a id="__codelineno-4-61" name="__codelineno-4-61" href="#__codelineno-4-61"></a><span class="w"> </span><span class="nx">heap</span><span class="p">.</span><span class="nx">Pop</span><span class="p">(</span><span class="nx">maxHeap</span><span class="p">)</span><span class="w"> </span><span class="c1">// 5</span>
|
||||
<a id="__codelineno-4-62" name="__codelineno-4-62" href="#__codelineno-4-62"></a><span class="w"> </span><span class="nx">heap</span><span class="p">.</span><span class="nx">Pop</span><span class="p">(</span><span class="nx">maxHeap</span><span class="p">)</span><span class="w"> </span><span class="c1">// 4</span>
|
||||
<a id="__codelineno-4-63" name="__codelineno-4-63" href="#__codelineno-4-63"></a><span class="w"> </span><span class="nx">heap</span><span class="p">.</span><span class="nx">Pop</span><span class="p">(</span><span class="nx">maxHeap</span><span class="p">)</span><span class="w"> </span><span class="c1">// 3</span>
|
||||
<a id="__codelineno-4-64" name="__codelineno-4-64" href="#__codelineno-4-64"></a><span class="w"> </span><span class="nx">heap</span><span class="p">.</span><span class="nx">Pop</span><span class="p">(</span><span class="nx">maxHeap</span><span class="p">)</span><span class="w"> </span><span class="c1">// 2</span>
|
||||
<a id="__codelineno-4-65" name="__codelineno-4-65" href="#__codelineno-4-65"></a><span class="w"> </span><span class="nx">heap</span><span class="p">.</span><span class="nx">Pop</span><span class="p">(</span><span class="nx">maxHeap</span><span class="p">)</span><span class="w"> </span><span class="c1">// 1</span>
|
||||
<a id="__codelineno-4-66" name="__codelineno-4-66" href="#__codelineno-4-66"></a>
|
||||
<a id="__codelineno-4-67" name="__codelineno-4-67" href="#__codelineno-4-67"></a><span class="w"> </span><span class="cm">/* 获取堆大小 */</span>
|
||||
<a id="__codelineno-4-67" name="__codelineno-4-67" href="#__codelineno-4-67"></a><span class="w"> </span><span class="cm">/* Get the size of the heap */</span>
|
||||
<a id="__codelineno-4-68" name="__codelineno-4-68" href="#__codelineno-4-68"></a><span class="w"> </span><span class="nx">size</span><span class="w"> </span><span class="o">:=</span><span class="w"> </span><span class="nb">len</span><span class="p">(</span><span class="o">*</span><span class="nx">maxHeap</span><span class="p">)</span>
|
||||
<a id="__codelineno-4-69" name="__codelineno-4-69" href="#__codelineno-4-69"></a><span class="w"> </span><span class="nx">fmt</span><span class="p">.</span><span class="nx">Printf</span><span class="p">(</span><span class="s">"堆元素数量为 %d\n"</span><span class="p">,</span><span class="w"> </span><span class="nx">size</span><span class="p">)</span>
|
||||
<a id="__codelineno-4-69" name="__codelineno-4-69" href="#__codelineno-4-69"></a><span class="w"> </span><span class="nx">fmt</span><span class="p">.</span><span class="nx">Printf</span><span class="p">(</span><span class="s">"The number of elements in the heap is %d\n"</span><span class="p">,</span><span class="w"> </span><span class="nx">size</span><span class="p">)</span>
|
||||
<a id="__codelineno-4-70" name="__codelineno-4-70" href="#__codelineno-4-70"></a>
|
||||
<a id="__codelineno-4-71" name="__codelineno-4-71" href="#__codelineno-4-71"></a><span class="w"> </span><span class="cm">/* 判断堆是否为空 */</span>
|
||||
<a id="__codelineno-4-71" name="__codelineno-4-71" href="#__codelineno-4-71"></a><span class="w"> </span><span class="cm">/* Check if the heap is empty */</span>
|
||||
<a id="__codelineno-4-72" name="__codelineno-4-72" href="#__codelineno-4-72"></a><span class="w"> </span><span class="nx">isEmpty</span><span class="w"> </span><span class="o">:=</span><span class="w"> </span><span class="nb">len</span><span class="p">(</span><span class="o">*</span><span class="nx">maxHeap</span><span class="p">)</span><span class="w"> </span><span class="o">==</span><span class="w"> </span><span class="mi">0</span>
|
||||
<a id="__codelineno-4-73" name="__codelineno-4-73" href="#__codelineno-4-73"></a><span class="w"> </span><span class="nx">fmt</span><span class="p">.</span><span class="nx">Printf</span><span class="p">(</span><span class="s">"堆是否为空 %t\n"</span><span class="p">,</span><span class="w"> </span><span class="nx">isEmpty</span><span class="p">)</span>
|
||||
<a id="__codelineno-4-73" name="__codelineno-4-73" href="#__codelineno-4-73"></a><span class="w"> </span><span class="nx">fmt</span><span class="p">.</span><span class="nx">Printf</span><span class="p">(</span><span class="s">"Is the heap empty? %t\n"</span><span class="p">,</span><span class="w"> </span><span class="nx">isEmpty</span><span class="p">)</span>
|
||||
<a id="__codelineno-4-74" name="__codelineno-4-74" href="#__codelineno-4-74"></a><span class="p">}</span>
|
||||
</code></pre></div>
|
||||
</div>
|
||||
<div class="tabbed-block">
|
||||
<div class="highlight"><span class="filename">heap.swift</span><pre><span></span><code><a id="__codelineno-5-1" name="__codelineno-5-1" href="#__codelineno-5-1"></a><span class="cm">/* 初始化堆 */</span>
|
||||
<a id="__codelineno-5-2" name="__codelineno-5-2" href="#__codelineno-5-2"></a><span class="c1">// Swift 的 Heap 类型同时支持最大堆和最小堆，且需要引入 swift-collections</span>
|
||||
<div class="highlight"><span class="filename">heap.swift</span><pre><span></span><code><a id="__codelineno-5-1" name="__codelineno-5-1" href="#__codelineno-5-1"></a><span class="cm">/* Initialize a heap */</span>
|
||||
<a id="__codelineno-5-2" name="__codelineno-5-2" href="#__codelineno-5-2"></a><span class="c1">// Swift’s Heap type supports both max heaps and min heaps, and need the swift-collections library</span>
|
||||
<a id="__codelineno-5-3" name="__codelineno-5-3" href="#__codelineno-5-3"></a><span class="kd">var</span> <span class="nv">heap</span> <span class="p">=</span> <span class="n">Heap</span><span class="p"><</span><span class="nb">Int</span><span class="p">>()</span>
|
||||
<a id="__codelineno-5-4" name="__codelineno-5-4" href="#__codelineno-5-4"></a>
|
||||
<a id="__codelineno-5-5" name="__codelineno-5-5" href="#__codelineno-5-5"></a><span class="cm">/* 元素入堆 */</span>
|
||||
<a id="__codelineno-5-5" name="__codelineno-5-5" href="#__codelineno-5-5"></a><span class="cm">/* Push elements into the heap */</span>
|
||||
<a id="__codelineno-5-6" name="__codelineno-5-6" href="#__codelineno-5-6"></a><span class="n">heap</span><span class="p">.</span><span class="bp">insert</span><span class="p">(</span><span class="mi">1</span><span class="p">)</span>
|
||||
<a id="__codelineno-5-7" name="__codelineno-5-7" href="#__codelineno-5-7"></a><span class="n">heap</span><span class="p">.</span><span class="bp">insert</span><span class="p">(</span><span class="mi">3</span><span class="p">)</span>
|
||||
<a id="__codelineno-5-8" name="__codelineno-5-8" href="#__codelineno-5-8"></a><span class="n">heap</span><span class="p">.</span><span class="bp">insert</span><span class="p">(</span><span class="mi">2</span><span class="p">)</span>
|
||||
<a id="__codelineno-5-9" name="__codelineno-5-9" href="#__codelineno-5-9"></a><span class="n">heap</span><span class="p">.</span><span class="bp">insert</span><span class="p">(</span><span class="mi">5</span><span class="p">)</span>
|
||||
<a id="__codelineno-5-10" name="__codelineno-5-10" href="#__codelineno-5-10"></a><span class="n">heap</span><span class="p">.</span><span class="bp">insert</span><span class="p">(</span><span class="mi">4</span><span class="p">)</span>
|
||||
<a id="__codelineno-5-11" name="__codelineno-5-11" href="#__codelineno-5-11"></a>
|
||||
<a id="__codelineno-5-12" name="__codelineno-5-12" href="#__codelineno-5-12"></a><span class="cm">/* 获取堆顶元素 */</span>
|
||||
<a id="__codelineno-5-12" name="__codelineno-5-12" href="#__codelineno-5-12"></a><span class="cm">/* Retrieve the top element of the heap */</span>
|
||||
<a id="__codelineno-5-13" name="__codelineno-5-13" href="#__codelineno-5-13"></a><span class="kd">var</span> <span class="nv">peek</span> <span class="p">=</span> <span class="n">heap</span><span class="p">.</span><span class="bp">max</span><span class="p">()</span><span class="o">!</span>
|
||||
<a id="__codelineno-5-14" name="__codelineno-5-14" href="#__codelineno-5-14"></a>
|
||||
<a id="__codelineno-5-15" name="__codelineno-5-15" href="#__codelineno-5-15"></a><span class="cm">/* 堆顶元素出堆 */</span>
|
||||
<a id="__codelineno-5-15" name="__codelineno-5-15" href="#__codelineno-5-15"></a><span class="cm">/* Pop the top element of the heap */</span>
|
||||
<a id="__codelineno-5-16" name="__codelineno-5-16" href="#__codelineno-5-16"></a><span class="n">peek</span> <span class="p">=</span> <span class="n">heap</span><span class="p">.</span><span class="n">removeMax</span><span class="p">()</span> <span class="c1">// 5</span>
|
||||
<a id="__codelineno-5-17" name="__codelineno-5-17" href="#__codelineno-5-17"></a><span class="n">peek</span> <span class="p">=</span> <span class="n">heap</span><span class="p">.</span><span class="n">removeMax</span><span class="p">()</span> <span class="c1">// 4</span>
|
||||
<a id="__codelineno-5-18" name="__codelineno-5-18" href="#__codelineno-5-18"></a><span class="n">peek</span> <span class="p">=</span> <span class="n">heap</span><span class="p">.</span><span class="n">removeMax</span><span class="p">()</span> <span class="c1">// 3</span>
|
||||
<a id="__codelineno-5-19" name="__codelineno-5-19" href="#__codelineno-5-19"></a><span class="n">peek</span> <span class="p">=</span> <span class="n">heap</span><span class="p">.</span><span class="n">removeMax</span><span class="p">()</span> <span class="c1">// 2</span>
|
||||
<a id="__codelineno-5-20" name="__codelineno-5-20" href="#__codelineno-5-20"></a><span class="n">peek</span> <span class="p">=</span> <span class="n">heap</span><span class="p">.</span><span class="n">removeMax</span><span class="p">()</span> <span class="c1">// 1</span>
|
||||
<a id="__codelineno-5-21" name="__codelineno-5-21" href="#__codelineno-5-21"></a>
|
||||
<a id="__codelineno-5-22" name="__codelineno-5-22" href="#__codelineno-5-22"></a><span class="cm">/* 获取堆大小 */</span>
|
||||
<a id="__codelineno-5-22" name="__codelineno-5-22" href="#__codelineno-5-22"></a><span class="cm">/* Get the size of the heap */</span>
|
||||
<a id="__codelineno-5-23" name="__codelineno-5-23" href="#__codelineno-5-23"></a><span class="kd">let</span> <span class="nv">size</span> <span class="p">=</span> <span class="n">heap</span><span class="p">.</span><span class="bp">count</span>
|
||||
<a id="__codelineno-5-24" name="__codelineno-5-24" href="#__codelineno-5-24"></a>
|
||||
<a id="__codelineno-5-25" name="__codelineno-5-25" href="#__codelineno-5-25"></a><span class="cm">/* 判断堆是否为空 */</span>
|
||||
<a id="__codelineno-5-25" name="__codelineno-5-25" href="#__codelineno-5-25"></a><span class="cm">/* Check if the heap is empty */</span>
|
||||
<a id="__codelineno-5-26" name="__codelineno-5-26" href="#__codelineno-5-26"></a><span class="kd">let</span> <span class="nv">isEmpty</span> <span class="p">=</span> <span class="n">heap</span><span class="p">.</span><span class="bp">isEmpty</span>
|
||||
<a id="__codelineno-5-27" name="__codelineno-5-27" href="#__codelineno-5-27"></a>
|
||||
<a id="__codelineno-5-28" name="__codelineno-5-28" href="#__codelineno-5-28"></a><span class="cm">/* 输入列表并建堆 */</span>
|
||||
<a id="__codelineno-5-28" name="__codelineno-5-28" href="#__codelineno-5-28"></a><span class="cm">/* Create a heap from a list */</span>
|
||||
<a id="__codelineno-5-29" name="__codelineno-5-29" href="#__codelineno-5-29"></a><span class="kd">let</span> <span class="nv">heap2</span> <span class="p">=</span> <span class="n">Heap</span><span class="p">([</span><span class="mi">1</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">5</span><span class="p">,</span> <span class="mi">4</span><span class="p">])</span>
|
||||
</code></pre></div>
|
||||
</div>
|
||||
<div class="tabbed-block">
|
||||
<div class="highlight"><span class="filename">heap.js</span><pre><span></span><code><a id="__codelineno-6-1" name="__codelineno-6-1" href="#__codelineno-6-1"></a><span class="c1">// JavaScript 未提供内置 Heap 类</span>
|
||||
<div class="highlight"><span class="filename">heap.js</span><pre><span></span><code><a id="__codelineno-6-1" name="__codelineno-6-1" href="#__codelineno-6-1"></a><span class="c1">// JavaScript does not provide a built-in Heap class</span>
|
||||
</code></pre></div>
|
||||
</div>
|
||||
<div class="tabbed-block">
|
||||
<div class="highlight"><span class="filename">heap.ts</span><pre><span></span><code><a id="__codelineno-7-1" name="__codelineno-7-1" href="#__codelineno-7-1"></a><span class="c1">// TypeScript 未提供内置 Heap 类</span>
|
||||
<div class="highlight"><span class="filename">heap.ts</span><pre><span></span><code><a id="__codelineno-7-1" name="__codelineno-7-1" href="#__codelineno-7-1"></a><span class="c1">// TypeScript does not provide a built-in Heap class</span>
|
||||
</code></pre></div>
|
||||
</div>
|
||||
<div class="tabbed-block">
|
||||
<div class="highlight"><span class="filename">heap.dart</span><pre><span></span><code><a id="__codelineno-8-1" name="__codelineno-8-1" href="#__codelineno-8-1"></a><span class="c1">// Dart 未提供内置 Heap 类</span>
|
||||
<div class="highlight"><span class="filename">heap.dart</span><pre><span></span><code><a id="__codelineno-8-1" name="__codelineno-8-1" href="#__codelineno-8-1"></a><span class="c1">// Dart does not provide a built-in Heap class</span>
|
||||
</code></pre></div>
|
||||
</div>
|
||||
<div class="tabbed-block">
|
||||
<div class="highlight"><span class="filename">heap.rs</span><pre><span></span><code><a id="__codelineno-9-1" name="__codelineno-9-1" href="#__codelineno-9-1"></a><span class="k">use</span><span class="w"> </span><span class="n">std</span>::<span class="n">collections</span>::<span class="n">BinaryHeap</span><span class="p">;</span>
|
||||
<a id="__codelineno-9-2" name="__codelineno-9-2" href="#__codelineno-9-2"></a><span class="k">use</span><span class="w"> </span><span class="n">std</span>::<span class="n">cmp</span>::<span class="n">Reverse</span><span class="p">;</span>
|
||||
<a id="__codelineno-9-3" name="__codelineno-9-3" href="#__codelineno-9-3"></a>
|
||||
<a id="__codelineno-9-4" name="__codelineno-9-4" href="#__codelineno-9-4"></a><span class="cm">/* 初始化堆 */</span>
|
||||
<a id="__codelineno-9-5" name="__codelineno-9-5" href="#__codelineno-9-5"></a><span class="c1">// 初始化小顶堆</span>
|
||||
<a id="__codelineno-9-4" name="__codelineno-9-4" href="#__codelineno-9-4"></a><span class="cm">/* Initialize a heap */</span>
|
||||
<a id="__codelineno-9-5" name="__codelineno-9-5" href="#__codelineno-9-5"></a><span class="c1">// Initialize a min heap</span>
|
||||
<a id="__codelineno-9-6" name="__codelineno-9-6" href="#__codelineno-9-6"></a><span class="kd">let</span><span class="w"> </span><span class="k">mut</span><span class="w"> </span><span class="n">min_heap</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">BinaryHeap</span>::<span class="o"><</span><span class="n">Reverse</span><span class="o"><</span><span class="kt">i32</span><span class="o">>></span>::<span class="n">new</span><span class="p">();</span>
|
||||
<a id="__codelineno-9-7" name="__codelineno-9-7" href="#__codelineno-9-7"></a><span class="c1">// 初始化大顶堆</span>
|
||||
<a id="__codelineno-9-7" name="__codelineno-9-7" href="#__codelineno-9-7"></a><span class="c1">// Initialize a max heap</span>
|
||||
<a id="__codelineno-9-8" name="__codelineno-9-8" href="#__codelineno-9-8"></a><span class="kd">let</span><span class="w"> </span><span class="k">mut</span><span class="w"> </span><span class="n">max_heap</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">BinaryHeap</span>::<span class="n">new</span><span class="p">();</span>
|
||||
<a id="__codelineno-9-9" name="__codelineno-9-9" href="#__codelineno-9-9"></a>
|
||||
<a id="__codelineno-9-10" name="__codelineno-9-10" href="#__codelineno-9-10"></a><span class="cm">/* 元素入堆 */</span>
|
||||
<a id="__codelineno-9-10" name="__codelineno-9-10" href="#__codelineno-9-10"></a><span class="cm">/* Push elements into the heap */</span>
|
||||
<a id="__codelineno-9-11" name="__codelineno-9-11" href="#__codelineno-9-11"></a><span class="n">max_heap</span><span class="p">.</span><span class="n">push</span><span class="p">(</span><span class="mi">1</span><span class="p">);</span>
|
||||
<a id="__codelineno-9-12" name="__codelineno-9-12" href="#__codelineno-9-12"></a><span class="n">max_heap</span><span class="p">.</span><span class="n">push</span><span class="p">(</span><span class="mi">3</span><span class="p">);</span>
|
||||
<a id="__codelineno-9-13" name="__codelineno-9-13" href="#__codelineno-9-13"></a><span class="n">max_heap</span><span class="p">.</span><span class="n">push</span><span class="p">(</span><span class="mi">2</span><span class="p">);</span>
|
||||
<a id="__codelineno-9-14" name="__codelineno-9-14" href="#__codelineno-9-14"></a><span class="n">max_heap</span><span class="p">.</span><span class="n">push</span><span class="p">(</span><span class="mi">5</span><span class="p">);</span>
|
||||
<a id="__codelineno-9-15" name="__codelineno-9-15" href="#__codelineno-9-15"></a><span class="n">max_heap</span><span class="p">.</span><span class="n">push</span><span class="p">(</span><span class="mi">4</span><span class="p">);</span>
|
||||
<a id="__codelineno-9-16" name="__codelineno-9-16" href="#__codelineno-9-16"></a>
|
||||
<a id="__codelineno-9-17" name="__codelineno-9-17" href="#__codelineno-9-17"></a><span class="cm">/* 获取堆顶元素 */</span>
|
||||
<a id="__codelineno-9-17" name="__codelineno-9-17" href="#__codelineno-9-17"></a><span class="cm">/* Retrieve the top element of the heap */</span>
|
||||
<a id="__codelineno-9-18" name="__codelineno-9-18" href="#__codelineno-9-18"></a><span class="kd">let</span><span class="w"> </span><span class="n">peek</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">max_heap</span><span class="p">.</span><span class="n">peek</span><span class="p">().</span><span class="n">unwrap</span><span class="p">();</span><span class="w"> </span><span class="c1">// 5</span>
|
||||
<a id="__codelineno-9-19" name="__codelineno-9-19" href="#__codelineno-9-19"></a>
|
||||
<a id="__codelineno-9-20" name="__codelineno-9-20" href="#__codelineno-9-20"></a><span class="cm">/* 堆顶元素出堆 */</span>
|
||||
<a id="__codelineno-9-21" name="__codelineno-9-21" href="#__codelineno-9-21"></a><span class="c1">// 出堆元素会形成一个从大到小的序列</span>
|
||||
<a id="__codelineno-9-20" name="__codelineno-9-20" href="#__codelineno-9-20"></a><span class="cm">/* Pop the top element of the heap */</span>
|
||||
<a id="__codelineno-9-21" name="__codelineno-9-21" href="#__codelineno-9-21"></a><span class="c1">// The popped elements will form a sequence in descending order</span>
|
||||
<a id="__codelineno-9-22" name="__codelineno-9-22" href="#__codelineno-9-22"></a><span class="kd">let</span><span class="w"> </span><span class="n">peek</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">max_heap</span><span class="p">.</span><span class="n">pop</span><span class="p">().</span><span class="n">unwrap</span><span class="p">();</span><span class="w"> </span><span class="c1">// 5</span>
|
||||
<a id="__codelineno-9-23" name="__codelineno-9-23" href="#__codelineno-9-23"></a><span class="kd">let</span><span class="w"> </span><span class="n">peek</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">max_heap</span><span class="p">.</span><span class="n">pop</span><span class="p">().</span><span class="n">unwrap</span><span class="p">();</span><span class="w"> </span><span class="c1">// 4</span>
|
||||
<a id="__codelineno-9-24" name="__codelineno-9-24" href="#__codelineno-9-24"></a><span class="kd">let</span><span class="w"> </span><span class="n">peek</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">max_heap</span><span class="p">.</span><span class="n">pop</span><span class="p">().</span><span class="n">unwrap</span><span class="p">();</span><span class="w"> </span><span class="c1">// 3</span>
|
||||
<a id="__codelineno-9-25" name="__codelineno-9-25" href="#__codelineno-9-25"></a><span class="kd">let</span><span class="w"> </span><span class="n">peek</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">max_heap</span><span class="p">.</span><span class="n">pop</span><span class="p">().</span><span class="n">unwrap</span><span class="p">();</span><span class="w"> </span><span class="c1">// 2</span>
|
||||
<a id="__codelineno-9-26" name="__codelineno-9-26" href="#__codelineno-9-26"></a><span class="kd">let</span><span class="w"> </span><span class="n">peek</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">max_heap</span><span class="p">.</span><span class="n">pop</span><span class="p">().</span><span class="n">unwrap</span><span class="p">();</span><span class="w"> </span><span class="c1">// 1</span>
|
||||
<a id="__codelineno-9-27" name="__codelineno-9-27" href="#__codelineno-9-27"></a>
|
||||
<a id="__codelineno-9-28" name="__codelineno-9-28" href="#__codelineno-9-28"></a><span class="cm">/* 获取堆大小 */</span>
|
||||
<a id="__codelineno-9-28" name="__codelineno-9-28" href="#__codelineno-9-28"></a><span class="cm">/* Get the size of the heap */</span>
|
||||
<a id="__codelineno-9-29" name="__codelineno-9-29" href="#__codelineno-9-29"></a><span class="kd">let</span><span class="w"> </span><span class="n">size</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">max_heap</span><span class="p">.</span><span class="n">len</span><span class="p">();</span>
|
||||
<a id="__codelineno-9-30" name="__codelineno-9-30" href="#__codelineno-9-30"></a>
|
||||
<a id="__codelineno-9-31" name="__codelineno-9-31" href="#__codelineno-9-31"></a><span class="cm">/* 判断堆是否为空 */</span>
|
||||
<a id="__codelineno-9-31" name="__codelineno-9-31" href="#__codelineno-9-31"></a><span class="cm">/* Check if the heap is empty */</span>
|
||||
<a id="__codelineno-9-32" name="__codelineno-9-32" href="#__codelineno-9-32"></a><span class="kd">let</span><span class="w"> </span><span class="n">is_empty</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">max_heap</span><span class="p">.</span><span class="n">is_empty</span><span class="p">();</span>
|
||||
<a id="__codelineno-9-33" name="__codelineno-9-33" href="#__codelineno-9-33"></a>
|
||||
<a id="__codelineno-9-34" name="__codelineno-9-34" href="#__codelineno-9-34"></a><span class="cm">/* 输入列表并建堆 */</span>
|
||||
<a id="__codelineno-9-34" name="__codelineno-9-34" href="#__codelineno-9-34"></a><span class="cm">/* Create a heap from a list */</span>
|
||||
<a id="__codelineno-9-35" name="__codelineno-9-35" href="#__codelineno-9-35"></a><span class="kd">let</span><span class="w"> </span><span class="n">min_heap</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">BinaryHeap</span>::<span class="n">from</span><span class="p">(</span><span class="fm">vec!</span><span class="p">[</span><span class="n">Reverse</span><span class="p">(</span><span class="mi">1</span><span class="p">),</span><span class="w"> </span><span class="n">Reverse</span><span class="p">(</span><span class="mi">3</span><span class="p">),</span><span class="w"> </span><span class="n">Reverse</span><span class="p">(</span><span class="mi">2</span><span class="p">),</span><span class="w"> </span><span class="n">Reverse</span><span class="p">(</span><span class="mi">5</span><span class="p">),</span><span class="w"> </span><span class="n">Reverse</span><span class="p">(</span><span class="mi">4</span><span class="p">)]);</span>
|
||||
</code></pre></div>
|
||||
</div>
|
||||
<div class="tabbed-block">
|
||||
<div class="highlight"><span class="filename">heap.c</span><pre><span></span><code><a id="__codelineno-10-1" name="__codelineno-10-1" href="#__codelineno-10-1"></a><span class="c1">// C 未提供内置 Heap 类</span>
|
||||
<div class="highlight"><span class="filename">heap.c</span><pre><span></span><code><a id="__codelineno-10-1" name="__codelineno-10-1" href="#__codelineno-10-1"></a><span class="c1">// C does not provide a built-in Heap class</span>
|
||||
</code></pre></div>
|
||||
</div>
|
||||
<div class="tabbed-block">
|
||||
<div class="highlight"><span class="filename">heap.kt</span><pre><span></span><code><a id="__codelineno-11-1" name="__codelineno-11-1" href="#__codelineno-11-1"></a><span class="cm">/* 初始化堆 */</span>
|
||||
<a id="__codelineno-11-2" name="__codelineno-11-2" href="#__codelineno-11-2"></a><span class="c1">// 初始化小顶堆</span>
|
||||
<div class="highlight"><span class="filename">heap.kt</span><pre><span></span><code><a id="__codelineno-11-1" name="__codelineno-11-1" href="#__codelineno-11-1"></a><span class="cm">/* Initialize a heap */</span>
|
||||
<a id="__codelineno-11-2" name="__codelineno-11-2" href="#__codelineno-11-2"></a><span class="c1">// Initialize a min heap</span>
|
||||
<a id="__codelineno-11-3" name="__codelineno-11-3" href="#__codelineno-11-3"></a><span class="kd">var</span><span class="w"> </span><span class="nv">minHeap</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">PriorityQueue</span><span class="o"><</span><span class="kt">Int</span><span class="o">></span><span class="p">()</span>
|
||||
<a id="__codelineno-11-4" name="__codelineno-11-4" href="#__codelineno-11-4"></a><span class="c1">// 初始化大顶堆（使用 lambda 表达式修改 Comparator 即可）</span>
|
||||
<a id="__codelineno-11-4" name="__codelineno-11-4" href="#__codelineno-11-4"></a><span class="c1">// Initialize a max heap (Simply modify the Comparator using a lambda expression）</span>
|
||||
<a id="__codelineno-11-5" name="__codelineno-11-5" href="#__codelineno-11-5"></a><span class="kd">val</span><span class="w"> </span><span class="nv">maxHeap</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">PriorityQueue</span><span class="w"> </span><span class="p">{</span><span class="w"> </span><span class="n">a</span><span class="p">:</span><span class="w"> </span><span class="kt">Int</span><span class="p">,</span><span class="w"> </span><span class="n">b</span><span class="p">:</span><span class="w"> </span><span class="kt">Int</span><span class="w"> </span><span class="o">-></span><span class="w"> </span><span class="n">b</span><span class="w"> </span><span class="o">-</span><span class="w"> </span><span class="n">a</span><span class="w"> </span><span class="p">}</span>
|
||||
<a id="__codelineno-11-6" name="__codelineno-11-6" href="#__codelineno-11-6"></a>
|
||||
<a id="__codelineno-11-7" name="__codelineno-11-7" href="#__codelineno-11-7"></a><span class="cm">/* 元素入堆 */</span>
|
||||
<a id="__codelineno-11-7" name="__codelineno-11-7" href="#__codelineno-11-7"></a><span class="cm">/* Push elements into the heap */</span>
|
||||
<a id="__codelineno-11-8" name="__codelineno-11-8" href="#__codelineno-11-8"></a><span class="n">maxHeap</span><span class="p">.</span><span class="na">offer</span><span class="p">(</span><span class="m">1</span><span class="p">)</span>
|
||||
<a id="__codelineno-11-9" name="__codelineno-11-9" href="#__codelineno-11-9"></a><span class="n">maxHeap</span><span class="p">.</span><span class="na">offer</span><span class="p">(</span><span class="m">3</span><span class="p">)</span>
|
||||
<a id="__codelineno-11-10" name="__codelineno-11-10" href="#__codelineno-11-10"></a><span class="n">maxHeap</span><span class="p">.</span><span class="na">offer</span><span class="p">(</span><span class="m">2</span><span class="p">)</span>
|
||||
<a id="__codelineno-11-11" name="__codelineno-11-11" href="#__codelineno-11-11"></a><span class="n">maxHeap</span><span class="p">.</span><span class="na">offer</span><span class="p">(</span><span class="m">5</span><span class="p">)</span>
|
||||
<a id="__codelineno-11-12" name="__codelineno-11-12" href="#__codelineno-11-12"></a><span class="n">maxHeap</span><span class="p">.</span><span class="na">offer</span><span class="p">(</span><span class="m">4</span><span class="p">)</span>
|
||||
<a id="__codelineno-11-13" name="__codelineno-11-13" href="#__codelineno-11-13"></a>
|
||||
<a id="__codelineno-11-14" name="__codelineno-11-14" href="#__codelineno-11-14"></a><span class="cm">/* 获取堆顶元素 */</span>
|
||||
<a id="__codelineno-11-14" name="__codelineno-11-14" href="#__codelineno-11-14"></a><span class="cm">/* Retrieve the top element of the heap */</span>
|
||||
<a id="__codelineno-11-15" name="__codelineno-11-15" href="#__codelineno-11-15"></a><span class="kd">var</span><span class="w"> </span><span class="nv">peek</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">maxHeap</span><span class="p">.</span><span class="na">peek</span><span class="p">()</span><span class="w"> </span><span class="c1">// 5</span>
|
||||
<a id="__codelineno-11-16" name="__codelineno-11-16" href="#__codelineno-11-16"></a>
|
||||
<a id="__codelineno-11-17" name="__codelineno-11-17" href="#__codelineno-11-17"></a><span class="cm">/* 堆顶元素出堆 */</span>
|
||||
<a id="__codelineno-11-18" name="__codelineno-11-18" href="#__codelineno-11-18"></a><span class="c1">// 出堆元素会形成一个从大到小的序列</span>
|
||||
<a id="__codelineno-11-17" name="__codelineno-11-17" href="#__codelineno-11-17"></a><span class="cm">/* Pop the top element of the heap */</span>
|
||||
<a id="__codelineno-11-18" name="__codelineno-11-18" href="#__codelineno-11-18"></a><span class="c1">// The popped elements will form a sequence in descending order</span>
|
||||
<a id="__codelineno-11-19" name="__codelineno-11-19" href="#__codelineno-11-19"></a><span class="n">peek</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">maxHeap</span><span class="p">.</span><span class="na">poll</span><span class="p">()</span><span class="w"> </span><span class="c1">// 5</span>
|
||||
<a id="__codelineno-11-20" name="__codelineno-11-20" href="#__codelineno-11-20"></a><span class="n">peek</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">maxHeap</span><span class="p">.</span><span class="na">poll</span><span class="p">()</span><span class="w"> </span><span class="c1">// 4</span>
|
||||
<a id="__codelineno-11-21" name="__codelineno-11-21" href="#__codelineno-11-21"></a><span class="n">peek</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">maxHeap</span><span class="p">.</span><span class="na">poll</span><span class="p">()</span><span class="w"> </span><span class="c1">// 3</span>
|
||||
<a id="__codelineno-11-22" name="__codelineno-11-22" href="#__codelineno-11-22"></a><span class="n">peek</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">maxHeap</span><span class="p">.</span><span class="na">poll</span><span class="p">()</span><span class="w"> </span><span class="c1">// 2</span>
|
||||
<a id="__codelineno-11-23" name="__codelineno-11-23" href="#__codelineno-11-23"></a><span class="n">peek</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">maxHeap</span><span class="p">.</span><span class="na">poll</span><span class="p">()</span><span class="w"> </span><span class="c1">// 1</span>
|
||||
<a id="__codelineno-11-24" name="__codelineno-11-24" href="#__codelineno-11-24"></a>
|
||||
<a id="__codelineno-11-25" name="__codelineno-11-25" href="#__codelineno-11-25"></a><span class="cm">/* 获取堆大小 */</span>
|
||||
<a id="__codelineno-11-25" name="__codelineno-11-25" href="#__codelineno-11-25"></a><span class="cm">/* Get the size of the heap */</span>
|
||||
<a id="__codelineno-11-26" name="__codelineno-11-26" href="#__codelineno-11-26"></a><span class="kd">val</span><span class="w"> </span><span class="nv">size</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">maxHeap</span><span class="p">.</span><span class="na">size</span>
|
||||
<a id="__codelineno-11-27" name="__codelineno-11-27" href="#__codelineno-11-27"></a>
|
||||
<a id="__codelineno-11-28" name="__codelineno-11-28" href="#__codelineno-11-28"></a><span class="cm">/* 判断堆是否为空 */</span>
|
||||
<a id="__codelineno-11-28" name="__codelineno-11-28" href="#__codelineno-11-28"></a><span class="cm">/* Check if the heap is empty */</span>
|
||||
<a id="__codelineno-11-29" name="__codelineno-11-29" href="#__codelineno-11-29"></a><span class="kd">val</span><span class="w"> </span><span class="nv">isEmpty</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">maxHeap</span><span class="p">.</span><span class="na">isEmpty</span><span class="p">()</span>
|
||||
<a id="__codelineno-11-30" name="__codelineno-11-30" href="#__codelineno-11-30"></a>
|
||||
<a id="__codelineno-11-31" name="__codelineno-11-31" href="#__codelineno-11-31"></a><span class="cm">/* 输入列表并建堆 */</span>
|
||||
<a id="__codelineno-11-31" name="__codelineno-11-31" href="#__codelineno-11-31"></a><span class="cm">/* Create a heap from a list */</span>
|
||||
<a id="__codelineno-11-32" name="__codelineno-11-32" href="#__codelineno-11-32"></a><span class="n">minHeap</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">PriorityQueue</span><span class="p">(</span><span class="n">mutableListOf</span><span class="p">(</span><span class="m">1</span><span class="p">,</span><span class="w"> </span><span class="m">3</span><span class="p">,</span><span class="w"> </span><span class="m">2</span><span class="p">,</span><span class="w"> </span><span class="m">5</span><span class="p">,</span><span class="w"> </span><span class="m">4</span><span class="p">))</span>
|
||||
</code></pre></div>
|
||||
</div>
|
||||
@@ -4102,13 +4102,13 @@
|
||||
</div>
|
||||
</div>
|
||||
<details class="pythontutor">
|
||||
<summary>可视化运行</summary>
|
||||
<summary>Code visualization</summary>
|
||||
<p>https://pythontutor.com/render.html#code=import%20heapq%0A%0A%22%22%22Driver%20Code%22%22%22%0Aif%20__name__%20%3D%3D%20%22__main__%22%3A%0A%20%20%20%20%23%20%E5%88%9D%E5%A7%8B%E5%8C%96%E5%B0%8F%E9%A1%B6%E5%A0%86%0A%20%20%20%20min_heap,%20flag%20%3D%20%5B%5D,%201%0A%20%20%20%20%23%20%E5%88%9D%E5%A7%8B%E5%8C%96%E5%A4%A7%E9%A1%B6%E5%A0%86%0A%20%20%20%20max_heap,%20flag%20%3D%20%5B%5D,%20-1%0A%20%20%20%20%0A%20%20%20%20%23%20Python%20%E7%9A%84%20heapq%20%E6%A8%A1%E5%9D%97%E9%BB%98%E8%AE%A4%E5%AE%9E%E7%8E%B0%E5%B0%8F%E9%A1%B6%E5%A0%86%0A%20%20%20%20%23%20%E8%80%83%E8%99%91%E5%B0%86%E2%80%9C%E5%85%83%E7%B4%A0%E5%8F%96%E8%B4%9F%E2%80%9D%E5%90%8E%E5%86%8D%E5%85%A5%E5%A0%86%EF%BC%8C%E8%BF%99%E6%A0%B7%E5%B0%B1%E5%8F%AF%E4%BB%A5%E5%B0%86%E5%A4%A7%E5%B0%8F%E5%85%B3%E7%B3%BB%E9%A2%A0%E5%80%92%EF%BC%8C%E4%BB%8E%E8%80%8C%E5%AE%9E%E7%8E%B0%E5%A4%A7%E9%A1%B6%E5%A0%86%0A%20%20%20%20%23%20%E5%9C%A8%E6%9C%AC%E7%A4%BA%E4%BE%8B%E4%B8%AD%EF%BC%8Cflag%20%3D%201%20%E6%97%B6%E5%AF%B9%E5%BA%94%E5%B0%8F%E9%A1%B6%E5%A0%86%EF%BC%8Cflag%20%3D%20-1%20%E6%97%B6%E5%AF%B9%E5%BA%94%E5%A4%A7%E9%A1%B6%E5%A0%86%0A%20%20%20%20%0A%20%20%20%20%23%20%E5%85%83%E7%B4%A0%E5%85%A5%E5%A0%86%0A%20%20%20%20heapq.heappush%28max_heap,%20flag%20*%201%29%0A%20%20%20%20heapq.heappush%28max_heap,%20flag%20*%203%29%0A%20%20%20%20heapq.heappush%28max_heap,%20flag%20*%202%29%0A%20%20%20%20heapq.heappush%28max_heap,%20flag%20*%205%29%0A%20%20%20%20heapq.heappush%28max_heap,%20flag%20*%204%29%0A%20%20%20%20%0A%20%20%20%20%23%20%E8%8E%B7%E5%8F%96%E5%A0%86%E9%A1%B6%E5%85%83%E7%B4%A0%0A%20%20%20%20peek%20%3D%20flag%20*%20max_heap%5B0%5D%20%23%205%0A%20%20%20%20%0A%20%20%20%20%23%20%E5%A0%86%E9%A1%B6%E5%85%83%E7%B4%A0%E5%87%BA%E5%A0%86%0A%20%20%20%20%23%20%E5%87%BA%E5%A0%86%E5%85%83%E7%B4%A0%E4%BC%9A%E5%BD%A2%E6%88%90%E4%B8%80%E4%B8%AA%E4%BB%8E%E5%A4%A7%E5%88%B0%E5%B0%8F%E7%9A%84%E5%BA%8F%E5%88%97%0A%20%20%20%20val%20%3D%20flag%20*%20heapq.heappop%28max_heap%29%20%23%205%0A%20%20%20%20val%20%3D%20flag%20*%20heapq.heappop%28max_heap%29%20%23%204%0A%20%20%20%20val%20%3D%20flag%20*%20heapq.heappop%28max_heap%29%20%23%203%0A%20%20%20%20val%20%3D%20flag%20*%20heapq.heappop%28max_heap%29%20%23%202%0A%20%20%20%20val%20%3D%20flag%20*%20heapq.heappop%28max_heap%29%20%23%201%0A%20%20%20%20%0A%20%20%20%20%23%20%E8%8E%B7%E5%8F%96%E5%A0%86%E5%A4%A7%E5%B0%8F%0A%20%20%20%20size%20%3D%20len%28max_heap%29%0A%20%20%20%20%0A%20%20%20%20%23%20%E5%88%A4%E6%96%AD%E5%A0%86%E6%98%AF%E5%90%A6%E4%B8%BA%E7%A9%BA%0A%20%20%20%20is_empty%20%3D%20not%20max_heap%0A%20%20%20%20%0A%20%20%20%20%23%20%E8%BE%93%E5%85%A5%E5%88%97%E8%A1%A8%E5%B9%B6%E5%BB%BA%E5%A0%86%0A%20%20%20%20min_heap%20%3D%20%5B1,%203,%202,%205,%204%5D%0A%20%20%20%20heapq.heapify%28min_heap%29&cumulative=false&curInstr=3&heapPrimitives=nevernest&mode=display&origin=opt-frontend.js&py=311&rawInputLstJSON=%5B%5D&textReferences=false</p>
|
||||
</details>
|
||||
<h2 id="812-implementation-of-heaps">8.1.2 Implementation of heaps<a class="headerlink" href="#812-implementation-of-heaps" title="Permanent link">¶</a></h2>
|
||||
<h2 id="812-implementation-of-the-heap">8.1.2 Implementation of the heap<a class="headerlink" href="#812-implementation-of-the-heap" title="Permanent link">¶</a></h2>
|
||||
<p>The following implementation is of a max heap. To convert it into a min heap, simply invert all size logic comparisons (for example, replace <span class="arithmatex">\(\geq\)</span> with <span class="arithmatex">\(\leq\)</span>). Interested readers are encouraged to implement it on their own.</p>
|
||||
<h3 id="1-storage-and-representation-of-heaps">1. Storage and representation of heaps<a class="headerlink" href="#1-storage-and-representation-of-heaps" title="Permanent link">¶</a></h3>
|
||||
<p>As mentioned in the "Binary Trees" section, complete binary trees are well-suited for array representation. Since heaps are a type of complete binary tree, <strong>we will use arrays to store heaps</strong>.</p>
|
||||
<h3 id="1-heap-storage-and-representation">1. Heap storage and representation<a class="headerlink" href="#1-heap-storage-and-representation" title="Permanent link">¶</a></h3>
|
||||
<p>As mentioned in the "Binary Trees" section, complete binary trees are highly suitable for array representation. Since heaps are a type of complete binary tree, <strong>we will use arrays to store heaps</strong>.</p>
|
||||
<p>When using an array to represent a binary tree, elements represent node values, and indexes represent node positions in the binary tree. <strong>Node pointers are implemented through an index mapping formula</strong>.</p>
|
||||
<p>As shown in Figure 8-2, given an index <span class="arithmatex">\(i\)</span>, the index of its left child is <span class="arithmatex">\(2i + 1\)</span>, the index of its right child is <span class="arithmatex">\(2i + 2\)</span>, and the index of its parent is <span class="arithmatex">\((i - 1) / 2\)</span> (floor division). When the index is out of bounds, it signifies a null node or the node does not exist.</p>
|
||||
<p><a class="glightbox" href="../heap.assets/representation_of_heap.png" data-type="image" data-width="100%" data-height="auto" data-desc-position="bottom"><img alt="Representation and storage of heaps" class="animation-figure" src="../heap.assets/representation_of_heap.png" /></a></p>
|
||||
@@ -4326,8 +4326,8 @@
|
||||
</div>
|
||||
</div>
|
||||
<h3 id="3-inserting-an-element-into-the-heap">3. Inserting an element into the heap<a class="headerlink" href="#3-inserting-an-element-into-the-heap" title="Permanent link">¶</a></h3>
|
||||
<p>Given an element <code>val</code>, we first add it to the bottom of the heap. After addition, since <code>val</code> may be larger than other elements in the heap, the heap's integrity might be compromised, <strong>thus it's necessary to repair the path from the inserted node to the root node</strong>. This operation is called <u>heapifying</u>.</p>
|
||||
<p>Considering starting from the node inserted, <strong>perform heapify from bottom to top</strong>. As shown in Figure 8-3, we compare the value of the inserted node with its parent node, and if the inserted node is larger, we swap them. Then continue this operation, repairing each node in the heap from bottom to top until passing the root node or encountering a node that does not need to be swapped.</p>
|
||||
<p>Given an element <code>val</code>, we first add it to the bottom of the heap. After addition, since <code>val</code> may be larger than other elements in the heap, the heap's integrity might be compromised, <strong>thus it's necessary to repair the path from the inserted node to the root node</strong>. This operation is called <u>heapify</u>.</p>
|
||||
<p>Considering starting from the node inserted, <strong>perform heapify from bottom to top</strong>. As shown in Figure 8-3, we compare the value of the inserted node with its parent node, and if the inserted node is larger, we swap them. Then continue this operation, repairing each node in the heap from bottom to top until reaching the root or a node that does not need swapping.</p>
|
||||
<div class="tabbed-set tabbed-alternate" data-tabs="4:9"><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" /><div class="tabbed-labels"><label for="__tabbed_4_1"><1></label><label for="__tabbed_4_2"><2></label><label for="__tabbed_4_3"><3></label><label for="__tabbed_4_4"><4></label><label for="__tabbed_4_5"><5></label><label for="__tabbed_4_6"><6></label><label for="__tabbed_4_7"><7></label><label for="__tabbed_4_8"><8></label><label for="__tabbed_4_9"><9></label></div>
|
||||
<div class="tabbed-content">
|
||||
<div class="tabbed-block">
|
||||
@@ -4505,13 +4505,13 @@
|
||||
</div>
|
||||
</div>
|
||||
<h3 id="4-removing-the-top-element-from-the-heap">4. Removing the top element from the heap<a class="headerlink" href="#4-removing-the-top-element-from-the-heap" title="Permanent link">¶</a></h3>
|
||||
<p>The top element of the heap is the root node of the binary tree, that is, the first element of the list. If we directly remove the first element from the list, all node indexes in the binary tree would change, making it difficult to use heapify for repairs subsequently. To minimize changes in element indexes, we use the following steps.</p>
|
||||
<p>The top element of the heap is the root node of the binary tree, that is, the first element of the list. If we directly remove the first element from the list, all node indexes in the binary tree will change, making it difficult to use heapify for subsequent repairs. To minimize changes in element indexes, we use the following steps.</p>
|
||||
<ol>
|
||||
<li>Swap the top element with the bottom element of the heap (swap the root node with the rightmost leaf node).</li>
|
||||
<li>After swapping, remove the bottom of the heap from the list (note, since it has been swapped, what is actually being removed is the original top element).</li>
|
||||
<li>After swapping, remove the bottom of the heap from the list (note that since it has been swapped, the original top element is actually being removed).</li>
|
||||
<li>Starting from the root node, <strong>perform heapify from top to bottom</strong>.</li>
|
||||
</ol>
|
||||
<p>As shown in Figure 8-4, <strong>the direction of "heapify from top to bottom" is opposite to "heapify from bottom to top"</strong>. We compare the value of the root node with its two children and swap it with the largest child. Then repeat this operation until passing the leaf node or encountering a node that does not need to be swapped.</p>
|
||||
<p>As shown in Figure 8-4, <strong>the direction of "heapify from top to bottom" is opposite to "heapify from bottom to top"</strong>. We compare the value of the root node with its two children and swap it with the largest child. Then, repeat this operation until reaching the leaf node or encountering a node that does not need swapping.</p>
|
||||
<div class="tabbed-set tabbed-alternate" data-tabs="6:10"><input checked="checked" id="__tabbed_6_1" name="__tabbed_6" type="radio" /><input id="__tabbed_6_2" name="__tabbed_6" type="radio" /><input id="__tabbed_6_3" name="__tabbed_6" type="radio" /><input id="__tabbed_6_4" name="__tabbed_6" type="radio" /><input id="__tabbed_6_5" name="__tabbed_6" type="radio" /><input id="__tabbed_6_6" name="__tabbed_6" type="radio" /><input id="__tabbed_6_7" name="__tabbed_6" type="radio" /><input id="__tabbed_6_8" name="__tabbed_6" type="radio" /><input id="__tabbed_6_9" name="__tabbed_6" type="radio" /><input id="__tabbed_6_10" name="__tabbed_6" type="radio" /><div class="tabbed-labels"><label for="__tabbed_6_1"><1></label><label for="__tabbed_6_2"><2></label><label for="__tabbed_6_3"><3></label><label for="__tabbed_6_4"><4></label><label for="__tabbed_6_5"><5></label><label for="__tabbed_6_6"><6></label><label for="__tabbed_6_7"><7></label><label for="__tabbed_6_8"><8></label><label for="__tabbed_6_9"><9></label><label for="__tabbed_6_10"><10></label></div>
|
||||
<div class="tabbed-content">
|
||||
<div class="tabbed-block">
|
||||
@@ -4725,8 +4725,8 @@
|
||||
<h2 id="813-common-applications-of-heaps">8.1.3 Common applications of heaps<a class="headerlink" href="#813-common-applications-of-heaps" title="Permanent link">¶</a></h2>
|
||||
<ul>
|
||||
<li><strong>Priority Queue</strong>: Heaps are often the preferred data structure for implementing priority queues, with both enqueue and dequeue operations having a time complexity of <span class="arithmatex">\(O(\log n)\)</span>, and building a queue having a time complexity of <span class="arithmatex">\(O(n)\)</span>, all of which are very efficient.</li>
|
||||
<li><strong>Heap Sort</strong>: Given a set of data, we can create a heap from them and then continually perform element removal operations to obtain ordered data. However, we usually use a more elegant method to implement heap sort, as detailed in the "Heap Sort" section.</li>
|
||||
<li><strong>Finding the Largest <span class="arithmatex">\(k\)</span> Elements</strong>: This is a classic algorithm problem and also a typical application, such as selecting the top 10 hot news for Weibo hot search, picking the top 10 selling products, etc.</li>
|
||||
<li><strong>Heap Sort</strong>: Given a set of data, we can create a heap from them and then continually perform element removal operations to obtain ordered data. However, there is a more elegant way to implement heap sort, as explained in the "Heap Sort" chapter.</li>
|
||||
<li><strong>Finding the Largest <span class="arithmatex">\(k\)</span> Elements</strong>: This is a classic algorithm problem and also a common use case, such as selecting the top 10 hot news for Weibo hot search, picking the top 10 selling products, etc.</li>
|
||||
</ul>
|
||||
|
||||
<!-- Source file information -->
|
||||
|
||||
@@ -3520,8 +3520,8 @@
|
||||
<p><a class="glightbox" href="../assets/covers/chapter_heap.jpg" data-type="image" data-width="100%" data-height="auto" data-desc-position="bottom"><img alt="Heap" class="cover-image" src="../assets/covers/chapter_heap.jpg" /></a></p>
|
||||
<div class="admonition abstract">
|
||||
<p class="admonition-title">Abstract</p>
|
||||
<p>The heap is like mountain peaks, stacked and undulating, each with its unique shape.</p>
|
||||
<p>Among these peaks, the highest one always catches the eye first.</p>
|
||||
<p>Heaps resemble mountains and their jagged peaks, layered and undulating, each with its unique form.</p>
|
||||
<p>Each mountain peak rises and falls in scattered heights, yet the tallest always captures attention first.</p>
|
||||
</div>
|
||||
<h2 id="chapter-contents">Chapter contents<a class="headerlink" href="#chapter-contents" title="Permanent link">¶</a></h2>
|
||||
<ul>
|
||||
|
||||
@@ -2169,18 +2169,18 @@
|
||||
<ul class="md-nav__list">
|
||||
|
||||
<li class="md-nav__item">
|
||||
<a href="#1-reusing-the-search-for-the-left-boundary" class="md-nav__link">
|
||||
<a href="#1-reuse-the-left-boundary-search" class="md-nav__link">
|
||||
<span class="md-ellipsis">
|
||||
1. Reusing the search for the left boundary
|
||||
1. Reuse the left boundary search
|
||||
</span>
|
||||
</a>
|
||||
|
||||
</li>
|
||||
|
||||
<li class="md-nav__item">
|
||||
<a href="#2-transforming-into-an-element-search" class="md-nav__link">
|
||||
<a href="#2-transform-into-an-element-search" class="md-nav__link">
|
||||
<span class="md-ellipsis">
|
||||
2. Transforming into an element search
|
||||
2. Transform into an element search
|
||||
</span>
|
||||
</a>
|
||||
|
||||
@@ -3573,18 +3573,18 @@
|
||||
<ul class="md-nav__list">
|
||||
|
||||
<li class="md-nav__item">
|
||||
<a href="#1-reusing-the-search-for-the-left-boundary" class="md-nav__link">
|
||||
<a href="#1-reuse-the-left-boundary-search" class="md-nav__link">
|
||||
<span class="md-ellipsis">
|
||||
1. Reusing the search for the left boundary
|
||||
1. Reuse the left boundary search
|
||||
</span>
|
||||
</a>
|
||||
|
||||
</li>
|
||||
|
||||
<li class="md-nav__item">
|
||||
<a href="#2-transforming-into-an-element-search" class="md-nav__link">
|
||||
<a href="#2-transform-into-an-element-search" class="md-nav__link">
|
||||
<span class="md-ellipsis">
|
||||
2. Transforming into an element search
|
||||
2. Transform into an element search
|
||||
</span>
|
||||
</a>
|
||||
|
||||
@@ -3637,8 +3637,8 @@
|
||||
<p class="admonition-title">Question</p>
|
||||
<p>Given a sorted array <code>nums</code> of length <span class="arithmatex">\(n\)</span>, which may contain duplicate elements, return the index of the leftmost element <code>target</code>. If the element is not present in the array, return <span class="arithmatex">\(-1\)</span>.</p>
|
||||
</div>
|
||||
<p>Recall the method of binary search for an insertion point, after the search is completed, <span class="arithmatex">\(i\)</span> points to the leftmost <code>target</code>, <strong>thus searching for the insertion point is essentially searching for the index of the leftmost <code>target</code></strong>.</p>
|
||||
<p>Consider implementing the search for the left boundary using the function for finding an insertion point. Note that the array might not contain <code>target</code>, which could lead to the following two results:</p>
|
||||
<p>Recalling the method of binary search for an insertion point, after the search is completed, the index <span class="arithmatex">\(i\)</span> will point to the leftmost occurrence of <code>target</code>. Therefore, <strong>searching for the insertion point is essentially the same as finding the index of the leftmost <code>target</code></strong>.</p>
|
||||
<p>We can use the function for finding an insertion point to find the left boundary of <code>target</code>. Note that the array might not contain <code>target</code>, which could lead to the following two results:</p>
|
||||
<ul>
|
||||
<li>The index <span class="arithmatex">\(i\)</span> of the insertion point is out of bounds.</li>
|
||||
<li>The element <code>nums[i]</code> is not equal to <code>target</code>.</li>
|
||||
@@ -3733,15 +3733,15 @@
|
||||
</div>
|
||||
</div>
|
||||
<h2 id="1032-find-the-right-boundary">10.3.2 Find the right boundary<a class="headerlink" href="#1032-find-the-right-boundary" title="Permanent link">¶</a></h2>
|
||||
<p>So how do we find the rightmost <code>target</code>? The most straightforward way is to modify the code, replacing the pointer contraction operation in the case of <code>nums[m] == target</code>. The code is omitted here, but interested readers can implement it on their own.</p>
|
||||
<p>Below we introduce two more cunning methods.</p>
|
||||
<h3 id="1-reusing-the-search-for-the-left-boundary">1. Reusing the search for the left boundary<a class="headerlink" href="#1-reusing-the-search-for-the-left-boundary" title="Permanent link">¶</a></h3>
|
||||
<p>In fact, we can use the function for finding the leftmost element to find the rightmost element, specifically by <strong>transforming the search for the rightmost <code>target</code> into a search for the leftmost <code>target + 1</code></strong>.</p>
|
||||
<p>As shown in Figure 10-7, after the search is completed, the pointer <span class="arithmatex">\(i\)</span> points to the leftmost <code>target + 1</code> (if it exists), while <span class="arithmatex">\(j\)</span> points to the rightmost <code>target</code>, <strong>thus returning <span class="arithmatex">\(j\)</span> is sufficient</strong>.</p>
|
||||
<p>How do we find the rightmost occurrence of <code>target</code>? The most straightforward way is to modify the traditional binary search logic by changing how we adjust the search boundaries in the case of <code>nums[m] == target</code>. The code is omitted here. If you are interested, try to implement the code on your own.</p>
|
||||
<p>Below we are going to introduce two more ingenious methods.</p>
|
||||
<h3 id="1-reuse-the-left-boundary-search">1. Reuse the left boundary search<a class="headerlink" href="#1-reuse-the-left-boundary-search" title="Permanent link">¶</a></h3>
|
||||
<p>To find the rightmost occurrence of <code>target</code>, we can reuse the function used for locating the leftmost <code>target</code>. Specifically, we transform the search for the rightmost target into a search for the leftmost target + 1.</p>
|
||||
<p>As shown in Figure 10-7, after the search is complete, pointer <span class="arithmatex">\(i\)</span> will point to the leftmost <code>target + 1</code> (if exists), while pointer <span class="arithmatex">\(j\)</span> will point to the rightmost occurrence of <code>target</code>. Therefore, returning <span class="arithmatex">\(j\)</span> will give us the right boundary.</p>
|
||||
<p><a class="glightbox" href="../binary_search_edge.assets/binary_search_right_edge_by_left_edge.png" data-type="image" data-width="100%" data-height="auto" data-desc-position="bottom"><img alt="Transforming the search for the right boundary into the search for the left boundary" class="animation-figure" src="../binary_search_edge.assets/binary_search_right_edge_by_left_edge.png" /></a></p>
|
||||
<p align="center"> Figure 10-7 Transforming the search for the right boundary into the search for the left boundary </p>
|
||||
|
||||
<p>Please note, the insertion point returned is <span class="arithmatex">\(i\)</span>, therefore, it should be subtracted by <span class="arithmatex">\(1\)</span> to obtain <span class="arithmatex">\(j\)</span>:</p>
|
||||
<p>Note that the insertion point returned is <span class="arithmatex">\(i\)</span>, therefore, it should be subtracted by <span class="arithmatex">\(1\)</span> to obtain <span class="arithmatex">\(j\)</span>:</p>
|
||||
<div class="tabbed-set tabbed-alternate" data-tabs="2:14"><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" /><input id="__tabbed_2_13" name="__tabbed_2" type="radio" /><input id="__tabbed_2_14" name="__tabbed_2" type="radio" /><div class="tabbed-labels"><label for="__tabbed_2_1">Python</label><label for="__tabbed_2_2">C++</label><label for="__tabbed_2_3">Java</label><label for="__tabbed_2_4">C#</label><label for="__tabbed_2_5">Go</label><label for="__tabbed_2_6">Swift</label><label for="__tabbed_2_7">JS</label><label for="__tabbed_2_8">TS</label><label for="__tabbed_2_9">Dart</label><label for="__tabbed_2_10">Rust</label><label for="__tabbed_2_11">C</label><label for="__tabbed_2_12">Kotlin</label><label for="__tabbed_2_13">Ruby</label><label for="__tabbed_2_14">Zig</label></div>
|
||||
<div class="tabbed-content">
|
||||
<div class="tabbed-block">
|
||||
@@ -3836,8 +3836,8 @@
|
||||
</div>
|
||||
</div>
|
||||
</div>
|
||||
<h3 id="2-transforming-into-an-element-search">2. Transforming into an element search<a class="headerlink" href="#2-transforming-into-an-element-search" title="Permanent link">¶</a></h3>
|
||||
<p>We know that when the array does not contain <code>target</code>, <span class="arithmatex">\(i\)</span> and <span class="arithmatex">\(j\)</span> will eventually point to the first element greater and smaller than <code>target</code> respectively.</p>
|
||||
<h3 id="2-transform-into-an-element-search">2. Transform into an element search<a class="headerlink" href="#2-transform-into-an-element-search" title="Permanent link">¶</a></h3>
|
||||
<p>When the array does not contain <code>target</code>, <span class="arithmatex">\(i\)</span> and <span class="arithmatex">\(j\)</span> will eventually point to the first element greater and smaller than <code>target</code> respectively.</p>
|
||||
<p>Thus, as shown in Figure 10-8, we can construct an element that does not exist in the array, to search for the left and right boundaries.</p>
|
||||
<ul>
|
||||
<li>To find the leftmost <code>target</code>: it can be transformed into searching for <code>target - 0.5</code>, and return the pointer <span class="arithmatex">\(i\)</span>.</li>
|
||||
@@ -3846,10 +3846,10 @@
|
||||
<p><a class="glightbox" href="../binary_search_edge.assets/binary_search_edge_by_element.png" data-type="image" data-width="100%" data-height="auto" data-desc-position="bottom"><img alt="Transforming the search for boundaries into the search for an element" class="animation-figure" src="../binary_search_edge.assets/binary_search_edge_by_element.png" /></a></p>
|
||||
<p align="center"> Figure 10-8 Transforming the search for boundaries into the search for an element </p>
|
||||
|
||||
<p>The code is omitted here, but two points are worth noting.</p>
|
||||
<p>The code is omitted here, but here are two important points to note about this approach.</p>
|
||||
<ul>
|
||||
<li>The given array does not contain decimals, meaning we do not need to worry about how to handle equal situations.</li>
|
||||
<li>Since this method introduces decimals, the variable <code>target</code> in the function needs to be changed to a floating point type (no change needed in Python).</li>
|
||||
<li>The given array <code>nums</code> does not contain decimal, so handling equal cases is not a concern.</li>
|
||||
<li>However, introducing decimals in this approach requires modifying the <code>target</code> variable to a floating-point type (no change needed in Python).</li>
|
||||
</ul>
|
||||
|
||||
<!-- Source file information -->
|
||||
|
||||
@@ -3588,17 +3588,17 @@
|
||||
<h2 id="1021-case-with-no-duplicate-elements">10.2.1 Case with no duplicate elements<a class="headerlink" href="#1021-case-with-no-duplicate-elements" title="Permanent link">¶</a></h2>
|
||||
<div class="admonition question">
|
||||
<p class="admonition-title">Question</p>
|
||||
<p>Given an ordered array <code>nums</code> of length <span class="arithmatex">\(n\)</span> and an element <code>target</code>, where the array has no duplicate elements. Now insert <code>target</code> into the array <code>nums</code> while maintaining its order. If the element <code>target</code> already exists in the array, insert it to its left side. Please return the index of <code>target</code> in the array after insertion. See the example shown in Figure 10-4.</p>
|
||||
<p>Given a sorted array <code>nums</code> of length <span class="arithmatex">\(n\)</span> with unique elements and an element <code>target</code>, insert <code>target</code> into <code>nums</code> while maintaining its sorted order. If <code>target</code> already exists in the array, insert it to the left of the existing element. Return the index of <code>target</code> in the array after insertion. See the example shown in Figure 10-4.</p>
|
||||
</div>
|
||||
<p><a class="glightbox" href="../binary_search_insertion.assets/binary_search_insertion_example.png" data-type="image" data-width="100%" data-height="auto" data-desc-position="bottom"><img alt="Example data for binary search insertion point" class="animation-figure" src="../binary_search_insertion.assets/binary_search_insertion_example.png" /></a></p>
|
||||
<p align="center"> Figure 10-4 Example data for binary search insertion point </p>
|
||||
|
||||
<p>If you want to reuse the binary search code from the previous section, you need to answer the following two questions.</p>
|
||||
<p><strong>Question one</strong>: When the array contains <code>target</code>, is the insertion point index the index of that element?</p>
|
||||
<p>The requirement to insert <code>target</code> to the left of equal elements means that the newly inserted <code>target</code> replaces the original <code>target</code> position. Thus, <strong>when the array contains <code>target</code>, the insertion point index is the index of that <code>target</code></strong>.</p>
|
||||
<p><strong>Question two</strong>: When the array does not contain <code>target</code>, what is the index of the insertion point?</p>
|
||||
<p>Further consider the binary search process: when <code>nums[m] < target</code>, pointer <span class="arithmatex">\(i\)</span> moves, meaning that pointer <span class="arithmatex">\(i\)</span> is approaching an element greater than or equal to <code>target</code>. Similarly, pointer <span class="arithmatex">\(j\)</span> is always approaching an element less than or equal to <code>target</code>.</p>
|
||||
<p>Therefore, at the end of the binary, it is certain that: <span class="arithmatex">\(i\)</span> points to the first element greater than <code>target</code>, and <span class="arithmatex">\(j\)</span> points to the first element less than <code>target</code>. <strong>It is easy to see that when the array does not contain <code>target</code>, the insertion index is <span class="arithmatex">\(i\)</span></strong>. The code is as follows:</p>
|
||||
<p><strong>Question one</strong>: If the array already contains <code>target</code>, would the insertion point be the index of existing element?</p>
|
||||
<p>The requirement to insert <code>target</code> to the left of equal elements means that the newly inserted <code>target</code> will replace the original <code>target</code> position. In other words, <strong>when the array contains <code>target</code>, the insertion point is indeed the index of that <code>target</code></strong>.</p>
|
||||
<p><strong>Question two</strong>: When the array does not contain <code>target</code>, at which index would it be inserted?</p>
|
||||
<p>Let's further consider the binary search process: when <code>nums[m] < target</code>, pointer <span class="arithmatex">\(i\)</span> moves, meaning that pointer <span class="arithmatex">\(i\)</span> is approaching an element greater than or equal to <code>target</code>. Similarly, pointer <span class="arithmatex">\(j\)</span> is always approaching an element less than or equal to <code>target</code>.</p>
|
||||
<p>Therefore, at the end of the binary, it is certain that: <span class="arithmatex">\(i\)</span> points to the first element greater than <code>target</code>, and <span class="arithmatex">\(j\)</span> points to the first element less than <code>target</code>. <strong>It is easy to see that when the array does not contain <code>target</code>, the insertion point is <span class="arithmatex">\(i\)</span></strong>. The code is as follows:</p>
|
||||
<div class="tabbed-set tabbed-alternate" data-tabs="1:14"><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" /><input id="__tabbed_1_13" name="__tabbed_1" type="radio" /><input id="__tabbed_1_14" name="__tabbed_1" type="radio" /><div class="tabbed-labels"><label for="__tabbed_1_1">Python</label><label for="__tabbed_1_2">C++</label><label for="__tabbed_1_3">Java</label><label for="__tabbed_1_4">C#</label><label for="__tabbed_1_5">Go</label><label for="__tabbed_1_6">Swift</label><label for="__tabbed_1_7">JS</label><label for="__tabbed_1_8">TS</label><label for="__tabbed_1_9">Dart</label><label for="__tabbed_1_10">Rust</label><label for="__tabbed_1_11">C</label><label for="__tabbed_1_12">Kotlin</label><label for="__tabbed_1_13">Ruby</label><label for="__tabbed_1_14">Zig</label></div>
|
||||
<div class="tabbed-content">
|
||||
<div class="tabbed-block">
|
||||
@@ -3706,20 +3706,20 @@
|
||||
<p class="admonition-title">Question</p>
|
||||
<p>Based on the previous question, assume the array may contain duplicate elements, all else remains the same.</p>
|
||||
</div>
|
||||
<p>Suppose there are multiple <code>target</code>s in the array, ordinary binary search can only return the index of one of the <code>target</code>s, <strong>and it cannot determine how many <code>target</code>s are to the left and right of that element</strong>.</p>
|
||||
<p>The task requires inserting the target element to the very left, <strong>so we need to find the index of the leftmost <code>target</code> in the array</strong>. Initially consider implementing this through the steps shown in Figure 10-5.</p>
|
||||
<p>When there are multiple occurrences of <code>target</code> in the array, a regular binary search can only return the index of one occurrence of <code>target</code>, <strong>and it cannot determine how many occurrences of <code>target</code> are to the left and right of that position</strong>.</p>
|
||||
<p>The problem requires inserting the target element at the leftmost position, <strong>so we need to find the index of the leftmost <code>target</code> in the array</strong>. Initially consider implementing this through the steps shown in Figure 10-5.</p>
|
||||
<ol>
|
||||
<li>Perform a binary search, get an arbitrary index of <code>target</code>, denoted as <span class="arithmatex">\(k\)</span>.</li>
|
||||
<li>Start from index <span class="arithmatex">\(k\)</span>, and perform a linear search to the left until the leftmost <code>target</code> is found and return.</li>
|
||||
<li>Perform a binary search to find any index of <code>target</code>, say <span class="arithmatex">\(k\)</span>.</li>
|
||||
<li>Starting from index <span class="arithmatex">\(k\)</span>, conduct a linear search to the left until the leftmost occurrence of <code>target</code> is found, then return this index.</li>
|
||||
</ol>
|
||||
<p><a class="glightbox" href="../binary_search_insertion.assets/binary_search_insertion_naive.png" data-type="image" data-width="100%" data-height="auto" data-desc-position="bottom"><img alt="Linear search for the insertion point of duplicate elements" class="animation-figure" src="../binary_search_insertion.assets/binary_search_insertion_naive.png" /></a></p>
|
||||
<p align="center"> Figure 10-5 Linear search for the insertion point of duplicate elements </p>
|
||||
|
||||
<p>Although this method is feasible, it includes linear search, so its time complexity is <span class="arithmatex">\(O(n)\)</span>. This method is inefficient when the array contains many duplicate <code>target</code>s.</p>
|
||||
<p>Now consider extending the binary search code. As shown in Figure 10-6, the overall process remains the same, each round first calculates the midpoint index <span class="arithmatex">\(m\)</span>, then judges the size relationship between <code>target</code> and <code>nums[m]</code>, divided into the following cases.</p>
|
||||
<p>Now consider extending the binary search code. As shown in Figure 10-6, the overall process remains the same. In each round, we first calculate the middle index <span class="arithmatex">\(m\)</span>, then compare the value of <code>target</code> with <code>nums[m]</code>, leading to the following cases.</p>
|
||||
<ul>
|
||||
<li>When <code>nums[m] < target</code> or <code>nums[m] > target</code>, it means <code>target</code> has not been found yet, thus use the normal binary search interval reduction operation, <strong>thus making pointers <span class="arithmatex">\(i\)</span> and <span class="arithmatex">\(j\)</span> approach <code>target</code></strong>.</li>
|
||||
<li>When <code>nums[m] == target</code>, it indicates that the elements less than <code>target</code> are in the interval <span class="arithmatex">\([i, m - 1]\)</span>, therefore use <span class="arithmatex">\(j = m - 1\)</span> to narrow the interval, <strong>thus making pointer <span class="arithmatex">\(j\)</span> approach elements less than <code>target</code></strong>.</li>
|
||||
<li>When <code>nums[m] < target</code> or <code>nums[m] > target</code>, it means <code>target</code> has not been found yet, thus use the normal binary search to narrow the search range, <strong>bringing pointers <span class="arithmatex">\(i\)</span> and <span class="arithmatex">\(j\)</span> closer to <code>target</code></strong>.</li>
|
||||
<li>When <code>nums[m] == target</code>, it indicates that the elements less than <code>target</code> are in the range <span class="arithmatex">\([i, m - 1]\)</span>, therefore use <span class="arithmatex">\(j = m - 1\)</span> to narrow the range, <strong>thus bringing pointer <span class="arithmatex">\(j\)</span> closer to the elements less than <code>target</code></strong>.</li>
|
||||
</ul>
|
||||
<p>After the loop, <span class="arithmatex">\(i\)</span> points to the leftmost <code>target</code>, and <span class="arithmatex">\(j\)</span> points to the first element less than <code>target</code>, <strong>therefore index <span class="arithmatex">\(i\)</span> is the insertion point</strong>.</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"><1></label><label for="__tabbed_2_2"><2></label><label for="__tabbed_2_3"><3></label><label for="__tabbed_2_4"><4></label><label for="__tabbed_2_5"><5></label><label for="__tabbed_2_6"><6></label><label for="__tabbed_2_7"><7></label><label for="__tabbed_2_8"><8></label></div>
|
||||
@@ -3752,8 +3752,8 @@
|
||||
</div>
|
||||
<p align="center"> Figure 10-6 Steps for binary search insertion point of duplicate elements </p>
|
||||
|
||||
<p>Observe the code, the operations of the branch <code>nums[m] > target</code> and <code>nums[m] == target</code> are the same, so the two can be combined.</p>
|
||||
<p>Even so, we can still keep the conditions expanded, as their logic is clearer and more readable.</p>
|
||||
<p>Observe the following code. The operations in the branches <code>nums[m] > target</code> and <code>nums[m] == target</code> are the same, so these two branches can be merged.</p>
|
||||
<p>Even so, we can still keep the conditions expanded, as it makes the logic clearer and improves readability.</p>
|
||||
<div class="tabbed-set tabbed-alternate" data-tabs="3:14"><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" /><input id="__tabbed_3_13" name="__tabbed_3" type="radio" /><input id="__tabbed_3_14" name="__tabbed_3" type="radio" /><div class="tabbed-labels"><label for="__tabbed_3_1">Python</label><label for="__tabbed_3_2">C++</label><label for="__tabbed_3_3">Java</label><label for="__tabbed_3_4">C#</label><label for="__tabbed_3_5">Go</label><label for="__tabbed_3_6">Swift</label><label for="__tabbed_3_7">JS</label><label for="__tabbed_3_8">TS</label><label for="__tabbed_3_9">Dart</label><label for="__tabbed_3_10">Rust</label><label for="__tabbed_3_11">C</label><label for="__tabbed_3_12">Kotlin</label><label for="__tabbed_3_13">Ruby</label><label for="__tabbed_3_14">Zig</label></div>
|
||||
<div class="tabbed-content">
|
||||
<div class="tabbed-block">
|
||||
@@ -3858,9 +3858,9 @@
|
||||
</div>
|
||||
<div class="admonition tip">
|
||||
<p class="admonition-title">Tip</p>
|
||||
<p>The code in this section uses "closed intervals". Readers interested can implement the "left-closed right-open" method themselves.</p>
|
||||
<p>The code in this section uses "closed interval". If you are interested in "left-closed, right-open", try to implement the code on your own.</p>
|
||||
</div>
|
||||
<p>In summary, binary search is merely about setting search targets for pointers <span class="arithmatex">\(i\)</span> and <span class="arithmatex">\(j\)</span>, which might be a specific element (like <code>target</code>) or a range of elements (like elements less than <code>target</code>).</p>
|
||||
<p>In summary, binary search essentially involves setting search targets for pointers <span class="arithmatex">\(i\)</span> and <span class="arithmatex">\(j\)</span>. These targets could be a specific element (like <code>target</code>) or a range of elements (such as those smaller than <code>target</code>).</p>
|
||||
<p>In the continuous loop of binary search, pointers <span class="arithmatex">\(i\)</span> and <span class="arithmatex">\(j\)</span> gradually approach the predefined target. Ultimately, they either find the answer or stop after crossing the boundary.</p>
|
||||
|
||||
<!-- Source file information -->
|
||||
|
||||
@@ -3602,8 +3602,8 @@
|
||||
|
||||
<!-- Page content -->
|
||||
<h1 id="113-bubble-sort">11.3 Bubble sort<a class="headerlink" href="#113-bubble-sort" title="Permanent link">¶</a></h1>
|
||||
<p><u>Bubble sort</u> achieves sorting by continuously comparing and swapping adjacent elements. This process resembles bubbles rising from the bottom to the top, hence the name bubble sort.</p>
|
||||
<p>As shown in Figure 11-4, the bubbling process can be simulated using element swap operations: starting from the leftmost end of the array and moving right, sequentially compare the size of adjacent elements. If "left element > right element," then swap them. After the traversal, the largest element will be moved to the far right end of the array.</p>
|
||||
<p><u>Bubble sort</u> works by continuously comparing and swapping adjacent elements. This process is like bubbles rising from the bottom to the top, hence the name "bubble sort."</p>
|
||||
<p>As shown in Figure 11-4, the bubbling process can be simulated using element swaps: start from the leftmost end of the array and move right, comparing each pair of adjacent elements. If the left element is greater than the right element, swap them. After the traversal, the largest element will have bubbled up to the rightmost end of the array.</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"><1></label><label for="__tabbed_1_2"><2></label><label for="__tabbed_1_3"><3></label><label for="__tabbed_1_4"><4></label><label for="__tabbed_1_5"><5></label><label for="__tabbed_1_6"><6></label><label for="__tabbed_1_7"><7></label></div>
|
||||
<div class="tabbed-content">
|
||||
<div class="tabbed-block">
|
||||
@@ -3632,12 +3632,12 @@
|
||||
<p align="center"> Figure 11-4 Simulating bubble process using element swap </p>
|
||||
|
||||
<h2 id="1131-algorithm-process">11.3.1 Algorithm process<a class="headerlink" href="#1131-algorithm-process" title="Permanent link">¶</a></h2>
|
||||
<p>Assuming the length of the array is <span class="arithmatex">\(n\)</span>, the steps of bubble sort are shown in Figure 11-5.</p>
|
||||
<p>Assume the array has length <span class="arithmatex">\(n\)</span>. The steps of bubble sort are shown in Figure 11-5:</p>
|
||||
<ol>
|
||||
<li>First, perform a "bubble" on <span class="arithmatex">\(n\)</span> elements, <strong>swapping the largest element to its correct position</strong>.</li>
|
||||
<li>Next, perform a "bubble" on the remaining <span class="arithmatex">\(n - 1\)</span> elements, <strong>swapping the second largest element to its correct position</strong>.</li>
|
||||
<li>Similarly, after <span class="arithmatex">\(n - 1\)</span> rounds of "bubbling," <strong>the top <span class="arithmatex">\(n - 1\)</span> largest elements will be swapped to their correct positions</strong>.</li>
|
||||
<li>The only remaining element is necessarily the smallest and does not require sorting, thus the array sorting is complete.</li>
|
||||
<li>First, perform one "bubble" pass on <span class="arithmatex">\(n\)</span> elements, <strong>swapping the largest element to its correct position</strong>.</li>
|
||||
<li>Next, perform a "bubble" pass on the remaining <span class="arithmatex">\(n - 1\)</span> elements, <strong>swapping the second largest element to its correct position</strong>.</li>
|
||||
<li>Continue in this manner; after <span class="arithmatex">\(n - 1\)</span> such passes, <strong>the largest <span class="arithmatex">\(n - 1\)</span> elements will have been moved to their correct positions</strong>.</li>
|
||||
<li>The only remaining element <strong>must</strong> be the smallest, so <strong>no</strong> further sorting is required. At this point, the array is sorted.</li>
|
||||
</ol>
|
||||
<p><a class="glightbox" href="../bubble_sort.assets/bubble_sort_overview.png" data-type="image" data-width="100%" data-height="auto" data-desc-position="bottom"><img alt="Bubble sort process" class="animation-figure" src="../bubble_sort.assets/bubble_sort_overview.png" /></a></p>
|
||||
<p align="center"> Figure 11-5 Bubble sort process </p>
|
||||
@@ -3740,8 +3740,8 @@
|
||||
</div>
|
||||
</div>
|
||||
<h2 id="1132-efficiency-optimization">11.3.2 Efficiency optimization<a class="headerlink" href="#1132-efficiency-optimization" title="Permanent link">¶</a></h2>
|
||||
<p>We find that if no swaps are performed in a round of "bubbling," the array is already sorted, and we can return the result immediately. Thus, we can add a flag <code>flag</code> to monitor this situation and return immediately when it occurs.</p>
|
||||
<p>Even after optimization, the worst-case time complexity and average time complexity of bubble sort remain at <span class="arithmatex">\(O(n^2)\)</span>; however, when the input array is completely ordered, it can achieve the best time complexity of <span class="arithmatex">\(O(n)\)</span>.</p>
|
||||
<p>If no swaps occur during a round of "bubbling," the array is already sorted, so we can return immediately. To detect this, we can add a <code>flag</code> variable; whenever no swaps are made in a pass, we set the flag and return early.</p>
|
||||
<p>Even with this optimization, the worst time complexity and average time complexity of bubble sort remains <span class="arithmatex">\(O(n^2)\)</span>. However, if the input array is already sorted, the best-case time complexity can be as low as <span class="arithmatex">\(O(n)\)</span>.</p>
|
||||
<div class="tabbed-set tabbed-alternate" data-tabs="3:14"><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" /><input id="__tabbed_3_13" name="__tabbed_3" type="radio" /><input id="__tabbed_3_14" name="__tabbed_3" type="radio" /><div class="tabbed-labels"><label for="__tabbed_3_1">Python</label><label for="__tabbed_3_2">C++</label><label for="__tabbed_3_3">Java</label><label for="__tabbed_3_4">C#</label><label for="__tabbed_3_5">Go</label><label for="__tabbed_3_6">Swift</label><label for="__tabbed_3_7">JS</label><label for="__tabbed_3_8">TS</label><label for="__tabbed_3_9">Dart</label><label for="__tabbed_3_10">Rust</label><label for="__tabbed_3_11">C</label><label for="__tabbed_3_12">Kotlin</label><label for="__tabbed_3_13">Ruby</label><label for="__tabbed_3_14">Zig</label></div>
|
||||
<div class="tabbed-content">
|
||||
<div class="tabbed-block">
|
||||
@@ -3852,9 +3852,9 @@
|
||||
</div>
|
||||
<h2 id="1133-algorithm-characteristics">11.3.3 Algorithm characteristics<a class="headerlink" href="#1133-algorithm-characteristics" title="Permanent link">¶</a></h2>
|
||||
<ul>
|
||||
<li><strong>Time complexity of <span class="arithmatex">\(O(n^2)\)</span>, adaptive sorting</strong>: The length of the array traversed in each round of "bubbling" decreases sequentially from <span class="arithmatex">\(n - 1\)</span>, <span class="arithmatex">\(n - 2\)</span>, <span class="arithmatex">\(\dots\)</span>, <span class="arithmatex">\(2\)</span>, <span class="arithmatex">\(1\)</span>, totaling <span class="arithmatex">\((n - 1) n / 2\)</span>. With the introduction of <code>flag</code> optimization, the best time complexity can reach <span class="arithmatex">\(O(n)\)</span>.</li>
|
||||
<li><strong>Space complexity of <span class="arithmatex">\(O(1)\)</span>, in-place sorting</strong>: Only a constant amount of extra space is used by pointers <span class="arithmatex">\(i\)</span> and <span class="arithmatex">\(j\)</span>.</li>
|
||||
<li><strong>Stable sorting</strong>: As equal elements are not swapped during the "bubbling".</li>
|
||||
<li><strong>Time complexity of <span class="arithmatex">\(O(n^2)\)</span>, adaptive sorting.</strong> Each round of "bubbling" traverses array segments of length <span class="arithmatex">\(n - 1\)</span>, <span class="arithmatex">\(n - 2\)</span>, <span class="arithmatex">\(\dots\)</span>, <span class="arithmatex">\(2\)</span>, <span class="arithmatex">\(1\)</span>, which sums to <span class="arithmatex">\((n - 1) n / 2\)</span>. With a <code>flag</code> optimization, the best-case time complexity can reach <span class="arithmatex">\(O(n)\)</span> when the array is already sorted.</li>
|
||||
<li><strong>Space complexity of <span class="arithmatex">\(O(1)\)</span>, in-place sorting.</strong> Only a constant amount of extra space is used by pointers <span class="arithmatex">\(i\)</span> and <span class="arithmatex">\(j\)</span>.</li>
|
||||
<li><strong>Stable sorting.</strong> Because equal elements are not swapped during "bubbling," their original order is preserved, making this a stable sort.</li>
|
||||
</ul>
|
||||
|
||||
<!-- Source file information -->
|
||||
|
||||
@@ -3602,10 +3602,10 @@
|
||||
|
||||
<!-- Page content -->
|
||||
<h1 id="118-bucket-sort">11.8 Bucket sort<a class="headerlink" href="#118-bucket-sort" title="Permanent link">¶</a></h1>
|
||||
<p>The previously mentioned sorting algorithms are all "comparison-based sorting algorithms," which sort by comparing the size of elements. Such sorting algorithms cannot surpass a time complexity of <span class="arithmatex">\(O(n \log n)\)</span>. Next, we will discuss several "non-comparison sorting algorithms" that can achieve linear time complexity.</p>
|
||||
<p><u>Bucket sort</u> is a typical application of the divide-and-conquer strategy. It involves setting up a series of ordered buckets, each corresponding to a range of data, and then distributing the data evenly among these buckets; each bucket is then sorted individually; finally, all the data are merged in the order of the buckets.</p>
|
||||
<p>The previously mentioned sorting algorithms are all "comparison-based sorting algorithms," which sort elements by comparing their values. Such sorting algorithms cannot have better time complexity of <span class="arithmatex">\(O(n \log n)\)</span>. Next, we will discuss several "non-comparison sorting algorithms" that could achieve linear time complexity.</p>
|
||||
<p><u>Bucket sort</u> is a typical application of the divide-and-conquer strategy. It works by setting up a series of ordered buckets, each containing a range of data, and distributing the input data evenly across these buckets. And then, the data in each bucket is sorted individually. Finally, the sorted data from all the buckets is merged in sequence to produce the final result.</p>
|
||||
<h2 id="1181-algorithm-process">11.8.1 Algorithm process<a class="headerlink" href="#1181-algorithm-process" title="Permanent link">¶</a></h2>
|
||||
<p>Consider an array of length <span class="arithmatex">\(n\)</span>, with elements in the range <span class="arithmatex">\([0, 1)\)</span>. The bucket sort process is illustrated in Figure 11-13.</p>
|
||||
<p>Consider an array of length <span class="arithmatex">\(n\)</span>, with float numbers in the range <span class="arithmatex">\([0, 1)\)</span>. The bucket sort process is illustrated in Figure 11-13.</p>
|
||||
<ol>
|
||||
<li>Initialize <span class="arithmatex">\(k\)</span> buckets and distribute <span class="arithmatex">\(n\)</span> elements into these <span class="arithmatex">\(k\)</span> buckets.</li>
|
||||
<li>Sort each bucket individually (using the built-in sorting function of the programming language).</li>
|
||||
@@ -3747,21 +3747,21 @@
|
||||
</div>
|
||||
</div>
|
||||
<h2 id="1182-algorithm-characteristics">11.8.2 Algorithm characteristics<a class="headerlink" href="#1182-algorithm-characteristics" title="Permanent link">¶</a></h2>
|
||||
<p>Bucket sort is suitable for handling very large data sets. For example, if the input data includes 1 million elements, and system memory limitations prevent loading all the data at once, you can divide the data into 1,000 buckets and sort each bucket separately before merging the results.</p>
|
||||
<p>Bucket sort is suitable for handling very large data sets. For example, if the input data includes 1 million elements, and system memory limitations prevent loading all the data at the same time, you can divide the data into 1,000 buckets and sort each bucket separately before merging the results.</p>
|
||||
<ul>
|
||||
<li><strong>Time complexity is <span class="arithmatex">\(O(n + k)\)</span></strong>: Assuming the elements are evenly distributed across the buckets, the number of elements in each bucket is <span class="arithmatex">\(n/k\)</span>. Assuming sorting a single bucket takes <span class="arithmatex">\(O(n/k \log(n/k))\)</span> time, sorting all buckets takes <span class="arithmatex">\(O(n \log(n/k))\)</span> time. <strong>When the number of buckets <span class="arithmatex">\(k\)</span> is relatively large, the time complexity tends towards <span class="arithmatex">\(O(n)\)</span></strong>. Merging the results requires traversing all buckets and elements, taking <span class="arithmatex">\(O(n + k)\)</span> time. In the worst case, all data is distributed into a single bucket, and sorting that bucket takes <span class="arithmatex">\(O(n^2)\)</span> time.</li>
|
||||
<li><strong>Time complexity is <span class="arithmatex">\(O(n + k)\)</span></strong>: Assuming the elements are evenly distributed across the buckets, the number of elements in each bucket is <span class="arithmatex">\(n/k\)</span>. Assuming sorting a single bucket takes <span class="arithmatex">\(O(n/k \log(n/k))\)</span> time, sorting all buckets takes <span class="arithmatex">\(O(n \log(n/k))\)</span> time. <strong>When the number of buckets <span class="arithmatex">\(k\)</span> is relatively large, the time complexity approaches <span class="arithmatex">\(O(n)\)</span></strong>. Merging the results requires traversing all buckets and elements, taking <span class="arithmatex">\(O(n + k)\)</span> time. In the worst case, all data is distributed into a single bucket, and sorting that bucket takes <span class="arithmatex">\(O(n^2)\)</span> time.</li>
|
||||
<li><strong>Space complexity is <span class="arithmatex">\(O(n + k)\)</span>, non-in-place sorting</strong>: It requires additional space for <span class="arithmatex">\(k\)</span> buckets and a total of <span class="arithmatex">\(n\)</span> elements.</li>
|
||||
<li>Whether bucket sort is stable depends on whether the algorithm used to sort elements within the buckets is stable.</li>
|
||||
<li>Whether bucket sort is stable depends on whether the sorting algorithm used within each bucket is stable.</li>
|
||||
</ul>
|
||||
<h2 id="1183-how-to-achieve-even-distribution">11.8.3 How to achieve even distribution<a class="headerlink" href="#1183-how-to-achieve-even-distribution" title="Permanent link">¶</a></h2>
|
||||
<p>The theoretical time complexity of bucket sort can reach <span class="arithmatex">\(O(n)\)</span>, <strong>the key is to evenly distribute the elements across all buckets</strong>, as real data is often not uniformly distributed. For example, if we want to evenly distribute all products on Taobao by price range into 10 buckets, but the distribution of product prices is uneven, with many under 100 yuan and few over 1000 yuan. If the price range is evenly divided into 10, the difference in the number of products in each bucket will be very large.</p>
|
||||
<p>To achieve even distribution, we can initially set a rough dividing line, roughly dividing the data into 3 buckets. <strong>After the distribution is complete, the buckets with more products can be further divided into 3 buckets, until the number of elements in all buckets is roughly equal</strong>.</p>
|
||||
<p>As shown in Figure 11-14, this method essentially creates a recursive tree, aiming to make the leaf node values as even as possible. Of course, you don't have to divide the data into 3 buckets each round; the specific division method can be flexibly chosen based on data characteristics.</p>
|
||||
<p>The theoretical time complexity of bucket sort can reach <span class="arithmatex">\(O(n)\)</span>. <strong>The key is to evenly distribute the elements across all buckets</strong> as real-world data is often not uniformly distributed. For example, we may want to evenly distribute all products on eBay by price range into 10 buckets. However, the distribution of product prices may not be even, with many under $100 and few over $500. If the price range is evenly divided into 10, the difference in the number of products in each bucket will be significant.</p>
|
||||
<p>To achieve even distribution, we can initially set an approximate boundary to roughly divide the data into 3 buckets. <strong>After the distribution is complete, the buckets with more items can be further divided into 3 buckets, until the number of elements in all buckets is roughly equal</strong>.</p>
|
||||
<p>As shown in Figure 11-14, this method essentially constructs a recursive tree, aiming to ensure the element counts in leaf nodes are as even as possible. Of course, you don't have to divide the data into 3 buckets each round - the partitioning strategy can be adaptively tailored to the data's unique characteristics.</p>
|
||||
<p><a class="glightbox" href="../bucket_sort.assets/scatter_in_buckets_recursively.png" data-type="image" data-width="100%" data-height="auto" data-desc-position="bottom"><img alt="Recursive division of buckets" class="animation-figure" src="../bucket_sort.assets/scatter_in_buckets_recursively.png" /></a></p>
|
||||
<p align="center"> Figure 11-14 Recursive division of buckets </p>
|
||||
|
||||
<p>If we know the probability distribution of product prices in advance, <strong>we can set the price dividing line for each bucket based on the data probability distribution</strong>. It is worth noting that it is not necessarily required to specifically calculate the data distribution; it can also be approximated based on data characteristics using some probability model.</p>
|
||||
<p>As shown in Figure 11-15, we assume that product prices follow a normal distribution, allowing us to reasonably set the price intervals, thereby evenly distributing the products into the respective buckets.</p>
|
||||
<p>If we know the probability distribution of product prices in advance, <strong>we can set the price boundaries for each bucket based on the data probability distribution</strong>. It is worth noting that it is not necessarily required to specifically calculate the data distribution; instead, it can be approximated based on data characteristics using a probability model.</p>
|
||||
<p>As shown in Figure 11-15, assuming that product prices follow a normal distribution, we can define reasonable price intervals to balance the distribution of items across the buckets.</p>
|
||||
<p><a class="glightbox" href="../bucket_sort.assets/scatter_in_buckets_distribution.png" data-type="image" data-width="100%" data-height="auto" data-desc-position="bottom"><img alt="Dividing buckets based on probability distribution" class="animation-figure" src="../bucket_sort.assets/scatter_in_buckets_distribution.png" /></a></p>
|
||||
<p align="center"> Figure 11-15 Dividing buckets based on probability distribution </p>
|
||||
|
||||
|
||||
@@ -3620,13 +3620,13 @@
|
||||
|
||||
<!-- Page content -->
|
||||
<h1 id="119-counting-sort">11.9 Counting sort<a class="headerlink" href="#119-counting-sort" title="Permanent link">¶</a></h1>
|
||||
<p><u>Counting sort</u> achieves sorting by counting the number of elements, typically applied to arrays of integers.</p>
|
||||
<p><u>Counting sort</u> achieves sorting by counting the number of elements, usually applied to integer arrays.</p>
|
||||
<h2 id="1191-simple-implementation">11.9.1 Simple implementation<a class="headerlink" href="#1191-simple-implementation" title="Permanent link">¶</a></h2>
|
||||
<p>Let's start with a simple example. Given an array <code>nums</code> of length <span class="arithmatex">\(n\)</span>, where all elements are "non-negative integers", the overall process of counting sort is illustrated in Figure 11-16.</p>
|
||||
<p>Let's start with a simple example. Given an array <code>nums</code> of length <span class="arithmatex">\(n\)</span>, where all elements are "non-negative integers", the overall process of counting sort is shown in Figure 11-16.</p>
|
||||
<ol>
|
||||
<li>Traverse the array to find the maximum number, denoted as <span class="arithmatex">\(m\)</span>, then create an auxiliary array <code>counter</code> of length <span class="arithmatex">\(m + 1\)</span>.</li>
|
||||
<li><strong>Use <code>counter</code> to count the occurrence of each number in <code>nums</code></strong>, where <code>counter[num]</code> corresponds to the occurrence of the number <code>num</code>. The counting method is simple, just traverse <code>nums</code> (suppose the current number is <code>num</code>), and increase <code>counter[num]</code> by <span class="arithmatex">\(1\)</span> each round.</li>
|
||||
<li><strong>Since the indices of <code>counter</code> are naturally ordered, all numbers are essentially sorted already</strong>. Next, we traverse <code>counter</code>, filling <code>nums</code> in ascending order of occurrence.</li>
|
||||
<li><strong>Since the indices of <code>counter</code> are naturally ordered, all numbers are essentially sorted already</strong>. Next, we traverse <code>counter</code>, and fill in <code>nums</code> in ascending order of occurrence.</li>
|
||||
</ol>
|
||||
<p><a class="glightbox" href="../counting_sort.assets/counting_sort_overview.png" data-type="image" data-width="100%" data-height="auto" data-desc-position="bottom"><img alt="Counting sort process" class="animation-figure" src="../counting_sort.assets/counting_sort_overview.png" /></a></p>
|
||||
<p align="center"> Figure 11-16 Counting sort process </p>
|
||||
@@ -3756,15 +3756,15 @@
|
||||
<p>From the perspective of bucket sort, we can consider each index of the counting array <code>counter</code> in counting sort as a bucket, and the process of counting as distributing elements into the corresponding buckets. Essentially, counting sort is a special case of bucket sort for integer data.</p>
|
||||
</div>
|
||||
<h2 id="1192-complete-implementation">11.9.2 Complete implementation<a class="headerlink" href="#1192-complete-implementation" title="Permanent link">¶</a></h2>
|
||||
<p>Astute readers might have noticed, <strong>if the input data is an object, the above step <code>3.</code> becomes ineffective</strong>. Suppose the input data is a product object, we want to sort the products by their price (a class member variable), but the above algorithm can only provide the sorting result for the price.</p>
|
||||
<p>Observant readers might notice, <strong>if the input data is an object, the above step <code>3.</code> is invalid</strong>. Suppose the input data is a product object, we want to sort the products by the price (a class member variable), but the above algorithm can only give the sorted price as the result.</p>
|
||||
<p>So how can we get the sorting result for the original data? First, we calculate the "prefix sum" of <code>counter</code>. As the name suggests, the prefix sum at index <code>i</code>, <code>prefix[i]</code>, equals the sum of the first <code>i</code> elements of the array:</p>
|
||||
<div class="arithmatex">\[
|
||||
\text{prefix}[i] = \sum_{j=0}^i \text{counter[j]}
|
||||
\]</div>
|
||||
<p><strong>The prefix sum has a clear meaning, <code>prefix[num] - 1</code> represents the last occurrence index of element <code>num</code> in the result array <code>res</code></strong>. This information is crucial, as it tells us where each element should appear in the result array. Next, we traverse the original array <code>nums</code> for each element <code>num</code> in reverse order, performing the following two steps in each iteration.</p>
|
||||
<p><strong>The prefix sum has a clear meaning, <code>prefix[num] - 1</code> represents the index of the last occurrence of element <code>num</code> in the result array <code>res</code></strong>. This information is crucial, as it tells us where each element should appear in the result array. Next, we traverse each element <code>num</code> of the original array <code>nums</code> in reverse order, performing the following two steps in each iteration.</p>
|
||||
<ol>
|
||||
<li>Fill <code>num</code> into the array <code>res</code> at the index <code>prefix[num] - 1</code>.</li>
|
||||
<li>Reduce the prefix sum <code>prefix[num]</code> by <span class="arithmatex">\(1\)</span>, thus obtaining the next index to place <code>num</code>.</li>
|
||||
<li>Decrease the prefix sum <code>prefix[num]</code> by <span class="arithmatex">\(1\)</span> to obtain the next index to place <code>num</code>.</li>
|
||||
</ol>
|
||||
<p>After the traversal, the array <code>res</code> contains the sorted result, and finally, <code>res</code> replaces the original array <code>nums</code>. The complete counting sort process is shown in Figure 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"><1></label><label for="__tabbed_2_2"><2></label><label for="__tabbed_2_3"><3></label><label for="__tabbed_2_4"><4></label><label for="__tabbed_2_5"><5></label><label for="__tabbed_2_6"><6></label><label for="__tabbed_2_7"><7></label><label for="__tabbed_2_8"><8></label></div>
|
||||
@@ -3946,14 +3946,14 @@
|
||||
</div>
|
||||
<h2 id="1193-algorithm-characteristics">11.9.3 Algorithm characteristics<a class="headerlink" href="#1193-algorithm-characteristics" title="Permanent link">¶</a></h2>
|
||||
<ul>
|
||||
<li><strong>Time complexity is <span class="arithmatex">\(O(n + m)\)</span>, non-adaptive sort</strong>: Involves traversing <code>nums</code> and <code>counter</code>, both using linear time. Generally, <span class="arithmatex">\(n \gg m\)</span>, and the time complexity tends towards <span class="arithmatex">\(O(n)\)</span>.</li>
|
||||
<li><strong>Space complexity is <span class="arithmatex">\(O(n + m)\)</span>, non-in-place sort</strong>: Utilizes arrays <code>res</code> and <code>counter</code> of lengths <span class="arithmatex">\(n\)</span> and <span class="arithmatex">\(m\)</span> respectively.</li>
|
||||
<li><strong>Time complexity is <span class="arithmatex">\(O(n + m)\)</span>, non-adaptive sort</strong>: It involves traversing <code>nums</code> and <code>counter</code>, both using linear time. Generally, <span class="arithmatex">\(n \gg m\)</span>, and the time complexity tends towards <span class="arithmatex">\(O(n)\)</span>.</li>
|
||||
<li><strong>Space complexity is <span class="arithmatex">\(O(n + m)\)</span>, non-in-place sort</strong>: It uses array <code>res</code> of lengths <span class="arithmatex">\(n\)</span> and array <code>counter</code> of length <span class="arithmatex">\(m\)</span> respectively.</li>
|
||||
<li><strong>Stable sort</strong>: Since elements are filled into <code>res</code> in a "right-to-left" order, reversing the traversal of <code>nums</code> can prevent changing the relative position between equal elements, thereby achieving a stable sort. Actually, traversing <code>nums</code> in order can also produce the correct sorting result, but the outcome is unstable.</li>
|
||||
</ul>
|
||||
<h2 id="1194-limitations">11.9.4 Limitations<a class="headerlink" href="#1194-limitations" title="Permanent link">¶</a></h2>
|
||||
<p>By now, you might find counting sort very clever, as it can achieve efficient sorting merely by counting quantities. However, the prerequisites for using counting sort are relatively strict.</p>
|
||||
<p><strong>Counting sort is only suitable for non-negative integers</strong>. If you want to apply it to other types of data, you need to ensure that these data can be converted to non-negative integers without changing the relative sizes of the elements. For example, for an array containing negative integers, you can first add a constant to all numbers, converting them all to positive numbers, and then convert them back after sorting is complete.</p>
|
||||
<p><strong>Counting sort is suitable for large data volumes but small data ranges</strong>. For example, in the above example, <span class="arithmatex">\(m\)</span> should not be too large, otherwise, it will occupy too much space. And when <span class="arithmatex">\(n \ll m\)</span>, counting sort uses <span class="arithmatex">\(O(m)\)</span> time, which may be slower than <span class="arithmatex">\(O(n \log n)\)</span> sorting algorithms.</p>
|
||||
<p><strong>Counting sort is only suitable for non-negative integers</strong>. If you want to apply it to other types of data, you need to ensure that these data can be converted to non-negative integers without changing the original order of the elements. For example, for an array containing negative integers, you can first add a constant to all numbers, converting them all to positive numbers, and then convert them back after sorting is complete.</p>
|
||||
<p><strong>Counting sort is suitable for large datasets with a small range of values</strong>. For example, in the above example, <span class="arithmatex">\(m\)</span> should not be too large, otherwise, it will occupy too much space. And when <span class="arithmatex">\(n \ll m\)</span>, counting sort uses <span class="arithmatex">\(O(m)\)</span> time, which may be slower than <span class="arithmatex">\(O(n \log n)\)</span> sorting algorithms.</p>
|
||||
|
||||
<!-- Source file information -->
|
||||
|
||||
|
||||
@@ -3586,25 +3586,25 @@
|
||||
<h1 id="117-heap-sort">11.7 Heap sort<a class="headerlink" href="#117-heap-sort" title="Permanent link">¶</a></h1>
|
||||
<div class="admonition tip">
|
||||
<p class="admonition-title">Tip</p>
|
||||
<p>Before reading this section, please make sure you have completed the "Heap" chapter.</p>
|
||||
<p>Before reading this section, please ensure you have completed the "Heap" chapter.</p>
|
||||
</div>
|
||||
<p><u>Heap sort</u> is an efficient sorting algorithm based on the heap data structure. We can implement heap sort using the "heap creation" and "element extraction" operations we have already learned.</p>
|
||||
<ol>
|
||||
<li>Input the array and establish a min-heap, where the smallest element is at the heap's top.</li>
|
||||
<li>Continuously perform the extraction operation, recording the extracted elements in sequence to obtain a sorted list from smallest to largest.</li>
|
||||
<li>Input the array and construct a min-heap, where the smallest element is at the top of the heap.</li>
|
||||
<li>Continuously perform the extraction operation, record the extracted elements sequentially to obtain a sorted list from smallest to largest.</li>
|
||||
</ol>
|
||||
<p>Although the above method is feasible, it requires an additional array to save the popped elements, which is somewhat space-consuming. In practice, we usually use a more elegant implementation.</p>
|
||||
<p>Although the above method is feasible, it requires an additional array to store the popped elements, which is somewhat space-consuming. In practice, we usually use a more elegant implementation.</p>
|
||||
<h2 id="1171-algorithm-flow">11.7.1 Algorithm flow<a class="headerlink" href="#1171-algorithm-flow" title="Permanent link">¶</a></h2>
|
||||
<p>Suppose the array length is <span class="arithmatex">\(n\)</span>, the heap sort process is as follows.</p>
|
||||
<ol>
|
||||
<li>Input the array and establish a max-heap. After completion, the largest element is at the heap's top.</li>
|
||||
<li>Swap the top element of the heap (the first element) with the heap's bottom element (the last element). After the swap, reduce the heap's length by <span class="arithmatex">\(1\)</span> and increase the sorted elements count by <span class="arithmatex">\(1\)</span>.</li>
|
||||
<li>Input the array and establish a max-heap. After this step, the largest element is positioned at the top of the heap.</li>
|
||||
<li>Swap the top element of the heap (the first element) with the heap's bottom element (the last element). Following this swap, reduce the heap's length by <span class="arithmatex">\(1\)</span> and increase the sorted elements count by <span class="arithmatex">\(1\)</span>.</li>
|
||||
<li>Starting from the heap top, perform the sift-down operation from top to bottom. After the sift-down, the heap's property is restored.</li>
|
||||
<li>Repeat steps <code>2.</code> and <code>3.</code> Loop for <span class="arithmatex">\(n - 1\)</span> rounds to complete the sorting of the array.</li>
|
||||
</ol>
|
||||
<div class="admonition tip">
|
||||
<p class="admonition-title">Tip</p>
|
||||
<p>In fact, the element extraction operation also includes steps <code>2.</code> and <code>3.</code>, with the addition of a popping element step.</p>
|
||||
<p>In fact, the element extraction operation also includes steps <code>2.</code> and <code>3.</code>, with an additional step to pop (remove) the extracted element from the heap.</p>
|
||||
</div>
|
||||
<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"><1></label><label for="__tabbed_1_2"><2></label><label for="__tabbed_1_3"><3></label><label for="__tabbed_1_4"><4></label><label for="__tabbed_1_5"><5></label><label for="__tabbed_1_6"><6></label><label for="__tabbed_1_7"><7></label><label for="__tabbed_1_8"><8></label><label for="__tabbed_1_9"><9></label><label for="__tabbed_1_10"><10></label><label for="__tabbed_1_11"><11></label><label for="__tabbed_1_12"><12></label></div>
|
||||
<div class="tabbed-content">
|
||||
|
||||
@@ -3520,7 +3520,7 @@
|
||||
<p><a class="glightbox" href="../assets/covers/chapter_sorting.jpg" data-type="image" data-width="100%" data-height="auto" data-desc-position="bottom"><img alt="Sorting" class="cover-image" src="../assets/covers/chapter_sorting.jpg" /></a></p>
|
||||
<div class="admonition abstract">
|
||||
<p class="admonition-title">Abstract</p>
|
||||
<p>Sorting is like a magical key that turns chaos into order, enabling us to understand and handle data in a more efficient manner.</p>
|
||||
<p>Sorting is like a magical key that turns chaos into order, enabling us to understand and handle data more efficiently.</p>
|
||||
<p>Whether it's simple ascending order or complex categorical arrangements, sorting reveals the harmonious beauty of data.</p>
|
||||
</div>
|
||||
<h2 id="chapter-contents">Chapter contents<a class="headerlink" href="#chapter-contents" title="Permanent link">¶</a></h2>
|
||||
|
||||
@@ -3603,18 +3603,18 @@
|
||||
<!-- Page content -->
|
||||
<h1 id="114-insertion-sort">11.4 Insertion sort<a class="headerlink" href="#114-insertion-sort" title="Permanent link">¶</a></h1>
|
||||
<p><u>Insertion sort</u> is a simple sorting algorithm that works very much like the process of manually sorting a deck of cards.</p>
|
||||
<p>Specifically, we select a pivot element from the unsorted interval, compare it with the elements in the sorted interval to its left, and insert the element into the correct position.</p>
|
||||
<p>Figure 11-6 shows the process of inserting an element into an array. Assuming the pivot element is <code>base</code>, we need to move all elements between the target index and <code>base</code> one position to the right, then assign <code>base</code> to the target index.</p>
|
||||
<p>Specifically, we select a base element from the unsorted interval, compare it with the elements in the sorted interval to its left, and insert the element into the correct position.</p>
|
||||
<p>Figure 11-6 illustrates how an element is inserted into the array. Assuming the base element is <code>base</code>, we need to shift all elements from the target index up to <code>base</code> one position to the right, then assign <code>base</code> to the target index.</p>
|
||||
<p><a class="glightbox" href="../insertion_sort.assets/insertion_operation.png" data-type="image" data-width="100%" data-height="auto" data-desc-position="bottom"><img alt="Single insertion operation" class="animation-figure" src="../insertion_sort.assets/insertion_operation.png" /></a></p>
|
||||
<p align="center"> Figure 11-6 Single insertion operation </p>
|
||||
|
||||
<h2 id="1141-algorithm-process">11.4.1 Algorithm process<a class="headerlink" href="#1141-algorithm-process" title="Permanent link">¶</a></h2>
|
||||
<p>The overall process of insertion sort is shown in Figure 11-7.</p>
|
||||
<ol>
|
||||
<li>Initially, the first element of the array is sorted.</li>
|
||||
<li>The second element of the array is taken as <code>base</code>, and after inserting it into the correct position, <strong>the first two elements of the array are sorted</strong>.</li>
|
||||
<li>The third element is taken as <code>base</code>, and after inserting it into the correct position, <strong>the first three elements of the array are sorted</strong>.</li>
|
||||
<li>And so on, in the last round, the last element is taken as <code>base</code>, and after inserting it into the correct position, <strong>all elements are sorted</strong>.</li>
|
||||
<li>Consider the first element of the array as sorted.</li>
|
||||
<li>Select the second element as <code>base</code>, insert it into its correct position, <strong>leaving the first two elements sorted</strong>.</li>
|
||||
<li>Select the third element as <code>base</code>, insert it into its correct position, <strong>leaving the first three elements sorted</strong>.</li>
|
||||
<li>Continuing in this manner, in the final iteration, the last element is taken as <code>base</code>, and after inserting it into the correct position, <strong>all elements are sorted</strong>.</li>
|
||||
</ol>
|
||||
<p><a class="glightbox" href="../insertion_sort.assets/insertion_sort_overview.png" data-type="image" data-width="100%" data-height="auto" data-desc-position="bottom"><img alt="Insertion sort process" class="animation-figure" src="../insertion_sort.assets/insertion_sort_overview.png" /></a></p>
|
||||
<p align="center"> Figure 11-7 Insertion sort process </p>
|
||||
@@ -3721,10 +3721,10 @@
|
||||
<li><strong>Stable sorting</strong>: During the insertion operation, we insert elements to the right of equal elements, not changing their order.</li>
|
||||
</ul>
|
||||
<h2 id="1143-advantages-of-insertion-sort">11.4.3 Advantages of insertion sort<a class="headerlink" href="#1143-advantages-of-insertion-sort" title="Permanent link">¶</a></h2>
|
||||
<p>The time complexity of insertion sort is <span class="arithmatex">\(O(n^2)\)</span>, while the time complexity of quicksort, which we will study next, is <span class="arithmatex">\(O(n \log n)\)</span>. Although insertion sort has a higher time complexity, <strong>it is usually faster in cases of small data volumes</strong>.</p>
|
||||
<p>This conclusion is similar to that for linear and binary search. Algorithms like quicksort that have a time complexity of <span class="arithmatex">\(O(n \log n)\)</span> and are based on the divide-and-conquer strategy often involve more unit operations. In cases of small data volumes, the numerical values of <span class="arithmatex">\(n^2\)</span> and <span class="arithmatex">\(n \log n\)</span> are close, and complexity does not dominate, with the number of unit operations per round playing a decisive role.</p>
|
||||
<p>In fact, many programming languages (such as Java) use insertion sort in their built-in sorting functions. The general approach is: for long arrays, use sorting algorithms based on divide-and-conquer strategies, such as quicksort; for short arrays, use insertion sort directly.</p>
|
||||
<p>Although bubble sort, selection sort, and insertion sort all have a time complexity of <span class="arithmatex">\(O(n^2)\)</span>, in practice, <strong>insertion sort is used significantly more frequently than bubble sort and selection sort</strong>, mainly for the following reasons.</p>
|
||||
<p>The time complexity of insertion sort is <span class="arithmatex">\(O(n^2)\)</span>, while the time complexity of quicksort, which we will study next, is <span class="arithmatex">\(O(n \log n)\)</span>. Although insertion sort has a higher time complexity, <strong>it is usually faster in small input sizes</strong>.</p>
|
||||
<p>This conclusion is similar to that for linear and binary search. Algorithms like quicksort that have a time complexity of <span class="arithmatex">\(O(n \log n)\)</span> and are based on the divide-and-conquer strategy often involve more unit operations. For small input sizes, the numerical values of <span class="arithmatex">\(n^2\)</span> and <span class="arithmatex">\(n \log n\)</span> are close, and complexity does not dominate, with the number of unit operations per round playing a decisive role.</p>
|
||||
<p>In fact, many programming languages (such as Java) use insertion sort within their built-in sorting functions. The general approach is: for long arrays, use sorting algorithms based on divide-and-conquer strategies, such as quicksort; for short arrays, use insertion sort directly.</p>
|
||||
<p>Although bubble sort, selection sort, and insertion sort all have a time complexity of <span class="arithmatex">\(O(n^2)\)</span>, in practice, <strong>insertion sort is commonly used than bubble sort and selection sort</strong>, mainly for the following reasons.</p>
|
||||
<ul>
|
||||
<li>Bubble sort is based on element swapping, which requires the use of a temporary variable, involving 3 unit operations; insertion sort is based on element assignment, requiring only 1 unit operation. Therefore, <strong>the computational overhead of bubble sort is generally higher than that of insertion sort</strong>.</li>
|
||||
<li>The time complexity of selection sort is always <span class="arithmatex">\(O(n^2)\)</span>. <strong>Given a set of partially ordered data, insertion sort is usually more efficient than selection sort</strong>.</li>
|
||||
|
||||
@@ -3604,8 +3604,8 @@
|
||||
<h1 id="116-merge-sort">11.6 Merge sort<a class="headerlink" href="#116-merge-sort" title="Permanent link">¶</a></h1>
|
||||
<p><u>Merge sort</u> is a sorting algorithm based on the divide-and-conquer strategy, involving the "divide" and "merge" phases shown in Figure 11-10.</p>
|
||||
<ol>
|
||||
<li><strong>Divide phase</strong>: Recursively split the array from the midpoint, transforming the sorting problem of a long array into that of shorter arrays.</li>
|
||||
<li><strong>Merge phase</strong>: Stop dividing when the length of the sub-array is 1, start merging, and continuously combine two shorter ordered arrays into one longer ordered array until the process is complete.</li>
|
||||
<li><strong>Divide phase</strong>: Recursively split the array from the midpoint, transforming the sorting problem of a long array into shorter arrays.</li>
|
||||
<li><strong>Merge phase</strong>: Stop dividing when the length of the sub-array is 1, and then begin merging. The two shorter sorted arrays are continuously merged into a longer sorted array until the process is complete.</li>
|
||||
</ol>
|
||||
<p><a class="glightbox" href="../merge_sort.assets/merge_sort_overview.png" data-type="image" data-width="100%" data-height="auto" data-desc-position="bottom"><img alt="The divide and merge phases of merge sort" class="animation-figure" src="../merge_sort.assets/merge_sort_overview.png" /></a></p>
|
||||
<p align="center"> Figure 11-10 The divide and merge phases of merge sort </p>
|
||||
@@ -3614,9 +3614,9 @@
|
||||
<p>As shown in Figure 11-11, the "divide phase" recursively splits the array from the midpoint into two sub-arrays from top to bottom.</p>
|
||||
<ol>
|
||||
<li>Calculate the midpoint <code>mid</code>, recursively divide the left sub-array (interval <code>[left, mid]</code>) and the right sub-array (interval <code>[mid + 1, right]</code>).</li>
|
||||
<li>Continue with step <code>1.</code> recursively until the sub-array interval length is 1 to stop.</li>
|
||||
<li>Continue with step <code>1.</code> recursively until sub-array length becomes 1, then stops.</li>
|
||||
</ol>
|
||||
<p>The "merge phase" combines the left and right sub-arrays into a single ordered array from bottom to top. Note that merging starts with sub-arrays of length 1, and each sub-array is ordered during the merge phase.</p>
|
||||
<p>The "merge phase" combines the left and right sub-arrays into a sorted array from bottom to top. It is important to note that, merging starts with sub-arrays of length 1, and each sub-array is sorted during the merge phase.</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"><1></label><label for="__tabbed_1_2"><2></label><label for="__tabbed_1_3"><3></label><label for="__tabbed_1_4"><4></label><label for="__tabbed_1_5"><5></label><label for="__tabbed_1_6"><6></label><label for="__tabbed_1_7"><7></label><label for="__tabbed_1_8"><8></label><label for="__tabbed_1_9"><9></label><label for="__tabbed_1_10"><10></label></div>
|
||||
<div class="tabbed-content">
|
||||
<div class="tabbed-block">
|
||||
@@ -3653,10 +3653,10 @@
|
||||
</div>
|
||||
<p align="center"> Figure 11-11 Merge sort process </p>
|
||||
|
||||
<p>It is observed that the order of recursion in merge sort is consistent with the post-order traversal of a binary tree.</p>
|
||||
<p>It can be observed that the order of recursion in merge sort is consistent with the post-order traversal of a binary tree.</p>
|
||||
<ul>
|
||||
<li><strong>Post-order traversal</strong>: First recursively traverse the left subtree, then the right subtree, and finally handle the root node.</li>
|
||||
<li><strong>Merge sort</strong>: First recursively handle the left sub-array, then the right sub-array, and finally perform the merge.</li>
|
||||
<li><strong>Post-order traversal</strong>: First recursively traverse the left subtree, then the right subtree, and finally process the root node.</li>
|
||||
<li><strong>Merge sort</strong>: First recursively process the left sub-array, then the right sub-array, and finally perform the merge.</li>
|
||||
</ul>
|
||||
<p>The implementation of merge sort is shown in the following code. Note that the interval to be merged in <code>nums</code> is <code>[left, right]</code>, while the corresponding interval in <code>tmp</code> is <code>[0, right - left]</code>.</p>
|
||||
<div class="tabbed-set tabbed-alternate" data-tabs="2:14"><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" /><input id="__tabbed_2_13" name="__tabbed_2" type="radio" /><input id="__tabbed_2_14" name="__tabbed_2" type="radio" /><div class="tabbed-labels"><label for="__tabbed_2_1">Python</label><label for="__tabbed_2_2">C++</label><label for="__tabbed_2_3">Java</label><label for="__tabbed_2_4">C#</label><label for="__tabbed_2_5">Go</label><label for="__tabbed_2_6">Swift</label><label for="__tabbed_2_7">JS</label><label for="__tabbed_2_8">TS</label><label for="__tabbed_2_9">Dart</label><label for="__tabbed_2_10">Rust</label><label for="__tabbed_2_11">C</label><label for="__tabbed_2_12">Kotlin</label><label for="__tabbed_2_13">Ruby</label><label for="__tabbed_2_14">Zig</label></div>
|
||||
@@ -3863,12 +3863,12 @@
|
||||
<li><strong>Stable sort</strong>: During the merging process, the order of equal elements remains unchanged.</li>
|
||||
</ul>
|
||||
<h2 id="1163-linked-list-sorting">11.6.3 Linked List sorting<a class="headerlink" href="#1163-linked-list-sorting" title="Permanent link">¶</a></h2>
|
||||
<p>For linked lists, merge sort has significant advantages over other sorting algorithms, <strong>optimizing the space complexity of the linked list sorting task to <span class="arithmatex">\(O(1)\)</span></strong>.</p>
|
||||
<p>For linked lists, merge sort has significant advantages over other sorting algorithms. <strong>It can optimize the space complexity of the linked list sorting task to <span class="arithmatex">\(O(1)\)</span></strong>.</p>
|
||||
<ul>
|
||||
<li><strong>Divide phase</strong>: "Iteration" can be used instead of "recursion" to perform the linked list division work, thus saving the stack frame space used by recursion.</li>
|
||||
<li><strong>Merge phase</strong>: In linked lists, node addition and deletion operations can be achieved by changing references (pointers), so no extra lists need to be created during the merge phase (combining two short ordered lists into one long ordered list).</li>
|
||||
<li><strong>Merge phase</strong>: In linked lists, node insertion and deletion operations can be achieved by changing references (pointers), so no extra lists need to be created during the merge phase (combining two short ordered lists into one long ordered list).</li>
|
||||
</ul>
|
||||
<p>Detailed implementation details are complex, and interested readers can consult related materials for learning.</p>
|
||||
<p>The implementation details are relatively complex, and interested readers can consult related materials for learning.</p>
|
||||
|
||||
<!-- Source file information -->
|
||||
|
||||
|
||||
@@ -3638,11 +3638,11 @@
|
||||
|
||||
<!-- Page content -->
|
||||
<h1 id="115-quick-sort">11.5 Quick sort<a class="headerlink" href="#115-quick-sort" title="Permanent link">¶</a></h1>
|
||||
<p><u>Quick sort</u> is a sorting algorithm based on the divide and conquer strategy, known for its efficiency and wide application.</p>
|
||||
<p>The core operation of quick sort is "pivot partitioning," aiming to: select an element from the array as the "pivot," move all elements smaller than the pivot to its left, and move elements greater than the pivot to its right. Specifically, the pivot partitioning process is illustrated in Figure 11-8.</p>
|
||||
<p><u>Quick sort</u> is a sorting algorithm based on the divide-and-conquer strategy, known for its efficiency and wide application.</p>
|
||||
<p>The core operation of quick sort is "pivot partitioning," which aims to select an element from the array as the "pivot" and move all elements less than the pivot to its left side, while moving all elements greater than the pivot to its right side. Specifically, the process of pivot partitioning is illustrated in Figure 11-8.</p>
|
||||
<ol>
|
||||
<li>Select the leftmost element of the array as the pivot, and initialize two pointers <code>i</code> and <code>j</code> at both ends of the array.</li>
|
||||
<li>Set up a loop where each round uses <code>i</code> (<code>j</code>) to find the first element larger (smaller) than the pivot, then swap these two elements.</li>
|
||||
<li>Select the leftmost element of the array as the pivot, and initialize two pointers <code>i</code> and <code>j</code> to point to the two ends of the array respectively.</li>
|
||||
<li>Set up a loop where each round uses <code>i</code> (<code>j</code>) to search for the first element larger (smaller) than the pivot, then swap these two elements.</li>
|
||||
<li>Repeat step <code>2.</code> until <code>i</code> and <code>j</code> meet, finally swap the pivot to the boundary between the two sub-arrays.</li>
|
||||
</ol>
|
||||
<div class="tabbed-set tabbed-alternate" data-tabs="1:9"><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" /><div class="tabbed-labels"><label for="__tabbed_1_1"><1></label><label for="__tabbed_1_2"><2></label><label for="__tabbed_1_3"><3></label><label for="__tabbed_1_4"><4></label><label for="__tabbed_1_5"><5></label><label for="__tabbed_1_6"><6></label><label for="__tabbed_1_7"><7></label><label for="__tabbed_1_8"><8></label><label for="__tabbed_1_9"><9></label></div>
|
||||
@@ -3678,10 +3678,10 @@
|
||||
</div>
|
||||
<p align="center"> Figure 11-8 Pivot division process </p>
|
||||
|
||||
<p>After the pivot partitioning, the original array is divided into three parts: left sub-array, pivot, and right sub-array, satisfying "any element in the left sub-array <span class="arithmatex">\(\leq\)</span> pivot <span class="arithmatex">\(\leq\)</span> any element in the right sub-array." Therefore, we only need to sort these two sub-arrays next.</p>
|
||||
<p>After the pivot partitioning, the original array is divided into three parts: left sub-array, pivot, and right sub-array, satisfying "any element in the left sub-array <span class="arithmatex">\(\leq\)</span> pivot <span class="arithmatex">\(\leq\)</span> any element in the right sub-array." Therefore, we then only need to sort these two sub-arrays.</p>
|
||||
<div class="admonition note">
|
||||
<p class="admonition-title">Quick sort's divide and conquer strategy</p>
|
||||
<p>The essence of pivot partitioning is to simplify a longer array's sorting problem into two shorter arrays' sorting problems.</p>
|
||||
<p class="admonition-title">Divide-and-conquer strategy for quick sort</p>
|
||||
<p>The essence of pivot partitioning is to simplify the sorting problem of a longer array into two shorter arrays.</p>
|
||||
</div>
|
||||
<div class="tabbed-set tabbed-alternate" data-tabs="2:14"><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" /><input id="__tabbed_2_13" name="__tabbed_2" type="radio" /><input id="__tabbed_2_14" name="__tabbed_2" type="radio" /><div class="tabbed-labels"><label for="__tabbed_2_1">Python</label><label for="__tabbed_2_2">C++</label><label for="__tabbed_2_3">Java</label><label for="__tabbed_2_4">C#</label><label for="__tabbed_2_5">Go</label><label for="__tabbed_2_6">Swift</label><label for="__tabbed_2_7">JS</label><label for="__tabbed_2_8">TS</label><label for="__tabbed_2_9">Dart</label><label for="__tabbed_2_10">Rust</label><label for="__tabbed_2_11">C</label><label for="__tabbed_2_12">Kotlin</label><label for="__tabbed_2_13">Ruby</label><label for="__tabbed_2_14">Zig</label></div>
|
||||
<div class="tabbed-content">
|
||||
@@ -3807,8 +3807,8 @@
|
||||
<p>The overall process of quick sort is shown in Figure 11-9.</p>
|
||||
<ol>
|
||||
<li>First, perform a "pivot partitioning" on the original array to obtain the unsorted left and right sub-arrays.</li>
|
||||
<li>Then, recursively perform "pivot partitioning" on both the left and right sub-arrays.</li>
|
||||
<li>Continue recursively until the sub-array length reaches 1, thus completing the sorting of the entire array.</li>
|
||||
<li>Then, recursively perform "pivot partitioning" on the left and right sub-arrays separately.</li>
|
||||
<li>Continue recursively until the length of sub-array is 1, thus completing the sorting of the entire array.</li>
|
||||
</ol>
|
||||
<p><a class="glightbox" href="../quick_sort.assets/quick_sort_overview.png" data-type="image" data-width="100%" data-height="auto" data-desc-position="bottom"><img alt="Quick sort process" class="animation-figure" src="../quick_sort.assets/quick_sort_overview.png" /></a></p>
|
||||
<p align="center"> Figure 11-9 Quick sort process </p>
|
||||
@@ -3904,22 +3904,22 @@
|
||||
</div>
|
||||
<h2 id="1152-algorithm-features">11.5.2 Algorithm features<a class="headerlink" href="#1152-algorithm-features" title="Permanent link">¶</a></h2>
|
||||
<ul>
|
||||
<li><strong>Time complexity of <span class="arithmatex">\(O(n \log n)\)</span>, non-adaptive sorting</strong>: In average cases, the recursive levels of pivot partitioning are <span class="arithmatex">\(\log n\)</span>, and the total number of loops per level is <span class="arithmatex">\(n\)</span>, using <span class="arithmatex">\(O(n \log n)\)</span> time overall. In the worst case, each round of pivot partitioning divides an array of length <span class="arithmatex">\(n\)</span> into two sub-arrays of lengths <span class="arithmatex">\(0\)</span> and <span class="arithmatex">\(n - 1\)</span>, reaching <span class="arithmatex">\(n\)</span> recursive levels, and using <span class="arithmatex">\(O(n^2)\)</span> time overall.</li>
|
||||
<li><strong>Space complexity of <span class="arithmatex">\(O(n)\)</span>, in-place sorting</strong>: In completely reversed input arrays, reaching the worst recursion depth of <span class="arithmatex">\(n\)</span>, using <span class="arithmatex">\(O(n)\)</span> stack frame space. The sorting operation is performed on the original array without the aid of additional arrays.</li>
|
||||
<li><strong>Time complexity of <span class="arithmatex">\(O(n \log n)\)</span>, non-adaptive sorting</strong>: In average cases, the recursive levels of pivot partitioning are <span class="arithmatex">\(\log n\)</span>, and the total number of loops per level is <span class="arithmatex">\(n\)</span>, using <span class="arithmatex">\(O(n \log n)\)</span> time overall. In the worst case, each round of pivot partitioning divides an array of length <span class="arithmatex">\(n\)</span> into two sub-arrays of lengths <span class="arithmatex">\(0\)</span> and <span class="arithmatex">\(n - 1\)</span>, when the number of recursive levels reaches <span class="arithmatex">\(n\)</span>, the number of loops in each level is <span class="arithmatex">\(n\)</span>, and the total time used is <span class="arithmatex">\(O(n^2)\)</span>.</li>
|
||||
<li><strong>Space complexity of <span class="arithmatex">\(O(n)\)</span>, in-place sorting</strong>: In the case where the input array is completely reversed, the worst recursive depth reaches <span class="arithmatex">\(n\)</span>, using <span class="arithmatex">\(O(n)\)</span> stack frame space. The sorting operation is performed on the original array without the aid of additional arrays.</li>
|
||||
<li><strong>Non-stable sorting</strong>: In the final step of pivot partitioning, the pivot may be swapped to the right of equal elements.</li>
|
||||
</ul>
|
||||
<h2 id="1153-why-is-quick-sort-fast">11.5.3 Why is quick sort fast<a class="headerlink" href="#1153-why-is-quick-sort-fast" title="Permanent link">¶</a></h2>
|
||||
<p>From its name, it is apparent that quick sort should have certain efficiency advantages. Although the average time complexity of quick sort is the same as "merge sort" and "heap sort," quick sort is generally more efficient, mainly for the following reasons.</p>
|
||||
<p>As the name suggests, quick sort should have certain advantages in terms of efficiency. Although the average time complexity of quick sort is the same as that of "merge sort" and "heap sort," it is generally more efficient for the following reasons.</p>
|
||||
<ul>
|
||||
<li><strong>Low probability of worst-case scenarios</strong>: Although the worst time complexity of quick sort is <span class="arithmatex">\(O(n^2)\)</span>, less stable than merge sort, in most cases, quick sort can operate under a time complexity of <span class="arithmatex">\(O(n \log n)\)</span>.</li>
|
||||
<li><strong>High cache usage efficiency</strong>: During the pivot partitioning operation, the system can load the entire sub-array into the cache, thus accessing elements more efficiently. In contrast, algorithms like "heap sort" need to access elements in a jumping manner, lacking this feature.</li>
|
||||
<li><strong>Small constant coefficient of complexity</strong>: Among the mentioned algorithms, quick sort has the fewest total number of comparisons, assignments, and swaps. This is similar to why "insertion sort" is faster than "bubble sort."</li>
|
||||
<li><strong>High cache utilization</strong>: During the pivot partitioning operation, the system can load the entire sub-array into the cache, thus accessing elements more efficiently. In contrast, algorithms like "heap sort" need to access elements in a jumping manner, lacking this feature.</li>
|
||||
<li><strong>Small constant coefficient of complexity</strong>: Among the three algorithms mentioned above, quick sort has the least total number of operations such as comparisons, assignments, and swaps. This is similar to why "insertion sort" is faster than "bubble sort."</li>
|
||||
</ul>
|
||||
<h2 id="1154-pivot-optimization">11.5.4 Pivot optimization<a class="headerlink" href="#1154-pivot-optimization" title="Permanent link">¶</a></h2>
|
||||
<p><strong>Quick sort's time efficiency may decrease under certain inputs</strong>. For example, if the input array is completely reversed, since we select the leftmost element as the pivot, after the pivot partitioning, the pivot is swapped to the array's right end, causing the left sub-array length to be <span class="arithmatex">\(n - 1\)</span> and the right sub-array length to be <span class="arithmatex">\(0\)</span>. If this recursion continues, each round of pivot partitioning will have a sub-array length of <span class="arithmatex">\(0\)</span>, and the divide and conquer strategy fails, degrading quick sort to a form similar to "bubble sort."</p>
|
||||
<p>To avoid this situation, <strong>we can optimize the strategy for selecting the pivot in the pivot partitioning</strong>. For instance, we can randomly select an element as the pivot. However, if luck is not on our side, and we keep selecting suboptimal pivots, the efficiency is still not satisfactory.</p>
|
||||
<p><strong>Quick sort's time efficiency may degrade under certain inputs</strong>. For example, if the input array is completely reversed, since we select the leftmost element as the pivot, after the pivot partitioning, the pivot is swapped to the array's right end, causing the left sub-array length to be <span class="arithmatex">\(n - 1\)</span> and the right sub-array length to be <span class="arithmatex">\(0\)</span>. Continuing this way, each round of pivot partitioning will have a sub-array length of <span class="arithmatex">\(0\)</span>, and the divide-and-conquer strategy fails, degrading quick sort to a form similar to "bubble sort."</p>
|
||||
<p>To avoid this situation, <strong>we can optimize the pivot selection strategy in the pivot partitioning</strong>. For instance, we can randomly select an element as the pivot. However, if luck is not on our side, and we consistently select suboptimal pivots, the efficiency is still not satisfactory.</p>
|
||||
<p>It's important to note that programming languages usually generate "pseudo-random numbers". If we construct a specific test case for a pseudo-random number sequence, the efficiency of quick sort may still degrade.</p>
|
||||
<p>For further improvement, we can select three candidate elements (usually the first, last, and midpoint elements of the array), <strong>and use the median of these three candidate elements as the pivot</strong>. This significantly increases the probability that the pivot is "neither too small nor too large". Of course, we can also select more candidate elements to further enhance the algorithm's robustness. Using this method significantly reduces the probability of time complexity degradation to <span class="arithmatex">\(O(n^2)\)</span>.</p>
|
||||
<p>For further improvement, we can select three candidate elements (usually the first, last, and midpoint elements of the array), <strong>and use the median of these three candidate elements as the pivot</strong>. This way, the probability that the pivot is "neither too small nor too large" will be greatly increased. Of course, we can also select more candidate elements to further enhance robustness of the algorithm. With this method, the probability of the time complexity degrading to <span class="arithmatex">\(O(n^2)\)</span> is greatly reduced.</p>
|
||||
<p>Sample code is as follows:</p>
|
||||
<div class="tabbed-set tabbed-alternate" data-tabs="4:14"><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" /><input id="__tabbed_4_12" name="__tabbed_4" type="radio" /><input id="__tabbed_4_13" name="__tabbed_4" type="radio" /><input id="__tabbed_4_14" name="__tabbed_4" type="radio" /><div class="tabbed-labels"><label for="__tabbed_4_1">Python</label><label for="__tabbed_4_2">C++</label><label for="__tabbed_4_3">Java</label><label for="__tabbed_4_4">C#</label><label for="__tabbed_4_5">Go</label><label for="__tabbed_4_6">Swift</label><label for="__tabbed_4_7">JS</label><label for="__tabbed_4_8">TS</label><label for="__tabbed_4_9">Dart</label><label for="__tabbed_4_10">Rust</label><label for="__tabbed_4_11">C</label><label for="__tabbed_4_12">Kotlin</label><label for="__tabbed_4_13">Ruby</label><label for="__tabbed_4_14">Zig</label></div>
|
||||
<div class="tabbed-content">
|
||||
@@ -4084,7 +4084,8 @@
|
||||
</div>
|
||||
</div>
|
||||
<h2 id="1155-tail-recursion-optimization">11.5.5 Tail recursion optimization<a class="headerlink" href="#1155-tail-recursion-optimization" title="Permanent link">¶</a></h2>
|
||||
<p><strong>Under certain inputs, quick sort may occupy more space</strong>. For a completely ordered input array, assume the sub-array length in recursion is <span class="arithmatex">\(m\)</span>, each round of pivot partitioning produces a left sub-array of length <span class="arithmatex">\(0\)</span> and a right sub-array of length <span class="arithmatex">\(m - 1\)</span>, meaning the problem size reduced per recursive call is very small (only one element), and the height of the recursion tree can reach <span class="arithmatex">\(n - 1\)</span>, requiring <span class="arithmatex">\(O(n)\)</span> stack frame space.</p>
|
||||
<p><strong>Under certain inputs, quick sort may occupy more space</strong>. For example, consider a completely ordered input array. Let the length of the sub-array in the recursion be <span class="arithmatex">\(m\)</span>. In each round of pivot partitioning, a left sub-array of length <span class="arithmatex">\(0\)</span> and a right sub-array of length <span class="arithmatex">\(m - 1\)</span> are produced. This means that the problem size is reduced by only one element per recursive call, resulting in a very small reduction at each level of recursion.
|
||||
As a result, the height of the recursion tree can reach <span class="arithmatex">\(n − 1\)</span> , which requires <span class="arithmatex">\(O(n)\)</span> of stack frame space.</p>
|
||||
<p>To prevent the accumulation of stack frame space, we can compare the lengths of the two sub-arrays after each round of pivot sorting, <strong>and only recursively sort the shorter sub-array</strong>. Since the length of the shorter sub-array will not exceed <span class="arithmatex">\(n / 2\)</span>, this method ensures that the recursion depth does not exceed <span class="arithmatex">\(\log n\)</span>, thus optimizing the worst space complexity to <span class="arithmatex">\(O(\log n)\)</span>. The code is as follows:</p>
|
||||
<div class="tabbed-set tabbed-alternate" data-tabs="5:14"><input checked="checked" id="__tabbed_5_1" name="__tabbed_5" type="radio" /><input id="__tabbed_5_2" name="__tabbed_5" type="radio" /><input id="__tabbed_5_3" name="__tabbed_5" type="radio" /><input id="__tabbed_5_4" name="__tabbed_5" type="radio" /><input id="__tabbed_5_5" name="__tabbed_5" type="radio" /><input id="__tabbed_5_6" name="__tabbed_5" type="radio" /><input id="__tabbed_5_7" name="__tabbed_5" type="radio" /><input id="__tabbed_5_8" name="__tabbed_5" type="radio" /><input id="__tabbed_5_9" name="__tabbed_5" type="radio" /><input id="__tabbed_5_10" name="__tabbed_5" type="radio" /><input id="__tabbed_5_11" name="__tabbed_5" type="radio" /><input id="__tabbed_5_12" name="__tabbed_5" type="radio" /><input id="__tabbed_5_13" name="__tabbed_5" type="radio" /><input id="__tabbed_5_14" name="__tabbed_5" type="radio" /><div class="tabbed-labels"><label for="__tabbed_5_1">Python</label><label for="__tabbed_5_2">C++</label><label for="__tabbed_5_3">Java</label><label for="__tabbed_5_4">C#</label><label for="__tabbed_5_5">Go</label><label for="__tabbed_5_6">Swift</label><label for="__tabbed_5_7">JS</label><label for="__tabbed_5_8">TS</label><label for="__tabbed_5_9">Dart</label><label for="__tabbed_5_10">Rust</label><label for="__tabbed_5_11">C</label><label for="__tabbed_5_12">Kotlin</label><label for="__tabbed_5_13">Ruby</label><label for="__tabbed_5_14">Zig</label></div>
|
||||
<div class="tabbed-content">
|
||||
|
||||
@@ -3584,14 +3584,14 @@
|
||||
|
||||
<!-- Page content -->
|
||||
<h1 id="1110-radix-sort">11.10 Radix sort<a class="headerlink" href="#1110-radix-sort" title="Permanent link">¶</a></h1>
|
||||
<p>The previous section introduced counting sort, which is suitable for scenarios where the data volume <span class="arithmatex">\(n\)</span> is large but the data range <span class="arithmatex">\(m\)</span> is small. Suppose we need to sort <span class="arithmatex">\(n = 10^6\)</span> student IDs, where each ID is an <span class="arithmatex">\(8\)</span>-digit number. This means the data range <span class="arithmatex">\(m = 10^8\)</span> is very large, requiring a significant amount of memory space for counting sort, while radix sort can avoid this situation.</p>
|
||||
<p><u>Radix sort</u> shares the core idea with counting sort, which also sorts by counting the frequency of elements. Building on this, radix sort utilizes the progressive relationship between the digits of numbers, sorting each digit in turn to achieve the final sorted order.</p>
|
||||
<p>The previous section introduced counting sort, which is suitable for scenarios where the data size <span class="arithmatex">\(n\)</span> is large but the data range <span class="arithmatex">\(m\)</span> is small. Suppose we need to sort <span class="arithmatex">\(n = 10^6\)</span> student IDs, where each ID is an <span class="arithmatex">\(8\)</span>-digit number. This means the data range <span class="arithmatex">\(m = 10^8\)</span> is very large. Using counting sort in this case would require significant memory space. Radix sort can avoid this situation.</p>
|
||||
<p><u>Radix sort</u> shares the same core concept as counting sort, which also sorts by counting the frequency of elements. Meanwhile, radix sort builds upon this by utilizing the progressive relationship between the digits of numbers. It processes and sorts the digits one at a time, achieving the final sorted order.</p>
|
||||
<h2 id="11101-algorithm-process">11.10.1 Algorithm process<a class="headerlink" href="#11101-algorithm-process" title="Permanent link">¶</a></h2>
|
||||
<p>Taking the student ID data as an example, assuming the least significant digit is the <span class="arithmatex">\(1^{st}\)</span> and the most significant is the <span class="arithmatex">\(8^{th}\)</span>, the radix sort process is illustrated in Figure 11-18.</p>
|
||||
<p>Taking the student ID data as an example, assume the least significant digit is the <span class="arithmatex">\(1^{st}\)</span> and the most significant is the <span class="arithmatex">\(8^{th}\)</span>, the radix sort process is illustrated in Figure 11-18.</p>
|
||||
<ol>
|
||||
<li>Initialize digit <span class="arithmatex">\(k = 1\)</span>.</li>
|
||||
<li>Perform "counting sort" on the <span class="arithmatex">\(k^{th}\)</span> digit of the student IDs. After completion, the data will be sorted from smallest to largest based on the <span class="arithmatex">\(k^{th}\)</span> digit.</li>
|
||||
<li>Increment <span class="arithmatex">\(k\)</span> by <span class="arithmatex">\(1\)</span>, then return to step <code>2.</code> and continue iterating until all digits have been sorted, then the process ends.</li>
|
||||
<li>Increment <span class="arithmatex">\(k\)</span> by <span class="arithmatex">\(1\)</span>, then return to step <code>2.</code> and continue iterating until all digits have been sorted, at which point the process ends.</li>
|
||||
</ol>
|
||||
<p><a class="glightbox" href="../radix_sort.assets/radix_sort_overview.png" data-type="image" data-width="100%" data-height="auto" data-desc-position="bottom"><img alt="Radix sort algorithm process" class="animation-figure" src="../radix_sort.assets/radix_sort_overview.png" /></a></p>
|
||||
<p align="center"> Figure 11-18 Radix sort algorithm process </p>
|
||||
@@ -3840,14 +3840,14 @@ x_k = \lfloor\frac{x}{d^{k-1}}\rfloor \bmod d
|
||||
</div>
|
||||
<div class="admonition question">
|
||||
<p class="admonition-title">Why start sorting from the least significant digit?</p>
|
||||
<p>In consecutive sorting rounds, the result of a later round will override the result of an earlier round. For example, if the result of the first round is <span class="arithmatex">\(a < b\)</span> and the result of the second round is <span class="arithmatex">\(a > b\)</span>, the result of the second round will replace the first round's result. Since the significance of higher digits is greater than that of lower digits, it makes sense to sort lower digits before higher digits.</p>
|
||||
<p>In consecutive sorting rounds, the result of a later round will override the result of an earlier round. For example, if the result of the first round is <span class="arithmatex">\(a < b\)</span> and the second round is <span class="arithmatex">\(a > b\)</span>, the second round's result will replace the first round's result. Since higher-order digits take precedence over lower-order digits, it makes sense to sort the lower digits before the higher digits.</p>
|
||||
</div>
|
||||
<h2 id="11102-algorithm-characteristics">11.10.2 Algorithm characteristics<a class="headerlink" href="#11102-algorithm-characteristics" title="Permanent link">¶</a></h2>
|
||||
<p>Compared to counting sort, radix sort is suitable for larger numerical ranges, <strong>but it assumes that the data can be represented in a fixed number of digits, and the number of digits should not be too large</strong>. For example, floating-point numbers are not suitable for radix sort, as their digit count <span class="arithmatex">\(k\)</span> may be large, potentially leading to a time complexity <span class="arithmatex">\(O(nk) \gg O(n^2)\)</span>.</p>
|
||||
<p>Compared to counting sort, radix sort is suitable for larger numerical ranges, <strong>but it assumes that the data can be represented in a fixed number of digits, and the number of digits should not be too large</strong>. For example, floating-point numbers are unsuitable for radix sort, as their digit count <span class="arithmatex">\(k\)</span> may be large, potentially leading to a time complexity <span class="arithmatex">\(O(nk) \gg O(n^2)\)</span>.</p>
|
||||
<ul>
|
||||
<li><strong>Time complexity is <span class="arithmatex">\(O(nk)\)</span>, non-adaptive sorting</strong>: Assuming the data size is <span class="arithmatex">\(n\)</span>, the data is in base <span class="arithmatex">\(d\)</span>, and the maximum number of digits is <span class="arithmatex">\(k\)</span>, then sorting a single digit takes <span class="arithmatex">\(O(n + d)\)</span> time, and sorting all <span class="arithmatex">\(k\)</span> digits takes <span class="arithmatex">\(O((n + d)k)\)</span> time. Generally, both <span class="arithmatex">\(d\)</span> and <span class="arithmatex">\(k\)</span> are relatively small, leading to a time complexity approaching <span class="arithmatex">\(O(n)\)</span>.</li>
|
||||
<li><strong>Space complexity is <span class="arithmatex">\(O(n + d)\)</span>, non-in-place sorting</strong>: Like counting sort, radix sort relies on arrays <code>res</code> and <code>counter</code> of lengths <span class="arithmatex">\(n\)</span> and <span class="arithmatex">\(d\)</span> respectively.</li>
|
||||
<li><strong>Stable sorting</strong>: When counting sort is stable, radix sort is also stable; if counting sort is unstable, radix sort cannot guarantee a correct sorting outcome.</li>
|
||||
<li><strong>Stable sorting</strong>: When counting sort is stable, radix sort is also stable; if counting sort is unstable, radix sort cannot ensure a correct sorting order.</li>
|
||||
</ul>
|
||||
|
||||
<!-- Source file information -->
|
||||
|
||||
@@ -3566,14 +3566,14 @@
|
||||
|
||||
<!-- Page content -->
|
||||
<h1 id="112-selection-sort">11.2 Selection sort<a class="headerlink" href="#112-selection-sort" title="Permanent link">¶</a></h1>
|
||||
<p><u>Selection sort</u> works on a very simple principle: it starts a loop where each iteration selects the smallest element from the unsorted interval and moves it to the end of the sorted interval.</p>
|
||||
<p>Suppose the length of the array is <span class="arithmatex">\(n\)</span>, the algorithm flow of selection sort is as shown in Figure 11-2.</p>
|
||||
<p><u>Selection sort</u> works on a very simple principle: it uses a loop where each iteration selects the smallest element from the unsorted interval and moves it to the end of the sorted section.</p>
|
||||
<p>Suppose the length of the array is <span class="arithmatex">\(n\)</span>, the steps of selection sort is shown in Figure 11-2.</p>
|
||||
<ol>
|
||||
<li>Initially, all elements are unsorted, i.e., the unsorted (index) interval is <span class="arithmatex">\([0, n-1]\)</span>.</li>
|
||||
<li>Select the smallest element in the interval <span class="arithmatex">\([0, n-1]\)</span> and swap it with the element at index <span class="arithmatex">\(0\)</span>. After this, the first element of the array is sorted.</li>
|
||||
<li>Select the smallest element in the interval <span class="arithmatex">\([1, n-1]\)</span> and swap it with the element at index <span class="arithmatex">\(1\)</span>. After this, the first two elements of the array are sorted.</li>
|
||||
<li>Continue in this manner. After <span class="arithmatex">\(n - 1\)</span> rounds of selection and swapping, the first <span class="arithmatex">\(n - 1\)</span> elements are sorted.</li>
|
||||
<li>The only remaining element is necessarily the largest element and does not need sorting, thus the array is sorted.</li>
|
||||
<li>The only remaining element is subsequently the largest element and does not need sorting, thus the array is sorted.</li>
|
||||
</ol>
|
||||
<div class="tabbed-set tabbed-alternate" data-tabs="1:11"><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" /><div class="tabbed-labels"><label for="__tabbed_1_1"><1></label><label for="__tabbed_1_2"><2></label><label for="__tabbed_1_3"><3></label><label for="__tabbed_1_4"><4></label><label for="__tabbed_1_5"><5></label><label for="__tabbed_1_6"><6></label><label for="__tabbed_1_7"><7></label><label for="__tabbed_1_8"><8></label><label for="__tabbed_1_9"><9></label><label for="__tabbed_1_10"><10></label><label for="__tabbed_1_11"><11></label></div>
|
||||
<div class="tabbed-content">
|
||||
@@ -3718,7 +3718,7 @@
|
||||
</div>
|
||||
<h2 id="1121-algorithm-characteristics">11.2.1 Algorithm characteristics<a class="headerlink" href="#1121-algorithm-characteristics" title="Permanent link">¶</a></h2>
|
||||
<ul>
|
||||
<li><strong>Time complexity of <span class="arithmatex">\(O(n^2)\)</span>, non-adaptive sort</strong>: There are <span class="arithmatex">\(n - 1\)</span> rounds in the outer loop, with the unsorted interval length starting at <span class="arithmatex">\(n\)</span> in the first round and decreasing to <span class="arithmatex">\(2\)</span> in the last round, i.e., the outer loops contain <span class="arithmatex">\(n\)</span>, <span class="arithmatex">\(n - 1\)</span>, <span class="arithmatex">\(\dots\)</span>, <span class="arithmatex">\(3\)</span>, <span class="arithmatex">\(2\)</span> inner loops respectively, summing up to <span class="arithmatex">\(\frac{(n - 1)(n + 2)}{2}\)</span>.</li>
|
||||
<li><strong>Time complexity of <span class="arithmatex">\(O(n^2)\)</span>, non-adaptive sort</strong>: There are <span class="arithmatex">\(n - 1\)</span> iterations in the outer loop, with the length of the unsorted section starting at <span class="arithmatex">\(n\)</span> in the first iteration and decreasing to <span class="arithmatex">\(2\)</span> in the last iteration, i.e., each outer loop iterations contain <span class="arithmatex">\(n\)</span>, <span class="arithmatex">\(n - 1\)</span>, <span class="arithmatex">\(\dots\)</span>, <span class="arithmatex">\(3\)</span>, <span class="arithmatex">\(2\)</span> inner loop iterations respectively, summing up to <span class="arithmatex">\(\frac{(n - 1)(n + 2)}{2}\)</span>.</li>
|
||||
<li><strong>Space complexity of <span class="arithmatex">\(O(1)\)</span>, in-place sort</strong>: Uses constant extra space with pointers <span class="arithmatex">\(i\)</span> and <span class="arithmatex">\(j\)</span>.</li>
|
||||
<li><strong>Non-stable sort</strong>: As shown in Figure 11-3, an element <code>nums[i]</code> may be swapped to the right of an equal element, causing their relative order to change.</li>
|
||||
</ul>
|
||||
|
||||
@@ -3588,12 +3588,12 @@
|
||||
<ul>
|
||||
<li>Bubble sort works by swapping adjacent elements. By adding a flag to enable early return, we can optimize the best-case time complexity of bubble sort to <span class="arithmatex">\(O(n)\)</span>.</li>
|
||||
<li>Insertion sort sorts each round by inserting elements from the unsorted interval into the correct position in the sorted interval. Although the time complexity of insertion sort is <span class="arithmatex">\(O(n^2)\)</span>, it is very popular in sorting small amounts of data due to relatively fewer operations per unit.</li>
|
||||
<li>Quick sort is based on sentinel partitioning operations. In sentinel partitioning, it's possible to always pick the worst pivot, leading to a time complexity degradation to <span class="arithmatex">\(O(n^2)\)</span>. Introducing median or random pivots can reduce the probability of such degradation. Tail recursion can effectively reduce the recursion depth, optimizing the space complexity to <span class="arithmatex">\(O(\log n)\)</span>.</li>
|
||||
<li>Quick sort is based on sentinel partitioning operations. In sentinel partitioning, it's possible to always pick the worst pivot, leading to a time complexity degradation to <span class="arithmatex">\(O(n^2)\)</span>. Introducing median or random pivots can reduce the probability of such degradation. Tail recursion effectively reduce the recursion depth, optimizing the space complexity to <span class="arithmatex">\(O(\log n)\)</span>.</li>
|
||||
<li>Merge sort includes dividing and merging two phases, typically embodying the divide-and-conquer strategy. In merge sort, sorting an array requires creating auxiliary arrays, resulting in a space complexity of <span class="arithmatex">\(O(n)\)</span>; however, the space complexity for sorting a list can be optimized to <span class="arithmatex">\(O(1)\)</span>.</li>
|
||||
<li>Bucket sort consists of three steps: data bucketing, sorting within buckets, and merging results. It also embodies the divide-and-conquer strategy, suitable for very large datasets. The key to bucket sort is the even distribution of data.</li>
|
||||
<li>Counting sort is a special case of bucket sort, which sorts by counting the occurrences of each data point. Counting sort is suitable for large datasets with a limited range of data and requires that data can be converted to positive integers.</li>
|
||||
<li>Radix sort sorts data by sorting digit by digit, requiring data to be represented as fixed-length numbers.</li>
|
||||
<li>Overall, we hope to find a sorting algorithm that has high efficiency, stability, in-place operation, and adaptability. However, like other data structures and algorithms, no sorting algorithm can meet all these conditions simultaneously. In practical applications, we need to choose the appropriate sorting algorithm based on the characteristics of the data.</li>
|
||||
<li>Bucket sort consists of three steps: distributing data into buckets, sorting within each bucket, and merging results in bucket order. It also embodies the divide-and-conquer strategy, suitable for very large datasets. The key to bucket sort is the even distribution of data.</li>
|
||||
<li>Counting sort is a variant of bucket sort, which sorts by counting the occurrences of each data point. Counting sort is suitable for large datasets with a limited range of data and requires data conversion to positive integers.</li>
|
||||
<li>Radix sort processes data by sorting it digit by digit, requiring data to be represented as fixed-length numbers.</li>
|
||||
<li>Overall, we seek sorting algorithm that has high efficiency, stability, in-place operation, and adaptability. However, like other data structures and algorithms, no sorting algorithm can meet all these conditions simultaneously. In practical applications, we need to choose the appropriate sorting algorithm based on the characteristics of the data.</li>
|
||||
<li>Figure 11-19 compares mainstream sorting algorithms in terms of efficiency, stability, in-place nature, and adaptability.</li>
|
||||
</ul>
|
||||
<p><a class="glightbox" href="../summary.assets/sorting_algorithms_comparison.png" data-type="image" data-width="100%" data-height="auto" data-desc-position="bottom"><img alt="Sorting Algorithm Comparison" class="animation-figure" src="../summary.assets/sorting_algorithms_comparison.png" /></a></p>
|
||||
@@ -3605,7 +3605,7 @@
|
||||
<p>It can be seen that the positions of students D and C have been swapped, disrupting the orderliness of the names, which is undesirable.</p>
|
||||
<p><strong>Q</strong>: Can the order of "searching from right to left" and "searching from left to right" in sentinel partitioning be swapped?</p>
|
||||
<p>No, when using the leftmost element as the pivot, we must first "search from right to left" then "search from left to right". This conclusion is somewhat counterintuitive, so let's analyze the reason.</p>
|
||||
<p>The last step of the sentinel partition <code>partition()</code> is to swap <code>nums[left]</code> and <code>nums[i]</code>. After the swap, the elements to the left of the pivot are all <code><=</code> the pivot, <strong>which requires that <code>nums[left] >= nums[i]</code> must hold before the last swap</strong>. Suppose we "search from left to right" first, then if no element larger than the pivot is found, <strong>we will exit the loop when <code>i == j</code>, possibly with <code>nums[j] == nums[i] > nums[left]</code></strong>. In other words, the final swap operation will exchange an element larger than the pivot to the left end of the array, causing the sentinel partition to fail.</p>
|
||||
<p>The last step of the sentinel partition <code>partition()</code> is to swap <code>nums[left]</code> and <code>nums[i]</code>. After the swap, the elements to the left of the pivot are all <code><=</code> the pivot, <strong>which requires that <code>nums[left] >= nums[i]</code> must hold before the last swap</strong>. Suppose we "search from left to right" first, and if no element larger than the pivot is found, <strong>we will exit the loop when <code>i == j</code>, possibly with <code>nums[j] == nums[i] > nums[left]</code></strong>. In other words, the final swap operation will exchange an element larger than the pivot to the left end of the array, causing the sentinel partition to fail.</p>
|
||||
<p>For example, given the array <code>[0, 0, 0, 0, 1]</code>, if we first "search from left to right", the array after the sentinel partition is <code>[1, 0, 0, 0, 0]</code>, which is incorrect.</p>
|
||||
<p>Upon further consideration, if we choose <code>nums[right]</code> as the pivot, then exactly the opposite, we must first "search from left to right".</p>
|
||||
<p><strong>Q</strong>: Regarding tail recursion optimization, why does choosing the shorter array ensure that the recursion depth does not exceed <span class="arithmatex">\(\log n\)</span>?</p>
|
||||
|
||||
File diff suppressed because one or more lines are too long
+105
-105
@@ -2,527 +2,527 @@
|
||||
<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/en/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/en/chapter_appendix/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/en/chapter_appendix/contribution/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/en/chapter_appendix/installation/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/en/chapter_appendix/terminology/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/en/chapter_array_and_linkedlist/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/en/chapter_array_and_linkedlist/array/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/en/chapter_array_and_linkedlist/linked_list/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/en/chapter_array_and_linkedlist/list/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/en/chapter_array_and_linkedlist/ram_and_cache/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/en/chapter_array_and_linkedlist/summary/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/en/chapter_backtracking/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/en/chapter_backtracking/backtracking_algorithm/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/en/chapter_backtracking/n_queens_problem/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/en/chapter_backtracking/permutations_problem/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/en/chapter_backtracking/subset_sum_problem/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/en/chapter_backtracking/summary/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/en/chapter_computational_complexity/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/en/chapter_computational_complexity/iteration_and_recursion/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/en/chapter_computational_complexity/performance_evaluation/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/en/chapter_computational_complexity/space_complexity/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/en/chapter_computational_complexity/summary/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/en/chapter_computational_complexity/time_complexity/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/en/chapter_data_structure/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/en/chapter_data_structure/basic_data_types/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/en/chapter_data_structure/character_encoding/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/en/chapter_data_structure/classification_of_data_structure/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/en/chapter_data_structure/number_encoding/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/en/chapter_data_structure/summary/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/en/chapter_divide_and_conquer/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/en/chapter_divide_and_conquer/binary_search_recur/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/en/chapter_divide_and_conquer/build_binary_tree_problem/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/en/chapter_divide_and_conquer/divide_and_conquer/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/en/chapter_divide_and_conquer/hanota_problem/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/en/chapter_divide_and_conquer/summary/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/en/chapter_dynamic_programming/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/en/chapter_dynamic_programming/dp_problem_features/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/en/chapter_dynamic_programming/dp_solution_pipeline/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/en/chapter_dynamic_programming/edit_distance_problem/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/en/chapter_dynamic_programming/intro_to_dynamic_programming/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/en/chapter_dynamic_programming/knapsack_problem/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/en/chapter_dynamic_programming/summary/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/en/chapter_dynamic_programming/unbounded_knapsack_problem/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/en/chapter_graph/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/en/chapter_graph/graph/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/en/chapter_graph/graph_operations/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/en/chapter_graph/graph_traversal/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/en/chapter_graph/summary/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/en/chapter_greedy/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/en/chapter_greedy/fractional_knapsack_problem/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/en/chapter_greedy/greedy_algorithm/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/en/chapter_greedy/max_capacity_problem/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/en/chapter_greedy/max_product_cutting_problem/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/en/chapter_greedy/summary/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/en/chapter_hashing/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/en/chapter_hashing/hash_algorithm/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/en/chapter_hashing/hash_collision/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/en/chapter_hashing/hash_map/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/en/chapter_hashing/summary/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/en/chapter_heap/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/en/chapter_heap/build_heap/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/en/chapter_heap/heap/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/en/chapter_heap/summary/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/en/chapter_heap/top_k/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/en/chapter_hello_algo/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/en/chapter_introduction/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/en/chapter_introduction/algorithms_are_everywhere/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/en/chapter_introduction/summary/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/en/chapter_introduction/what_is_dsa/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/en/chapter_preface/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/en/chapter_preface/about_the_book/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/en/chapter_preface/suggestions/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/en/chapter_preface/summary/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/en/chapter_reference/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/en/chapter_searching/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/en/chapter_searching/binary_search/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/en/chapter_searching/binary_search_edge/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/en/chapter_searching/binary_search_insertion/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/en/chapter_searching/replace_linear_by_hashing/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/en/chapter_searching/searching_algorithm_revisited/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/en/chapter_searching/summary/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/en/chapter_sorting/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/en/chapter_sorting/bubble_sort/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/en/chapter_sorting/bucket_sort/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/en/chapter_sorting/counting_sort/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/en/chapter_sorting/heap_sort/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/en/chapter_sorting/insertion_sort/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/en/chapter_sorting/merge_sort/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/en/chapter_sorting/quick_sort/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/en/chapter_sorting/radix_sort/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/en/chapter_sorting/selection_sort/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/en/chapter_sorting/sorting_algorithm/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/en/chapter_sorting/summary/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/en/chapter_stack_and_queue/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/en/chapter_stack_and_queue/deque/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/en/chapter_stack_and_queue/queue/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/en/chapter_stack_and_queue/stack/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/en/chapter_stack_and_queue/summary/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/en/chapter_tree/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/en/chapter_tree/array_representation_of_tree/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/en/chapter_tree/avl_tree/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/en/chapter_tree/binary_search_tree/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/en/chapter_tree/binary_tree/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/en/chapter_tree/binary_tree_traversal/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/en/chapter_tree/summary/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
</urlset>
|
||||
Binary file not shown.
File diff suppressed because one or more lines are too long
+106
-106
@@ -2,532 +2,532 @@
|
||||
<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_appendix/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_appendix/contribution/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_appendix/installation/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_appendix/terminology/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_array_and_linkedlist/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_array_and_linkedlist/array/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_array_and_linkedlist/linked_list/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_array_and_linkedlist/list/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_array_and_linkedlist/ram_and_cache/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_array_and_linkedlist/summary/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_backtracking/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_backtracking/backtracking_algorithm/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_backtracking/n_queens_problem/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_backtracking/permutations_problem/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_backtracking/subset_sum_problem/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_backtracking/summary/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_computational_complexity/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_computational_complexity/iteration_and_recursion/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_computational_complexity/performance_evaluation/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_computational_complexity/space_complexity/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_computational_complexity/summary/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_computational_complexity/time_complexity/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_data_structure/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_data_structure/basic_data_types/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_data_structure/character_encoding/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_data_structure/classification_of_data_structure/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_data_structure/number_encoding/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_data_structure/summary/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_divide_and_conquer/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_divide_and_conquer/binary_search_recur/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_divide_and_conquer/build_binary_tree_problem/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_divide_and_conquer/divide_and_conquer/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_divide_and_conquer/hanota_problem/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_divide_and_conquer/summary/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_dynamic_programming/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_dynamic_programming/dp_problem_features/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_dynamic_programming/dp_solution_pipeline/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_dynamic_programming/edit_distance_problem/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_dynamic_programming/intro_to_dynamic_programming/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_dynamic_programming/knapsack_problem/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_dynamic_programming/summary/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_dynamic_programming/unbounded_knapsack_problem/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_graph/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_graph/graph/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_graph/graph_operations/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_graph/graph_traversal/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_graph/summary/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_greedy/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_greedy/fractional_knapsack_problem/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_greedy/greedy_algorithm/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_greedy/max_capacity_problem/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_greedy/max_product_cutting_problem/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_greedy/summary/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_hashing/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_hashing/hash_algorithm/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_hashing/hash_collision/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_hashing/hash_map/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_hashing/summary/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_heap/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_heap/build_heap/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_heap/heap/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_heap/summary/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_heap/top_k/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_hello_algo/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_introduction/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_introduction/algorithms_are_everywhere/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_introduction/summary/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_introduction/what_is_dsa/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_paperbook/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_preface/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_preface/about_the_book/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_preface/suggestions/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_preface/summary/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_reference/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_searching/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_searching/binary_search/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_searching/binary_search_edge/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_searching/binary_search_insertion/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_searching/replace_linear_by_hashing/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_searching/searching_algorithm_revisited/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_searching/summary/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_sorting/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_sorting/bubble_sort/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_sorting/bucket_sort/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_sorting/counting_sort/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_sorting/heap_sort/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_sorting/insertion_sort/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_sorting/merge_sort/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_sorting/quick_sort/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_sorting/radix_sort/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_sorting/selection_sort/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_sorting/sorting_algorithm/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_sorting/summary/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_stack_and_queue/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_stack_and_queue/deque/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_stack_and_queue/queue/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_stack_and_queue/stack/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_stack_and_queue/summary/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_tree/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_tree/array_representation_of_tree/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_tree/avl_tree/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_tree/binary_search_tree/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_tree/binary_tree/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_tree/binary_tree_traversal/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/chapter_tree/summary/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
</urlset>
|
||||
Binary file not shown.
+105
-105
@@ -2,527 +2,527 @@
|
||||
<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/zh-hant/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/zh-hant/chapter_appendix/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/zh-hant/chapter_appendix/contribution/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/zh-hant/chapter_appendix/installation/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/zh-hant/chapter_appendix/terminology/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/zh-hant/chapter_array_and_linkedlist/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/zh-hant/chapter_array_and_linkedlist/array/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/zh-hant/chapter_array_and_linkedlist/linked_list/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/zh-hant/chapter_array_and_linkedlist/list/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/zh-hant/chapter_array_and_linkedlist/ram_and_cache/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/zh-hant/chapter_array_and_linkedlist/summary/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/zh-hant/chapter_backtracking/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/zh-hant/chapter_backtracking/backtracking_algorithm/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/zh-hant/chapter_backtracking/n_queens_problem/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/zh-hant/chapter_backtracking/permutations_problem/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/zh-hant/chapter_backtracking/subset_sum_problem/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/zh-hant/chapter_backtracking/summary/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/zh-hant/chapter_computational_complexity/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/zh-hant/chapter_computational_complexity/iteration_and_recursion/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/zh-hant/chapter_computational_complexity/performance_evaluation/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/zh-hant/chapter_computational_complexity/space_complexity/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/zh-hant/chapter_computational_complexity/summary/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/zh-hant/chapter_computational_complexity/time_complexity/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/zh-hant/chapter_data_structure/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/zh-hant/chapter_data_structure/basic_data_types/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/zh-hant/chapter_data_structure/character_encoding/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/zh-hant/chapter_data_structure/classification_of_data_structure/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/zh-hant/chapter_data_structure/number_encoding/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/zh-hant/chapter_data_structure/summary/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/zh-hant/chapter_divide_and_conquer/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/zh-hant/chapter_divide_and_conquer/binary_search_recur/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/zh-hant/chapter_divide_and_conquer/build_binary_tree_problem/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/zh-hant/chapter_divide_and_conquer/divide_and_conquer/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/zh-hant/chapter_divide_and_conquer/hanota_problem/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/zh-hant/chapter_divide_and_conquer/summary/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/zh-hant/chapter_dynamic_programming/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/zh-hant/chapter_dynamic_programming/dp_problem_features/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/zh-hant/chapter_dynamic_programming/dp_solution_pipeline/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/zh-hant/chapter_dynamic_programming/edit_distance_problem/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/zh-hant/chapter_dynamic_programming/intro_to_dynamic_programming/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/zh-hant/chapter_dynamic_programming/knapsack_problem/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/zh-hant/chapter_dynamic_programming/summary/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/zh-hant/chapter_dynamic_programming/unbounded_knapsack_problem/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/zh-hant/chapter_graph/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/zh-hant/chapter_graph/graph/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/zh-hant/chapter_graph/graph_operations/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/zh-hant/chapter_graph/graph_traversal/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/zh-hant/chapter_graph/summary/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/zh-hant/chapter_greedy/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/zh-hant/chapter_greedy/fractional_knapsack_problem/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/zh-hant/chapter_greedy/greedy_algorithm/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/zh-hant/chapter_greedy/max_capacity_problem/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/zh-hant/chapter_greedy/max_product_cutting_problem/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/zh-hant/chapter_greedy/summary/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/zh-hant/chapter_hashing/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/zh-hant/chapter_hashing/hash_algorithm/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/zh-hant/chapter_hashing/hash_collision/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/zh-hant/chapter_hashing/hash_map/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/zh-hant/chapter_hashing/summary/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/zh-hant/chapter_heap/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/zh-hant/chapter_heap/build_heap/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/zh-hant/chapter_heap/heap/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/zh-hant/chapter_heap/summary/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/zh-hant/chapter_heap/top_k/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/zh-hant/chapter_hello_algo/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/zh-hant/chapter_introduction/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/zh-hant/chapter_introduction/algorithms_are_everywhere/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/zh-hant/chapter_introduction/summary/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/zh-hant/chapter_introduction/what_is_dsa/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/zh-hant/chapter_preface/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/zh-hant/chapter_preface/about_the_book/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/zh-hant/chapter_preface/suggestions/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/zh-hant/chapter_preface/summary/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/zh-hant/chapter_reference/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/zh-hant/chapter_searching/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/zh-hant/chapter_searching/binary_search/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/zh-hant/chapter_searching/binary_search_edge/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/zh-hant/chapter_searching/binary_search_insertion/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/zh-hant/chapter_searching/replace_linear_by_hashing/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/zh-hant/chapter_searching/searching_algorithm_revisited/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/zh-hant/chapter_searching/summary/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/zh-hant/chapter_sorting/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/zh-hant/chapter_sorting/bubble_sort/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/zh-hant/chapter_sorting/bucket_sort/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/zh-hant/chapter_sorting/counting_sort/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/zh-hant/chapter_sorting/heap_sort/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/zh-hant/chapter_sorting/insertion_sort/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/zh-hant/chapter_sorting/merge_sort/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/zh-hant/chapter_sorting/quick_sort/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/zh-hant/chapter_sorting/radix_sort/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/zh-hant/chapter_sorting/selection_sort/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/zh-hant/chapter_sorting/sorting_algorithm/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/zh-hant/chapter_sorting/summary/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/zh-hant/chapter_stack_and_queue/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/zh-hant/chapter_stack_and_queue/deque/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/zh-hant/chapter_stack_and_queue/queue/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/zh-hant/chapter_stack_and_queue/stack/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/zh-hant/chapter_stack_and_queue/summary/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/zh-hant/chapter_tree/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/zh-hant/chapter_tree/array_representation_of_tree/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/zh-hant/chapter_tree/avl_tree/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/zh-hant/chapter_tree/binary_search_tree/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/zh-hant/chapter_tree/binary_tree/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/zh-hant/chapter_tree/binary_tree_traversal/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
<url>
|
||||
<loc>https://www.hello-algo.com/zh-hant/chapter_tree/summary/</loc>
|
||||
<lastmod>2025-01-21</lastmod>
|
||||
<lastmod>2025-03-14</lastmod>
|
||||
<changefreq>daily</changefreq>
|
||||
</url>
|
||||
</urlset>
|
||||
Binary file not shown.
Reference in New Issue
Block a user