【二分查找专题】剑指 Offer 53 – I. 在排序数组中查找-跟着帅地玩副业，开拓第二曲线PlayOffer

YOLO 普通 2024年4月12日下午9:29

/*统计一个数字在排序数组中出现的次数。 */
class Solution {
    public int countTarget(int[] scores, int target) {
        //常见题型：
        //1、寻找第一个>=target的数；2、寻找第一个=target的数
        //3、寻找最后一个>=target的数；4、寻找最后一个=target的数

        int left = search2(scores , target);
        int right = search4(scores, target);

        if(left < 0 || right < 0)  return 0;
        return right - left + 1;
    }

    //2、寻找第一个=target的数的下标
    int search2(int[] nums , int target){
        if(nums == null || nums.length <= 0){
            return -1;
        }
        int left = 0,right = nums.length - 1;
        while(left < right){
            //向下取整
            int mid = (right - left)/2 + left;
            if(nums[mid]>=target){
                right = mid; 
            }
            else{
                left = mid + 1;
            }
        }
    //判断该数是否存在
    if(nums[left]!=target) return -1;
    return left;
    }

    //4、寻找最后一个=target的数的下标
    int search4(int[] nums , int target){
        if(nums == null || nums.length <= 0){
            return -1;
        }
        int left = 0 , right = nums.length -1;
        while(left < right){
            //向上取整
            int mid = (right - left + 1)/2 + left;
            if(nums[mid] <= target){
                left = mid;
            }
            else{
                right = mid - 1;
            }
        }
        //判断该数是否存在
        if(nums[left] != target) return -1;
        return left;
    }

}

0 赞同 0 条回复

=.= 普通 2024年3月30日下午3:03

class Solution {
public int countTarget(int[] scores, int target) {
int num1 = 0;
int num2 = 0;
int n = scores.length;

    int left = 0;
    int right = n-1;
    while(left <= right){
        int mid = left + (right-left) / 2;
        if(scores[mid] == target) right = mid - 1;
        else if(scores[mid] > target) right = mid - 1;
        else if(scores[mid] < target) left = mid + 1;
    }

    if(left >= n || scores[left] != target) {
        num1 = -1;
        return 0;
    }
    else num1 = left;


    left = 0;
    right = n-1;
    while(left <= right){
        int mid = left + (right-left) / 2;
        if(scores[mid] == target) left = mid + 1;
        else if(scores[mid] < target) left = mid + 1;
        else if(scores[mid] > target) right = mid - 1;
    }
    if(right >= 0 && scores[right] == target) num2 = right;

    return num2 - num1 + 1;
}

}

时间复杂度：O(logn)
空间复杂度：O(1)

0 赞同 0 条回复

NULL 普通 2024年3月25日下午10:36

class Solution {
public int countTarget(int[] scores, int target) {
// 初始化左右边界，分别用于查找第一个和最后一个目标值的位置
int left = binarySearch(scores, target, true); // 查找第一个目标值的位置
int right = binarySearch(scores, target, false); // 查找最后一个目标值的位置

    // 如果没有找到目标值，则返回 0
    if (left == -1 || right == -1) return 0;

    // 返回目标值的数量
    return right - left + 1;
}

// 二分查找函数
public int binarySearch(int[] nums, int target, boolean isFirst) {
    // 数组为空或者长度为 0，则直接返回 -1
    if (nums == null || nums.length == 0) return -1;

    // 初始化左右指针，分别指向数组的第一个和最后一个元素
    int left = 0, right = nums.length - 1;

    // 开始二分查找
    while (left <= right) {
        // 计算中间位置
        int mid = left + (right - left) / 2;
        // 根据 isFirst 参数决定是查找第一个还是最后一个目标值的位置
        if ((isFirst && nums[mid] >= target) || (!isFirst && nums[mid] > target)) {
            right = mid - 1; // 更新右边界
        } else {
            left = mid + 1; // 更新左边界
        }
    }

    // 如果是查找第一个目标值，并且左指针超出数组边界，或者找到的值不等于目标值，则返回 -1
    // 如果是查找最后一个目标值，并且右指针超出数组边界，或者找到的值不等于目标值，则返回 -1
    if ((isFirst && (left >= nums.length || nums[left] != target)) ||
        (!isFirst && (right < 0 || nums[right] != target))) return -1;

    // 返回找到的目标值的位置
    return isFirst ? left : right;
}

}

