排序数组中查找出现数字的个数

1：题目描述

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

 

示例 1:

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

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

限制：

0 <= 数组长度 <= 50000

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/zai-pai-xu-shu-zu-zhong-cha-zhao-shu-zi-lcof
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

2：题目分析

　　采用二分法查找定位，然后左右遍历统计个数。

3：代码示例

package JianZhiOffer53_1;

import jdk.nashorn.internal.ir.ReturnNode;

import javax.sound.midi.Soundbank;

/**
 * @author ：dazhu
 * @date ：Created in 2020/4/6 16:40
 * @description：
 * @modified By：
 * @version: $
 */
public class Main {
    public static void main(String[]args){
        Solution solution = new Solution();
        int[] arr = new int[]{1,1,1,1,1,1,2,3,4,5,6,7,8,9,9,9,9,9,9};
        System.out.println(solution.search(arr,9));

    }
}

//先通过二分法找到定位，再左右扩展找到次数
class Solution {
    int junzhi = 0;
    int resultIndex = -1;
    public int search(int[] nums, int target) {
        return counterTarget(nums,binarySearch(nums,0,nums.length-1,target),target);
    }

    //迭代二分法，找到位置，找不到返回-1
    //迭代终止条件：左指针大于等于右指针，或者已经找到target。
    //迭代逻辑：取左右指针之平均，然后比较，如果大于target，则右指针赋值为平均，再递归
    //如果小于target，则左指针赋值为平均，再递归。
    public void binaryRecur(int[] nums, int left,int right,int target) {
        if(left<=right){
            junzhi = (left+right)/2;
            if(nums[junzhi] > target ){
                binaryRecur(nums, left,junzhi-1,target);
            }
            else{
                if(nums[junzhi] < target ){
                    binaryRecur(nums, junzhi+1,right,target);
                }
                else{
                    resultIndex = junzhi;
                }
            }
        }
    }

    //不用迭代，用遍历来二分查找
    public int binarySearch(int[] nums, int left,int right,int target) {
        int junzhi = 0;
        while(left<=right){
            junzhi = (left+right)/2;
            if(nums[junzhi]>target){
                right = junzhi-1;
            }
            else{
                if(nums[junzhi]<target){
                    left = junzhi+1;
                }
                else{
                    return junzhi;
                }
            }
        }
        return -1;
    }

    //在所在定位，左右寻找，然后获得长度
    public int counterTarget(int[] nums, int resultIndex,int target) {
        if(resultIndex == -1){
            return 0;
        }
        else{
            int tempIndex = resultIndex;
            int counter = 1;
            //向右寻找,要不能大于等于右边界
            while(true){
                if(resultIndex>=nums.length-1){
                    break;
                }
                resultIndex++;
                if(nums[resultIndex] != target){
                    break;
                }
                counter++;
            }

            //向左寻找,不能小于等于0
            resultIndex =tempIndex;
            while(true){
                if(resultIndex<=0){
                    break;
                }
                resultIndex--;
                if(nums[resultIndex] != target){
                    break;
                }
                counter++;
            }

            return counter;
        }
    }
}

注意再二分法中遍历和递归条件都为left<=right，同时当进入新的一次查找时，要进行+1或者-1的操作。