LeetCode 704.二分查找
1、题目
题目链接：704. 二分查找
2、思路
这道题目是要在有序数组 nums 中找到目标值 target，符合二分查找的前提条件（线性表必须是有序的，且采用顺序存储）。同时题目还强调数组中无重复元素（若有重复元素，则使用二分查找法返回的元素下标可能不唯一）。
基于上述条件，这道题可以使用二分查找寻找目标值。
二分查找的做法是，定义查找的范围 [left, right]，初始查找范围是整个数组，每次取查找范围的中点 middle，比较 nums[middle] 和 target 的大小，如果相等，则 middle 就是要寻找的下标，如果 nums[middle] > target，则 target 只可能在 middle 的左侧，如果 nums[middle] < target，则 target 在 middle 的右侧。
这样每次查找都会将查找范围缩小一半，因此二分查找的时间复杂度是 O(logn)，其中 n 是数组的长度。
二分查找的条件是查找范围不为空，如果 target 在数组中，二分查找可以保证找到 target，返回 target 在数组中的下标。如果 target 不在数组中，则返回 -1。
3、二分法（左闭右闭区间）
代码：
class Solution {
public:
int search(vector<int>& nums, int target) {
// 避免当 target 小于 nums[0] 或者 target 大于 nums[nums.size() - 1] 时多次循环运算
if(nums[0] > target || nums[nums.size() - 1] < target) {
return -1;
}
int left = 0;
int right = nums.size() - 1; // 定义target在左闭右闭的区间里，[left, right]
while(left <= right) { // 当 left == right，区间 [left, right] 依然有效，所以用 <=
int middle = left + ((right - left) >> 1); // 防止溢出 等同于 (left + right)/2
if(nums[middle] == target) { // 找到目标值，直接返回下标
return middle;
}else if(nums[middle] < target) {
left = middle + 1; // target 在右区间，所以 [middle + 1, right]
}else { // nums[middle] > target
right = middle - 1; // target 在左区间，所以 [left, middle - 1]
}
}
return -1; // 未找到目标值
}
};
复杂度分析
- 时间复杂度：O(log n)
- 空间复杂度：O(1)
二分法（左闭右开区间）
代码：
class Solution {
public:
int search(vector<int>& nums, int target) {
// 避免当 target 小于 nums[0] 或者 target 大于 nums[nums.size() - 1] 时多次循环运算
if(nums[0] > target || nums[nums.size() - 1] < target) {
return -1;
}
int left = 0;
int right = nums.size(); // 定义 target 在左闭右开的区间里，[left, right)
while(left < right) { // 当 left == right时，在区间 [left, right)是无效的，所以用 <
int middle = left + ((right - left) >> 1); // 防止溢出 等同于(left + right)/2
if(nums[middle] == target) { // 找到目标值，直接返回下标
return middle;
}else if(nums[middle] < target) {
left = middle + 1; // target 在右区间，所以 [middle + 1, right)
}else { // nums[middle] > target
right = middle; // target 在左区间，所以 [left, middle)
}
}
return -1; // 未找到目标值
}
};
复杂度分析
- 时间复杂度：O(log n)
- 空间复杂度：O(1)
二分法（递归）(左闭右闭区间)
代码：
class Solution {
public:
int binary(vector<int>& nums, int left, int right, int target) {
if (nums[0] > target || nums[nums.size() - 1] < target) {
return -1;
}
if (left > right) {
return -1;
}
int middle = left + ((right - left) >> 1);
if (nums[middle] == target) {
return middle;
} else if(nums[middle] < target) {
return binary(nums, middle + 1, right, target);
} else {
return binary(nums, left, middle - 1, target);
}
}
int search(vector<int>& nums, int target) {
return binary(nums, 0, nums.size() - 1, target);
}
};
复杂度分析
- 时间复杂度：O(log n)
- 空间复杂度：O(log n)
二分法（递归）(左闭右开区间)
代码：
class Solution {
public:
int binary(vector<int>& nums, int left, int right, int target) {
if (nums[0] > target || nums[nums.size() - 1] < target) {
return -1;
}
if (left >= right) {
return -1;
}
int middle = left + ((right - left) >> 1);
if (nums[middle] == target) {
return middle;
} else if (nums[middle] < target) {
return binary(nums, middle + 1, right, target);
} else {
return binary(nums, left, middle, target);
}
}
int search(vector<int>& nums, int target) {
return binary(nums, 0, nums.size(), target);
}
};
复杂度分析
- 时间复杂度：O(log n)
- 空间复杂度：O(log n)
总结
二分查找有点类似分治思想。即每次都通过跟区间中的中间元素对比，将待查找的区间缩小为一半，直到找到要查找的元素，或者区间被缩小为 0。
二分查找的代码实现容易写错。需要注意三个容易出错的地方：
- 循环退出条件；
- middle 的取值；
- left 和 right 的更新。
二分查找虽然性能比较优秀，但应用场景也比较有限。底层必须依赖数组，并且还要求数据是有序的。如果数据未排序，则必须进行排序才能够使用。
对于其他的数据结构，例如链表，如果使用二分查找，每次比较都必须遍历链表寻找中间节点，时间复杂度会很高。
二分查找更适合处理静态数据，也就是没有频繁的数据插入、删除操作。而且，它更适合用在数据量较大的场景，如果数据量太小，直接顺序遍历即可。