0 赞同 0 条回复

南梁陈庆之普通 2024年3月23日上午1:37

分别查找匹配元素的最小值及最大值对应坐标

class Solution {
    public int countTarget(int[] scores, int target) {
        if (scores.length == 0) {
            return 0;
        }
        int leftIndex = lower(scores, target);
        if (leftIndex == -1 || scores[leftIndex] != target) {
            return 0;
        }
        int rightIndex = upper(scores, target);
        return rightIndex - leftIndex + 1;
    }

    int lower(int[] arr, int target) {
        int l = 0, r = arr.length - 1;
        if (arr[l] > target) {
            return -1;
        }
        while (l < r) {
            int m = (r - l + 1) / 2 + l;
            if (arr[m] >= target) {
                r = m - 1;
            } else {
                l = m;
            }

        } 
        if (l + 1 != arr.length && arr[l] != target && arr[l + 1] == target) {
            return l + 1;
        }
        return l;
    }

    int upper(int[] arr, int target) {
        int l = 0, r = arr.length - 1;
        if (arr[r] < target) {
            return -1;
        }
        while (l < r) {
            int m = (r - l) / 2 + l;
            if (arr[m] > target) {
                r = m;
            } else {
                l = m + 1;
            }

        } 
        if (l - 1 >= 0 && arr[l] != target && arr[l - 1] == target) {
            return l - 1;
        }
        return l;
    }
}

0 赞同 0 条回复

kfaebot 普通 2024年3月20日上午10:53

class Solution {
public:
    int countTarget(vector<int>& scores, int target) {
        //极端情况
        if(scores.empty()){
            return 0;
        }

        //找到最后一个比target小的元素
        int l1=0;
        int r1=scores.size()-1;

        //判断极端情况
        if(scores[l1]>target){
            return 0;
        }

        while(l1<r1){
            int m1=(l1+r1+1)/2;
            if(scores[m1]>target){
                r1=m1-1;
            }
            else if(scores[m1]<target){
                l1=m1;
            }
            else if(scores[m1]==target){
                r1=m1-1;
            }
        }

        //找到第一个比target大的元素
        int l2=0;
        int r2=scores.size()-1;

        //判断极端情况
        if(scores[r2]<target){
            return 0;
        }

        while(l2<r2){
            int m2=(l2+r2)/2;
            if(scores[m2]>target){
                r2=m2;
            }
            else if(scores[m2]<target){
                l2=m2+1;
            }
            else if(scores[m2]==target){
                l2=m2+1;
            }
        }
        int ll,rr;
        if(scores[l1]==target){
            ll=l1;
        }
        else if(l1+1<scores.size()&&scores[l1+1]==target){
            ll=l1+1;
        }
        else{
            //ll=l1;
            return 0;
        }

        if(scores[l2]==target){
            rr=l2;
        }
        else if(l2-1>=0&&scores[l2-1]==target){
            rr=l2-1;
        }
        else{
            //rr=l2;
            return 0;
        }
        return rr-ll+1;
    }
};
//时间复杂度O(logn)
//空间复杂度O（1）

0 赞同 0 条回复

mpweixin用户普通 2024年3月18日下午5:25

public int countTarget(int[] scores, int target) {
int l=0,r=scores.length-1;
int count=0;
int mid=(r-l)/2+l;
if(target<scores[l]|| target>scores[r]) return 0;
while(l<r){
mid=(r-l)/2+l;
if(scores[mid]>target){
r=mid;
}else if(scores[mid]target){
count++;
l=mid+1;
break;
}else{
l=mid+1;
}
}

        int t;
    t=mid;
    while(--mid>0){
        if(scores[mid]==target){
            count++;
        }
        else{
            break;
        }
    }
    while(++t<scores.length){
        if(scores[t]==target){
            count++;
        }
        else{
            break;
        }
    }

    return count;
}

思路：一次二分加遍历题解有两次2分分别找左右边界

0 赞同 0 条回复

RunAsOne 普通 2024年3月18日下午4:27

时间复杂度(OlogN)

