2020-1-8

1.第一题

项目场景：

给定一个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target ，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1。
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/binary-search

问题描述：

输入: nums = [-1,0,3,5,9,12], target = 9
输出: 4
解释: 9 出现在 nums 中并且下标为 4

输入: nums = [-1,0,3,5,9,12], target = 2
输出: -1
解释: 2 不存在 nums 中因此返回 -1

提示：
你可以假设 nums 中的所有元素是不重复的。
n 将在 [1, 10000]之间。
nums 的每个元素都将在 [-9999, 9999]之间。

解决方案：

因为是一个升序数组，二分查找每次缩小一半，当不存在另一半时即可继续循环直到找到或者找完，相比较从头循环遍历时间复杂度更低，所以使用二分查找较为快捷。
二分查找先找到数组最高的下标（high）与最低下标（low）–>【中间项mid=(low+high)/2+low,num=nums[mid]–>if(num==目标值)进行输出else if(num<目标值)将最低下标（low）换成中间值+1，else将最高下标换成中间值-1；以此循环】

代码：

var search = function(nums, target) {
    let low=0,high=nums.length-1;
    while(low<=high){
        let mid=Math.floor((high-low)/2)+low
        //此处因为是用js写的所以要进行取整操作
        let num=nums[mid]
        if(num==target)
        {
            return mid;
        }else if(num<target){
            low=mid+1
        }else{
            high=mid-1
        }
    }
    return -1
};

2. 第二题

项目场景：

你是产品经理，目前正在带领一个团队开发新的产品。不幸的是，你的产品的最新版本没有通过质量检测。
由于每个版本都是基于之前的版本开发的，所以错误的版本之后的所有版本都是错的。
假设你有 n 个版本 [1, 2, ..., n]，你想找出导致之后所有版本出错的第一个错误的版本。
你可以通过调用 bool isBadVersion(version) 接口来判断版本号 version 是否在单元测试中出错。
实现一个函数来查找第一个错误的版本。你应该尽量减少对调用 API 的次数。
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/first-bad-version

问题描述：

	示例 1：
	输入：n = 5, bad = 4
	输出：4
	解释：
	调用 isBadVersion(3) -> false 
	调用 isBadVersion(5) -> true 
	调用 isBadVersion(4) -> true
	所以，4 是第一个错误的版本。

	示例 2：
	输入：n = 1, bad = 1
	输出：1

	提示：
	1 <= bad <= n <= 231 - 1

解决方案：

和上一题一样，因为版本号是递增的，所以查找错误的版本号选用二分法最为合适，而与上一题不同则是该题是错误的版本号之后的版本号都为错误，所以循环结束条件改为当左边和右边相同时结束循环，此时左边=右边=第一个错误的版本号，而if判断正确时，则说明第一个错误的版本号在低位，则将二分查找的高位改为中间位，此时不能将高位改为中间位-1，因为此时的中间位也有可能就是第一个错误的版本号，不能够进行排除。

代码：

/**
 1. Definition for isBadVersion()
 2. 
 3. @param {integer} version number
 4. @return {boolean} whether the version is bad
 5. isBadVersion = function(version) {
 6.     ...
 7. };
 */
/**
 8. @param {function} isBadVersion()
 9. @return {function}
 */
var solution = function(isBadVersion) {
    /**
     * @param {integer} n Total versions
     * @return {integer} The first bad version
     */
    return function(n) {
        let left=1,right=n
        while(left<right){
            let mid=Math.floor((right-left)/2+left)
            if(isBadVersion(mid)){
                right=mid;
            }else{
                left=mid+1;
            }
        }
        return left
    };
};

3.第三题

项目场景：

给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。
请必须使用时间复杂度为 O(log n) 的算法。
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/search-insert-position

问题描述：

示例 1:
	输入: nums = [1,3,5,6], target = 5
	输出: 2
示例 2:
	输入: nums = [1,3,5,6], target = 2
	输出: 1
示例 3:
	输入: nums = [1,3,5,6], target = 7
	输出: 4
示例 4:
	输入: nums = [1,3,5,6], target = 0
	输出: 0
示例 5:
	输入: nums = [1], target = 0
	输出: 0
提示:
	1 <= nums.length <= 104
	-104 <= nums[i] <= 104
	nums 为无重复元素的升序排列数组
	-104 <= target <= 104

解决方案：

与第一题一样，只是多了一个条件要输出插入的位置，其实就是进行逼近查找第一个大于目标值的下标；如果相等则结果就是中间值，如果中间值>目标值，则让结果等于中间值，右边界=中间值-1；相反中间值<目标值，则让左边界=中间值-1即可，进行以上的循环。

代码：

var searchInsert = function(nums, target) {
    let left=0 ,right=nums.length-1
    let result=right+1
    while(left<=right){
        let mid=Math.floor(right-left)+left
        
      /*该方法要更优
      if(nums[mid]>=target){
            result=mid
            right=mid-1
        }else{
            left=mid+1
        }*/
        if(nums[mid]==target){
            result=mid
            break;
        }else if(nums[mid]>target){
            result=mid
            right=mid-1
        }else{
            left=mid+1
        }
    }
    return result
};