mirror of
https://github.com/krahets/hello-algo.git
synced 2026-07-12 15:36:05 +00:00
First commit
This commit is contained in:
krahets
Executable
+555
@@ -0,0 +1,555 @@
|
||||
---
|
||||
comments: true
|
||||
---
|
||||
|
||||
# 10.2. 二分查找
|
||||
|
||||
「二分查找 Binary Search」利用数据的有序性，通过每轮缩小一半搜索区间来查找目标元素。
|
||||
|
||||
使用二分查找有两个前置条件：
|
||||
|
||||
- **要求输入数据是有序的**，这样才能通过判断大小关系来排除一半的搜索区间；
|
||||
- **二分查找仅适用于数组**，而在链表中使用效率很低，因为其在循环中需要跳跃式（非连续地）访问元素。
|
||||
|
||||
## 10.2.1. 算法实现
|
||||
|
||||
给定一个长度为 $n$ 的排序数组 `nums` ，元素从小到大排列。数组的索引取值范围为
|
||||
|
||||
$$
|
||||
0, 1, 2, \cdots, n-1
|
||||
$$
|
||||
|
||||
使用「区间」来表示这个取值范围的方法主要有两种：
|
||||
|
||||
1. **双闭区间 $[0, n-1]$** ，即两个边界都包含自身；此方法下，区间 $[0, 0]$ 仍包含一个元素；
|
||||
2. **左闭右开 $[0, n)$** ，即左边界包含自身、右边界不包含自身；此方法下，区间 $[0, 0)$ 为空；
|
||||
|
||||
### “双闭区间”实现
|
||||
|
||||
首先，我们先采用“双闭区间”的表示，在数组 `nums` 中查找目标元素 `target` 的对应索引。
|
||||
|
||||
=== "Step 1"
|
||||
|
||||
|
||||
=== "Step 2"
|
||||
|
||||
|
||||
=== "Step 3"
|
||||
|
||||
|
||||
=== "Step 4"
|
||||
|
||||
|
||||
=== "Step 5"
|
||||
|
||||
|
||||
=== "Step 6"
|
||||
|
||||
|
||||
=== "Step 7"
|
||||
|
||||
|
||||
二分查找“双闭区间”表示下的代码如下所示。
|
||||
|
||||
=== "Java"
|
||||
|
||||
```java title="binary_search.java"
|
||||
/* 二分查找（双闭区间） */
|
||||
int binarySearch(int[] nums, int target) {
|
||||
// 初始化双闭区间 [0, n-1] ，即 i, j 分别指向数组首元素、尾元素
|
||||
int i = 0, j = nums.length - 1;
|
||||
// 循环，当搜索区间为空时跳出（当 i > j 时为空）
|
||||
while (i <= j) {
|
||||
int m = (i + j) / 2; // 计算中点索引 m
|
||||
if (nums[m] < target) // 此情况说明 target 在区间 [m+1, j] 中
|
||||
i = m + 1;
|
||||
else if (nums[m] > target) // 此情况说明 target 在区间 [i, m-1] 中
|
||||
j = m - 1;
|
||||
else // 找到目标元素，返回其索引
|
||||
return m;
|
||||
}
|
||||
// 未找到目标元素，返回 -1
|
||||
return -1;
|
||||
}
|
||||
```
|
||||
|
||||
=== "C++"
|
||||
|
||||
```cpp title="binary_search.cpp"
|
||||
/* 二分查找（双闭区间） */
|
||||
int binarySearch(vector<int>& nums, int target) {
|
||||
// 初始化双闭区间 [0, n-1] ，即 i, j 分别指向数组首元素、尾元素
|
||||
int i = 0, j = nums.size() - 1;
|
||||
// 循环，当搜索区间为空时跳出（当 i > j 时为空）
|
||||
while (i <= j) {
|
||||
int m = (i + j) / 2; // 计算中点索引 m
|
||||
if (nums[m] < target) // 此情况说明 target 在区间 [m+1, j] 中
|
||||
i = m + 1;
|
||||
else if (nums[m] > target) // 此情况说明 target 在区间 [i, m-1] 中
|
||||
j = m - 1;
|
||||
else // 找到目标元素，返回其索引
|
||||
return m;
|
||||
}
|
||||
// 未找到目标元素，返回 -1
|
||||
return -1;
|
||||
}
|
||||
```
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python title="binary_search.py"
|
||||
""" 二分查找（双闭区间） """
|
||||
def binary_search(nums, target):
|
||||
# 初始化双闭区间 [0, n-1] ，即 i, j 分别指向数组首元素、尾元素
|
||||
i, j = 0, len(nums) - 1
|
||||
while i <= j:
|
||||
m = (i + j) // 2 # 计算中点索引 m
|
||||
if nums[m] < target: # 此情况说明 target 在区间 [m+1, j] 中
|
||||
i = m + 1
|
||||
elif nums[m] > target: # 此情况说明 target 在区间 [i, m-1] 中
|
||||
j = m - 1
|
||||
else:
|
||||
return m # 找到目标元素，返回其索引
|
||||
return -1 # 未找到目标元素，返回 -1
|
||||
```
|
||||
|
||||
=== "Go"
|
||||
|
||||
```go title="binary_search.go"
|
||||
/* 二分查找（双闭区间） */
|
||||
func binarySearch(nums []int, target int) int {
|
||||
// 初始化双闭区间 [0, n-1] ，即 i, j 分别指向数组首元素、尾元素
|
||||
i, j := 0, len(nums)-1
|
||||
// 循环，当搜索区间为空时跳出（当 i > j 时为空）
|
||||
for i <= j {
|
||||
m := (i + j) / 2 // 计算中点索引 m
|
||||
if nums[m] < target { // 此情况说明 target 在区间 [m+1, j] 中
|
||||
i = m + 1
|
||||
} else if nums[m] > target { // 此情况说明 target 在区间 [i, m-1] 中
|
||||
j = m - 1
|
||||
} else { // 找到目标元素，返回其索引
|
||||
return m
|
||||
}
|
||||
}
|
||||
// 未找到目标元素，返回 -1
|
||||
return -1
|
||||
}
|
||||
```
|
||||
|
||||
=== "JavaScript"
|
||||
|
||||
```javascript title="binary_search.js"
|
||||
/* 二分查找（双闭区间） */
|
||||
function binarySearch(nums, target) {
|
||||
// 初始化双闭区间 [0, n-1] ，即 i, j 分别指向数组首元素、尾元素
|
||||
let i = 0, j = nums.length - 1;
|
||||
// 循环，当搜索区间为空时跳出（当 i > j 时为空）
|
||||
while (i <= j) {
|
||||
let m = parseInt((i + j) / 2); // 计算中点索引 m ，在 JS 中需使用 parseInt 函数取整
|
||||
if (nums[m] < target) // 此情况说明 target 在区间 [m+1, j] 中
|
||||
i = m + 1;
|
||||
else if (nums[m] > target) // 此情况说明 target 在区间 [i, m-1] 中
|
||||
j = m - 1;
|
||||
else
|
||||
return m; // 找到目标元素，返回其索引
|
||||
}
|
||||
// 未找到目标元素，返回 -1
|
||||
return -1;
|
||||
}
|
||||
```
|
||||
|
||||
=== "TypeScript"
|
||||
|
||||
```typescript title="binary_search.ts"
|
||||
/* 二分查找（双闭区间） */
|
||||
const binarySearch = function (nums: number[], target: number): number {
|
||||
// 初始化双闭区间 [0, n-1] ，即 i, j 分别指向数组首元素、尾元素
|
||||
let i = 0, j = nums.length - 1;
|
||||
// 循环，当搜索区间为空时跳出（当 i > j 时为空）
|
||||
while (i <= j) {
|
||||
const m = Math.floor(i + (j - i) / 2); // 计算中点索引 m
|
||||
if (nums[m] < target) { // 此情况说明 target 在区间 [m+1, j] 中
|
||||
i = m + 1;
|
||||
} else if (nums[m] > target) { // 此情况说明 target 在区间 [i, m-1] 中
|
||||
j = m - 1;
|
||||
} else { // 找到目标元素，返回其索引
|
||||
return m;
|
||||
}
|
||||
}
|
||||
return -1; // 未找到目标元素，返回 -1
|
||||
}
|
||||
```
|
||||
|
||||
=== "C"
|
||||
|
||||
```c title="binary_search.c"
|
||||
|
||||
```
|
||||
|
||||
=== "C#"
|
||||
|
||||
```csharp title="binary_search.cs"
|
||||
/* 二分查找（双闭区间） */
|
||||
int binarySearch(int[] nums, int target)
|
||||
{
|
||||
// 初始化双闭区间 [0, n-1] ，即 i, j 分别指向数组首元素、尾元素
|
||||
int i = 0, j = nums.Length - 1;
|
||||
// 循环，当搜索区间为空时跳出（当 i > j 时为空）
|
||||
while (i <= j)
|
||||
{
|
||||
int m = (i + j) / 2; // 计算中点索引 m
|
||||
if (nums[m] < target) // 此情况说明 target 在区间 [m+1, j] 中
|
||||
i = m + 1;
|
||||
else if (nums[m] > target) // 此情况说明 target 在区间 [i, m-1] 中
|
||||
j = m - 1;
|
||||
else // 找到目标元素，返回其索引
|
||||
return m;
|
||||
}
|
||||
// 未找到目标元素，返回 -1
|
||||
return -1;
|
||||
}
|
||||
```
|
||||
|
||||
=== "Swift"
|
||||
|
||||
```swift title="binary_search.swift"
|
||||
/* 二分查找（双闭区间） */
|
||||
func binarySearch(nums: [Int], target: Int) -> Int {
|
||||
// 初始化双闭区间 [0, n-1] ，即 i, j 分别指向数组首元素、尾元素
|
||||
var i = 0
|
||||
var j = nums.count - 1
|
||||
// 循环，当搜索区间为空时跳出（当 i > j 时为空）
|
||||
while i <= j {
|
||||
let m = (i + j) / 2 // 计算中点索引 m
|
||||
if nums[m] < target { // 此情况说明 target 在区间 [m+1, j] 中
|
||||
i = m + 1
|
||||
} else if nums[m] > target { // 此情况说明 target 在区间 [i, m-1] 中
|
||||
j = m - 1
|
||||
} else { // 找到目标元素，返回其索引
|
||||
return m
|
||||
}
|
||||
}
|
||||
// 未找到目标元素，返回 -1
|
||||
return -1
|
||||
}
|
||||
```
|
||||
|
||||
=== "Zig"
|
||||
|
||||
```zig title="binary_search.zig"
|
||||
|
||||
```
|
||||
|
||||
### “左闭右开”实现
|
||||
|
||||
当然，我们也可以使用“左闭右开”的表示方法，写出相同功能的二分查找代码。
|
||||
|
||||
=== "Java"
|
||||
|
||||
```java title="binary_search.java"
|
||||
/* 二分查找（左闭右开） */
|
||||
int binarySearch1(int[] nums, int target) {
|
||||
// 初始化左闭右开 [0, n) ，即 i, j 分别指向数组首元素、尾元素+1
|
||||
int i = 0, j = nums.length;
|
||||
// 循环，当搜索区间为空时跳出（当 i = j 时为空）
|
||||
while (i < j) {
|
||||
int m = (i + j) / 2; // 计算中点索引 m
|
||||
if (nums[m] < target) // 此情况说明 target 在区间 [m+1, j) 中
|
||||
i = m + 1;
|
||||
else if (nums[m] > target) // 此情况说明 target 在区间 [i, m) 中
|
||||
j = m;
|
||||
else // 找到目标元素，返回其索引
|
||||
return m;
|
||||
}
|
||||
// 未找到目标元素，返回 -1
|
||||
return -1;
|
||||
}
|
||||
```
|
||||
|
||||
=== "C++"
|
||||
|
||||
```cpp title="binary_search.cpp"
|
||||
/* 二分查找（左闭右开） */
|
||||
int binarySearch1(vector<int>& nums, int target) {
|
||||
// 初始化左闭右开 [0, n) ，即 i, j 分别指向数组首元素、尾元素+1
|
||||
int i = 0, j = nums.size();
|
||||
// 循环，当搜索区间为空时跳出（当 i = j 时为空）
|
||||
while (i < j) {
|
||||
int m = (i + j) / 2; // 计算中点索引 m
|
||||
if (nums[m] < target) // 此情况说明 target 在区间 [m+1, j) 中
|
||||
i = m + 1;
|
||||
else if (nums[m] > target) // 此情况说明 target 在区间 [i, m) 中
|
||||
j = m;
|
||||
else // 找到目标元素，返回其索引
|
||||
return m;
|
||||
}
|
||||
// 未找到目标元素，返回 -1
|
||||
return -1;
|
||||
}
|
||||
```
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python title="binary_search.py"
|
||||
""" 二分查找（左闭右开） """
|
||||
def binary_search1(nums, target):
|
||||
# 初始化左闭右开 [0, n) ，即 i, j 分别指向数组首元素、尾元素+1
|
||||
i, j = 0, len(nums)
|
||||
# 循环，当搜索区间为空时跳出（当 i = j 时为空）
|
||||
while i < j:
|
||||
m = (i + j) // 2 # 计算中点索引 m
|
||||
if nums[m] < target: # 此情况说明 target 在区间 [m+1, j) 中
|
||||
i = m + 1
|
||||
elif nums[m] > target: # 此情况说明 target 在区间 [i, m) 中
|
||||
j = m
|
||||
else: # 找到目标元素，返回其索引
|
||||
return m
|
||||
return -1 # 未找到目标元素，返回 -1
|
||||
```
|
||||
|
||||
=== "Go"
|
||||
|
||||
```go title="binary_search.go"
|
||||
/* 二分查找（左闭右开） */
|
||||
func binarySearch1(nums []int, target int) int {
|
||||
// 初始化左闭右开 [0, n) ，即 i, j 分别指向数组首元素、尾元素+1
|
||||
i, j := 0, len(nums)
|
||||
// 循环，当搜索区间为空时跳出（当 i = j 时为空）
|
||||
for i < j {
|
||||
m := (i + j) / 2 // 计算中点索引 m
|
||||
if nums[m] < target { // 此情况说明 target 在区间 [m+1, j) 中
|
||||
i = m + 1
|
||||
} else if nums[m] > target { // 此情况说明 target 在区间 [i, m) 中
|
||||
j = m
|
||||
} else { // 找到目标元素，返回其索引
|
||||
return m
|
||||
}
|
||||
}
|
||||
// 未找到目标元素，返回 -1
|
||||
return -1
|
||||
}
|
||||
```
|
||||
|
||||
=== "JavaScript"
|
||||
|
||||
```javascript title="binary_search.js"
|
||||
/* 二分查找（左闭右开） */
|
||||
function binarySearch1(nums, target) {
|
||||
// 初始化左闭右开 [0, n) ，即 i, j 分别指向数组首元素、尾元素+1
|
||||
let i = 0, j = nums.length;
|
||||
// 循环，当搜索区间为空时跳出（当 i = j 时为空）
|
||||
while (i < j) {
|
||||
let m = parseInt((i + j) / 2); // 计算中点索引 m ，在 JS 中需使用 parseInt 函数取整
|
||||
if (nums[m] < target) // 此情况说明 target 在区间 [m+1, j) 中
|
||||
i = m + 1;
|
||||
else if (nums[m] > target) // 此情况说明 target 在区间 [i, m) 中
|
||||
j = m;
|
||||
else // 找到目标元素，返回其索引
|
||||
return m;
|
||||
}
|
||||
// 未找到目标元素，返回 -1
|
||||
return -1;
|
||||
}
|
||||
```
|
||||
|
||||
=== "TypeScript"
|
||||
|
||||
```typescript title="binary_search.ts"
|
||||
/* 二分查找（左闭右开） */
|
||||
const binarySearch1 = function (nums: number[], target: number): number {
|
||||
// 初始化左闭右开 [0, n) ，即 i, j 分别指向数组首元素、尾元素+1
|
||||
let i = 0, j = nums.length;
|
||||
// 循环，当搜索区间为空时跳出（当 i = j 时为空）
|
||||
while (i < j) {
|
||||
const m = Math.floor(i + (j - i) / 2); // 计算中点索引 m
|
||||
if (nums[m] < target) { // 此情况说明 target 在区间 [m+1, j) 中
|
||||
i = m + 1;
|
||||
} else if (nums[m] > target) { // 此情况说明 target 在区间 [i, m) 中
|
||||
j = m;
|
||||
} else { // 找到目标元素，返回其索引
|
||||
return m;
|
||||
}
|
||||
}
|
||||
return -1; // 未找到目标元素，返回 -1
|
||||
}
|
||||
```
|
||||
|
||||
=== "C"
|
||||
|
||||
```c title="binary_search.c"
|
||||
|
||||
```
|
||||
|
||||
=== "C#"
|
||||
|
||||
```csharp title="binary_search.cs"
|
||||
/* 二分查找（左闭右开） */
|
||||
int binarySearch1(int[] nums, int target)
|
||||
{
|
||||
// 初始化左闭右开 [0, n) ，即 i, j 分别指向数组首元素、尾元素+1
|
||||
int i = 0, j = nums.Length;
|
||||
// 循环，当搜索区间为空时跳出（当 i = j 时为空）
|
||||
while (i < j)
|
||||
{
|
||||
int m = (i + j) / 2; // 计算中点索引 m
|
||||
if (nums[m] < target) // 此情况说明 target 在区间 [m+1, j) 中
|
||||
i = m + 1;
|
||||
else if (nums[m] > target) // 此情况说明 target 在区间 [i, m) 中
|
||||
j = m;
|
||||
else // 找到目标元素，返回其索引
|
||||
return m;
|
||||
}
|
||||
// 未找到目标元素，返回 -1
|
||||
return -1;
|
||||
}
|
||||
```
|
||||
|
||||
=== "Swift"
|
||||
|
||||
```swift title="binary_search.swift"
|
||||
/* 二分查找（左闭右开） */
|
||||
func binarySearch1(nums: [Int], target: Int) -> Int {
|
||||
// 初始化左闭右开 [0, n) ，即 i, j 分别指向数组首元素、尾元素+1
|
||||
var i = 0
|
||||
var j = nums.count
|
||||
// 循环，当搜索区间为空时跳出（当 i = j 时为空）
|
||||
while i < j {
|
||||
let m = (i + j) / 2 // 计算中点索引 m
|
||||
if nums[m] < target { // 此情况说明 target 在区间 [m+1, j) 中
|
||||
i = m + 1
|
||||
} else if nums[m] > target { // 此情况说明 target 在区间 [i, m) 中
|
||||
j = m
|
||||
} else { // 找到目标元素，返回其索引
|
||||
return m
|
||||
}
|
||||
}
|
||||
// 未找到目标元素，返回 -1
|
||||
return -1
|
||||
}
|
||||
```
|
||||
|
||||
=== "Zig"
|
||||
|
||||
```zig title="binary_search.zig"
|
||||
|
||||
```
|
||||
|
||||
### 两种表示对比
|
||||
|
||||
对比下来，两种表示的代码写法有以下不同点：
|
||||
|
||||
<div class="center-table" markdown>
|
||||
|
||||
| 表示方法 | 初始化指针 | 缩小区间 | 循环终止条件 |
|
||||
| ------------------- | ------------------- | ------------------------- | ------------ |
|
||||
| 双闭区间 $[0, n-1]$ | $i = 0$ , $j = n-1$ | $i = m + 1$ , $j = m - 1$ | $i > j$ |
|
||||
| 左闭右开 $[0, n)$ | $i = 0$ , $j = n$ | $i = m + 1$ , $j = m$ | $i = j$ |
|
||||
|
||||
</div>
|
||||
|
||||
观察发现，在“双闭区间”表示中，由于对左右两边界的定义是相同的，因此缩小区间的 $i$ , $j$ 处理方法也是对称的，这样更不容易出错。综上所述，**建议你采用“双闭区间”的写法。**
|
||||
|
||||
### 大数越界处理
|
||||
|
||||
当数组长度很大时，加法 $i + j$ 的结果有可能会超出 `int` 类型的取值范围。在此情况下，我们需要换一种计算中点的写法。
|
||||
|
||||
=== "Java"
|
||||
|
||||
```java title=""
|
||||
// (i + j) 有可能超出 int 的取值范围
|
||||
int m = (i + j) / 2;
|
||||
// 更换为此写法则不会越界
|
||||
int m = i + (j - i) / 2;
|
||||
```
|
||||
|
||||
=== "C++"
|
||||
|
||||
```cpp title=""
|
||||
// (i + j) 有可能超出 int 的取值范围
|
||||
int m = (i + j) / 2;
|
||||
// 更换为此写法则不会越界
|
||||
int m = i + (j - i) / 2;
|
||||
```
|
||||
|
||||
=== "Python"
|
||||
|
||||
```py title=""
|
||||
# Python 中的数字理论上可以无限大（取决于内存大小）
|
||||
# 因此无需考虑大数越界问题
|
||||
```
|
||||
|
||||
=== "Go"
|
||||
|
||||
```go title=""
|
||||
// (i + j) 有可能超出 int 的取值范围
|
||||
m := (i + j) / 2
|
||||
// 更换为此写法则不会越界
|
||||
m := i + (j - i) / 2
|
||||
```
|
||||
|
||||
=== "JavaScript"
|
||||
|
||||
```javascript title=""
|
||||
// (i + j) 有可能超出 int 的取值范围
|
||||
let m = parseInt((i + j) / 2);
|
||||
// 更换为此写法则不会越界
|
||||
let m = parseInt(i + (j - i) / 2);
|
||||
```
|
||||
|
||||
=== "TypeScript"
|
||||
|
||||
```typescript title=""
|
||||
// (i + j) 有可能超出 Number 的取值范围
|
||||
let m = Math.floor((i + j) / 2);
|
||||
// 更换为此写法则不会越界
|
||||
let m = Math.floor(i + (j - i) / 2);
|
||||
```
|
||||
|
||||
=== "C"
|
||||
|
||||
```c title=""
|
||||
|
||||
```
|
||||
|
||||
=== "C#"
|
||||
|
||||
```csharp title=""
|
||||
// (i + j) 有可能超出 int 的取值范围
|
||||
int m = (i + j) / 2;
|
||||
// 更换为此写法则不会越界
|
||||
int m = i + (j - i) / 2;
|
||||
```
|
||||
|
||||
=== "Swift"
|
||||
|
||||
```swift title=""
|
||||
// (i + j) 有可能超出 int 的取值范围
|
||||
let m = (i + j) / 2
|
||||
// 更换为此写法则不会越界
|
||||
let m = i + (j - 1) / 2
|
||||
```
|
||||
|
||||
=== "Zig"
|
||||
|
||||
```zig title=""
|
||||
|
||||
```
|
||||
|
||||
## 10.2.2. 复杂度分析
|
||||
|
||||
**时间复杂度 $O(\log n)$** ：其中 $n$ 为数组或链表长度；每轮排除一半的区间，因此循环轮数为 $\log_2 n$ ，使用 $O(\log n)$ 时间。
|
||||
|
||||
**空间复杂度 $O(1)$** ：指针 `i` , `j` 使用常数大小空间。
|
||||
|
||||
## 10.2.3. 优点与缺点
|
||||
|
||||
二分查找效率很高，体现在：
|
||||
|
||||
- **二分查找时间复杂度低**。对数阶在数据量很大时具有巨大优势，例如，当数据大小 $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$ 较小时，线性查找反而比二分查找更快。
|
||||
Executable
+251
@@ -0,0 +1,251 @@
|
||||
---
|
||||
comments: true
|
||||
---
|
||||
|
||||
# 10.3. 哈希查找
|
||||
|
||||
!!! question
|
||||
|
||||
在数据量很大时，「线性查找」太慢；而「二分查找」要求数据必须是有序的，并且只能在数组中应用。那么是否有方法可以同时避免上述缺点呢？答案是肯定的，此方法被称为「哈希查找」。
|
||||
|
||||
「哈希查找 Hash Searching」借助一个哈希表来存储需要的「键值对 Key Value Pair」，我们可以在 $O(1)$ 时间下实现“键 $\rightarrow$ 值”映射查找，体现着“以空间换时间”的算法思想。
|
||||
|
||||
## 10.3.1. 算法实现
|
||||
|
||||
如果我们想要给定数组中的一个目标元素 `target` ，获取该元素的索引，那么可以借助一个哈希表实现查找。
|
||||
|
||||
|
||||
|
||||
=== "Java"
|
||||
|
||||
```java title="hashing_search.java"
|
||||
/* 哈希查找（数组） */
|
||||
int hashingSearchArray(Map<Integer, Integer> map, int target) {
|
||||
// 哈希表的 key: 目标元素，value: 索引
|
||||
// 若哈希表中无此 key ，返回 -1
|
||||
return map.getOrDefault(target, -1);
|
||||
}
|
||||
```
|
||||
|
||||
=== "C++"
|
||||
|
||||
```cpp title="hashing_search.cpp"
|
||||
/* 哈希查找（数组） */
|
||||
int hashingSearchArray(unordered_map<int, int> map, int target) {
|
||||
// 哈希表的 key: 目标元素，value: 索引
|
||||
// 若哈希表中无此 key ，返回 -1
|
||||
if (map.find(target) == map.end())
|
||||
return -1;
|
||||
return map[target];
|
||||
}
|
||||
```
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python title="hashing_search.py"
|
||||
""" 哈希查找（数组） """
|
||||
def hashing_search_array(mapp, target):
|
||||
# 哈希表的 key: 目标元素，value: 索引
|
||||
# 若哈希表中无此 key ，返回 -1
|
||||
return mapp.get(target, -1)
|
||||
```
|
||||
|
||||
=== "Go"
|
||||
|
||||
```go title="hashing_search.go"
|
||||
/* 哈希查找（数组） */
|
||||
func hashingSearchArray(m map[int]int, target int) int {
|
||||
// 哈希表的 key: 目标元素，value: 索引
|
||||
// 若哈希表中无此 key ，返回 -1
|
||||
if index, ok := m[target]; ok {
|
||||
return index
|
||||
} else {
|
||||
return -1
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
=== "JavaScript"
|
||||
|
||||
```javascript title="hashing_search.js"
|
||||
/* 哈希查找（数组） */
|
||||
function hashingSearchArray(map, target) {
|
||||
// 哈希表的 key: 目标元素，value: 索引
|
||||
// 若哈希表中无此 key ，返回 -1
|
||||
return map.has(target) ? map.get(target) : -1;
|
||||
}
|
||||
```
|
||||
|
||||
=== "TypeScript"
|
||||
|
||||
```typescript title="hashing_search.ts"
|
||||
/* 哈希查找（数组） */
|
||||
function hashingSearchArray(map: Map<number, number>, target: number): number {
|
||||
// 哈希表的 key: 目标元素，value: 索引
|
||||
// 若哈希表中无此 key ，返回 -1
|
||||
return map.has(target) ? map.get(target) as number : -1;
|
||||
}
|
||||
```
|
||||
|
||||
=== "C"
|
||||
|
||||
```c title="hashing_search.c"
|
||||
|
||||
```
|
||||
|
||||
=== "C#"
|
||||
|
||||
```csharp title="hashing_search.cs"
|
||||
/* 哈希查找（数组） */
|
||||
int hashingSearchArray(Dictionary<int, int> map, int target)
|
||||
{
|
||||
// 哈希表的 key: 目标元素，value: 索引
|
||||
// 若哈希表中无此 key ，返回 -1
|
||||
return map.GetValueOrDefault(target, -1);
|
||||
}
|
||||
```
|
||||
|
||||
=== "Swift"
|
||||
|
||||
```swift title="hashing_search.swift"
|
||||
/* 哈希查找（数组） */
|
||||
func hashingSearchArray(map: [Int: Int], target: Int) -> Int {
|
||||
// 哈希表的 key: 目标元素，value: 索引
|
||||
// 若哈希表中无此 key ，返回 -1
|
||||
return map[target, default: -1]
|
||||
}
|
||||
```
|
||||
|
||||
=== "Zig"
|
||||
|
||||
```zig title="hashing_search.zig"
|
||||
|
||||
```
|
||||
|
||||
再比如，如果我们想要给定一个目标结点值 `target` ，获取对应的链表结点对象，那么也可以使用哈希查找实现。
|
||||
|
||||
|
||||
|
||||
=== "Java"
|
||||
|
||||
```java title="hashing_search.java"
|
||||
/* 哈希查找（链表） */
|
||||
ListNode hashingSearchLinkedList(Map<Integer, ListNode> map, int target) {
|
||||
// 哈希表的 key: 目标结点值，value: 结点对象
|
||||
// 若哈希表中无此 key ，返回 null
|
||||
return map.getOrDefault(target, null);
|
||||
}
|
||||
```
|
||||
|
||||
=== "C++"
|
||||
|
||||
```cpp title="hashing_search.cpp"
|
||||
/* 哈希查找（链表） */
|
||||
ListNode* hashingSearchLinkedList(unordered_map<int, ListNode*> map, int target) {
|
||||
// 哈希表的 key: 目标结点值，value: 结点对象
|
||||
// 若哈希表中无此 key ，返回 nullptr
|
||||
if (map.find(target) == map.end())
|
||||
return nullptr;
|
||||
return map[target];
|
||||
}
|
||||
```
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python title="hashing_search.py"
|
||||
""" 哈希查找（链表） """
|
||||
def hashing_search_linkedlist(mapp, target):
|
||||
# 哈希表的 key: 目标元素，value: 结点对象
|
||||
# 若哈希表中无此 key ，返回 -1
|
||||
return mapp.get(target, -1)
|
||||
```
|
||||
|
||||
=== "Go"
|
||||
|
||||
```go title="hashing_search.go"
|
||||
/* 哈希查找（链表） */
|
||||
func hashingSearchLinkedList(m map[int]*ListNode, target int) *ListNode {
|
||||
// 哈希表的 key: 目标结点值，value: 结点对象
|
||||
// 若哈希表中无此 key ，返回 nil
|
||||
if node, ok := m[target]; ok {
|
||||
return node
|
||||
} else {
|
||||
return nil
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
=== "JavaScript"
|
||||
|
||||
```javascript title="hashing_search.js"
|
||||
/* 哈希查找（链表） */
|
||||
function hashingSearchLinkedList(map, target) {
|
||||
// 哈希表的 key: 目标结点值，value: 结点对象
|
||||
// 若哈希表中无此 key ，返回 null
|
||||
return map.has(target) ? map.get(target) : null;
|
||||
}
|
||||
```
|
||||
|
||||
=== "TypeScript"
|
||||
|
||||
```typescript title="hashing_search.ts"
|
||||
/* 哈希查找（链表） */
|
||||
function hashingSearchLinkedList(map: Map<number, ListNode>, target: number): ListNode | null {
|
||||
// 哈希表的 key: 目标结点值，value: 结点对象
|
||||
// 若哈希表中无此 key ，返回 null
|
||||
return map.has(target) ? map.get(target) as ListNode : null;
|
||||
}
|
||||
```
|
||||
|
||||
=== "C"
|
||||
|
||||
```c title="hashing_search.c"
|
||||
|
||||
```
|
||||
|
||||
=== "C#"
|
||||
|
||||
```csharp title="hashing_search.cs"
|
||||
/* 哈希查找（链表） */
|
||||
ListNode? hashingSearchLinkedList(Dictionary<int, ListNode> map, int target)
|
||||
{
|
||||
|
||||
// 哈希表的 key: 目标结点值，value: 结点对象
|
||||
// 若哈希表中无此 key ，返回 null
|
||||
return map.GetValueOrDefault(target);
|
||||
}
|
||||
```
|
||||
|
||||
=== "Swift"
|
||||
|
||||
```swift title="hashing_search.swift"
|
||||
/* 哈希查找（链表） */
|
||||
func hashingSearchLinkedList(map: [Int: ListNode], target: Int) -> ListNode? {
|
||||
// 哈希表的 key: 目标结点值，value: 结点对象
|
||||
// 若哈希表中无此 key ，返回 null
|
||||
return map[target]
|
||||
}
|
||||
```
|
||||
|
||||
=== "Zig"
|
||||
|
||||
```zig title="hashing_search.zig"
|
||||
|
||||
```
|
||||
|
||||
## 10.3.2. 复杂度分析
|
||||
|
||||
**时间复杂度 $O(1)$** ：哈希表的查找操作使用 $O(1)$ 时间。
|
||||
|
||||
**空间复杂度 $O(n)$** ：其中 $n$ 为数组或链表长度。
|
||||
|
||||
## 10.3.3. 优点与缺点
|
||||
|
||||
在哈希表中，**查找、插入、删除操作的平均时间复杂度都为 $O(1)$** ，这意味着无论是高频增删还是高频查找场景，哈希查找的性能表现都非常好。当然，一切的前提是保证哈希表未退化。
|
||||
|
||||
即使如此，哈希查找仍存在一些问题，在实际应用中，需要根据情况灵活选择方法。
|
||||
|
||||
- 辅助哈希表 **需要使用 $O(n)$ 的额外空间**，意味着需要预留更多的计算机内存；
|
||||
- 建立和维护哈希表需要时间，因此哈希查找 **不适合高频增删、低频查找的使用场景**；
|
||||
- 当哈希冲突严重时，哈希表会退化为链表，**时间复杂度劣化至 $O(n)$** ；
|
||||
- **当数据量很小时，线性查找比哈希查找更快**。这是因为计算哈希映射函数可能比遍历一个小型数组更慢；
|
||||
Executable
+322
@@ -0,0 +1,322 @@
|
||||
---
|
||||
comments: true
|
||||
---
|
||||
|
||||
# 10.1. 线性查找
|
||||
|
||||
「线性查找 Linear Search」是一种最基础的查找方法，其从数据结构的一端开始，依次访问每个元素，直到另一端后停止。
|
||||
|
||||
## 10.1.1. 算法实现
|
||||
|
||||
线性查找实质上就是遍历数据结构 + 判断条件。比如，我们想要在数组 `nums` 中查找目标元素 `target` 的对应索引，那么可以在数组中进行线性查找。
|
||||
|
||||
|
||||
|
||||
=== "Java"
|
||||
|
||||
```java title="linear_search.java"
|
||||
/* 线性查找（数组） */
|
||||
int linearSearchArray(int[] nums, int target) {
|
||||
// 遍历数组
|
||||
for (int i = 0; i < nums.length; i++) {
|
||||
// 找到目标元素，返回其索引
|
||||
if (nums[i] == target)
|
||||
return i;
|
||||
}
|
||||
// 未找到目标元素，返回 -1
|
||||
return -1;
|
||||
}
|
||||
```
|
||||
|
||||
=== "C++"
|
||||
|
||||
```cpp title="linear_search.cpp"
|
||||
/* 线性查找（数组） */
|
||||
int linearSearchArray(vector<int>& nums, int target) {
|
||||
// 遍历数组
|
||||
for (int i = 0; i < nums.size(); i++) {
|
||||
// 找到目标元素，返回其索引
|
||||
if (nums[i] == target)
|
||||
return i;
|
||||
}
|
||||
// 未找到目标元素，返回 -1
|
||||
return -1;
|
||||
}
|
||||
```
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python title="linear_search.py"
|
||||
""" 线性查找（数组） """
|
||||
def linear_search_array(nums, target):
|
||||
# 遍历数组
|
||||
for i in range(len(nums)):
|
||||
if nums[i] == target: # 找到目标元素，返回其索引
|
||||
return i
|
||||
return -1 # 未找到目标元素，返回 -1
|
||||
```
|
||||
|
||||
=== "Go"
|
||||
|
||||
```go title="linear_search.go"
|
||||
/* 线性查找（数组） */
|
||||
func linearSearchArray(nums []int, target int) int {
|
||||
// 遍历数组
|
||||
for i := 0; i < len(nums); i++ {
|
||||
// 找到目标元素，返回其索引
|
||||
if nums[i] == target {
|
||||
return i
|
||||
}
|
||||
}
|
||||
// 未找到目标元素，返回 -1
|
||||
return -1
|
||||
}
|
||||
```
|
||||
|
||||
=== "JavaScript"
|
||||
|
||||
```javascript title="linear_search.js"
|
||||
/* 线性查找（数组） */
|
||||
function linearSearchArray(nums, target) {
|
||||
// 遍历数组
|
||||
for (let i = 0; i < nums.length; i++) {
|
||||
// 找到目标元素，返回其索引
|
||||
if (nums[i] === target) {
|
||||
return i;
|
||||
}
|
||||
}
|
||||
// 未找到目标元素，返回 -1
|
||||
return -1;
|
||||
}
|
||||
|
||||
```
|
||||
|
||||
=== "TypeScript"
|
||||
|
||||
```typescript title="linear_search.ts"
|
||||
/* 线性查找（数组）*/
|
||||
function linearSearchArray(nums: number[], target: number): number {
|
||||
// 遍历数组
|
||||
for (let i = 0; i < nums.length; i++) {
|
||||
// 找到目标元素，返回其索引
|
||||
if (nums[i] === target) {
|
||||
return i;
|
||||
}
|
||||
}
|
||||
// 未找到目标元素，返回 -1
|
||||
return -1;
|
||||
}
|
||||
```
|
||||
|
||||
=== "C"
|
||||
|
||||
```c title="linear_search.c"
|
||||
|
||||
```
|
||||
|
||||
=== "C#"
|
||||
|
||||
```csharp title="linear_search.cs"
|
||||
/* 线性查找（数组） */
|
||||
int linearSearchArray(int[] nums, int target)
|
||||
{
|
||||
// 遍历数组
|
||||
for (int i = 0; i < nums.Length; i++)
|
||||
{
|
||||
// 找到目标元素，返回其索引
|
||||
if (nums[i] == target)
|
||||
return i;
|
||||
}
|
||||
// 未找到目标元素，返回 -1
|
||||
return -1;
|
||||
}
|
||||
|
||||
```
|
||||
|
||||
=== "Swift"
|
||||
|
||||
```swift title="linear_search.swift"
|
||||
/* 线性查找（数组） */
|
||||
func linearSearchArray(nums: [Int], target: Int) -> Int {
|
||||
// 遍历数组
|
||||
for i in nums.indices {
|
||||
// 找到目标元素，返回其索引
|
||||
if nums[i] == target {
|
||||
return i
|
||||
}
|
||||
}
|
||||
// 未找到目标元素，返回 -1
|
||||
return -1
|
||||
}
|
||||
```
|
||||
|
||||
=== "Zig"
|
||||
|
||||
```zig title="linear_search.zig"
|
||||
|
||||
```
|
||||
|
||||
再比如，我们想要在给定一个目标结点值 `target` ，返回此结点对象，也可以在链表中进行线性查找。
|
||||
|
||||
=== "Java"
|
||||
|
||||
```java title="linear_search.java"
|
||||
/* 线性查找（链表） */
|
||||
ListNode linearSearchLinkedList(ListNode head, int target) {
|
||||
// 遍历链表
|
||||
while (head != null) {
|
||||
// 找到目标结点，返回之
|
||||
if (head.val == target)
|
||||
return head;
|
||||
head = head.next;
|
||||
}
|
||||
// 未找到目标结点，返回 null
|
||||
return null;
|
||||
}
|
||||
```
|
||||
|
||||
=== "C++"
|
||||
|
||||
```cpp title="linear_search.cpp"
|
||||
/* 线性查找（链表） */
|
||||
ListNode* linearSearchLinkedList(ListNode* head, int target) {
|
||||
// 遍历链表
|
||||
while (head != nullptr) {
|
||||
// 找到目标结点，返回之
|
||||
if (head->val == target)
|
||||
return head;
|
||||
head = head->next;
|
||||
}
|
||||
// 未找到目标结点，返回 nullptr
|
||||
return nullptr;
|
||||
}
|
||||
```
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python title="linear_search.py"
|
||||
""" 线性查找（链表） """
|
||||
def linear_search_linkedlist(head, target):
|
||||
# 遍历链表
|
||||
while head:
|
||||
if head.val == target: # 找到目标结点，返回之
|
||||
return head
|
||||
head = head.next
|
||||
return None # 未找到目标结点，返回 None
|
||||
```
|
||||
|
||||
=== "Go"
|
||||
|
||||
```go title="linear_search.go"
|
||||
/* 线性查找（链表）*/
|
||||
func linerSearchLinkedList(node *ListNode, target int) *ListNode {
|
||||
// 遍历链表
|
||||
for node != nil {
|
||||
// 找到目标结点，返回之
|
||||
if node.Val == target {
|
||||
return node
|
||||
}
|
||||
node = node.Next
|
||||
}
|
||||
// 未找到目标元素，返回 nil
|
||||
return nil
|
||||
}
|
||||
```
|
||||
|
||||
=== "JavaScript"
|
||||
|
||||
```javascript title="linear_search.js"
|
||||
/* 线性查找（链表）*/
|
||||
function linearSearchLinkedList(head, target) {
|
||||
// 遍历链表
|
||||
while(head) {
|
||||
// 找到目标结点，返回之
|
||||
if(head.val === target) {
|
||||
return head;
|
||||
}
|
||||
head = head.next;
|
||||
}
|
||||
// 未找到目标结点，返回 null
|
||||
return null;
|
||||
}
|
||||
```
|
||||
|
||||
=== "TypeScript"
|
||||
|
||||
```typescript title="linear_search.ts"
|
||||
/* 线性查找（链表）*/
|
||||
function linearSearchLinkedList(head: ListNode | null, target: number): ListNode | null {
|
||||
// 遍历链表
|
||||
while (head) {
|
||||
// 找到目标结点，返回之
|
||||
if (head.val === target) {
|
||||
return head;
|
||||
}
|
||||
head = head.next;
|
||||
}
|
||||
// 未找到目标结点，返回 null
|
||||
return null;
|
||||
}
|
||||
```
|
||||
|
||||
=== "C"
|
||||
|
||||
```c title="linear_search.c"
|
||||
|
||||
```
|
||||
|
||||
=== "C#"
|
||||
|
||||
```csharp title="linear_search.cs"
|
||||
/* 线性查找（链表） */
|
||||
ListNode? linearSearchLinkedList(ListNode head, int target)
|
||||
{
|
||||
// 遍历链表
|
||||
while (head != null)
|
||||
{
|
||||
// 找到目标结点，返回之
|
||||
if (head.val == target)
|
||||
return head;
|
||||
head = head.next;
|
||||
}
|
||||
// 未找到目标结点，返回 null
|
||||
return null;
|
||||
}
|
||||
```
|
||||
|
||||
=== "Swift"
|
||||
|
||||
```swift title="linear_search.swift"
|
||||
/* 线性查找（链表） */
|
||||
func linearSearchLinkedList(head: ListNode?, target: Int) -> ListNode? {
|
||||
var head = head
|
||||
// 遍历链表
|
||||
while head != nil {
|
||||
// 找到目标结点，返回之
|
||||
if head?.val == target {
|
||||
return head
|
||||
}
|
||||
head = head?.next
|
||||
}
|
||||
// 未找到目标结点，返回 null
|
||||
return nil
|
||||
}
|
||||
```
|
||||
|
||||
=== "Zig"
|
||||
|
||||
```zig title="linear_search.zig"
|
||||
|
||||
```
|
||||
|
||||
## 10.1.2. 复杂度分析
|
||||
|
||||
**时间复杂度 $O(n)$** ：其中 $n$ 为数组或链表长度。
|
||||
|
||||
**空间复杂度 $O(1)$** ：无需使用额外空间。
|
||||
|
||||
## 10.1.3. 优点与缺点
|
||||
|
||||
**线性查找的通用性极佳**。由于线性查找是依次访问元素的，即没有跳跃访问元素，因此数组或链表皆适用。
|
||||
|
||||
**线性查找的时间复杂度太高**。在数据量 $n$ 很大时，查找效率很低。
|
||||
@@ -0,0 +1,23 @@
|
||||
---
|
||||
comments: true
|
||||
---
|
||||
|
||||
# 10.4. 小结
|
||||
|
||||
- 线性查找是一种最基础的查找方法，通过遍历数据结构 + 判断条件实现查找。
|
||||
- 二分查找利用数据的有序性，通过循环不断缩小一半搜索区间来实现查找，其要求输入数据是有序的，并且仅适用于数组或基于数组实现的数据结构。
|
||||
- 哈希查找借助哈希表来实现常数阶时间复杂度的查找操作，体现以空间换时间的算法思想。
|
||||
|
||||
<p align="center"> Table. 三种查找方法对比 </p>
|
||||
|
||||
<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)$ |
|
||||
|
||||
</div>
|
||||
Reference in New Issue
Block a user