class Solution {
    public int countTarget(int[] scores, int target) {
        return getIndex(scores, target) - getIndex(scores, target-1);
    }
    public int getIndex(int[] scores, int target) {
        int l = 0;
        int r = scores.length - 1;

        while (l <= r) {
            int mid = (l+r)/2;
            if (scores[mid] <= target) {
                l=mid+1;
            } else {
                r = mid-1;
            }
        }
        return l;
    }
}

0 赞同 0 条回复

一个达不刘普通 2024年3月18日下午3:44

class Solution {
public:
int countTarget(vector& scores, int target) {
int n = scores.size();
int sum =0;
for(int i = 0; i<n;i++){
if(scores[i] target){
sum++;
}
}
return sum;

};
直接遍历

0 赞同 0 条回复

Jimmy 普通 2024年3月17日下午6:48

先求出左右边界，然后再根据左右边界相减统计个数

class Solution {
public:
    int leftBorder(vector<int>& scores, int target){
        int l = 0;
        int r = scores.size()-1;
        int leftBorder = -2;
        while(l <= r){
            int mid = l + (r-l)/2;
            if(scores[mid] >= target){
                r = mid - 1;
                leftBorder = r;
            }else{
                l = mid + 1;
            }
        }
        return leftBorder;
    }
    int rightBorder(vector<int>& scores, int target){
        int l = 0;
        int r = scores.size()-1;
        int rightBorder = -2;
        while(l <= r){
            int mid = l + (r-l)/2;
            if(scores[mid] > target){
                r = mid - 1;
            }else{
                l = mid + 1;
                rightBorder = l;
            }
        }
        return rightBorder;
    }
    int countTarget(vector<int>& scores, int target) {
        int left = leftBorder(scores,target);
        int right = rightBorder(scores,target);

        if(left == -2 || right == -2){
            return 0;
        }
        // cout<<"left :"<<left<<endl;
        // cout<<"right:"<<right<<endl;
        if(right-left>1)return right-1-(left+1)+1;
        return 0;
    }
};

0 赞同 0 条回复

神经蛙普通 2024年3月16日下午11:05

class Solution {
public:
int countTarget(vector& scores, int target) {
if(scores.size() <= 0)
{
return 0;
}
int left =0 ;
int right= scores.size() – 1;
int mid = 0;
// 寻找第一个等于target的索引
while(left < right)
{
mid = left + (right – left)/2;
if(scores[mid] >= target)
{
right = mid;
}
else
{
left = mid+1;
}
}

    if(scores[left] != target)
    {
        return 0;
    }
    int floor = left;

    left = 0;
    right  = scores.size() -1;
    //寻找最后一个等于target的索引
    while(left < right)
    {
        mid = left + (right - left +1)/2;
        if(scores[mid] > target)
        {
            right = mid -1;
        }
        else
        {
            left  = mid;
        }
    }
    if(scores[left] != target)
    {
        return 0;
    }

    int upper = left;

    return upper - floor +1;

}

};
思路：寻找最后一个和第一个等于target的位置

0 赞同 0 条回复

白雪公主倒拔垂杨柳永久会员 2024年3月16日下午9:42

时间复杂度O(log(n))
空间复杂度O(1)

class Solution {
    int search2(int[] nums, int target){
        if(nums == null || nums.length <= 0){
            return -1;
        }
        int left = 0, right = nums.length - 1;
        while(left < right){
            // 向下取整
            int mid = (right - left) / 2 + left;
            if(nums[mid] >= target){
                right = mid;
            }else{
                left = mid + 1;
            }
        }
        // 判断该数是否存在
        if(nums[left] != target) return -1;
        return left;
    }
    //4.寻找最后一个等于 target 的数下标
    int search4(int[] nums, int target){
        if(nums == null || nums.length <= 0){
            return -1;
        }
        int left = 0, right = nums.length - 1;
        while(left < right){
            //向上取整
            int mid = (right - left + 1) / 2 + left;
            if(nums[mid] <= target){
                left = mid;
            }else{
                right = mid - 1;
            }
        }
        // 判断该数是否存在
        if(nums[left] != target) return -1;
        return left;
    }
    public int countTarget(int[] scores, int target) {
       int left = search2(scores, target);
        int right = search4(scores, target);

        if(left < 0 || right < 0) return 0;
        return right - left + 1;
    }

}

0 赞同 0 条回复

mpweixin用户普通 2024年3月16日下午9:32

java
class Solution{
public int countTarget(int[] scores, int target){
int i = 0, j = scores.length – 1;
while(i <= j){
int m = (i + j) / 2;
if(scores[m] <= target) i = m + 1;
else j = m – 1;
}
int right = i;
if(j >= 0 && scores[j] != target) return 0;
i = 0; j = scores.length – 1;
while(i <= j){
int m = (i + j) / 2;
if(scores[m] < target) i = m + 1;
else j = m – 1;
}
int left = j;
return right – left – 1;
}
}
提交

0 赞同 0 条回复

方铎码农普通 2024年3月16日下午6:43

class Solution {
    public int countTarget(int[] scores, int target) {
        //target的右界 - target-1的右界 = target的覆盖范围
        return helper(scores,target)-helper(scores,target-1);
    }

