- 二分法
二分法的常见应用是在有序数组中搜索给定的某个目标值的索引，比起使用暴力搜索的方法，它能提供O(logn)的复杂度
二分查找框架1
int binarySearch(vector<int>& nums, int target) {
int left = 0;
int right = nums.size() - 1;
while (left <= right) {
int mid = (right - left) / 2;
if (nums[mid] > target)
...
else if (nums[mid] < target)
...
else if (nums[mid] == target)
...
}
return -1;
}
上面这种情况，对于数组中包含有重复的数值的情况就不太方便了，例如给定数组为[3,4,5,5,5,6,6,7]，当然可以先找到第一个符合条件索引，然后向左向右在搜索，但是这样的话，在极端情况下，搜索的时间复杂度就达不到对数级别的了。
对此可以衍生出二分查找的框架2和框架3
二分查找框架2-寻找左侧边界的二分搜索
int leftBound(vector<int>& nums, int target) {
if (nums.size() == 0) return -1;
int left = 0;
int right = nums.size() - 1;
while (left <= right) {
int mid = left + (right - left) / 2;
if (nums[mid] > target) {
right = mid - 1;
} else if (nums[mid] < target) {
left = mid + 1;
} else if (nums[mid] == target) {
right = mid - 1; //与前面一个不同，这里需要将区间缩小至左半部分，因为要求的是左侧边界
}
}
//target比所有数都大
if (left == nums.size()) return -1;
return nums[left] == target ? left : -1;
}
二分查找框架3-寻找右侧边界的二分搜索
int rightBound(vector<int>& nums, int target) {
if (nums.size() == 0) return -1;
int left = 0;
int right = nums.size();
while (left < right) {
//左闭右开
int mid = left + (right - left) / 2;
if (nums[mid] > target) {
right = mid;
} else if (nums[mid] < target) {
left = mid + 1;
} else {
//nums[mid] == target
left = mid + 1;
}
}
//return left - 1; //减一很关键
if (left == 0) return -1;
return nums[left -1] == target ? (left - 1) : -1;
}
题目
整数数组 nums 按升序排列，数组中的值 互不相同 。
在传递给函数之前，nums 在预先未知的某个下标 k（0 <= k < nums.length）上进行了 旋转，使数组变为 [nums[k], nums[k+1], …, nums[n-1], nums[0], nums[1], …, nums[k-1]]（下标 从 0 开始 计数）。例如， [0,1,2,4,5,6,7] 在下标 3 处经旋转后可能变为 [4,5,6,7,0,1,2] 。
给你 旋转后 的数组 nums 和一个整数 target ，如果 nums 中存在这个目标值 target ，则返回它的下标，否则返回 -1 。
示例 1：
输入：nums = [4,5,6,7,0,1,2], target = 0
输出：4示例 2：
输入：nums = [4,5,6,7,0,1,2], target = 3
输出：-1
示例 3：
输入：nums = [1], target = 0
输出：-1
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/search-in-rotated-sorted-array
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
解题
对于这样一个数组，一分为二，由此划分两个区间[left, mid]和[mid+1,right]，其中必定有一个区间的有序的，另外一个可能有序，也可能部分有序，有序部分二分查找，无序部分再一分为二，其中一个一定有序，另一个可能有序，可能无序。就这样一直循环下去。
class Solution {
public:
int search(vector<int>& nums, int target) {
int n = nums.size();
if (n == 0) return -1;
//对数组大小为0和1的情况直接做相应的处理
if (n == 1) return nums[0] == target ? 0 : -1;
int left = 0, right = n - 1;
while (left <= right) {
//左闭右闭的区间
//等价于mid = (left + right) / 2
//这样写可以防止数值越界
//假设left和right都是INT_MAX，那么left+right则会发生数值越界的情况
int mid = left + (right - left) / 2;
if (nums[mid] == target) return mid;
if (nums[left] <= nums[mid]) {
//左边有序
//判断target是否在[left, mid]区间中
//因为是闭区间所以下面left和right变化时需要加一或者减一
if (nums[left] <= target && target < nums[mid]) {
right = mid - 1; //在区间中，则缩小范围
} else {
left = mid + 1; //不在区间中，则对另外的区间重复前面过程
}
} else {
//右边有序
//处理过程与左边类似，只是区间缩小的方向不同
if (nums[mid] < target && target <=nums[right]) {
left = mid + 1;
} else {
right = mid - 1;
}
}
}
//没有找到target则返回-1
return -1;
}
};