二分查找法介绍
首先，什么是二分查找法?
二分查找也称折半查找（Binary Search），它是一种效率较高的查找方法。但是，折半查找要求线性表必须采用顺序存储结构，而且表中元素按关键字有序排列
二分查找的执行过程如下
1.从已经排好序的数组或区间中，取出中间位置的元素，将其与我们的目标值进行比较，判断是否相等，如果相等
则返回。
2.如果 nums[mid] 和 target 不相等，则对 nums[mid] 和 target 值进行比较大小，通过比较结果决定是从 mid
的左半部分还是右半部分继续搜索。如果 target > nums[mid] 则右半区间继续进行搜索，即 left = mid + 1; 若
target < nums[mid] 则在左半区间继续进行搜索，即 right = mid -1；
动图解析
JavaScript代码实现
function binarySearch(arr,target){
if(!arr.length) return -1;// 考虑边界值
if(arr.length == 1)return 0;//只有一位无需进入循环
let start = 0;
let end = arr.length-1;
while(start <= end){
let mid = Math.floor((start + end) / 2);//取中位数，可能除不尽向下取整
if(arr[mid] === target){
return mid;
}else if(target > arr[mid]){// 若目标值大于中位值
start = mid +1 //则说明目标值在更右侧，将初始下标右移至中位数右侧，再次循环
}else{// 若目标值小于中位值
end = mid -1 //则说明目标值在更左侧，将结束下标左移至中位数左侧，再次循环
}
}
return -1
}
34. 在排序数组中查找元素的第一个和最后一个位置
给定一个按照升序排列的整数数组 nums，和一个目标值 target。找出给定目标值在数组中的开始位置和结束位置。
如果数组中不存在目标值 target，返回 [-1, -1]。
进阶：
你可以设计并实现时间复杂度为 O(log n) 的算法解决此问题吗？
示例 1：
输入：nums = [5,7,7,8,8,10], target = 8 输出：[3,4]
示例 2：
输入：nums = [5,7,7,8,8,10], target = 6 输出：[-1,-1]
示例 3：
输入：nums = [], target = 0 输出：[-1,-1]
提示：
0 <= nums.length <= 105 -109 <= nums[i] <= 109 nums 是一个非递减数组 -109 <= target <= 109
解题代码
/**
* @param {number[]} nums
* @param {number} target
* @return {number[]}
*/
var searchRange = function(nums, target) {
let res = [-1, -1];
// 特殊情况：非数组、空数组
if(!Array.isArray(nums) || !nums.length) return res;
else {
// 遍历到中间偏右
for(let i = 0, len = nums.length; i< parseInt(len/2)+1; i++) {
// 头部开始向中间查找
if(nums[i] === target) {
res[0] = res[0] < 0 || res[0] > i ?i: res[0];
res[1] = res[1] < 0 || res[1] < i? i: res[1];
}
// 尾部开始向中间查找
if(nums[len - 1 - i] === target) {
res[0] = res[0] < 0 || res[0] > i? (len-1-i): res[0];
res[1] = res[1] < (len-1-i)? (len-1-i): res[1];
}
}
return res;
}
};
33. 搜索旋转排序数组
整数数组 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
提示：
- 1 <= nums.length <= 5000
- -10^4 <= nums[i] <= 10^4
- nums 中的每个值都 独一无二
- 题目数据保证 nums 在预先未知的某个下标上进行了旋转
- -10^4 <= target <= 10^4
进阶：你可以设计一个时间复杂度为 O(log n) 的解决方案吗？\
题解思路
可以发现的是，我们将数组从中间分开成左右两部分的时候，一定有一部分的数组是有序的。拿示例来看，我们从 6 这个位置分开以后数组变成了 [4, 5, 6] 和 [7, 0, 1, 2] 两个部分，其中左边 [4, 5, 6] 这个部分的数组是有序的，其他也是如此。
这启示我们可以在常规二分查找的时候查看当前 mid 为分割位置分割出来的两个部分 [l, mid] 和 [mid + 1, r] 哪个部分是有序的，并根据有序的那个部分确定我们该如何改变二分查找的上下界，因为我们能够根据有序的那部分判断出 target 在不在这个部分：
- 如果 [l, mid - 1] 是有序数组，且 target 的大小满足 [\textit{nums}[l],\textit{nums}[mid])[nums[l],nums[mid])，则我们应该将搜索范围缩小至 [l, mid - 1]，否则在 [mid + 1, r] 中寻找。
- 如果 [mid, r] 是有序数组，且 target 的大小满足 (\textit{nums}[mid+1],\textit{nums}[r]](nums[mid+1],nums[r]]，则我们应该将搜索范围缩小至 [mid + 1, r]，否则在 [l, mid - 1] 中寻找。
解题代码
/**
* @param {number[]} nums
* @param {number} target
* @return {number}
*/
var search = function(nums, target) {
// 特殊情况： 非数组或空数组
if(!Array.isArray(nums) || !nums.length) return -1;
else{
// 查找数组的起点和终点坐标
let left = 0, right = nums.length-1;
// 数组仅有一个值
if(nums.length == 1) return target == nums[0]? 0: -1;
// 目标值在数组的头部或尾部
else if(nums[0] == target || nums[right] == target) return target == nums[0]? 0: right;
// 目标值在数组中间或者不存在
while(left<=right) {
let mid = left + ((right - left) >> 1);
if(nums[mid] == target) return mid;
if(nums[0] < nums[mid]){
if (nums[0] <= target && target < nums[mid]) {
right = mid - 1;
} else {
left = mid + 1;
}
}
else{
if (nums[mid] < target && target <= nums[nums.length - 1]) {
left = mid + 1;
} else {
right = mid - 1;
}
}
}
}
};
74. 搜索二维矩阵
编写一个高效的算法来判断
m x n矩阵中，是否存在一个目标值。该矩阵具有如下特性：
- 每行中的整数从左到右按升序排列。
- 每行的第一个整数大于前一行的最后一个整数。
示例 1：
输入： matrix = [[1,3,5,7],[10,11,16,20],[23,30,34,60]], target = 3
输出： true
示例 2：
输入： matrix = [[1,3,5,7],[10,11,16,20],[23,30,34,60]], target = 13
输出： false
提示：
m == matrix.lengthn == matrix[i].length1 <= m, n <= 100-104 <= matrix[i][j], target <= 104
解题代码
/**
* @param {number[][]} matrix
* @param {number} target
* @return {boolean}
* 判断 m x n 矩阵中，是否存在一个目标值。
*/
var searchMatrix = function(matrix, target) {
// 特殊情况： 非数组或空数组
if(!Array.isArray(matrix) || !matrix.length || !matrix[0].length) return false;
else {
let row = matrix.length, col = matrix[0].length, left = 0, right = (row * col) - 1;
while(right >= left){
// 避免数值溢出，使用位运算 >> 相当于 (right+left)/2
let mid = left + ((right-left) >> 1);
// 将二维数组转为一维数组坐标
let rownum = parseInt( mid / col), colnum = mid % col;
// 如果中间值即是目标值
if(matrix[rownum][colnum] == target) {
return true;
}
// 如果目标值比中间值小，则终点位置向左移一位
else if(matrix[rownum][colnum] > target) {
right = mid - 1;
}
// 如果目标值比中间值大，则起点位置向右移一位
else if(matrix[rownum][colnum] < target){
left = mid + 1;
}
}
return false;
}
};
参考文献来源：力扣（LeetCode）
