mirror of
https://github.com/krahets/hello-algo.git
synced 2025-07-28 21:02:56 +08:00
deploy
This commit is contained in:
krahets
@ -1368,7 +1368,7 @@
|
||||
|
||||
<li class="md-nav__item">
|
||||
<a href="#1023" class="md-nav__link">
|
||||
10.2.3. 优点与缺点
|
||||
10.2.3. 优点与局限性
|
||||
</a>
|
||||
|
||||
</li>
|
||||
@ -1793,7 +1793,7 @@
|
||||
|
||||
<li class="md-nav__item">
|
||||
<a href="#1023" class="md-nav__link">
|
||||
10.2.3. 优点与缺点
|
||||
10.2.3. 优点与局限性
|
||||
</a>
|
||||
|
||||
</li>
|
||||
@ -1822,24 +1822,19 @@
|
||||
|
||||
|
||||
<h1 id="102">10.2. 二分查找<a class="headerlink" href="#102" title="Permanent link">¶</a></h1>
|
||||
<p>「二分查找 Binary Search」利用数据的有序性，通过每轮缩小一半搜索区间来查找目标元素。</p>
|
||||
<p>使用二分查找有两个前置条件：</p>
|
||||
<ul>
|
||||
<li><strong>要求输入数据是有序的</strong>，这样才能通过判断大小关系来排除一半的搜索区间；</li>
|
||||
<li><strong>二分查找仅适用于数组</strong>，而在链表中使用效率很低，因为其在循环中需要跳跃式（非连续地）访问元素。</li>
|
||||
</ul>
|
||||
<p>「二分查找 Binary Search」利用数据的有序性，通过每轮减少一半搜索范围来定位目标元素。</p>
|
||||
<h2 id="1021">10.2.1. 算法实现<a class="headerlink" href="#1021" title="Permanent link">¶</a></h2>
|
||||
<p>给定一个长度为 <span class="arithmatex">\(n\)</span> 的排序数组 <code>nums</code> ，元素从小到大排列。数组的索引取值范围为</p>
|
||||
<p>给定一个长度为 <span class="arithmatex">\(n\)</span> 的有序数组 <code>nums</code> ，元素按从小到大的顺序排列。数组索引的取值范围为：</p>
|
||||
<div class="arithmatex">\[
|
||||
0, 1, 2, \cdots, n-1
|
||||
\]</div>
|
||||
<p>使用「区间」来表示这个取值范围的方法主要有两种：</p>
|
||||
<p>我们通常使用以下两种方法来表示这个取值范围：</p>
|
||||
<ol>
|
||||
<li><strong>双闭区间 <span class="arithmatex">\([0, n-1]\)</span></strong> ，即两个边界都包含自身；此方法下，区间 <span class="arithmatex">\([0, 0]\)</span> 仍包含一个元素；</li>
|
||||
<li><strong>左闭右开 <span class="arithmatex">\([0, n)\)</span></strong> ，即左边界包含自身、右边界不包含自身；此方法下，区间 <span class="arithmatex">\([0, 0)\)</span> 为空；</li>
|
||||
<li><strong>双闭区间 <span class="arithmatex">\([0, n-1]\)</span></strong> ，即两个边界都包含自身；在此方法下，区间 <span class="arithmatex">\([0, 0]\)</span> 仍包含 <span class="arithmatex">\(1\)</span> 个元素；</li>
|
||||
<li><strong>左闭右开 <span class="arithmatex">\([0, n)\)</span></strong> ，即左边界包含自身、右边界不包含自身；在此方法下，区间 <span class="arithmatex">\([0, 0)\)</span> 不包含元素；</li>
|
||||
</ol>
|
||||
<h3 id="_1">“双闭区间”实现<a class="headerlink" href="#_1" title="Permanent link">¶</a></h3>
|
||||
<p>首先，我们先采用“双闭区间”的表示，在数组 <code>nums</code> 中查找目标元素 <code>target</code> 的对应索引。</p>
|
||||
<p>首先，我们采用“双闭区间”表示法，在数组 <code>nums</code> 中查找目标元素 <code>target</code> 的对应索引。</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">
|
||||
@ -1865,7 +1860,7 @@
|
||||
</div>
|
||||
</div>
|
||||
</div>
|
||||
<p>二分查找“双闭区间”表示下的代码如下所示。</p>
|
||||
<p>二分查找在“双闭区间”表示下的代码如下所示。</p>
|
||||
<div class="tabbed-set tabbed-alternate" data-tabs="2:10"><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" /><div class="tabbed-labels"><label for="__tabbed_2_1">Java</label><label for="__tabbed_2_2">C++</label><label for="__tabbed_2_3">Python</label><label for="__tabbed_2_4">Go</label><label for="__tabbed_2_5">JavaScript</label><label for="__tabbed_2_6">TypeScript</label><label for="__tabbed_2_7">C</label><label for="__tabbed_2_8">C#</label><label for="__tabbed_2_9">Swift</label><label for="__tabbed_2_10">Zig</label></div>
|
||||
<div class="tabbed-content">
|
||||
<div class="tabbed-block">
|
||||
@ -2058,7 +2053,7 @@
|
||||
</div>
|
||||
</div>
|
||||
<h3 id="_2">“左闭右开”实现<a class="headerlink" href="#_2" title="Permanent link">¶</a></h3>
|
||||
<p>当然，我们也可以使用“左闭右开”的表示方法，写出相同功能的二分查找代码。</p>
|
||||
<p>此外，我们也可以采用“左闭右开”的表示法，编写具有相同功能的二分查找代码。</p>
|
||||
<div class="tabbed-set tabbed-alternate" data-tabs="3:10"><input checked="checked" id="__tabbed_3_1" name="__tabbed_3" type="radio" /><input id="__tabbed_3_2" name="__tabbed_3" type="radio" /><input id="__tabbed_3_3" name="__tabbed_3" type="radio" /><input id="__tabbed_3_4" name="__tabbed_3" type="radio" /><input id="__tabbed_3_5" name="__tabbed_3" type="radio" /><input id="__tabbed_3_6" name="__tabbed_3" type="radio" /><input id="__tabbed_3_7" name="__tabbed_3" type="radio" /><input id="__tabbed_3_8" name="__tabbed_3" type="radio" /><input id="__tabbed_3_9" name="__tabbed_3" type="radio" /><input id="__tabbed_3_10" name="__tabbed_3" type="radio" /><div class="tabbed-labels"><label for="__tabbed_3_1">Java</label><label for="__tabbed_3_2">C++</label><label for="__tabbed_3_3">Python</label><label for="__tabbed_3_4">Go</label><label for="__tabbed_3_5">JavaScript</label><label for="__tabbed_3_6">TypeScript</label><label for="__tabbed_3_7">C</label><label for="__tabbed_3_8">C#</label><label for="__tabbed_3_9">Swift</label><label for="__tabbed_3_10">Zig</label></div>
|
||||
<div class="tabbed-content">
|
||||
<div class="tabbed-block">
|
||||
@ -2252,7 +2247,7 @@
|
||||
</div>
|
||||
</div>
|
||||
<h3 id="_3">两种表示对比<a class="headerlink" href="#_3" title="Permanent link">¶</a></h3>
|
||||
<p>对比下来，两种表示的代码写法有以下不同点：</p>
|
||||
<p>对比这两种代码写法，我们可以发现以下不同点：</p>
|
||||
<div class="center-table">
|
||||
<table>
|
||||
<thead>
|
||||
@ -2279,9 +2274,9 @@
|
||||
</tbody>
|
||||
</table>
|
||||
</div>
|
||||
<p>观察发现，在“双闭区间”表示中，由于对左右两边界的定义是相同的，因此缩小区间的 <span class="arithmatex">\(i\)</span> , <span class="arithmatex">\(j\)</span> 处理方法也是对称的，这样更不容易出错。综上所述，<strong>建议你采用“双闭区间”的写法。</strong></p>
|
||||
<p>在“双闭区间”表示法中，由于对左右两边界的定义相同，因此缩小区间的 <span class="arithmatex">\(i\)</span> 和 <span class="arithmatex">\(j\)</span> 的处理方法也是对称的，这样更不容易出错。因此，<strong>建议采用“双闭区间”的写法</strong>。</p>
|
||||
<h3 id="_4">大数越界处理<a class="headerlink" href="#_4" title="Permanent link">¶</a></h3>
|
||||
<p>当数组长度很大时，加法 <span class="arithmatex">\(i + j\)</span> 的结果有可能会超出 <code>int</code> 类型的取值范围。在此情况下，我们需要换一种计算中点的写法。</p>
|
||||
<p>当数组长度非常大时，加法 <span class="arithmatex">\(i + j\)</span> 的结果可能会超出 <code>int</code> 类型的取值范围。在这种情况下，我们需要采用一种更安全的计算中点的方法。</p>
|
||||
<div class="tabbed-set tabbed-alternate" data-tabs="4:10"><input checked="checked" id="__tabbed_4_1" name="__tabbed_4" type="radio" /><input id="__tabbed_4_2" name="__tabbed_4" type="radio" /><input id="__tabbed_4_3" name="__tabbed_4" type="radio" /><input id="__tabbed_4_4" name="__tabbed_4" type="radio" /><input id="__tabbed_4_5" name="__tabbed_4" type="radio" /><input id="__tabbed_4_6" name="__tabbed_4" type="radio" /><input id="__tabbed_4_7" name="__tabbed_4" type="radio" /><input id="__tabbed_4_8" name="__tabbed_4" type="radio" /><input id="__tabbed_4_9" name="__tabbed_4" type="radio" /><input id="__tabbed_4_10" name="__tabbed_4" type="radio" /><div class="tabbed-labels"><label for="__tabbed_4_1">Java</label><label for="__tabbed_4_2">C++</label><label for="__tabbed_4_3">Python</label><label for="__tabbed_4_4">Go</label><label for="__tabbed_4_5">JavaScript</label><label for="__tabbed_4_6">TypeScript</label><label for="__tabbed_4_7">C</label><label for="__tabbed_4_8">C#</label><label for="__tabbed_4_9">Swift</label><label for="__tabbed_4_10">Zig</label></div>
|
||||
<div class="tabbed-content">
|
||||
<div class="tabbed-block">
|
||||
@ -2349,19 +2344,19 @@
|
||||
</div>
|
||||
</div>
|
||||
<h2 id="1022">10.2.2. 复杂度分析<a class="headerlink" href="#1022" title="Permanent link">¶</a></h2>
|
||||
<p><strong>时间复杂度 <span class="arithmatex">\(O(\log n)\)</span></strong> ：其中 <span class="arithmatex">\(n\)</span> 为数组或链表长度；每轮排除一半的区间，因此循环轮数为 <span class="arithmatex">\(\log_2 n\)</span> ，使用 <span class="arithmatex">\(O(\log n)\)</span> 时间。</p>
|
||||
<p><strong>时间复杂度 <span class="arithmatex">\(O(\log n)\)</span></strong> ：其中 <span class="arithmatex">\(n\)</span> 为数组长度；每轮排除一半的区间，因此循环轮数为 <span class="arithmatex">\(\log_2 n\)</span> ，使用 <span class="arithmatex">\(O(\log n)\)</span> 时间。</p>
|
||||
<p><strong>空间复杂度 <span class="arithmatex">\(O(1)\)</span></strong> ：指针 <code>i</code> , <code>j</code> 使用常数大小空间。</p>
|
||||
<h2 id="1023">10.2.3. 优点与缺点<a class="headerlink" href="#1023" title="Permanent link">¶</a></h2>
|
||||
<p>二分查找效率很高，体现在：</p>
|
||||
<h2 id="1023">10.2.3. 优点与局限性<a class="headerlink" href="#1023" title="Permanent link">¶</a></h2>
|
||||
<p>二分查找效率很高，主要体现在：</p>
|
||||
<ul>
|
||||
<li><strong>二分查找时间复杂度低</strong>。对数阶在数据量很大时具有巨大优势，例如，当数据大小 <span class="arithmatex">\(n = 2^{20}\)</span> 时，线性查找需要 <span class="arithmatex">\(2^{20} = 1048576\)</span> 轮循环，而二分查找仅需要 <span class="arithmatex">\(\log_2 2^{20} = 20\)</span> 轮循环。</li>
|
||||
<li><strong>二分查找不需要额外空间</strong>。相对于借助额外数据结构来实现查找的算法来说，其更加节约空间使用。</li>
|
||||
<li><strong>二分查找的时间复杂度较低</strong>。对数阶在大数据量情况下具有显著优势。例如，当数据大小 <span class="arithmatex">\(n = 2^{20}\)</span> 时，线性查找需要 <span class="arithmatex">\(2^{20} = 1048576\)</span> 轮循环，而二分查找仅需 <span class="arithmatex">\(\log_2 2^{20} = 20\)</span> 轮循环。</li>
|
||||
<li><strong>二分查找无需额外空间</strong>。与哈希查找相比，二分查找更加节省空间。</li>
|
||||
</ul>
|
||||
<p>但并不意味着所有情况下都应使用二分查找，这是因为：</p>
|
||||
<p>然而，并非所有情况下都可使用二分查找，原因如下：</p>
|
||||
<ul>
|
||||
<li><strong>二分查找仅适用于有序数据</strong>。如果输入数据是无序的，为了使用二分查找而专门执行数据排序，那么是得不偿失的，因为排序算法的时间复杂度一般为 <span class="arithmatex">\(O(n \log n)\)</span> ，比线性查找和二分查找都更差。再例如，对于频繁插入元素的场景，为了保持数组的有序性，需要将元素插入到特定位置，时间复杂度为 <span class="arithmatex">\(O(n)\)</span> ，也是非常昂贵的。</li>
|
||||
<li><strong>二分查找仅适用于数组</strong>。由于在二分查找中，访问索引是 “非连续” 的，因此链表或者基于链表实现的数据结构都无法使用。</li>
|
||||
<li><strong>在小数据量下，线性查找的性能更好</strong>。在线性查找中，每轮只需要 1 次判断操作；而在二分查找中，需要 1 次加法、1 次除法、1 ~ 3 次判断操作、1 次加法（减法），共 4 ~ 6 个单元操作；因此，在数据量 <span class="arithmatex">\(n\)</span> 较小时，线性查找反而比二分查找更快。</li>
|
||||
<li><strong>二分查找仅适用于有序数据</strong>。若输入数据无序，为了使用二分查找而专门进行排序，得不偿失。因为排序算法的时间复杂度通常为 <span class="arithmatex">\(O(n \log n)\)</span> ，比线性查找和二分查找都更高。对于频繁插入元素的场景，为保持数组有序性，需要将元素插入到特定位置，时间复杂度为 <span class="arithmatex">\(O(n)\)</span> ，也是非常昂贵的。</li>
|
||||
<li><strong>二分查找仅适用于数组</strong>。二分查找需要跳跃式（非连续地）访问元素，而在链表中执行跳跃式访问的效率较低，因此不适合应用在链表或基于链表实现的数据结构。</li>
|
||||
<li><strong>小数据量下，线性查找性能更佳</strong>。在线性查找中，每轮只需要 1 次判断操作；而在二分查找中，需要 1 次加法、1 次除法、1 ~ 3 次判断操作、1 次加法（减法），共 4 ~ 6 个单元操作；因此，当数据量 <span class="arithmatex">\(n\)</span> 较小时，线性查找反而比二分查找更快。</li>
|
||||
</ul>
|
||||
|
||||
|
||||
|
||||
@ -1348,7 +1348,7 @@
|
||||
|
||||
<li class="md-nav__item">
|
||||
<a href="#1033" class="md-nav__link">
|
||||
10.3.3. 优点与缺点
|
||||
10.3.3. 优点与局限性
|
||||
</a>
|
||||
|
||||
</li>
|
||||
@ -1725,7 +1725,7 @@
|
||||
|
||||
<li class="md-nav__item">
|
||||
<a href="#1033" class="md-nav__link">
|
||||
10.3.3. 优点与缺点
|
||||
10.3.3. 优点与局限性
|
||||
</a>
|
||||
|
||||
</li>
|
||||
@ -1754,13 +1754,10 @@
|
||||
|
||||
|
||||
<h1 id="103">10.3. 哈希查找<a class="headerlink" href="#103" title="Permanent link">¶</a></h1>
|
||||
<div class="admonition question">
|
||||
<p class="admonition-title">Question</p>
|
||||
<p>在数据量很大时，「线性查找」太慢；而「二分查找」要求数据必须是有序的，并且只能在数组中应用。那么是否有方法可以同时避免上述缺点呢？答案是肯定的，此方法被称为「哈希查找」。</p>
|
||||
</div>
|
||||
<p>「哈希查找 Hash Searching」借助一个哈希表来存储需要的「键值对 Key Value Pair」，我们可以在 <span class="arithmatex">\(O(1)\)</span> 时间下实现“键 <span class="arithmatex">\(\rightarrow\)</span> 值”映射查找，体现着“以空间换时间”的算法思想。</p>
|
||||
<p>「哈希查找 Hash Searching」通过使用哈希表来存储所需的键值对，从而可在 <span class="arithmatex">\(O(1)\)</span> 时间内完成“键 <span class="arithmatex">\(\rightarrow\)</span> 值”的查找操作。</p>
|
||||
<p>与线性查找相比，哈希查找通过利用额外空间来提高效率，体现了“以空间换时间”的算法思想。</p>
|
||||
<h2 id="1031">10.3.1. 算法实现<a class="headerlink" href="#1031" title="Permanent link">¶</a></h2>
|
||||
<p>如果我们想要给定数组中的一个目标元素 <code>target</code> ，获取该元素的索引，那么可以借助一个哈希表实现查找。</p>
|
||||
<p>例如，若我们想要在给定数组中找到目标元素 <code>target</code> 的索引，则可以使用哈希查找来实现。</p>
|
||||
<p><img alt="哈希查找数组索引" src="../hashing_search.assets/hash_search_index.png" /></p>
|
||||
<p align="center"> Fig. 哈希查找数组索引 </p>
|
||||
|
||||
@ -1860,7 +1857,7 @@
|
||||
</div>
|
||||
</div>
|
||||
</div>
|
||||
<p>再比如，如果我们想要给定一个目标节点值 <code>target</code> ，获取对应的链表节点对象，那么也可以使用哈希查找实现。</p>
|
||||
<p>同样，若要根据目标节点值 target 查找对应的链表节点对象，也可以采用哈希查找方法。</p>
|
||||
<p><img alt="哈希查找链表节点" src="../hashing_search.assets/hash_search_listnode.png" /></p>
|
||||
<p align="center"> Fig. 哈希查找链表节点 </p>
|
||||
|
||||
@ -1960,16 +1957,16 @@
|
||||
</div>
|
||||
<h2 id="1032">10.3.2. 复杂度分析<a class="headerlink" href="#1032" title="Permanent link">¶</a></h2>
|
||||
<p><strong>时间复杂度 <span class="arithmatex">\(O(1)\)</span></strong> ：哈希表的查找操作使用 <span class="arithmatex">\(O(1)\)</span> 时间。</p>
|
||||
<p><strong>空间复杂度 <span class="arithmatex">\(O(n)\)</span></strong> ：其中 <span class="arithmatex">\(n\)</span> 为数组或链表长度。</p>
|
||||
<h2 id="1033">10.3.3. 优点与缺点<a class="headerlink" href="#1033" title="Permanent link">¶</a></h2>
|
||||
<p>在哈希表中，<strong>查找、插入、删除操作的平均时间复杂度都为 <span class="arithmatex">\(O(1)\)</span></strong> ，这意味着无论是高频增删还是高频查找场景，哈希查找的性能表现都非常好。当然，一切的前提是保证哈希表未退化。</p>
|
||||
<p>即使如此，哈希查找仍存在一些问题，在实际应用中，需要根据情况灵活选择方法。</p>
|
||||
<p><strong>空间复杂度 <span class="arithmatex">\(O(n)\)</span></strong> ：其中 <span class="arithmatex">\(n\)</span> 是数组或链表的长度。</p>
|
||||
<h2 id="1033">10.3.3. 优点与局限性<a class="headerlink" href="#1033" title="Permanent link">¶</a></h2>
|
||||
<p>哈希查找的性能表现相当优秀，查找、插入、删除操作的平均时间复杂度均为 <span class="arithmatex">\(O(1)\)</span> 。尽管如此，哈希查找仍然存在一些问题：</p>
|
||||
<ul>
|
||||
<li>辅助哈希表 <strong>需要使用 <span class="arithmatex">\(O(n)\)</span> 的额外空间</strong>，意味着需要预留更多的计算机内存；</li>
|
||||
<li>建立和维护哈希表需要时间，因此哈希查找 <strong>不适合高频增删、低频查找的使用场景</strong>；</li>
|
||||
<li>当哈希冲突严重时，哈希表会退化为链表，<strong>时间复杂度劣化至 <span class="arithmatex">\(O(n)\)</span></strong> ；</li>
|
||||
<li><strong>当数据量很小时，线性查找比哈希查找更快</strong>。这是因为计算哈希映射函数可能比遍历一个小型数组更慢；</li>
|
||||
<li>辅助哈希表需要占用 <span class="arithmatex">\(O(n)\)</span> 的额外空间，意味着需要预留更多的计算机内存；</li>
|
||||
<li>构建和维护哈希表需要时间，因此哈希查找不适用于高频增删、低频查找的场景；</li>
|
||||
<li>当哈希冲突严重时，哈希表可能退化为链表，导致时间复杂度劣化至 <span class="arithmatex">\(O(n)\)</span> ；</li>
|
||||
<li>当数据量较小时，线性查找可能比哈希查找更快。这是因为计算哈希函数可能比遍历一个小型数组更慢；</li>
|
||||
</ul>
|
||||
<p>因此，在实际应用中，我们需要根据具体情况灵活选择解决方案。</p>
|
||||
|
||||
|
||||
|
||||
|
||||
@ -1320,7 +1320,7 @@
|
||||
|
||||
<li class="md-nav__item">
|
||||
<a href="#1013" class="md-nav__link">
|
||||
10.1.3. 优点与缺点
|
||||
10.1.3. 优点与局限性
|
||||
</a>
|
||||
|
||||
</li>
|
||||
@ -1725,7 +1725,7 @@
|
||||
|
||||
<li class="md-nav__item">
|
||||
<a href="#1013" class="md-nav__link">
|
||||
10.1.3. 优点与缺点
|
||||
10.1.3. 优点与局限性
|
||||
</a>
|
||||
|
||||
</li>
|
||||
@ -1754,9 +1754,9 @@
|
||||
|
||||
|
||||
<h1 id="101">10.1. 线性查找<a class="headerlink" href="#101" title="Permanent link">¶</a></h1>
|
||||
<p>「线性查找 Linear Search」是一种最基础的查找方法，其从数据结构的一端开始，依次访问每个元素，直到另一端后停止。</p>
|
||||
<p>「线性查找 Linear Search」是一种简单的查找方法，其从数据结构的一端开始，逐个访问每个元素，直至另一端为止。</p>
|
||||
<h2 id="1011">10.1.1. 算法实现<a class="headerlink" href="#1011" title="Permanent link">¶</a></h2>
|
||||
<p>线性查找实质上就是遍历数据结构 + 判断条件。比如，我们想要在数组 <code>nums</code> 中查找目标元素 <code>target</code> 的对应索引，那么可以在数组中进行线性查找。</p>
|
||||
<p>例如，若我们想要在数组 <code>nums</code> 中查找目标元素 <code>target</code> 的对应索引，可以采用线性查找方法。</p>
|
||||
<p><img alt="在数组中线性查找元素" src="../linear_search.assets/linear_search.png" /></p>
|
||||
<p align="center"> Fig. 在数组中线性查找元素 </p>
|
||||
|
||||
@ -1897,7 +1897,7 @@
|
||||
</div>
|
||||
</div>
|
||||
</div>
|
||||
<p>再比如，我们想要在给定一个目标节点值 <code>target</code> ，返回此节点对象，也可以在链表中进行线性查找。</p>
|
||||
<p>另一个例子，若需要在链表中查找给定目标节点值 <code>target</code> 并返回该节点对象，同样可以使用线性查找。</p>
|
||||
<div class="tabbed-set tabbed-alternate" data-tabs="2:10"><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" /><div class="tabbed-labels"><label for="__tabbed_2_1">Java</label><label for="__tabbed_2_2">C++</label><label for="__tabbed_2_3">Python</label><label for="__tabbed_2_4">Go</label><label for="__tabbed_2_5">JavaScript</label><label for="__tabbed_2_6">TypeScript</label><label for="__tabbed_2_7">C</label><label for="__tabbed_2_8">C#</label><label for="__tabbed_2_9">Swift</label><label for="__tabbed_2_10">Zig</label></div>
|
||||
<div class="tabbed-content">
|
||||
<div class="tabbed-block">
|
||||
@ -2044,11 +2044,11 @@
|
||||
</div>
|
||||
</div>
|
||||
<h2 id="1012">10.1.2. 复杂度分析<a class="headerlink" href="#1012" title="Permanent link">¶</a></h2>
|
||||
<p><strong>时间复杂度 <span class="arithmatex">\(O(n)\)</span></strong> ：其中 <span class="arithmatex">\(n\)</span> 为数组或链表长度。</p>
|
||||
<p><strong>空间复杂度 <span class="arithmatex">\(O(1)\)</span></strong> ：无需使用额外空间。</p>
|
||||
<h2 id="1013">10.1.3. 优点与缺点<a class="headerlink" href="#1013" title="Permanent link">¶</a></h2>
|
||||
<p><strong>线性查找的通用性极佳</strong>。由于线性查找是依次访问元素的，即没有跳跃访问元素，因此数组或链表皆适用。</p>
|
||||
<p><strong>线性查找的时间复杂度太高</strong>。在数据量 <span class="arithmatex">\(n\)</span> 很大时，查找效率很低。</p>
|
||||
<p><strong>时间复杂度 <span class="arithmatex">\(O(n)\)</span></strong> ：其中 <span class="arithmatex">\(n\)</span> 代表数组或链表的长度。</p>
|
||||
<p><strong>空间复杂度 <span class="arithmatex">\(O(1)\)</span></strong> ：无需借助额外的存储空间。</p>
|
||||
<h2 id="1013">10.1.3. 优点与局限性<a class="headerlink" href="#1013" title="Permanent link">¶</a></h2>
|
||||
<p><strong>线性查找具有极佳的通用性</strong>。由于线性查找是逐个访问元素的，没有跳跃式访问，因此适用于数组和链表的查找。</p>
|
||||
<p><strong>线性查找的时间复杂度较高</strong>。当数据量 <span class="arithmatex">\(n\)</span> 较大时，线性查找的效率较低。</p>
|
||||
|
||||
|
||||
|
||||
|
||||
@ -1681,10 +1681,10 @@
|
||||
|
||||
<h1 id="104">10.4. 小结<a class="headerlink" href="#104" title="Permanent link">¶</a></h1>
|
||||
<ul>
|
||||
<li>线性查找是一种最基础的查找方法，通过遍历数据结构 + 判断条件实现查找。</li>
|
||||
<li>二分查找利用数据的有序性，通过循环不断缩小一半搜索区间来实现查找，其要求输入数据是有序的，并且仅适用于数组或基于数组实现的数据结构。</li>
|
||||
<li>哈希查找借助哈希表来实现常数阶时间复杂度的查找操作，体现以空间换时间的算法思想。</li>
|
||||
<li>下表总结对比了查找算法的各种特性和时间复杂度。</li>
|
||||
<li>线性查找通过遍历数据结构并进行条件判断来完成查找任务。</li>
|
||||
<li>二分查找依赖于数据的有序性，通过循环逐步缩减一半搜索区间来实现查找。它要求输入数据有序，且仅适用于数组或基于数组实现的数据结构。</li>
|
||||
<li>哈希查找利用哈希表实现常数阶时间复杂度的查找操作，体现了空间换时间的算法思维。</li>
|
||||
<li>下表概括并对比了三种查找算法的特性和时间复杂度。</li>
|
||||
</ul>
|
||||
<div class="center-table">
|
||||
<table>
|
||||
@ -1700,26 +1700,14 @@
|
||||
<tr>
|
||||
<td>适用数据结构</td>
|
||||
<td>数组、链表</td>
|
||||
<td>数组</td>
|
||||
<td>有序数组</td>
|
||||
<td>数组、链表</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td>输入数据要求</td>
|
||||
<td>无</td>
|
||||
<td>有序</td>
|
||||
<td>无</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td>平均时间复杂度</br>查找 / 插入 / 删除</td>
|
||||
<td><span class="arithmatex">\(O(n)\)</span> / <span class="arithmatex">\(O(1)\)</span> / <span class="arithmatex">\(O(n)\)</span></td>
|
||||
<td><span class="arithmatex">\(O(\log n)\)</span> / <span class="arithmatex">\(O(n)\)</span> / <span class="arithmatex">\(O(n)\)</span></td>
|
||||
<td><span class="arithmatex">\(O(1)\)</span> / <span class="arithmatex">\(O(1)\)</span> / <span class="arithmatex">\(O(1)\)</span></td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td>最差时间复杂度</br>查找 / 插入 / 删除</td>
|
||||
<td><span class="arithmatex">\(O(n)\)</span> / <span class="arithmatex">\(O(1)\)</span> / <span class="arithmatex">\(O(n)\)</span></td>
|
||||
<td><span class="arithmatex">\(O(\log n)\)</span> / <span class="arithmatex">\(O(n)\)</span> / <span class="arithmatex">\(O(n)\)</span></td>
|
||||
<td><span class="arithmatex">\(O(n)\)</span> / <span class="arithmatex">\(O(n)\)</span> / <span class="arithmatex">\(O(n)\)</span></td>
|
||||
<td>时间复杂度</br>（查找，插入，删除）</td>
|
||||
<td><span class="arithmatex">\(O(n)\)</span> , <span class="arithmatex">\(O(1)\)</span> , <span class="arithmatex">\(O(n)\)</span></td>
|
||||
<td><span class="arithmatex">\(O(\log n)\)</span> , <span class="arithmatex">\(O(n)\)</span> , <span class="arithmatex">\(O(n)\)</span></td>
|
||||
<td><span class="arithmatex">\(O(1)\)</span> , <span class="arithmatex">\(O(1)\)</span> , <span class="arithmatex">\(O(1)\)</span></td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td>空间复杂度</td>
|
||||
|
||||
Reference in New Issue
Block a user