    //寻找target出现的右界
    private int helper(int[] scores, int target){
        int l = 0, r = scores.length - 1;
        while(l <= r){
            int m = (l+r)/2;
            if(scores[m] <= target) l = m+1;
            else r = m-1;
        }
        return l;
    }
}

时间复杂度O(log(n))
空间复杂度O(1)

0 赞同 0 条回复

机电皮怪永久会员 2024年3月16日上午11:25

时间复杂度O(log(n))
空间复杂度O(1)

“`C++
class Solution {
public:
/*自己的代码
int countTarget(vector& scores, int target) {
int left = 0;
int right = scores.size() – 1;
//特殊情况判断
if(scores.empty() == true)
{
return 0;
}
if (target < scores[0] || target > scores[right])
{
return 0;
}

    int l = findleft(scores, target, left, right);
    int r = findright(scores, target, left ,right);
    //左右相等则判断是不是没找到或者只有一个元素
    if(l == r)
    {
        return scores[l] == target ? 1 : 0;
    }
    else
    {
        return r - l;
    }
}

private:
//查找最左边的元素
int findleft(vector& scores, int target, int l, int r)
{
int left = l;
int right = r;
while(l <= r)
{
int mid = (r + l)/2;
if(target > scores[mid])
{
l = mid + 1;
}
else if(target < scores[mid])
{
r = mid – 1;
}
else
{ //查找最左边的元素就应该在相等的时候让右边的游标移动
r = mid – 1;
}
}
return l;
}

//查找最右边的元素
int findright(vector<int>& scores, int target, int l, int r)
{
    int left = l;
    int right = r;
    while(l <= r)
    {
        int mid = (r + l)/2;
        if(target > scores[mid])
        {
            l = mid + 1;
        }
        else if(target < scores[mid])
        {
            r = mid - 1;
        }
        else
        {   //查找最右边的元素就应该在相等的时候让左边的游标移动
            l = mid + 1;
        }
    }
    return l;
}
*/
int countTarget(vector<int>& scores, int target)
{
    return help(scores, target) - help(scores, target - 1);
}

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

};

“`

0 赞同 0 条回复

Thaddeus 永久会员 2024年3月16日上午8:45

打卡

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

0 赞同 0 条回复

Yox 普通 2024年3月16日上午7:10

class Solution:
def countTarget(self, scores: List[int], target: int) -> int:
def searchRight(list,target):
left = 0
right = len(list)-1
while left <= right:
mid = (left+right)//2
if list[mid] <= target:
left = mid+1
else:
right = mid -1
return left
return searchRight(scores,target)- searchRight(scores,target-1)
O log N 时间空间 o 1

0 赞同 0 条回复

heathhou 普通 2024年3月15日下午11:11

class Solution {
public:
    int countTarget(vector<int>& scores, int target) {
        int l = search1(scores, target);
        int r = search2(scores, target);
        if(l == -1 || r == -1 ){
            return 0;
        }

        if(scores[l] != target || scores[r] != target){
            return 0;
        }
        return r - l + 1;
    }

