CS_learn/hello-algo
1
0
Fork 0
mirror of https://github.com/krahets/hello-algo.git synced 2026-04-24 02:21:30 +08:00
Code Issues Packages Projects Releases Wiki Activity

build

Browse Source
This commit is contained in:
krahets
2023-04-10 03:12:02 +08:00
parent 2289822dfd
commit 867ecf6d92
32 changed files with 329 additions and 445 deletions
Download Patch File Download Diff File Expand all files Collapse all files

45
chapter_searching/binary_search.md
View File

@@ -4,29 +4,24 @@ comments: true
# 10.2.   二分查找
「二分查找 Binary Search」利用数据的有序性，通过每轮缩小一半搜索区间来查找目标元素。
使用二分查找有两个前置条件：
- **要求输入数据是有序的**，这样才能通过判断大小关系来排除一半的搜索区间；
- **二分查找仅适用于数组**，而在链表中使用效率很低，因为其在循环中需要跳跃式（非连续地）访问元素。
「二分查找 Binary Search」利用数据的有序性，通过每轮减少一半搜索范围来定位目标元素。
## 10.2.1.   算法实现
给定一个长度为 $n$ 的排序数组 `nums` ，元素从小到大排列。数组的索引取值范围为
给定一个长度为 $n$ 的有序数组 `nums` ，元素按从小到大的顺序排列。数组索引的取值范围为：
$$
0, 1, 2, \cdots, n-1
$$
使用「区间」来表示这个取值范围的方法主要有两种：
我们通常使用以下两种方法来表示这个取值范围：
1. **双闭区间 $[0, n-1]$** ，即两个边界都包含自身；此方法下，区间 $[0, 0]$ 仍包含一个元素；
2. **左闭右开 $[0, n)$** ，即左边界包含自身、右边界不包含自身；此方法下，区间 $[0, 0)$ 为空；
1. **双闭区间 $[0, n-1]$** ，即两个边界都包含自身；在此方法下，区间 $[0, 0]$ 仍包含 $1$ 个元素；
2. **左闭右开 $[0, n)$** ，即左边界包含自身、右边界不包含自身；在此方法下，区间 $[0, 0)$ 不包含元素；
### “双闭区间”实现
首先，我们先采用“双闭区间”的表示，在数组 `nums` 中查找目标元素 `target` 的对应索引。
首先，我们采用“双闭区间”表示法，在数组 `nums` 中查找目标元素 `target` 的对应索引。
=== "<1>"
![二分查找步骤](binary_search.assets/binary_search_step1.png)
@@ -49,7 +44,7 @@ $$
=== "<7>"
![binary_search_step7](binary_search.assets/binary_search_step7.png)
二分查找“双闭区间”表示下的代码如下所示。
二分查找在“双闭区间”表示下的代码如下所示。
=== "Java"
@@ -260,7 +255,7 @@ $$
### “左闭右开”实现
当然，我们也可以使用“左闭右开”的表示方法，写出相同功能的二分查找代码。
此外，我们也可以采用“左闭右开”的表示法，编写具有相同功能的二分查找代码。
=== "Java"
@@ -472,7 +467,7 @@ $$
### 两种表示对比
对比下来，两种表示的代码写法有以下不同点：
对比这两种代码写法，我们可以发现以下不同点：
<div class="center-table" markdown>
@@ -483,11 +478,11 @@ $$
</div>
观察发现，在“双闭区间”表示中，由于对左右两边界的定义是相同的，因此缩小区间的 $i$ , $j$ 处理方法也是对称的，这样更不容易出错。综上所述，**建议你采用“双闭区间”的写法。**
在“双闭区间”表示法中，由于对左右两边界的定义相同，因此缩小区间的 $i$ 和 $j$ 的处理方法也是对称的，这样更不容易出错。因此，**建议采用“双闭区间”的写法**。
### 大数越界处理
当数组长度很大时，加法 $i + j$ 的结果有可能会超出 `int` 类型的取值范围。在此情况下，我们需要换一种计算中点的写法。
当数组长度非常大时，加法 $i + j$ 的结果可能会超出 `int` 类型的取值范围。在这种情况下，我们需要采用一种更安全的计算中点的方法。
=== "Java"
@@ -573,19 +568,19 @@ $$
## 10.2.2. &nbsp; 复杂度分析
**时间复杂度 $O(\log n)$** ：其中 $n$ 为数组或链表长度；每轮排除一半的区间，因此循环轮数为 $\log_2 n$ ，使用 $O(\log n)$ 时间。
**时间复杂度 $O(\log n)$** ：其中 $n$ 为数组长度；每轮排除一半的区间，因此循环轮数为 $\log_2 n$ ，使用 $O(\log n)$ 时间。
**空间复杂度 $O(1)$** ：指针 `i` , `j` 使用常数大小空间。
## 10.2.3. &nbsp; 优点与缺点
## 10.2.3. &nbsp; 优点与局限性
二分查找效率很高，体现在：
二分查找效率很高，主要体现在：
- **二分查找时间复杂度低**。对数阶在数据量很大时具有巨大优势，例如，当数据大小 $n = 2^{20}$ 时，线性查找需要 $2^{20} = 1048576$ 轮循环，而二分查找仅需要 $\log_2 2^{20} = 20$ 轮循环。
- **二分查找不需要额外空间**。相对于借助额外数据结构来实现查找的算法来说，其更加节约空间使用。
- **二分查找的时间复杂度较低**。对数阶在大数据量情况下具有显著优势。例如，当数据大小 $n = 2^{20}$ 时，线性查找需要 $2^{20} = 1048576$ 轮循环，而二分查找仅需 $\log_2 2^{20} = 20$ 轮循环。
- **二分查找无需额外空间**。与哈希查找相比，二分查找更加节省空间。
但并不意味着所有情况下都应使用二分查找，这是因为：
然而，并非所有情况下都可使用二分查找，原因如下：
- **二分查找仅适用于有序数据**。如果输入数据是无序的，为了使用二分查找而专门执行数据排序，那么是得不偿失的，因为排序算法的时间复杂度一般为 $O(n \log n)$ ，比线性查找和二分查找都更差。再例如，对于频繁插入元素的场景，为了保持数组的有序性，需要将元素插入到特定位置，时间复杂度为 $O(n)$ ，也是非常昂贵的。
- **二分查找仅适用于数组**。由于在二分查找中，访问索引是 “非连续” 的，因此链表或者基于链表实现的数据结构都无法使用。
- **在小数据量下，线性查找的性能更好**。在线性查找中，每轮只需要 1 次判断操作；而在二分查找中，需要 1 次加法、1 次除法、1 ~ 3 次判断操作、1 次加法（减法），共 4 ~ 6 个单元操作；因此，在数据量 $n$ 较小时，线性查找反而比二分查找更快。
- **二分查找仅适用于有序数据**。若输入数据无序，为了使用二分查找而专门进行排序，得不偿失。因为排序算法的时间复杂度通常为 $O(n \log n)$ ，比线性查找和二分查找都更高。对于频繁插入元素的场景，为保持数组有序性，需要将元素插入到特定位置，时间复杂度为 $O(n)$ ，也是非常昂贵的。
- **二分查找仅适用于数组**。二分查找需要跳跃式（非连续地）访问元素，而在链表中执行跳跃式访问的效率较低，因此不适合应用在链表或基于链表实现的数据结构。
- **小数据量下，线性查找性能更佳**。在线性查找中，每轮只需要 1 次判断操作；而在二分查找中，需要 1 次加法、1 次除法、1 ~ 3 次判断操作、1 次加法（减法），共 4 ~ 6 个单元操作；因此，当数据量 $n$ 较小时，线性查找反而比二分查找更快。

