leetcode hot100（day 6）

搜索插入位置

做法：二分

class Solution {
public:
    int searchInsert(vector& nums, int target) {
        return lower_bound(nums.begin(),nums.end(),target)-nums.begin();
    }
};

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

---

搜素二维矩阵

做法：对二分确实有点不熟练了。卡在超出范围了

class Solution {
public:
    bool searchMatrix(vector>& matrix, int target) {
        int row=matrix.size();
        int col=matrix[0].size();
        int left=0;
        int right=row-1;
        while(left<=right)
        {
            int mid=(left+right)>>1;
            if(matrix[mid][0]==target)return true;
            if(matrix[mid][0]=row||right<0)return false;
        //if(matrix[left][0]==target)return true;
        //if(right<0)return false;
        if(right<0)return false;
        int temp=right;
        left=0,right=col-1;
        while(left<=right)
        {
            int mid=(left+right)/2;
            if(matrix[temp][mid]==target)return true;
            if(matrix[temp][mid]=col)return false;
        //if(matrix[temp][left]==target)return true;
        return false;
    }
};

做法二:当成一维矩阵做。

class Solution {
public:
    bool searchMatrix(vector>& matrix, int target) {
        int m=matrix.size(),n=matrix[0].size();
        int low=0,high=m*n-1;
        while(low>1;
            int x=matrix[mid/n][mid%n];
            if(x

---

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

做法一：依旧lower upper

class Solution {
public:
    vector searchRange(vector& nums, int target) {
        int l=-1,r=-1;
        if(lower_bound(nums.begin(),nums.end(),target)!=nums.end())
        {
            l=lower_bound(nums.begin(),nums.end(),target)-nums.begin();
            if(nums[l]==target)
            {
            if(upper_bound(nums.begin(),nums.end(),target)!=nums.end())
            {
                r=upper_bound(nums.begin(),nums.end(),target)-nums.begin()-1;
            }
            else r=nums.size()-1;
            }
            else l=-1;
        }
        return {l,r};
    }
};

做法二：

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

---

搜索旋转排序数组

做法：由于时间复杂度要求logn，所以考虑二分，二分后，由于进行了旋转，所以必然是至少一个一个有序区间，和至多一个乱序区间。所以我们可以在判断有序区间后，判断target是否再有序区间内，如果在，就用二分，如果不在，就跳到另外一个无序区间，直到在其中找到有序区间才有机会找到target

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

---

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

做法：二分，图有两种情况nums[mid]>nums[r] nums[mid]nums[r]，根据这两种不同情况，二分即可。由于必定存在最小值，所以用L

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

---