二分查找题目整理1

 思路：升序数组用二分法查找。lower_bound查找第一个大于等于目标值的下标，upper_bound查找第一个大于target的下标。upper_bound得到的下标减一得到target的最后一个下标。

    int FindFirst(vector<int>& nums,int target)
    {
        int left=0;
        int right=nums.size()-1;
        while(left<=right)
        {
            int mid=left + (right - left) / 2;
            if(nums[mid]>target)
            {
                right=mid-1;
            }
            else if(nums[mid]<target)
            {
                left=mid+1;
            }
            else
            {
                right=mid-1;
            }
        }
        if(left!=nums.size()&&nums[left]==target)//left不越位且left为target下标
            return left;
        return -1;
    }
    int FindLast(vector<int>&nums,int target)
    {
        int left=0;
        int right=nums.size()-1;
        while(left<=right)
        {
            int mid=left + (right - left) / 2;
            if(nums[mid]>target)
            {
                right=mid-1;
            }
            else if(nums[mid]<target)
            {
                left=mid+1;
            }
            else left=mid+1;
        }
        if(nums[left-1]==target)
            return left-1;
        else return -1;
    }
    vector<int> searchRange(vector<int>& nums, int target) 
    {
        vector<int>res;
        //res={-1,-1};
        if(nums.size()==0)return res={-1,-1};
        int first=FindFirst(nums,target);
        if(first==-1)
        {
            return res={-1,-1};
        }
        int last=FindLast(nums,target);
        return res={first,last};
    }

 

思路：升序旋转数组用二分查找。首先判断旋转点（开始旋转的第一个下标）位置。

当nums[mid]>nums[right]时，mid到right部分是升序的。接着判断target是否在右半部分，如果在则收缩左边界，否则收缩右边界到mid-1。

当nums[mid]<nums[right]时,mid到left部分是升序的。判断target是否在左半部分。

    int search(vector<int>& nums, int target) 
    {
        int left=0;
        int right=nums.size()-1;
        int mid;
        while(left<=right)
        {
            mid=(left+right)/2;
            if(nums[mid]==target)return mid;
            else if(nums[mid]>nums[right])//左边是正序,旋转点在右边
            {
                if(nums[mid]>target&&target>=nums[left])//确保点在左区间
                {
                    right=mid-1;
                }
                else//点在右区间
                    left=mid+1;
            }
            else//nums[mid]<nums[right]
            {
                if(nums[mid]<target&&target<=nums[right])
                {
                    left=mid+1;
                }
                else
                    right=mid-1;
            }
        }
        return -1;
    }

 

 思路：根据矩阵性质，从矩阵右上角开始搜索，如果当前值大于target则列往左移；如果当前小于target则行往上移。

bool searchMatrix(vector<vector<int>>& matrix, int target) 
    {
        if(matrix.size()==0)return false;
        int rows=matrix.size();
        int row=0;
        int columns=matrix[0].size();
        int column=matrix[0].size()-1;
        while(row<rows&&column>=0)
        {
            int cur=matrix[row][column];
            if(target==cur)return true;
            else if(cur>target)
                column--;
            else if(cur<target)
                row++;
        }
        return false;
    }

 思路：升序旋转数组查找使用二分法。因为数组未旋转时是升序的，因此旋转后的旋转点（第一个旋转的下标）是最小的。如果nums[mid]>nums[right],则mid到right的序列是正序的，旋转点在mid之后因此右边界收缩为mid-1。如果num[mid]<num[right],则mid到left是升序的,旋转点在mid到right之间，因此左边界收缩到mid。

int minArray(vector<int>& numbers) 
    {
        int left = 0;
        int right = numbers.size() - 1;
        if (numbers[left] < numbers[right])return numbers[left];

        while (left <= right)
        {
            int mid = (left + right) / 2;
            if (numbers[mid] > numbers[right])left = mid + 1;//mid在左边段
            else if (numbers[mid] < numbers[right])right = mid;//mid在右边段
            else//相等时
            {
                right--;
            }
        }
        return numbers[left];
    }

 思路：排序的数组用二分。用lower_bound找到第一个目标值的下标，再用lower_bound找到第一个大于目标值+1的下标。相减得到数字出现次数。

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

    int search(vector<int>& nums, int target) 
    {
        int test1= FindFirst(nums,target);
        int test2=FindFirst(nums,target+1);
        return test2-test1;
    }