leetcode 剑指 Offer 53 - I. 在排序数组中查找数字 I Java-优快云博客

本文链接：https://blog.youkuaiyun.com/qq_43349112/article/details/113366276

本文介绍如何在已排序的整数数组中使用二分查找法统计目标数字的出现次数，提供了两种实现策略：直接边界搜索和优化的左边界查找。适合练习基础算法和优化技巧。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

在排序数组中查找数字

做题博客链接
题目链接
描述
示例
初始代码模板
代码

做题博客链接

https://blog.youkuaiyun.com/qq_43349112/article/details/108542248

题目链接

https://leetcode-cn.com/problems/zai-pai-xu-shu-zu-zhong-cha-zhao-shu-zi-lcof/

描述

统计一个数字在排序数组中出现的次数。

限制：

0 <= 数组长度 <= 50000

示例

示例 1:

输入: nums = [5,7,7,8,8,10], target = 8
输出: 2

示例 2:

输入: nums = [5,7,7,8,8,10], target = 6
输出: 0

初始代码模板

class Solution {
    public int search(int[] nums, int target) {
      
    }
}

代码

二分查找的经典题，如果为了练习，可以尝试直接用左右边界查找，只是代码比较臃肿

class Solution {
    public int search(int[] nums, int target) {
        int left = findLeft(nums, target);
        int right = findRight(nums, target);

        if (left == -1 && right == -1) {
            return 0;
        } else {
            return right - left + 1;
        }
    }

    private int findLeft(int[] nums, int target) {
        int left = 0;
        int right = nums.length - 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.length || nums[left] != target) {
            return -1;
        }

        return left;
    }

    private int findRight(int[] nums, int target) {
        int left = 0;
        int right = nums.length - 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 (right < 0 || nums[right] != target) {
            return -1;
        }
        return right;
    }
}

或者可以转变一下思路，查找两次左边界或者右边界，具体的可以看推荐题解

class Solution {
    public int search(int[] nums, int target) {
       return findLeft(nums, target + 1) - findLeft(nums, target);
    }

    private int findLeft(int[] nums, int target) {
        int left = 0;
        int right = nums.length - 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;
    }

}