二分查找算法

一、概念

        二分查找要求数组1）采用顺序存储结构，元素能够随机读取；2）必须按照关键字大小有序排列，从而可以在O（log2n）的时间复杂度解决问题。二分查找的常用场景：寻找一个数、寻找左侧边界、寻找右侧边界。

二、二分查找的框架

int binarySearch(vector<int> nums, int target) {
    int left = 0, right = ...;
    while(...) {
        int mid = (right + left) / 2;
        if (nums[mid] == target) {
            ...
        } else if (nums[mid] < target) {
            left = ...
        } else if (nums[mid] > target) {
            right = ...
        }
    }
    return ...;
}

注：1）不用else，把所有情况用else if写清楚，清晰展现所有细节。2）计算mid时为了防止溢出，可以写成mid = left + (right - left) / 2。

三、寻找一个数（基本的二分搜索）

        给定一个有序数组，搜索一个指定的数target，如果存在返回索引，不存在返回-1。

int binarySearch(vector<int> nums, int target) {
    int left = 0; 
    int right = nums.size() - 1;       // 搜索区间为左闭右闭[left,right] 
    while(left <= right) {             // 由于搜索区间为左闭右闭[left,right]，left==right仍在 
                                       // 搜索区间内
        int mid = (right + left) / 2;
        if(nums[mid] == target)
            return mid; 
        else if (nums[mid] < target)
            left = mid + 1;            
        else if (nums[mid] > target)
            right = mid - 1;           // 因为mid已经搜索过了，所以要搜索 [left, mid - 1] 或者 
                                       // [mid + 1, right] 
    }
    return -1;
}

 四、寻找左侧边界的二分搜索

        1、对于搜索左右侧边界的二分查找，一般采用左闭右开的写法，如下：

int binarySearch(vector<int> nums, int target) {
    if (nums.size == 0) return -1;
    int left = 0; 
    int right = nums.size();           // 搜索区间为左闭右开[left,right) 
    while(left < right) {              // 由于搜索区间为左闭右开[left,right)，left==right时 
                                       // 搜索区间[left,left)为空，所以可以正确终止
        int mid = (right + left) / 2;
        if(nums[mid] == target)
            right = mid;               // 缩小搜索区间的上界right，在[left,mid]中继续搜索
        else if (nums[mid] < target)
            left = mid + 1;            
        else if (nums[mid] > target)
            right = mid;               // 因为搜索区间是左闭右开[left,right)，当nums[mid]被 
                                       // 检测之后，下一步的搜索区间去掉mid分割成两个区间
    }                                  // 即[left, mid)或[mid + 1,right)。 
    return left;
}

对于target不存在于nums中的情况，函数的返回值（即 left 变量的值）取值区间是闭区间 [0, nums.length]，所以我们简单添加两行代码就能在正确的时候 return -1：

while (left < right) {
    //...
}
// target 比所有数都大
if (left == nums.length) return -1;
// 类似之前算法的处理方式
return nums[left] == target ? left : -1;

2、也可以采用左闭右闭的搜索区间，这样与基本的二分搜索写法相统一，由于其while

的退出条件是left == right +１；所以当 target 比 nums 中所有元素都大时，会存在索引越界的情况。

int left_bound(int[] nums, int target) {
    int left = 0, right = nums.length - 1;
    // 搜索区间为 [left, right]
    while (left <= right) {
        int mid = left + (right - left) / 2;
        if (nums[mid] < target) {
            // 搜索区间变为 [mid+1, right]
            left = mid + 1;
        } else if (nums[mid] > target) {
            // 搜索区间变为 [left, mid-1]
            right = mid - 1;
        } else if (nums[mid] == target) {
            // 收缩右侧边界
            right = mid - 1;
        }
    }
    // 检查出界情况
    if (left >= nums.length || nums[left] != target) {
        return -1;
    }
    return left;
}

五、寻找右侧边界的二分查找

类似寻找左侧边界的算法，这里也会提供两种写法，还是先写常见的左闭右开的写法，只有两处和搜索左侧边界不同，已标注：

int right_bound(int[] nums, int target) {
    if (nums.length == 0) return -1;
    int left = 0, right = nums.length;
    
    while (left < right) {
        int mid = left + (right - left) / 2;
        if (nums[mid] == target) {
            left = mid + 1; // 注意
        } else if (nums[mid] < target) {
            left = mid + 1;
        } else if (nums[mid] > target) {
            right = mid;
        }
    }
    return left - 1; // 注意
}

        类似之前的左侧边界搜索，因为 while 的终止条件是 left == right，就是说 left 的取值范围是 [0, nums.length]，所以可以添加两行代码，正确地返回 -1： 

while (left < right) {
    // ...
}
if (left == 0) return -1;
return nums[left-1] == target ? (left-1) : -1;

六、LeetCode例题

７０４．二分查找

３４.　对数的左右侧边界的二分查找

２４０.搜索二维矩阵Ⅱ

３３.旋转数组

参考：

我写了首诗，让你闭着眼睛也能写对二分搜索 :: labuladong的算法小抄