704. （Binary Search）二分查找

题目：

Given an array of integers nums which is sorted in ascending order, and an integer target, write a function to search target in nums. If target exists, then return its index. Otherwise, return -1.

You must write an algorithm with O(log n) runtime complexity.

给定一个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target ，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1。

Example 1:

Input: nums = [-1,0,3,5,9,12], target = 9
Output: 4
Explanation: 9 exists in nums and its index is 4
Example 2:

示例 1:

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

Example 2:

Input: nums = [-1,0,3,5,9,12], target = 2
Output: -1
Explanation: 2 does not exist in nums so return -1

示例 2:

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

Constraints:

1 <= nums.length <= $10^4$
-$10^4$ < nums[i], target < $10^4$
All the integers in nums are unique.
nums is sorted in ascending order.

提示：

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

解题思路：

方法：二分查找

• 如果目标值等于中间元素，则找到目标值。
• 如果目标值较小，继续在左侧搜索。
• 如果目标值较大，则继续在右侧搜索。

我们根据题目可知这个数组nums是个个数为n的升序整形数组，由此我们定义数组第一个下标 left = 0, 最后一个下标right = n - 1，数组中间元素nums[mid]。

比较中间元素 nums[mid] 和目标值 target 。

• 当 target = nums[mid]，返回 mid。
• 当 target < nums[mid]，则向左侧移动 right = mid - 1。
• 当target > nums[mid]，则向右侧移动 left = mid + 1。

Python代码

class Solution:
    def search(self, nums: List[int], target: int) -> int:
        left,right=0,len(nums)-1
        
        while left<=right:
            mid=left + (right - left)//2  # 避免left+right溢出
            if nums[mid]==target:
                return mid
            if nums[mid]>target:
                right=mid-1
            else:
                left=mid+1
        return -1

Java代码

class Solution {
    public int search(int[] nums, int target) {
        int left = 0, right = nums.length - 1;
        while(left<=right) {
            int mid = left + (right - left) / 2; # 避免left+right溢出
            if(nums[mid] > target) {
                right = mid - 1;
            } else if(nums[mid] < target) {
                left = mid + 1;
            } else {
                return mid;
            }
        }
        return -1;
    }
}

C++代码

class Solution {
public:
    int search(vector<int>& nums, int target) {
        int left = 0;
        int right = nums.size() - 1; 
        while (left <= right) { 
            int mid = left + ((right - left) / 2); // 避免left+right溢出
            if (nums[mid] > target) {
                right = mid - 1; 
            } else if (nums[mid] < target) {
                left = mid + 1; 
            } else { 
                return mid; 
            }
        }
        return -1;
    }
};

复杂度分析

时间复杂度：O($lo{g}_n$)，其中 n 是数组的长度。

空间复杂度：O(1)。我们只要保存若干变量。