二分查找算法

二分查找：

问题描述：

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

@Override
        public void run() {
            bytes = mmInStream.read(buffer);
            mHandler.obtainMessage(READ_DATA, bytes, -1, buffer).sendToTarget();
        }

---

思路分析：

1. 初始变量：left=0,right=n-1,mid=(left+right)/2;
2. 当 $target>nums[right]||target<nums[left]$，不存在；(可有可无，只是觉得速度会变快)
3. 当 left <=right,循环，
   当$target==nums[mid]$,找到目标，返回坐标；
   当$target<nums[mid],right=mid-1$;
   当$target>nums[mid],left=mid+1$
4. 没找到目标，返回-1

代码：

1. C++

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

        }
        return -1;
    }
};

2. Java

class Solution {
  public int search(int[] nums, int target) {
    int pivot, left = 0, right = nums.length - 1;
    while (left <= right) {
      pivot = left + (right - left) / 2;
      if (nums[pivot] == target) return pivot;
      if (target < nums[pivot]) right = pivot - 1;
      else left = pivot + 1;
    }
    return -1;
  }
}

作者：LeetCode
链接：https://leetcode-cn.com/problems/binary-search/solution/er-fen-cha-zhao-by-leetcode/
来源：力扣（LeetCode）

1. Python

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

作者：LeetCode
链接：https://leetcode-cn.com/problems/binary-search/solution/er-fen-cha-zhao-by-leetcode/
来源：力扣（LeetCode）

使用案例：

1. 寻找第一个错误的版本
   问题描述：
   你是产品经理，目前正在带领一个团队开发新的产品。不幸的是，你的产品的最新版本没有通过质量检测。由于每个版本都是基于之前的版本开发的，所以错误的版本之后的所有版本都是错的。

假设你有 n 个版本 [1, 2, …, n]，你想找出导致之后所有版本出错的第一个错误的版本。

你可以通过调用 bool isBadVersion(version) 接口来判断版本号 version 是否在单元测试中出错。实现一个函数来查找第一个错误的版本。你应该尽量减少对调用 API 的次数。

算法流程：
a、因为版本是有序的，所以可以用二分法来处理。$left=1,right=n$。
b、当$left<right$，循环

• $mid=left+(right-left)/2$;(防止内存泄漏，如果改成$(right+left)/2$, 就会造成内存泄漏，因为当right和left接近int类型的，那么right+left和超出int型内存，就会报错。)
• 如果$isBadVersion(mid)$是错误版本，那么搜索范围缩小到$[left,mid]$ ,否则，在$[mid+1,right]$

c、当 $left=right$ 时，就是第一个错误版本。

2. 代码

// The API isBadVersion is defined for you.
// bool isBadVersion(int version);
// C++代码
class Solution {
public:
    int firstBadVersion(int n) {
        int left = 1;
        int right = n;
        int mid;
        while (left<right){
            mid = left +(right - left) / 2;
            if(isBadVersion(mid)){
                right = mid;
            }
            else {
                left = mid + 1;
            }
        }
        return left;
    }
};

// Java代码
public class Solution extends VersionControl {
    public int firstBadVersion(int n) {
        int left = 1, right = n;
        while (left < right) { // 循环直至区间左右端点相同
            int mid = left + (right - left) / 2; // 防止计算时溢出
            if (isBadVersion(mid)) {
                right = mid; // 答案在区间 [left, mid] 中
            } else {
                left = mid + 1; // 答案在区间 [mid+1, right] 中
            }
        }
        // 此时有 left == right，区间缩为一个点，即为答案
        return left;
    }
}

复杂度分析

时间复杂度：$O(\log n)$，其中 n 是给定版本的数量。

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