leetcode打卡day02---二分查找

之前写过二分查找的模板，参见博客二分查找模板

744.大于给定元素的最小元素

leetcode744

解题思路：此题为找到大于目标字符的第一个字符，及0000011111问题查找第一个1，利用模板即可。另外注意特殊情况，当目标值比最后一个字符都大的时候，返回第一个字符串。

class Solution {
public:
    char nextGreatestLetter(vector<char>& letters, char target) {
        int l=0,r=letters.size()-1;
        //考虑特殊情况
        if(letters[letters.size()-1]<=target){
            return letters[0];
        }
        while(l!=r){
            int mid=(l+r)/2;
            if(letters[mid]>target){
                r=mid;
            }else{
                l=mid+1;
            }
        }
        return letters[l];
    }
};

540.查找有序数组中的单个元素

leetcode540

要求：时间复杂度为(OlogN）,因此不能遍历数组用异或操作，
解题思路：因为数组大小肯定为奇数，因此可以只索引偶数节点。

• 奇数长度的数组首尾元素索引都为偶数，因此我们可以将 lo 和 hi 设置为数组首尾。 我们需要确保 mid 是偶数，如果为奇数，则将其减1。
• 然后，我们检查 mid 的元素是否与其后面的索引相同。 如果相同，则我们知道 mid 不是单个元素。且单个元素在 mid之后。则我们将 lo 设置为 mid + 2。 如果不是，则我们知道单个元素位于 mid，或者在 mid 之前。我们将 hi 设置为mid。
• 一旦 lo == hi，则当前搜索空间为 1 个元素，那么该元素为单个元素，我们将返回它。

class Solution {
public:
    int singleNonDuplicate(vector<int>& nums) {
        // int ans=nums[0];
        // for(int i=1;i<nums.size();i++){
        //     ans^=nums[i];
        // }
        // return ans;
        int l=0,r=nums.size()-1;
        while(l!=r){
            int mid=(l+r)/2;
            if(mid%2){
                mid--;//保证待查找区间大小是基数，索引一直是偶数
            }
            if(nums[mid]==nums[mid+1]){
                l=mid+2;
            }else{
                r=mid;
            }
        }
        return nums[l];
    }

278.第一个错误的版本

leetcode278

0000111问题找第一个满足条件的1

// The API isBadVersion is defined for you.
// bool isBadVersion(int version);

class Solution {
public:
    int firstBadVersion(int n) {
        int l=0,r=n;
        while(l!=r){
        //注意写成l+(r-l)/2;否则会溢出
            int mid=l+(r-l)/2;
            if(isBadVersion(mid)){
                r=mid;
            }else{
                l=mid+1;
            }
        }
        return l;
    }
};

153.旋转数组中的最小数字

leetcode153

0001111问题查找第一个1

class Solution {
public:
//前面一堆0，后面一堆1，找带一个1，其中为1的条件是，右边大于等于中间的值
    int findMin(vector<int>& nums) {
        // sort(nums.begin(),nums.end());
        // return *nums.begin();
        int l=0,r=nums.size()-1;
        while(l!=r){
            int mid=(l+r)/2;
            if(nums[mid]<=nums[r]){
                r=mid;
            }else{
                l=mid+1;
            }
        }
        return nums[l];
    }
};

34.查找区间

leetcode34

题目描述：给定一个有序数组 nums 和一个目标 target，要求找到 target 在 nums 中的第一个位置和最后一个位置。

解题思路：可以用二分查找找出第一个位置和最后一个位置，但是寻找的方法有所不同，需要实现两个二分查找。即000111问题找第一个1和1111000问题找最后一个1，最后两者的并集即为答案。
但是如果我们将寻找 target 最后一个位置，转换成寻找 target+1
第一个位置，再往前移动一个位置。这样我们只需要实现一个二分查找代码即可。

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

       l=0,r=nums.size()-1;
       while(l!=r){
           int mid=(l+r+1)/2;
           if(nums[mid]<=target){
               l=mid;
           }else{
               r=mid-1;
           }
       }
       if(nums[l]!=target) return {-1,-1};
       int end=r;
       return {start,end};
    }
};

更改后的代码

class Solution {
public:
    int findFirst(vector<int>nums,int target){
        int l=0,h=nums.size();//注意h的初始值
        while(l!=h){
            int mid=l+(h-l)/2;
            if(nums[mid]>=target){
                h=mid;
            }else{
                l=mid+1;
            }
        }
        return l;
    }

    vector<int> searchRange(vector<int>& nums, int target) {
        int first=findFirst(nums,target);
        int last=findFirst(nums,target+1)-1;
        if(first==nums.size()||nums[first]!=target){
            return {-1,-1};
        }
        return {first,max(first,last)};
    }
};

在寻找第一个位置的二分查找代码中，需要注意 h 的取值为 nums.size()，而不是 nums.size() - 1。
先看以下示例：

nums = [2,2], target = 2

如果 h 的取值为 nums.size() - 1，那么 last = findFirst(nums, target + 1) - 1 =
1 - 1 = 0。这是因为 findLeft 只会返回 [0, nums.length - 1] 范围的值，对于
findFirst([2,2], 3) ，我们希望返回 3 插入 nums 中的位置，也就是数组最后一个位置再往后一个位置，即
nums.size()。所以我们需要将 h 取值为 nums.size()，从而使得 findFirst返回的区间更大，能够覆盖
target 大于 nums 最后一个元素的情况。

剑指offer–数字在升序数组中出现的次数

剑指offer–在升序数组中出现的次数

题目描述

解题思路：

二分查找，因为是有序数组，利用两次二分查找，查找小于等于k的最后一个位置，即1111000找最后一个1，再一次二分查找大于等于k的第一个位置，000111的第一个1；两者相减即为出现的次数,，和上面一题类似。

class Solution {
public:
    int GetNumberOfK(vector<int> data ,int k) {
        /*思路1：哈希表
        map<int,int>mp;
        for(int i=0;i<data.size();i++){
            ++mp[data[i]];
        }
        for(int i=0;i<data.size();i++){
            if(data[i]==k){
                return mp[data[i]];
            }
        }
        return 0;*/
        //思路2：标准函数库
        //return upper_bound(data.begin(), data.end(), k) - lower_bound(data.begin(), data.end(), k);
    //思路3：二分查找，利用两次二分查找，
    //查找小于等于k的最后一个位置，即1111000找最后一个1
    //大于等于k的第一个位置，000111的第一个1；
        if(data.size()==0||data[0]>k||data[data.size()-1]<k) return 0;
        int low_b=0,high_b=0;
        //注意右边界为data.size()-1；
        int l=0,r=data.size()-1;
        while(l!=r){
            int mid=(l+r+1)/2;
            if(data[mid]<=k){
                l=mid;
            }else{
                r=mid-1;
            }
        }
        low_b=l;
        
        l=0,r=data.size()-1;
        while(l!=r){
            int mid=(l+r)/2;
            if(data[mid]>=k){
                r=mid;
            }else{
                l=mid+1;
            }
        }
        high_b=r;
        return low_b-high_b+1;
    }
};