7道题解决二分查找问题

---

顺序数组搜索一个值

二分查找最基本的思想，查找的区间必须有序
本文全部按照闭区间来查找，此时while里面条件应该写为l<=r
若按开区间查找（r=nums.size()），此时while里面条件应该写为l<r
返回值-1表示未找到目标

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

---

搜索插入位置

题目链接

此题在搜索的基础上要求若搜索的元素不存在，要返回应该插入的位置

我们只需将上面的程序的返回值改为左区间l
分析：当程序找到目标时，会从return mid返回
未找到目标时，会打破while的条件返回
打破while条件有两种情况，即因为l=mid+1导致l>r或者因为r=mid-1导致l>r（因为搜索的最后一步l和r肯定在一起）
因为l=mid+1时说明目标比mid大，应该插入当前的后面，所以l=mid+1，
另一种情况同理，因此此时两种目标情况下均应该返回l

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

---

排序数组查找元素第一个和最后一个位置

题目链接

这题与前面题又不同，目标元素可能有若干个
当mid找到目标时并不一定是第一个或最后一个目标元素，
比如1,2,3,3,3,3 3,4,5
因此，对于找左边界，应该让查找区间向数组左半部分搜，即r=mid-1
右边界就向右半部分搜，即l=mid+1
注意判断条件应该加上=

class Solution {
    int lowerBound(vector<int>& nums, int target,int l,int r){
        while(l<=r){
            int mid=l+((r-l)>>1);
            if(nums[mid]>=target) r=mid-1;
            else l=mid+1;
        }
        return l;
    }
    int upperBound(vector<int>& nums, int target,int l,int r){
        while(l<=r){
            int mid=l+((r-l)>>1);
            if(nums[mid]<=target) l=mid+1;
            else r=mid-1;
        }
        return r;
    }
public:
    vector<int> searchRange(vector<int>& nums, int target) {
        int low=lowerBound(nums,target,0,nums.size()-1);
        int up=upperBound(nums,target,0,nums.size()-1);
        if(low>up) return {-1,-1};
        return {low,up};
    }
};

---

找第一个大于目标元素的索引

找比目标大的元素，那么这个题的目标不是真正求解的目标（好乱）
就是搜索逻辑要在nums[mid] > target中
两种找到题目要求元素，当前nums[mid]>target&&nums[mid-1] <= target
或者mid == left，这个条件的意思是，当前为搜索的最后一步，此时l和r肯定在一起
而前置判断条件是nums[mid] > target，说明当前l/r/mid一定是第一个大于目标的位置
返回l是为了方便理解与记忆

int lowBoundnum(int[] nums,int target,int left, int right) {
        while (left <= right) {
            //求中间值
            int mid = left + ((right - left) >> 1);
            //大于目标值的情况
            if (nums[mid] > target) {
                 //返回 mid
                if (mid == left || nums[mid-1] <= target) {
                    return mid;
                }
                else{
                    right = mid -1;
                }

            } else if (nums[mid] <= target){
                left = mid + 1;
            }
        }
        //所有元素都小于目标元素
        return -1;
    }

---

找最后一个比目标元素小的索引

同理

int upperBoundnum(int[] nums,int target,int left, int right) {

        while (left <= right) {

            int mid = left + ((right - left) >> 1);
             //小于目标值
            if (nums[mid] < target) {
            //看看是不是当前区间的最后一位，如果当前小于，后面一位大于，返回当前值即可
                if (mid == right || nums[mid+1] >= target) {
                    return mid;
                }
                else{
                    left = mid + 1;
                }

            } else if (nums[mid] >= target){
                right = mid - 1;
            }
        }
        //没有查询到的情况
        return -1;
    }

---

搜索旋转的排序数组

题目链接

这个题中数组是一个有序无重复数组经过旋转得到的，因此可以看做两个有序数组拼接在一起
那么对于mid首先要判断到底是在哪个有序数组中
注意一点，前面数组的最小值nums[l]一定大于后面数组最大值nums[r]
因此，若nums[mid]>=nums[l]，那么mid就是在前面的数组
nums[mid]>target&&target>=nums[l]判断目标是否在前面数组中，若不满足，则target可能在前面数组也可能在后面数组

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

---

搜索旋转的有重复排序数组

题目链接

本题有重复旋转数组，当出现1,3,1,1,1这样的情况下，前面的程序就不行了
此时if(nums[mid]==nums[l]){l++; continue;}将左边界移动一位重新计算mid就行了，变相去重。

class Solution {
public:
    bool search(vector<int>& nums, int target) {
        int l=0,r=nums.size()-1;
        while(l<=r){
            int mid=l+((r-l)>>1);
            if(nums[mid]==target) return true;
            if(nums[mid]==nums[l]){
                l++;
                continue;
            }
            if(nums[mid]>nums[l]){
                if(nums[mid]>target&&target>=nums[l]) r=mid-1;
                else l=mid+1;
            }
            else{
                if(nums[mid]<target&&target<=nums[r]) l=mid+1;
                else r=mid-1;
            }
        }
        return false;
    }
};

---

找旋转数组最小值

题目链接

分情况，如果搜索区间进入单调区间内，那nums[l]肯定最小
若不是，则跟前面一样判断mid在前面数组还是后面数组
mid在前面数组，那么最小值一定在后面
mid在后面数组，那么最小值一定在该区间内
注意r=mid而不是r=mid-1，因为r的位置就有可能是最小值

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