二分查找算法 (算法详解+模板+例题)

二分查找算法简介

二分查找算法并不是针对在数组有序的情况下,通过后面的题我们就会知道实际上只要是满足"二段性"的题目,都可以通过二分查找算法来实现

我们可以分成三种情况

1. 朴素的二分查找(最简单,但是基本不涉及)

2. 查找左边界的二分查找

3. 查找右边界的二分查找

第二第三基本是万能的,但细节较多

我们来看一张二分查找与遍历查找的效率对比图。

1.朴素的二分查找

题目链接

算法流程为:

1. 定义 left ， right 指针，分别指向数组的左右区间。

2. 找到待查找区间的中间点 mid ，找到之后分三种情况讨论：
   arr[mid] == target 说明正好找到，返回 mid 的值；
   arr[mid] > target 说明 [mid, right] 这段区间都是⼤于 target 的，因此舍去右边区间，在左边 [left, mid -1] 的区间继续查找，即让 right = mid - 1 ，然后重复 2 过程；
   arr[mid] < target 说明 [left, mid] 这段区间的值都是⼩于 target 的，因此舍去左边区间，在右边 [mid + 1, right] 区间继续查找，即让 left = mid + 1 ，然后重复 2 过程；

3. 当 left 与 right 错开时，说明整个区间都没有这个数，返回 -1

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

注意 ： 那么我们可以通过 left + (right - left) / 2来计算,通过变换就会发现这个公式实际上和 (left + right )/ 2是一样的,但是没有left+ right,就避免了数据范围溢出的风险，

2. 在排序数组中查找元素的第一个和最后一个位置

题目链接

我们先寻找左端点:

通过上图,我们会很容易地看出,左端点将数组划分为左区间和右区间,这不就就是我们在一开始就强调的"二段性",那么我们就可以利用二分查找来寻找这个左端点

(1) nums[mid] < target :那么就说明mid落在左边的区域,而左边是不可能存在target,那么我们就要到右边去寻找,所以left就要+1,接着在left到right区间寻找

(2)nums[mid] >= target ,说明我们的mid落在右边区域,但是我们不能单独判断等于,因为我们不知道是不是左端点,所以我们让right = mid,接着在left到right区间寻找

注意 ： 求中点操作

1. int mid = left + (right - left)/2;
   
2. 但是如果我们用mid = left + (right-left+1)/2 公式,那么此时mid = 5,right = mid后,死循环了
   .

我们再寻找右端点:

此时我们会发现分成两段区间,左边 <= target,右边 >= target

(1) nums[mid] <= target :那么就说明mid落在左边的区域,而左边是不可能存在target,那么我们就要到右边去寻找,所以left = mid,接着在left到right区间寻找

(2)nums[mid] > target ,说明我们的mid落在右边区域,所以我们让right = mid - 1,接着在left到right区间寻找

这样,left和right就会向中间靠拢,直到相遇,那么他们的相遇点就是左端点
实际上我们会发现与上面的操作是左右颠倒过来的

因此我们计算mid的公式应该用第二个,即left + (right - left + 1)/2

class Solution {
public:
    vector<int> searchRange(vector<int>& nums, int target) {
        vector<int> v;

        if(nums.size() == 0) return {-1,-1};

        int left = 0, right = nums.size()-1;
        //找左端点
        while(left < right)
        {
            int mid = left + (right - left)/2;
            if(nums[mid] < target)
            {
                left = mid + 1;
            }
            else if(nums[mid] >= target)
            {
                right = mid;
            }
        }
        v.push_back(left);

        left = 0;
        right = nums.size() - 1;
        //找右端点
        while(left < right)
        {
            int mid = left + (right - left + 1)/2;
            if(nums[mid] <= target)
            {
                left = mid;
            }
            else if(nums[mid] > target)
            {
                right = mid - 1;
            }
        }
        v.push_back(right);

        if(nums[right] != target) return {-1,-1};

        return v;
    }
};

3. 搜索插入位置

题目链接

此题是在寻找小于target的最后一个数的位置或者是等于target的数的位置,那么我们可以根据这个位置把区间划分为两段,左边 < target,右边是>= target,这就是"二段性",就可以利用二分查找的算法来解题.那么端点自然就在右区间了

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

4. 山脉数组的峰顶索引

题目链接

显而易见的二段性,把数组分为两段

左边的是上升阶段,即 nums[mid] > nums[mid-1] ，
右边阶段是下降阶段,即nums[mid] < nums[mid - 1] .由于我们是判断mid 和 mid - 1的关系,自然时把峰值包含在左区间的

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

5.寻找峰值

题目链接

此题与上一题不同的是峰值不止一个,题目说:nums[-1] 和 nums[n] 是负无穷,也就是峰值是一定存在的,哪怕是一个递增(递减)的序列

就会形成类似这样的走势,我们返回其中的一个峰值即可

加上我们在区间中随便找一个点k,那它大致分为两种情况:

(1)nums[k] < nums[k-1],即这个点是在下降区间的,那么这个点的左区间就一定存在峰值,因为nums[-1]是负无穷,那我们就要去左区间找

(2)nums[k] > nums[k-1],即这个点是在上升区间的,那么这个点的右区间就一定存在峰值,因为nums[-1]是负无穷,那我们就要去右区间找

因此又是显然的二段性,由于我们是判断mid 和 mid - 1的关系,自然时把峰值包含在左区间的

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

6. 寻找旋转排序数组中的最小值

题目链接

最小的元素会很明显地把数组划分为:

两段蓝色的区间,左边任何一个数都小于nums[n-1] (n是数组长度),那么我们就要去右边找;右边任何一个数都大于等于nums[n-1],但是我们不知道这个值是不是最小值,因此让right = mid,继续把区间往左缩小来找

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