2022-11-22 17:47:26 +08:00
|
|
|
|
---
|
|
|
|
|
comments: true
|
|
|
|
|
---
|
|
|
|
|
|
|
|
|
|
# 二分查找
|
|
|
|
|
|
|
|
|
|
「二分查找 Binary Search」利用数据的有序性,通过每轮缩小一半搜索区间来查找目标元素。
|
|
|
|
|
|
|
|
|
|
使用二分查找有两个前置条件:
|
|
|
|
|
|
|
|
|
|
- **要求输入数据是有序的**,这样才能通过判断大小关系来排除一半的搜索区间;
|
2023-01-09 22:39:30 +08:00
|
|
|
|
- **二分查找仅适用于数组**,而在链表中使用效率很低,因为其在循环中需要跳跃式(非连续地)访问元素。
|
2022-11-22 17:47:26 +08:00
|
|
|
|
|
|
|
|
|
## 算法实现
|
|
|
|
|
|
|
|
|
|
给定一个长度为 $n$ 的排序数组 `nums` ,元素从小到大排列。数组的索引取值范围为
|
|
|
|
|
|
|
|
|
|
$$
|
|
|
|
|
0, 1, 2, \cdots, n-1
|
|
|
|
|
$$
|
|
|
|
|
|
|
|
|
|
使用「区间」来表示这个取值范围的方法主要有两种:
|
|
|
|
|
|
|
|
|
|
1. **双闭区间 $[0, n-1]$** ,即两个边界都包含自身;此方法下,区间 $[0, 0]$ 仍包含一个元素;
|
|
|
|
|
2. **左闭右开 $[0, n)$** ,即左边界包含自身、右边界不包含自身;此方法下,区间 $[0, 0)$ 为空;
|
|
|
|
|
|
2022-12-21 01:37:58 +08:00
|
|
|
|
### “双闭区间”实现
|
2022-11-22 17:47:26 +08:00
|
|
|
|
|
2022-12-21 01:37:58 +08:00
|
|
|
|
首先,我们先采用“双闭区间”的表示,在数组 `nums` 中查找目标元素 `target` 的对应索引。
|
2022-11-22 17:47:26 +08:00
|
|
|
|
|
|
|
|
|
=== "Step 1"
|
|
|
|
|
![binary_search_step1](binary_search.assets/binary_search_step1.png)
|
|
|
|
|
|
|
|
|
|
=== "Step 2"
|
|
|
|
|
![binary_search_step2](binary_search.assets/binary_search_step2.png)
|
|
|
|
|
|
|
|
|
|
=== "Step 3"
|
|
|
|
|
![binary_search_step3](binary_search.assets/binary_search_step3.png)
|
|
|
|
|
|
|
|
|
|
=== "Step 4"
|
|
|
|
|
![binary_search_step4](binary_search.assets/binary_search_step4.png)
|
|
|
|
|
|
|
|
|
|
=== "Step 5"
|
|
|
|
|
![binary_search_step5](binary_search.assets/binary_search_step5.png)
|
|
|
|
|
|
|
|
|
|
=== "Step 6"
|
|
|
|
|
![binary_search_step6](binary_search.assets/binary_search_step6.png)
|
|
|
|
|
|
|
|
|
|
=== "Step 7"
|
|
|
|
|
![binary_search_step7](binary_search.assets/binary_search_step7.png)
|
|
|
|
|
|
2022-12-21 01:37:58 +08:00
|
|
|
|
二分查找“双闭区间”表示下的代码如下所示。
|
2022-11-22 17:47:26 +08:00
|
|
|
|
|
|
|
|
|
=== "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;
|
|
|
|
|
}
|
|
|
|
|
```
|
|
|
|
|
|
2022-11-27 04:20:30 +08:00
|
|
|
|
=== "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;
|
|
|
|
|
}
|
|
|
|
|
```
|
|
|
|
|
|
2022-12-03 01:31:29 +08:00
|
|
|
|
=== "Python"
|
|
|
|
|
|
|
|
|
|
```python title="binary_search.py"
|
2022-12-04 01:43:58 +08:00
|
|
|
|
""" 二分查找(双闭区间) """
|
|
|
|
|
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
|
2022-12-03 01:31:29 +08:00
|
|
|
|
```
|
|
|
|
|
|
|
|
|
|
=== "Go"
|
|
|
|
|
|
|
|
|
|
```go title="binary_search.go"
|
2022-12-27 06:30:20 +08:00
|
|
|
|
/* 二分查找(双闭区间) */
|
|
|
|
|
func binarySearch(nums []int, target int) int {
|
|
|
|
|
// 初始化双闭区间 [0, n-1] ,即 i, j 分别指向数组首元素、尾元素
|
|
|
|
|
i, j := 0, len(nums)-1
|
|
|
|
|
// 循环,当搜索区间为空时跳出(当 i > j 时为空)
|
|
|
|
|
for i <= j {
|
2022-12-05 19:08:24 +08:00
|
|
|
|
m := (i + j) / 2 // 计算中点索引 m
|
2022-12-27 06:30:20 +08:00
|
|
|
|
if nums[m] < target { // 此情况说明 target 在区间 [m+1, j] 中
|
2022-12-05 19:08:24 +08:00
|
|
|
|
i = m + 1
|
2022-12-27 06:30:20 +08:00
|
|
|
|
} else if nums[m] > target { // 此情况说明 target 在区间 [i, m-1] 中
|
|
|
|
|
j = m - 1
|
2022-12-05 19:08:24 +08:00
|
|
|
|
} else { // 找到目标元素,返回其索引
|
|
|
|
|
return m
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
// 未找到目标元素,返回 -1
|
|
|
|
|
return -1
|
|
|
|
|
}
|
2022-12-03 01:31:29 +08:00
|
|
|
|
```
|
|
|
|
|
|
|
|
|
|
=== "JavaScript"
|
|
|
|
|
|
|
|
|
|
```js title="binary_search.js"
|
2022-12-22 21:38:08 +08:00
|
|
|
|
/* 二分查找(双闭区间) */
|
|
|
|
|
function binarySearch(nums, target) {
|
2023-01-11 14:44:32 +08:00
|
|
|
|
// 初始化双闭区间 [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; // 找到目标元素,返回其索引
|
2022-12-22 21:38:08 +08:00
|
|
|
|
}
|
2023-01-11 14:44:32 +08:00
|
|
|
|
// 未找到目标元素,返回 -1
|
|
|
|
|
return -1;
|
2022-12-22 21:38:08 +08:00
|
|
|
|
}
|
2022-12-03 01:31:29 +08:00
|
|
|
|
```
|
|
|
|
|
|
|
|
|
|
=== "TypeScript"
|
|
|
|
|
|
|
|
|
|
```typescript title="binary_search.ts"
|
2022-12-27 06:45:33 +08:00
|
|
|
|
/* 二分查找(双闭区间) */
|
|
|
|
|
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) {
|
2022-12-27 14:06:39 +08:00
|
|
|
|
const m = Math.floor(i + (j - i) / 2); // 计算中点索引 m
|
|
|
|
|
if (nums[m] < target) { // 此情况说明 target 在区间 [m+1, j] 中
|
2022-12-27 06:30:20 +08:00
|
|
|
|
i = m + 1;
|
2022-12-27 14:06:39 +08:00
|
|
|
|
} else if (nums[m] > target) { // 此情况说明 target 在区间 [i, m-1] 中
|
2022-12-27 06:45:33 +08:00
|
|
|
|
j = m - 1;
|
2022-12-27 14:06:39 +08:00
|
|
|
|
} else { // 找到目标元素,返回其索引
|
2022-12-27 06:30:20 +08:00
|
|
|
|
return m;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
return -1; // 未找到目标元素,返回 -1
|
|
|
|
|
}
|
2022-12-03 01:31:29 +08:00
|
|
|
|
```
|
|
|
|
|
|
|
|
|
|
=== "C"
|
|
|
|
|
|
|
|
|
|
```c title="binary_search.c"
|
|
|
|
|
|
|
|
|
|
```
|
|
|
|
|
|
|
|
|
|
=== "C#"
|
|
|
|
|
|
|
|
|
|
```csharp title="binary_search.cs"
|
2022-12-23 15:42:02 +08:00
|
|
|
|
/* 二分查找(双闭区间) */
|
|
|
|
|
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;
|
|
|
|
|
}
|
2022-12-03 01:31:29 +08:00
|
|
|
|
```
|
|
|
|
|
|
2023-01-08 19:41:05 +08:00
|
|
|
|
=== "Swift"
|
|
|
|
|
|
|
|
|
|
```swift title="binary_search.swift"
|
2023-01-30 15:43:29 +08:00
|
|
|
|
/* 二分查找(双闭区间) */
|
|
|
|
|
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
|
|
|
|
|
}
|
2023-01-08 19:41:05 +08:00
|
|
|
|
```
|
|
|
|
|
|
2022-12-21 01:37:58 +08:00
|
|
|
|
### “左闭右开”实现
|
2022-11-22 17:47:26 +08:00
|
|
|
|
|
2022-12-21 01:37:58 +08:00
|
|
|
|
当然,我们也可以使用“左闭右开”的表示方法,写出相同功能的二分查找代码。
|
2022-11-22 17:47:26 +08:00
|
|
|
|
|
|
|
|
|
=== "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
|
2023-01-19 21:06:24 +08:00
|
|
|
|
if (nums[m] < target) // 此情况说明 target 在区间 [m+1, j) 中
|
2022-11-22 17:47:26 +08:00
|
|
|
|
i = m + 1;
|
2023-01-19 21:06:24 +08:00
|
|
|
|
else if (nums[m] > target) // 此情况说明 target 在区间 [i, m) 中
|
2022-11-22 17:47:26 +08:00
|
|
|
|
j = m;
|
|
|
|
|
else // 找到目标元素,返回其索引
|
|
|
|
|
return m;
|
|
|
|
|
}
|
|
|
|
|
// 未找到目标元素,返回 -1
|
|
|
|
|
return -1;
|
|
|
|
|
}
|
|
|
|
|
```
|
|
|
|
|
|
2022-11-27 04:20:30 +08:00
|
|
|
|
=== "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
|
2023-01-19 21:06:24 +08:00
|
|
|
|
if (nums[m] < target) // 此情况说明 target 在区间 [m+1, j) 中
|
2022-11-27 04:20:30 +08:00
|
|
|
|
i = m + 1;
|
2023-01-19 21:06:24 +08:00
|
|
|
|
else if (nums[m] > target) // 此情况说明 target 在区间 [i, m) 中
|
2022-11-27 04:20:30 +08:00
|
|
|
|
j = m;
|
|
|
|
|
else // 找到目标元素,返回其索引
|
|
|
|
|
return m;
|
|
|
|
|
}
|
|
|
|
|
// 未找到目标元素,返回 -1
|
|
|
|
|
return -1;
|
|
|
|
|
}
|
|
|
|
|
```
|
|
|
|
|
|
2022-12-03 01:31:29 +08:00
|
|
|
|
=== "Python"
|
|
|
|
|
|
|
|
|
|
```python title="binary_search.py"
|
2022-12-04 01:43:58 +08:00
|
|
|
|
""" 二分查找(左闭右开) """
|
|
|
|
|
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
|
2023-01-19 21:06:24 +08:00
|
|
|
|
if nums[m] < target: # 此情况说明 target 在区间 [m+1, j) 中
|
2022-12-04 01:43:58 +08:00
|
|
|
|
i = m + 1
|
2023-01-19 21:06:24 +08:00
|
|
|
|
elif nums[m] > target: # 此情况说明 target 在区间 [i, m) 中
|
2022-12-04 01:43:58 +08:00
|
|
|
|
j = m
|
|
|
|
|
else: # 找到目标元素,返回其索引
|
|
|
|
|
return m
|
|
|
|
|
return -1 # 未找到目标元素,返回 -1
|
2022-12-03 01:31:29 +08:00
|
|
|
|
```
|
|
|
|
|
|
|
|
|
|
=== "Go"
|
|
|
|
|
|
|
|
|
|
```go title="binary_search.go"
|
2022-12-05 13:36:51 +08:00
|
|
|
|
/* 二分查找(左闭右开) */
|
|
|
|
|
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
|
2023-01-19 21:06:24 +08:00
|
|
|
|
if nums[m] < target { // 此情况说明 target 在区间 [m+1, j) 中
|
2022-12-05 13:36:51 +08:00
|
|
|
|
i = m + 1
|
2023-01-19 21:06:24 +08:00
|
|
|
|
} else if nums[m] > target { // 此情况说明 target 在区间 [i, m) 中
|
2022-12-05 13:36:51 +08:00
|
|
|
|
j = m
|
|
|
|
|
} else { // 找到目标元素,返回其索引
|
|
|
|
|
return m
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
// 未找到目标元素,返回 -1
|
|
|
|
|
return -1
|
|
|
|
|
}
|
2022-12-03 01:31:29 +08:00
|
|
|
|
```
|
|
|
|
|
|
|
|
|
|
=== "JavaScript"
|
|
|
|
|
|
|
|
|
|
```js title="binary_search.js"
|
2022-12-22 21:38:08 +08:00
|
|
|
|
/* 二分查找(左闭右开) */
|
|
|
|
|
function binarySearch1(nums, target) {
|
2023-01-11 14:44:32 +08:00
|
|
|
|
// 初始化左闭右开 [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 函数取整
|
2023-01-19 21:06:24 +08:00
|
|
|
|
if (nums[m] < target) // 此情况说明 target 在区间 [m+1, j) 中
|
2023-01-11 14:44:32 +08:00
|
|
|
|
i = m + 1;
|
2023-01-19 21:06:24 +08:00
|
|
|
|
else if (nums[m] > target) // 此情况说明 target 在区间 [i, m) 中
|
2023-01-11 14:44:32 +08:00
|
|
|
|
j = m;
|
|
|
|
|
else // 找到目标元素,返回其索引
|
|
|
|
|
return m;
|
2022-12-22 21:38:08 +08:00
|
|
|
|
}
|
2023-01-11 14:44:32 +08:00
|
|
|
|
// 未找到目标元素,返回 -1
|
|
|
|
|
return -1;
|
2022-12-22 21:38:08 +08:00
|
|
|
|
}
|
2022-12-03 01:31:29 +08:00
|
|
|
|
```
|
|
|
|
|
|
|
|
|
|
=== "TypeScript"
|
|
|
|
|
|
|
|
|
|
```typescript title="binary_search.ts"
|
2022-12-27 06:30:20 +08:00
|
|
|
|
/* 二分查找(左闭右开) */
|
|
|
|
|
const binarySearch1 = function (nums: number[], target: number): number {
|
|
|
|
|
// 初始化左闭右开 [0, n) ,即 i, j 分别指向数组首元素、尾元素+1
|
|
|
|
|
let i = 0, j = nums.length;
|
|
|
|
|
// 循环,当搜索区间为空时跳出(当 i = j 时为空)
|
|
|
|
|
while (i < j) {
|
2022-12-27 14:06:39 +08:00
|
|
|
|
const m = Math.floor(i + (j - i) / 2); // 计算中点索引 m
|
2023-01-19 21:06:24 +08:00
|
|
|
|
if (nums[m] < target) { // 此情况说明 target 在区间 [m+1, j) 中
|
2022-12-27 06:30:20 +08:00
|
|
|
|
i = m + 1;
|
2023-01-19 21:06:24 +08:00
|
|
|
|
} else if (nums[m] > target) { // 此情况说明 target 在区间 [i, m) 中
|
2022-12-27 06:30:20 +08:00
|
|
|
|
j = m;
|
2022-12-27 14:06:39 +08:00
|
|
|
|
} else { // 找到目标元素,返回其索引
|
2022-12-27 06:30:20 +08:00
|
|
|
|
return m;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
return -1; // 未找到目标元素,返回 -1
|
|
|
|
|
}
|
2022-12-03 01:31:29 +08:00
|
|
|
|
```
|
|
|
|
|
|
|
|
|
|
=== "C"
|
|
|
|
|
|
|
|
|
|
```c title="binary_search.c"
|
|
|
|
|
|
|
|
|
|
```
|
|
|
|
|
|
|
|
|
|
=== "C#"
|
|
|
|
|
|
|
|
|
|
```csharp title="binary_search.cs"
|
2022-12-23 15:42:02 +08:00
|
|
|
|
/* 二分查找(左闭右开) */
|
|
|
|
|
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
|
2023-01-19 21:06:24 +08:00
|
|
|
|
if (nums[m] < target) // 此情况说明 target 在区间 [m+1, j) 中
|
2022-12-23 15:42:02 +08:00
|
|
|
|
i = m + 1;
|
2023-01-19 21:06:24 +08:00
|
|
|
|
else if (nums[m] > target) // 此情况说明 target 在区间 [i, m) 中
|
2022-12-23 15:42:02 +08:00
|
|
|
|
j = m;
|
|
|
|
|
else // 找到目标元素,返回其索引
|
|
|
|
|
return m;
|
|
|
|
|
}
|
|
|
|
|
// 未找到目标元素,返回 -1
|
|
|
|
|
return -1;
|
|
|
|
|
}
|
2022-12-03 01:31:29 +08:00
|
|
|
|
```
|
|
|
|
|
|
2023-01-08 19:41:05 +08:00
|
|
|
|
=== "Swift"
|
|
|
|
|
|
|
|
|
|
```swift title="binary_search.swift"
|
2023-01-30 15:43:29 +08:00
|
|
|
|
/* 二分查找(左闭右开) */
|
|
|
|
|
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
|
|
|
|
|
}
|
2023-01-08 19:41:05 +08:00
|
|
|
|
```
|
|
|
|
|
|
2022-11-22 17:47:26 +08:00
|
|
|
|
### 两种表示对比
|
|
|
|
|
|
|
|
|
|
对比下来,两种表示的代码写法有以下不同点:
|
|
|
|
|
|
|
|
|
|
<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>
|
|
|
|
|
|
2022-12-21 01:37:58 +08:00
|
|
|
|
观察发现,在“双闭区间”表示中,由于对左右两边界的定义是相同的,因此缩小区间的 $i$ , $j$ 处理方法也是对称的,这样更不容易出错。综上所述,**建议你采用“双闭区间”的写法。**
|
2022-11-22 17:47:26 +08:00
|
|
|
|
|
|
|
|
|
### 大数越界处理
|
|
|
|
|
|
|
|
|
|
当数组长度很大时,加法 $i + j$ 的结果有可能会超出 `int` 类型的取值范围。在此情况下,我们需要换一种计算中点的写法。
|
|
|
|
|
|
2022-11-29 03:26:50 +08:00
|
|
|
|
=== "Java"
|
|
|
|
|
|
2022-12-03 01:31:29 +08:00
|
|
|
|
```java title=""
|
2022-11-29 03:26:50 +08:00
|
|
|
|
// (i + j) 有可能超出 int 的取值范围
|
|
|
|
|
int m = (i + j) / 2;
|
|
|
|
|
// 更换为此写法则不会越界
|
|
|
|
|
int m = i + (j - i) / 2;
|
|
|
|
|
```
|
2022-12-03 01:31:29 +08:00
|
|
|
|
|
2022-11-29 03:26:50 +08:00
|
|
|
|
=== "C++"
|
|
|
|
|
|
2022-12-03 01:31:29 +08:00
|
|
|
|
```cpp title=""
|
2022-11-29 03:26:50 +08:00
|
|
|
|
// (i + j) 有可能超出 int 的取值范围
|
|
|
|
|
int m = (i + j) / 2;
|
|
|
|
|
// 更换为此写法则不会越界
|
|
|
|
|
int m = i + (j - i) / 2;
|
|
|
|
|
```
|
|
|
|
|
|
|
|
|
|
=== "Python"
|
|
|
|
|
|
2022-12-03 01:31:29 +08:00
|
|
|
|
```py title=""
|
2022-12-04 01:43:58 +08:00
|
|
|
|
# Python 中的数字理论上可以无限大(取决于内存大小)
|
|
|
|
|
# 因此无需考虑大数越界问题
|
2022-11-29 03:26:50 +08:00
|
|
|
|
```
|
2022-11-22 17:47:26 +08:00
|
|
|
|
|
2022-12-03 01:31:29 +08:00
|
|
|
|
=== "Go"
|
|
|
|
|
|
|
|
|
|
```go title=""
|
2022-12-05 19:14:50 +08:00
|
|
|
|
// (i + j) 有可能超出 int 的取值范围
|
|
|
|
|
m := (i + j) / 2
|
|
|
|
|
// 更换为此写法则不会越界
|
|
|
|
|
m := i + (j - i) / 2
|
2022-12-03 01:31:29 +08:00
|
|
|
|
```
|
|
|
|
|
|
|
|
|
|
=== "JavaScript"
|
|
|
|
|
|
|
|
|
|
```js title=""
|
2022-12-23 01:17:37 +08:00
|
|
|
|
// (i + j) 有可能超出 int 的取值范围
|
|
|
|
|
let m = parseInt((i + j) / 2);
|
|
|
|
|
// 更换为此写法则不会越界
|
|
|
|
|
let m = parseInt(i + (j - i) / 2);
|
2022-12-03 01:31:29 +08:00
|
|
|
|
```
|
|
|
|
|
|
|
|
|
|
=== "TypeScript"
|
|
|
|
|
|
|
|
|
|
```typescript title=""
|
2022-12-27 06:30:20 +08:00
|
|
|
|
// (i + j) 有可能超出 Number 的取值范围
|
|
|
|
|
let m = Math.floor((i + j) / 2);
|
|
|
|
|
// 更换为此写法则不会越界
|
|
|
|
|
let m = Math.floor(i + (j - i) / 2);
|
2022-12-03 01:31:29 +08:00
|
|
|
|
```
|
|
|
|
|
|
|
|
|
|
=== "C"
|
|
|
|
|
|
|
|
|
|
```c title=""
|
|
|
|
|
|
|
|
|
|
```
|
|
|
|
|
|
|
|
|
|
=== "C#"
|
|
|
|
|
|
|
|
|
|
```csharp title=""
|
2022-12-24 17:05:58 +08:00
|
|
|
|
// (i + j) 有可能超出 int 的取值范围
|
2022-12-23 15:42:02 +08:00
|
|
|
|
int m = (i + j) / 2;
|
|
|
|
|
// 更换为此写法则不会越界
|
|
|
|
|
int m = i + (j - i) / 2;
|
2022-12-03 01:31:29 +08:00
|
|
|
|
```
|
|
|
|
|
|
2023-01-08 19:41:05 +08:00
|
|
|
|
=== "Swift"
|
|
|
|
|
|
|
|
|
|
```swift title=""
|
2023-01-30 15:43:29 +08:00
|
|
|
|
// (i + j) 有可能超出 int 的取值范围
|
|
|
|
|
let m = (i + j) / 2
|
|
|
|
|
// 更换为此写法则不会越界
|
|
|
|
|
let m = i + (j - 1) / 2
|
2023-01-08 19:41:05 +08:00
|
|
|
|
```
|
|
|
|
|
|
2022-11-22 17:47:26 +08:00
|
|
|
|
## 复杂度分析
|
|
|
|
|
|
2023-01-09 22:39:30 +08:00
|
|
|
|
**时间复杂度 $O(\log n)$** :其中 $n$ 为数组或链表长度;每轮排除一半的区间,因此循环轮数为 $\log_2 n$ ,使用 $O(\log n)$ 时间。
|
2022-11-22 17:47:26 +08:00
|
|
|
|
|
2023-01-09 22:39:30 +08:00
|
|
|
|
**空间复杂度 $O(1)$** :指针 `i` , `j` 使用常数大小空间。
|
2022-11-22 17:47:26 +08:00
|
|
|
|
|
2023-01-03 15:47:06 +08:00
|
|
|
|
## 优点与缺点
|
2022-11-22 17:47:26 +08:00
|
|
|
|
|
|
|
|
|
二分查找效率很高,体现在:
|
|
|
|
|
|
2023-01-07 20:34:32 +08:00
|
|
|
|
- **二分查找时间复杂度低**。对数阶在数据量很大时具有巨大优势,例如,当数据大小 $n = 2^{20}$ 时,线性查找需要 $2^{20} = 1048576$ 轮循环,而二分查找仅需要 $\log_2 2^{20} = 20$ 轮循环。
|
|
|
|
|
- **二分查找不需要额外空间**。相对于借助额外数据结构来实现查找的算法来说,其更加节约空间使用。
|
2022-11-22 17:47:26 +08:00
|
|
|
|
|
|
|
|
|
但并不意味着所有情况下都应使用二分查找,这是因为:
|
|
|
|
|
|
2023-01-07 20:34:32 +08:00
|
|
|
|
- **二分查找仅适用于有序数据**。如果输入数据是无序的,为了使用二分查找而专门执行数据排序,那么是得不偿失的,因为排序算法的时间复杂度一般为 $O(n \log n)$ ,比线性查找和二分查找都更差。再例如,对于频繁插入元素的场景,为了保持数组的有序性,需要将元素插入到特定位置,时间复杂度为 $O(n)$ ,也是非常昂贵的。
|
2023-01-19 18:46:41 +08:00
|
|
|
|
- **二分查找仅适用于数组**。由于在二分查找中,访问索引是 “非连续” 的,因此链表或者基于链表实现的数据结构都无法使用。
|
2023-01-07 20:34:32 +08:00
|
|
|
|
- **在小数据量下,线性查找的性能更好**。在线性查找中,每轮只需要 1 次判断操作;而在二分查找中,需要 1 次加法、1 次除法、1 ~ 3 次判断操作、1 次加法(减法),共 4 ~ 6 个单元操作;因此,在数据量 $n$ 较小时,线性查找反而比二分查找更快。
|