    // 查找第一个等于target的元素下标
    int search1(vector<int>& scores, int target){
        if(scores.empty()){
            return -1;
        }
        int l = 0;
        int r = scores.size() - 1;
        if(scores[l] > target ){
            return -1;
        }

        while(l < r){
            int mid = (r - l + 1) / 2 + l;
            if(scores[mid] > target){
                r = mid - 1;
            }else if(scores[mid] == target){
                r = mid - 1;
            }else{
                l = mid;
            }
        }
        if(scores[l] == target){
            return l;
        }
        if( l + 1 <= scores.size()-1 &&  scores[l+1] == target){
            return l + 1;
        }
        return l;
    }

    // 查找最后一个等于target的元素下标
    int search2(vector<int>& scores, int target){
        if(scores.empty()){
            return -1;
        }
        int l = 0;
        int r = scores.size() - 1;
        if(scores[r] < target ){
            return -1;
        }

        while(l < r){
            int mid = (r - l) / 2 + l;
            if(scores[mid] > target){
                r = mid;
            }else if(scores[mid] == target){
                l = mid + 1;
            }else{
                l = mid + 1;
            }
        }
        if(scores[l] == target){
            return l;
        }
        if( l - 1 >= 0 &&  scores[l-1] == target){
            return l - 1;
        }
        return l;
    }


};

0 赞同 0 条回复

紫芝普通 2024年3月15日下午9:23

思路：直接按照之前的四种模板，查找最后一个小于target的下标，然后从该下标的下一个位置开始遍历，如果等于target，则结果+1，直到不等于target。返回结果。

“`c++
class Solution {
public:
int countTarget(vector& scores, int target) {
int len = scores.size();
if (len == 0) return 0;
int start = 0, end = len – 1, mid;
while (start <= end) { mid = (start + end) / 2; if (scores[mid] >= target) end = mid – 1;
else start = mid + 1;
}
int res = 0;
while (start < len && scores[start] == target) { start++; res++; } return res; } }; ```

0 赞同 0 条回复

言之命至普通 2024年3月15日下午9:17

思路：寻找第一个等于 target 的数的位置left，寻找最后一个等于 target 的数的位置 right，最后返回right – left + 1;

class Solution {
    public int search(int[] nums, int target) {
        //常见题型：
        // 1.寻找第一个大于等于 target 的数   2.寻找第一个等于 target 的数
        // 3.寻找最后一个大于等于 target 的数 4.寻找最后一个等于 target 的数
        //PS：其实这里是不需要写两个查找函数的，可以把代码优化放在同一个方法里滴
        int left = search2(nums, target);
        int right = search4(nums, target);

        if(left < 0 || right < 0) return 0; //也就是 等于 -1，不存在
        return right - left + 1;



    }
    //2.寻找第一个等于 target 的数的下标
    int search2(int[] nums, int target){
        if(nums == null || nums.length <= 0){
            return -1;
        }
        int left = 0, right = nums.length - 1;
        while(left < right){
            // 向下取整
            int mid = (right - left) / 2 + left;
            if(nums[mid] >= target){
                right = mid;
            }else{
                left = mid + 1;
            }
        }
        // 判断该数是否存在
        if(nums[left] != target) return -1;
        return left;
    }

