二分查找算法之详解

相信很多人和我一样，接触到的第一个算法就是二分查找法，这种算法使用的前提条件是有序排列的数字，算法复杂度是O(log(n))，这也就说明了数据量越大，二分查找算法的优势越明显。

二分查找的思想很简单，就是每次都会舍去一半的数据，大大提高了算法效率。

二分查找模板：

int low=0,high=(...);
while(...)
{
    int mid = ( high-low ) / 2+low;
    if(condition target)
        return (...);
    else if(condition one)
        high = (...);
    else
        low = (...);
}

下面介绍二分算法

前提条件：

• 有序数组

• 无重复元素

注意：

1. 取中值mid时，小心越界问题

int mid = (left + right)/2;            //left+right可能会出现溢出int
int mid = (right - left)/2 + left;     //防止int溢出（推荐使用）
int mid = ((right-left)>>1)+left;      //防止int溢出，同时使用位运算效率更高）

2. 搞清楚while的条件时left<=right还是left<right

3. 搞明白算法中left和right的转换问题

寻找一个数(基本的二分查找)

例题：leetcode 704.二分查找

题目：

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

Case 1：左闭右闭

while判断条件是left<=right，同时right=mid-1，left=mid+1；

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

Case 2：左闭右开

while判断条件为left<right。使用<是因为right取不到，同时left=mid+1，right=mid

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

此算法的缺陷，比如说给你有序数组 nums = [1,2,2,2,3]，target = 2，此算法返回的索引是 2，没错。但是如果我想得到 target 的左侧边界，即索引 1，或者我想得到 target 的右侧边界，即索引 3，这样的话此算法是无法处理的。

寻找最左侧边界的二分搜索

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

寻找最右侧边界的二分搜索

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

二分法相关练习（后续）