数组篇——二分查找
数组篇（一）——基于代码随想录
二分查找（leetcode704）
自己思路（顺序查找）
刚开始看到题目，直接感觉是查找类，可以用直接查找完成，由于先开始对vector的运用不熟，因此在官方文档查找有关函数：
发现是STL中的一员，作此顺序查找题解：
class Solution {
public:
int search(vector<int>& nums, int target) {
int n;
n = nums.size();
int number;
for(int i = 0 ; i < n ; i++)
{
if(nums[i]==target)
{
return i ;
}
}
return -1;
}
};
- 可是发现顺序查找的用时24ms,内存：26.9MB
- == 是判断关键
于是开始继续二分查找：
二分查找
- 思路：
使用二分查找的前提条件：
- 数组为有序数组；
- 数组中无重复元素；
由于二分查找的边界条件很多；
二分查找注意点：
- 明确区间的定义——不变量（使用while前找到循环不变量）
- 二分查找的区间一般两种：左闭右闭即[left, right]，或者左闭右开即[left, right)。
- 二分法使用
第一种——左闭右闭：
注意事项：
- while (left <= right) 要使用 <= ，因为left == right是有意义的，所以使用 <=
- if (nums[middle] > target) right 要赋值为 middle - 1，因为当前这个nums[middle]一定不是target，那么接下来要查找的左区间结束下标位置就是 middle - 1
代码：
class Solution {
public:
int search(vector<int>& nums, int target) {
int left = 0;
int right = nums.size()-1;
while(left<=right){
int middle = left + (right-left)/2;
if(nums[middle]>target){
right = middle -1;
}
else if(nums[middle]<target){
left = middle + 1;
}
else {
return middle;
}
}
return -1;
}
};
解释：
- 当left==right，区间[left, right]依然有效，所以用 <=
- 对right定义时表示的是左闭右闭
- 在定义middle时，防止溢出 等同于(left + right)/2
- 用时 24ms
- 内存 27MB
第二种——左闭右开：
注意事项：
- while (left < right)，这里使用 < ,因为left == right在区间[left, right)是没有意义的
- if (nums[middle] > target) right 更新为 middle，因为当前nums[middle]不等于target，去左区间继续寻找，而寻找区间是左闭右开区间，所以right更新为middle，即：下一个查询区间不会去比较nums[middle]
代码：
class Solution {
public:
int search(vector<int>& nums, int target) {
int left = 0;
int right = nums.size();
while (left < right) {
int middle = left + ((right - left) >> 1);
if (nums[middle] > target) {
right = middle; // target 在左区间，在[left, middle)中
} else if (nums[middle] < target) {
left = middle + 1; // target 在右区间，在[middle + 1, right)中
} else { // nums[middle] == target
return middle; // 数组中找到目标值，直接返回下标
}
}
// 未找到目标值
return -1;
}
};
解释：
- 对right定义时表示的是左闭右开
- 用时：36ms
- 内存：26.7MB
引申题目
35.搜索插入位置
- 自己思路：
初步设想是符合二分查找的两个条件（有序和不重复），然后分成两种情况；
一、target是序列之间的数；
则采用查找序列数return i；
二、target不是序列的数：
则直接return left。
但实现难点：
再对target是否在序列中的判断没有办法分开。
但是此路不通，可另辟蹊径——暴力顺序查找
class Solution {
public:
int searchInsert(vector<int>& nums, int target) {
for (int i = 0 ; i < nums.size();i++){
if(nums[i] >= target){
return i;
}
}
return nums.size();
}
};
失败的是不符合要求的时间复杂度
用时：8ms
内存：9.5MB
- 随想录思路：
也提到了这个暴力解法——提到了一种思考方式：
- 目标值在数组所有元素之前
- 目标值等于数组中某一个元素
- 目标值插入数组中的位置
- 目标值在数组所有元素之后
得出该时间复杂度——O(n)
空间复杂度——O(1)
于是通过二分法——降低时间复杂度：
——
- 第一种——左闭右闭：
先出代码：
class Solution {
public:
int searchInsert(vector<int>& nums, int target) {
int n = nums.size();
int left = 0;
int right = n - 1;
while(left<=right){
int middle = left + ((right-left)/2);
if(nums[middle]>target){
right = middle - 1;
}else if(nums[middle] < target){
left = middle + 1;
}else{
return middle;
}
}
return right + 1;
}
};
思考：
- 边界的选择：从以下四种情况开始考虑：
- 目标值在数组所有元素之前 [0, -1]；
- 目标值等于数组中某一个元素 return middle;
- 目标值插入数组中的位置 [left, right]，return right + 1；
- 目标值在数组所有元素之后的情况 [left, right]，——return right + 1；
- 此时的时间复杂度——O(logn)
- 空间复杂度——O(1)
- 第二种——左闭右开
代码：
class Solution {
public:
int searchInsert(vector<int>& nums, int target) {
int n = nums.size();
int left = 0;
int right = n; // 定义target在左闭右开的区间里，[left, right) target
while (left < right) { // 因为left == right的时候，在[left, right)是无效的空间
int middle = left + ((right - left) >> 1);
if (nums[middle] > target) {
right = middle; // target 在左区间，在[left, middle)中
} else if (nums[middle] < target) {
left = middle + 1; // target 在右区间，在 [middle+1, right)中
} else { // nums[middle] == target
return middle; // 数组中找到目标值的情况，直接返回下标
}
}
// 分别处理如下四种情况
// 目标值在数组所有元素之前 [0,0)
// 目标值等于数组中某一个元素 return middle
// 目标值插入数组中的位置 [left, right) ，return right 即可
// 目标值在数组所有元素之后的情况 [left, right)，return right 即可
return right;
}
};
注意要点：
- left < right ，即表示left == right 是无效的空间会导致程序进入死循环——出现超时现象。
- 最后是return right ——也是因为该输出是一个开区间。
- 用时：4ms
- 内存：9.3MB
- 时间空间复杂度与第一种相同。
34 在排序数组中查找元素的第一个和最后一个位置
思路：
依旧是分情况讨论：
- target在数组范围外——包括范围的左边或右边——return [-1,-1]
- target在数组范围内，但不是数组的数——return [-1,-1]
- target在数组范围内，且是数组的数——例如数组{3,6,7},target为6，此时应该返回{1, 1}
因此用两个二分法去寻找左右边界。
确定右边界——（此处右边界是不包含target的右边界）
getRightBorder(nums,target);
确定左边界：
getleftBorder(nums,target);
class Solution {
public:
vector<int> searchRange(vector<int>& nums, int target) {
int rightBorder = getRightBorder(nums,target);
int leftBorder = getLeftBorder(nums,target);
if(leftBorder == -2 || rightBorder == -2) return {-1,-1};
if (rightBorder-leftBorder > 1) return {leftBorder+1,rightBorder-1};
return{-1,-1};
}
private:
int getRightBorder(vector<int>& nums,int target){
int left = 0;
int right = nums.size() - 1;
int rightBorder = -2;
while(left <= right){
int middle = left + ((right-left)/2);
if(nums[middle]>target){
right = middle - 1;
}else{
left = middle + 1;
rightBorder = left;
}
}
return rightBorder;
}
int getLeftBorder(vector<int>&nums,int target){
int left = 0;
int right = nums.size() - 1;
int leftBorder = -2;
while(left <= right){
int middle = left + ((right-left)/2);
if(nums[middle]>=target){
right = middle -1;
leftBorder = right;
}else{
left = middle + 1;
}
}
return leftBorder;
}
};
注意点：
-
return 用{}即表示Lambda表达式捕获列表——1. &，函数体内可以使用Lambda所在作用范围内所有可见的局部变量（包括Lambda所在类的this），并且是引用传递方式（相当于编译器自动为我们按引用传递了所有局部变量），不过要注意是const引用。2. this，函数体内可以使用Lambda所在类中的成员变量。
-
寻找左边界和右边界的条件不同——寻找边界需要在
nums[middle] == target的时候，因此在寻找右边界的条件时，需要在left处更新，则条件是nums[middle]<=target时，而寻找左边界则是在nums[middle]>=target时。
-
想清楚三种情况之后，先专注于寻找右区间，然后专注于寻找左区间，左右根据左右区间做最后判断。
总结
二分法最重要的就是对区间的划分，可以先把各种情况写明后再表示出他的输出值。
998
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