26
chapter_searching/hashing_search.md
View File

@@ -4,15 +4,13 @@ comments: true
# 10.3. &nbsp; 哈希查找
!!! question
「哈希查找 Hash Searching」通过使用哈希表来存储所需的键值对，从而可在 $O(1)$ 时间内完成“键 $\rightarrow$ 值”的查找操作。
在数据量很大时，「线性查找」太慢；而「二分查找」要求数据必须是有序的，并且只能在数组中应用。那么是否有方法可以同时避免上述缺点呢？答案是肯定的，此方法被称为「哈希查找」。
「哈希查找 Hash Searching」借助一个哈希表来存储需要的「键值对 Key Value Pair」，我们可以在 $O(1)$ 时间下实现“键 $\rightarrow$ 值”映射查找，体现着“以空间换时间”的算法思想。
与线性查找相比，哈希查找通过利用额外空间来提高效率，体现了“以空间换时间”的算法思想。
## 10.3.1. &nbsp; 算法实现
如果我们想要给定数组中的一个目标元素 `target` ，获取该元素的索引，那么可以借助一个哈希表实现查找。
例如，若我们想要在给定数组中找到目标元素 `target` 的索引，则可以使用哈希查找来实现。
![哈希查找数组索引](hashing_search.assets/hash_search_index.png)
@@ -130,7 +128,7 @@ comments: true
}
```
再比如，如果我们想要给定一个目标节点值 `target` ，获取对应的链表节点对象，那么也可以使用哈希查找实现。
同样，若要根据目标节点值 target 查找对应的链表节点对象，也可以采用哈希查找方法。
![哈希查找链表节点](hashing_search.assets/hash_search_listnode.png)
@@ -250,15 +248,15 @@ comments: true
**时间复杂度 $O(1)$** ：哈希表的查找操作使用 $O(1)$ 时间。
**空间复杂度 $O(n)$** ：其中 $n$ 为数组或链表长度。
**空间复杂度 $O(n)$** ：其中 $n$ 是数组或链表的长度。
## 10.3.3. &nbsp; 优点与缺点
## 10.3.3. &nbsp; 优点与局限性
在哈希表中，**查找、插入、删除操作的平均时间复杂度都为 $O(1)$** ，这意味着无论是高频增删还是高频查找场景，哈希查找的性能表现都非常好。当然，一切的前提是保证哈希表未退化。
哈希查找的性能表现相当优秀，查找、插入、删除操作的平均时间复杂度均为 $O(1)$ 。尽管如此，哈希查找仍然存在一些问题：
即使如此，哈希查找仍存在一些问题，在实际应用中，需要根据情况灵活选择方法。
- 辅助哈希表需要占用 $O(n)$ 的额外空间，意味着需要预留更多的计算机内存；
- 构建和维护哈希表需要时间，因此哈希查找不适用于高频增删、低频查找的场景；
- 当哈希冲突严重时，哈希表可能退化为链表，导致时间复杂度劣化至 $O(n)$ ；
- 当数据量较小时，线性查找可能比哈希查找更快。这是因为计算哈希函数可能比遍历一个小型数组更慢；
- 辅助哈希表 **需要使用 $O(n)$ 的额外空间**，意味着需要预留更多的计算机内存；
- 建立和维护哈希表需要时间，因此哈希查找 **不适合高频增删、低频查找的使用场景**；
- 当哈希冲突严重时，哈希表会退化为链表，**时间复杂度劣化至 $O(n)$** ；
- **当数据量很小时，线性查找比哈希查找更快**。这是因为计算哈希映射函数可能比遍历一个小型数组更慢；
因此，在实际应用中，我们需要根据具体情况灵活选择解决方案。

16
chapter_searching/linear_search.md
View File

@@ -4,11 +4,11 @@ comments: true
# 10.1. &nbsp; 线性查找
「线性查找 Linear Search」是一种最基础的查找方法，其从数据结构的一端开始，依次访问每个元素，直到另一端后停止。
「线性查找 Linear Search」是一种简单的查找方法，其从数据结构的一端开始，逐个访问每个元素，直至另一端为止。
## 10.1.1. &nbsp; 算法实现
线性查找实质上就是遍历数据结构 + 判断条件。比如，我们想要在数组 `nums` 中查找目标元素 `target` 的对应索引，那么可以在数组中进行线性查找。
例如，若我们想要在数组 `nums` 中查找目标元素 `target` 的对应索引，可以采用线性查找方法。
![在数组中线性查找元素](linear_search.assets/linear_search.png)
@@ -167,7 +167,7 @@ comments: true
}
```
再比如，我们想要在给定一个目标节点值 `target` ，返回此节点对象，也可以在链表中进行线性查找。
另一个例子，若需要在链表中查找给定目标节点值 `target` 并返回该节点对象，同样可以使用线性查找。
=== "Java"
@@ -332,12 +332,12 @@ comments: true
## 10.1.2. &nbsp; 复杂度分析
**时间复杂度 $O(n)$** ：其中 $n$ 为数组或链表长度。
**时间复杂度 $O(n)$** ：其中 $n$ 代表数组或链表的长度。
**空间复杂度 $O(1)$** ：无需使用额外空间。
**空间复杂度 $O(1)$** ：无需借助额外的存储空间。
## 10.1.3. &nbsp; 优点与缺点
## 10.1.3. &nbsp; 优点与局限性
**线性查找的通用性极佳**。由于线性查找是依次访问元素的，即没有跳跃访问元素，因此数组或链表皆适用。
**线性查找具有极佳的通用性**。由于线性查找是逐个访问元素的，没有跳跃式访问，因此适用于数组和链表的查找。
**线性查找的时间复杂度太高**。在数据量 $n$ 很大时，查找效率很低。
**线性查找的时间复杂度较高**。当数据量 $n$ 较大时，线性查找的效率较低。

