剑指 Offer 53 - I. 在排序数组中查找数字 I

题目描述

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

示例 1:

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

示例 2:

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

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/zai-pai-xu-shu-zu-zhong-cha-zhao-shu-zi-lcof

解题思路

二分法（我的题解）

定义left和right指针 mid指针指向中间 mid
nums[mid]小于target,就让left指向mid+1
nums[mid]大于target,就让right指向mid-1
直到找到，记录index
如果没有找到。返回-1

找到元素之后，从这个元素的位置往两边扩散，查找相同元素的个数

关于循环条件 while(left<=right)
因为有可能在left=right的时候,算出来的mid值满足arr[mid]=target

class Solution {
   public int search(int[] nums, int target) {
        int left=0;int right=nums.length-1;
        int index=-1; int mid=0;
        int count=0;
        while(left<=right)
        {
            mid=(right+left)/2;
            if(target>nums[mid])  left=mid+1;
            else if(target<nums[mid]) right=mid-1;
            else  {
                index=mid;
                break;
            }
        }
        if(index==-1)
        {
            return 0;
        }
        int temp=index;
        while(temp<nums.length)
        {
            if(nums[temp]==target)
            {
                count++;
                temp++;
            }
            else{
                break;
            }
        }
        temp=index-1;
        while(temp>=0)
        {
            if(nums[temp]==target)
            {
                count++;
                temp--;
            }
            else{
                break;
            }
        }
        return count;
    }
}

二分优化（查找左右边界）

class Solution {
    public int search(int[] nums, int target) {
        // 搜索右边界 right
        int i = 0, j = nums.length - 1;
        //这边是“小于等于”，因此当循环结束后，ij不重合，且如果存在target值的话，i的位置就是右边界
        //（target值序列右边第一个大于target值的位置），因为最后一次循环一定是i=mid+1；且此时j指向target
        while(i <= j) {
            int m = (i + j) / 2;
         //这里是“小于等于”，目的是为了确定右边界，就是说当mid等于target时，因为不确定后面还有没有
         //target，所以同样需要左边收缩范围
            if(nums[m] <= target) i = m + 1;
            else j = m - 1;
        }
        int right = i;
        // 若数组中无 target ，则提前返回
        if(j >= 0 && nums[j] != target) return 0;
        // 搜索左边界 right
        i = 0; j = nums.length - 1;// //重置指针
        while(i <= j) {
            int m = (i + j) / 2;

            if(nums[m] < target) i = m + 1;
            else j = m - 1;
        }
        int left = j;
        return right - left - 1;
    }
}


作者：jyd
链接：https://leetcode-cn.com/problems/zai-pai-xu-shu-zu-zhong-cha-zhao-shu-zi-lcof/solution/mian-shi-ti-53-i-zai-pai-xu-shu-zu-zhong-cha-zha-5/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

class Solution {
    public int search(int[] nums, int target) {
        return helper(nums, target) - helper(nums, target - 1);
    }
    int helper(int[] nums, int tar) {
        int i = 0, j = nums.length - 1;
        while(i <= j) {
            int m = (i + j) / 2;
            if(nums[m] <= tar) i = m + 1;
            else j = m - 1;
        }
        return i;
    }
}


作者：jyd
链接：https://leetcode-cn.com/problems/zai-pai-xu-shu-zu-zhong-cha-zhao-shu-zi-lcof/solution/mian-shi-ti-53-i-zai-pai-xu-shu-zu-zhong-cha-zha-5/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

递归

写了一个二分查找的递归版本，返回target的索引，再根据上面的解法1我的二分，就可以计数了

   static int  dfsMidFind(int []arr,int left,int right,int target)
    {
        if(left>right) return -1;
        int mid=(left+right)/2;
        if(arr[mid]>target)   return dfsMidFind(arr, left, mid-1,target);
        else if(arr[mid]<target)     return dfsMidFind(arr, mid+1, right,target);
        else return mid;
    }