Leetcode——数组：二分搜索法&704.二分查找&相似题目

知识点：

二分搜索的区间，一般分为左闭右闭或左闭右开

left=0
易错点1
while(易错点2)
{
    middle=(left+right)/2
    if(nums[middle]>target)
    {
        right=易错点3
    }
    else if(nums[middle]<target)
    {
        left=middle+1
    }
    else if(nums[middle]=target)
    {
        return target
    }
}
return -1

易错点：

1、定义right时是否-1

1、while循环条件，left是<还是<=right

2、当更新右区间时，right等于middle还是middle-1

1、左闭右闭

（1）right=numsize-1

定义时，将右侧减去，右边界left代表的为真实数据，因此右侧为闭区间

（2）while(left<=right)

右侧为闭区间，nums[left]为数组中的数据，也需要被比较，因此应该包括到循环条件中

（3）right=middle-1

if判断nums[middle]是否大于target时，nums[right]为准确的右边界。重新定义区间时，新区间应该为除去nums[middle]以后，左侧的全部数，因此应该-1

2、左闭右开

（1）right=numsize

右侧不-1，最右侧为一个虚值，不是实际数组中的数据

（2）while(left<right)

最右侧为虚值，如果使用等于，则会少比较最右侧的数字

（2）right=middle

当判断后，接下来的搜索区间多包含nums[right]，因此不-1

nums[right]是否为准确值	右边界right=	while判断条件	右边界重定义right=
准确值	numsize-1	left<=right	middle-1
不准确	numsize	left<right	middle

例题：704：二分查找

题目

（1）nums[right]不是准确值

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

（2）nums[right]是准确值

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

vector的基础知识

vector分为容量和使用量，用size()返回向量的使用量，用capacity返回向量的容量

不可以使用sizeof计算长度

相似题目 ：2529：正整数和负整数的最大计算

题目

https://leetcode.cn/problems/maximum-count-of-positive-integer-and-negative-integer/

 

题解

class Solution {
public:
    int maximumCount(vector<int>& nums) {
        int pos=0;  //正整数数目
        int neg=0;  //负整数数目
        int numsize=nums.size();
        int i=0;
        while(i<numsize)
        {
            if(nums[i]<0)
            {
                neg++;
            }
            else if(nums[i]>0)
            {
                pos++;
            }
            i++;
        }
        if(neg>=pos)
        {
            return neg;
        }
        else
        {
            return pos;
        }
    }
};

相似题目：1351：统计有序矩阵中的负数

题目

题解

class Solution {
public:
    int countNegatives(vector<vector<int>>& grid) {
        int i=0;
        int j=0;
        int num=0;
        int length=grid.size();
        int width=grid[0].size();
        for(int i=0;i<length;i++)
        {
            for(int j=0;j<width;j++)
            {
                if(grid[i][j]<0)
                {
                    num++;
                }
            }
        }
        return num;
    }
};

矩阵vector

二维矩阵时，.size()得到的是行数