16
chapter_searching/summary.md
View File

@@ -4,19 +4,17 @@ comments: true
# 10.4. &nbsp; 小结
- 线性查找是一种最基础的查找方法，通过遍历数据结构 + 判断条件实现查找。
- 二分查找利用数据的有序性，通过循环不断缩小一半搜索区间来实现查找，其要求输入数据是有序的，并且仅适用于数组或基于数组实现的数据结构。
- 哈希查找借助哈希表来实现常数阶时间复杂度的查找操作，体现以空间换时间的算法思想。
- 下表总结对比了查找算法的各种特性和时间复杂度。
- 线性查找通过遍历数据结构并进行条件判断来完成查找任务。
- 二分查找依赖于数据的有序性，通过循环逐步缩减一半搜索区间来实现查找。它要求输入数据有序，且仅适用于数组或基于数组实现的数据结构。
- 哈希查找利用哈希表实现常数阶时间复杂度的查找操作，体现了空间换时间的算法思维。
- 下表概括并对比了三种查找算法的特性和时间复杂度。
<div class="center-table" markdown>
| | 线性查找 | 二分查找 | 哈希查找 |
| ------------------------------------- | ------------------------ | ----------------------------- | ------------------------ |
| 适用数据结构 | 数组、链表 | 数组 | 数组、链表 |
| 输入数据要求 | 无 | 有序 | 无 |
| 平均时间复杂度</br>查找 / 插入 / 删除 | $O(n)$ / $O(1)$ / $O(n)$ | $O(\log n)$ / $O(n)$ / $O(n)$ | $O(1)$ / $O(1)$ / $O(1)$ |
| 最差时间复杂度</br>查找 / 插入 / 删除 | $O(n)$ / $O(1)$ / $O(n)$ | $O(\log n)$ / $O(n)$ / $O(n)$ | $O(n)$ / $O(n)$ / $O(n)$ |
| 空间复杂度 | $O(1)$ | $O(1)$ | $O(n)$ |
| 适用数据结构 | 数组、链表 | 有序数组 | 数组、链表 |
| 时间复杂度</br>（查找，插入，删除） | $O(n)$ , $O(1)$ , $O(n)$ | $O(\log n)$ , $O(n)$ , $O(n)$ | $O(1)$ , $O(1)$ , $O(1)$ |
| 空间复杂度 | $O(1)$ | $O(1)$ | $O(n)$ |
</div>