    //4.寻找最后一个等于 target 的数下标
    int search4(int[] nums, int target){
        if(nums == null || nums.length <= 0){
            return -1;
        }
        int left = 0, right = nums.length - 1;
        while(left < right){
            //向上取整
            int mid = (right - left + 1) / 2 + left;
            if(nums[mid] <= target){
                left = mid;
            }else{
                right = mid - 1;
            }
        }
        // 判断该数是否存在
        if(nums[left] != target) return -1;
        return left;
    }

}

0 赞同 0 条回复

MARS 普通 2024年3月15日下午7:36

/**
 * @param {number[]} scores
 * @param {number} target
 * @return {number}
 */
var countTarget = function(scores, target) {
    //如果存在，返回下标最小的那个
    if(scores.length<=0) return 0
    let left = 0,right = scores.length-1
    while(left<right){
        let mid = Math.floor((left+right)/2)
        if(scores[mid]>target){
            right = mid
        }else if(scores[mid] == target){
            right = mid
        }else{   // cores[mid] < target
            left = mid+1 
        }
    }
    let count = 0
    if(scores[left] == target){
        for(let i =left;i<scores.length;i++){
            if(scores[i]==target) count++
            else break
        }
    }
    return count
};

0 赞同 0 条回复

Raphtalia. 普通 2024年3月15日下午3:51

class Solution {
public:
int countTarget(vector& scores, int target) {
int l = 0;
int r = scores.size() – 1;
int res = 0;
int flag = -1;
int mid = (l + r) / 2;
while(l <= r){
mid = (l + r) / 2;
if(scores[mid] > target){
r = mid – 1;
}
if(scores[mid] < target){
l = mid + 1;
}
if(scores[mid] target){
flag = mid;
break;
}
}
if(flag -1) return 0;
else{
for(int i = mid; i < scores.size(); i ++){
if(scores[i] target) res ++;
else break;
}
for(int i = mid – 1; i >= 0; i –){
if(scores[i] target) res ++;
else break;
}
}
return res;
}
};
时间复杂度O（logn）空间复杂度O（1）

0 赞同 0 条回复

云无深雁影普通 2024年3月15日下午3:12

class Solution {
public int countTarget(int[] scores, int target) {
if(scores.length 0)
return 0;
int begin = 0;
int end = scores.length – 1;
while(begin <= end){
int mid = (begin + end) / 2;
if(target < scores[mid]){
end = mid – 1;
}
else
begin = mid + 1;
}
//循环结束，begin处为右边界
if(end>=0 && scores[end] != target)
return 0;
int right = begin;
end = right;
begin = 0;
while(begin <= end){
int mid = (begin + end) / 2;
if(target <= scores[mid]){
end = mid – 1;
}
else
begin = mid + 1;
}
int left = end;
return right – left – 1;

}
//二分法时间复杂度O（logn）空间O1

0 赞同 0 条回复

王位詮釋普通 2024年3月15日下午1:32

暴力法：
class Solution {
    int count = 0;
    public int countTarget(int[] scores, int target) {
        count(scores,target,0,scores.length-1);
        return count;
    }
    public void count(int[] scores,int target,int begin,int end){
        if(scores.length==0||begin>end||scores[begin]>target||scores[end]<target){
            return;
        }
        int mid = begin+(end-begin)/2;
        if(scores[mid]==target){
            count++;
        }
        count(scores,target,begin,mid-1);
        count(scores,target,mid+1,end);
    }
}
思路：直接遍历所有数组所有元素，如果当前元素为target则count++，否则继续遍历下一个元素；
时间复杂度：O(n)

二分法：
class Solution {
    int count = 0;
    public int countTarget(int[] scores, int target) {
        count(scores,target,0,scores.length-1);
        return count;
    }
    public void count(int[] scores,int target,int begin,int end){
        if(scores.length==0||begin>end||scores[begin]>target||scores[end]<target){
            return;
        }
        int mid = begin+(end-begin)/2;
        if(scores[mid]==target){
            count++;
        }
        count(scores,target,begin,mid-1);
        count(scores,target,mid+1,end);
    }
}
思路：通过二分法递归将数组分为两部分，递归查询每一部分里值为target的值，碰到一个就count++，否则继续递归查询[begin,mid-1]和[mid+1,end]。
时间复杂度：O(logn)

0 赞同 0 条回复

Yuki 永久会员 2024年3月15日上午10:51

打卡
https://leetcode.cn/problems/zai-pai-xu-shu-zu-zhong-cha-zhao-shu-zi-lcof/solutions/2688196/pai-xu-shu-zu-zhong-cha-zhao-by-yukislab-c7r8

重写，套模板
class Solution {
public:
int countTarget(vector& scores, int target) {
int left=0,right=scores.size()-1;

    while(left<=right){
        int mid=left+(right-left)/2;
        if(target<scores[mid]){
            right=mid-1;
        }else if(target>scores[mid]){
            left=mid+1;
        }else{
            right=mid-1;
        }
    }
    int l=left;

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

};

0 赞同 0 条回复

【二分查找专题】剑指 Offer 53 – I. 在排序数组中查找

共以下 24 个回答

# 回答此问题取消回复

【二分查找专题】剑指 Offer 53 – I. 在排序数组中查找

共以下 24 个回答

# 回答此问题 取消回复

# 回答此问题取消回复