题目

在这里插入图片描述

解题

版本一、二、三：区间为 [left, right]，right 初始值为 nums.length - 1。
版本四、五：区间为 [left, right)，right 初始值为 nums.length。

二分查找细节详解，顺便赋诗一首有很多细节分析，如果的各种版本看着很绕，可以先去读读文章。或者看看二分查找模板分析 & LeetCode34 在排序数组中查找元素的第一个和最后一个位置对几个模板的分析。

其实，二分查找不用掌握每个模板，个人是因为看到各种二分查找题解里又相似又不同的写法，彻底看懵了，所以狠了狠心来瞧瞧究竟它们都遵循了什么章法。

版本一

// javascript
var search = function(nums, target) {
    let left = 0, right = nums.length - 1;
    while (left <= right) {
        const mid = left + ((right - left) >> 1);
        if (nums[mid] === target) return mid;
        else if (nums[mid] > target) right = mid - 1; // [left, mid - 1]
        else left = mid + 1;                          // [mid + 1, right]
    }
    return -1; // 没找到，返回 -1 
};

版本二

如果 nums 里有多个 target，left 是其出现的第一个位置，如果没有 target，left 是 target 应该在数组中插入的位置。

// javascript
var search = function(nums, target) {
    let left = 0, right = nums.length - 1;
    while (left <= right) {
        const mid = left + ((right - left) >> 1);
        if (nums[mid] >= target) {
            right = mid - 1;
        }
        else {
            left = mid + 1;
        }
    }
    // 如果没有 target，left 是 target 应该在数组中插入的位置
    // 所以判断一下 nums[left] 是不是 target
    return nums[left] === target ? left : -1;
};

版本三

如果 nums 里有多个 target，right 是其出现的最后一个位置，如果没有 target，right 是 target 应该在数组中插入的位置的前一个位。

// javascript
var search = function(nums, target) {
    let left = 0, right = nums.length - 1;
    while (left <= right) {
        const mid = left + ((right - left) >> 1);
        if (nums[mid] <= target) {
            left = mid + 1;
        }
        else {
            right = mid - 1;            
        }
    }
    return nums[right] === target ? right : -1;
};

版本四

与版本二一样，如果 nums 里有多个 target，left / right 是其出现的第一个位置，如果没有 target，left / right 是 target 应该在数组中插入的位置。

// javascript
var search = function(nums, target) {
    let left = 0, right = nums.length;
    while (left < right) {
        const mid = left + ((right - left) >> 1);
        // nums[mid] = target, right = mid; [left, mid) 排除 mid
        // nums[mid] > target, right = mid; [left, mid) => [left, mid - 1]
        if (nums[mid] >= target) {
            right = mid;
        }
        else {
            left = mid + 1;           
        }
    }
    // left = right
    // return nums[right] === target ? right : -1;
    return nums[left] === target ? left : -1;
};

版本五

与版本三一样，如果 nums 里有多个 target，left - 1 / right - 1 是其出现的最后一个位置，如果没有 target，left - 1 / right - 1 是 target 应该在数组中插入的位置的前一个位。

// javascript
var search = function(nums, target) {
    let left = 0, right = nums.length;
    while (left < right) {
        const mid = left + ((right - left) >> 1);
        // nums[mid] = target, left = mid; [mid + 1, right) 排除 mid
        // nums[mid] < target, left = mid + 1;
        if (nums[mid] <= target) {
            left = mid + 1;
        }
        else {
            right = mid;   
        }
    }
    // left = right
    // return nums[right - 1] === target ? right - 1 : -1;
    return nums[left - 1] === target ? left - 1 : -1;
};

版本六

版本六就是版本四将 right 初始值修改为 nums.length - 1，意为在 [left, right] 中查找

（符合）如果 nums 里有多个 target，left / right 是其出现的第一个位置
（不完全符合）如果没有 target，left / right 是 target 应该在数组中插入的位置
- （例外）nums = [0,1,2,3], target = 5 时, left = right = 3 是应该在数组中插入的位置前一个位置

因为第一条是符合的，所以可以用来查找 target。

// javascript
var search = function(nums, target) {
    let left = 0, right = nums.length;
    while (left < right) {
        const mid = left + ((right - left) >> 1);
        // nums[mid] = target, right = mid;
        // nums[mid] > target, right = mid - 1;
        if (nums[mid] >= target) {
        	// [left, mid]
            right = mid;
        }
        else {
        	// [mid + 1, right]
            left = mid + 1;           
        }
    }
    // left = right
    // return nums[right] === target ? right : -1;
    return nums[left] === target ? left : -1;
};

版本七

版本七 right 初始值为 nums.length - 1，意为在 [left, right] 中查找。mid 计算因为区间是 [mid, right] / [left, mid - 1]，所以采用上取整。

（符合）如果 nums 里有多个 target，left / right 是其出现的最后一个位置
（不完全符合）如果没有 target，left / right 是 target 应该在数组中插入的位置前一个位置
- （例外）nums = [0,1,2,3], target = -1 时, left = right = 0 是在数组中插入的位置

同样的，因为第一条是符合的，所以用来查找 target是完全没问题的。

// javascript
var search = function(nums, target) {
    let left = 0, right = nums.length - 1; // 初始值
    while (left < right) {
        const mid = left + ((right - left + 1) >> 1);
        // nums[mid] = target, left = mid;
        // nums[mid] < target, left = mid + 1;
        if (nums[mid] <= target) {
        	// [mid, right]
            left = mid;
        }
        else {
        	// [left, mid - 1]
            right = mid - 1;          
        }
    }
    // left = right
    // return nums[right] === target ? right : -1;
    return nums[left] === target ? left : -1;
};