【面试题】数字在排序数组中出现的次数（两种解法）

题目描述

解法一：剑指offer上的思路

Java

class Solution {
    public int search(int[] nums, int target) {
        if(nums.length == 0) return 0;
        int firstIndex = getFirstTarget(nums, 0, nums.length-1, target);
        int lastIndex = getLastTarget(nums, 0, nums.length-1, target);
        if(firstIndex > -1 && lastIndex > -1)
            return lastIndex-firstIndex+1;
        else
            return 0;
    }

    public int getFirstTarget(int[] nums, int left, int right, int target) {
        if(left > right) return -1;
        int mid = left + (right-left)/2;
        if(nums[mid] == target) {
            if((mid > 0 && nums[mid-1] != target) || mid == 0) 
                return mid;
            else return getFirstTarget(nums, left, mid-1, target);
        }
        else if(nums[mid] > target)
            return getFirstTarget(nums, left, mid-1, target);
        else
            return getFirstTarget(nums, mid+1, right, target);
    }

    public int getLastTarget(int[] nums, int left, int right, int target) {
        if(left > right) return -1;
        int mid = left + (right-left)/2;
        if(nums[mid] == target) {
            if((mid < nums.length-1 && nums[mid+1] != target) || mid == nums.length-1) 
                return mid;
            else return getLastTarget(nums, mid+1, right, target);
        }
        else if(nums[mid] > target)
            return getLastTarget(nums, left, mid-1, target);
        else
            return getLastTarget(nums, mid+1, right, target);
    }
}

解法二：不断收缩区间进行定位

class Solution {
    public int search(int[] nums, int target) {
        if(nums.length == 0) return 0;
        int firstIndex = getFirstTarget(nums, 0, nums.length-1, target);
        if(firstIndex == -1) return 0; // 若找不到第一个target的位置，说明不存在该树，直接返回 0
        int lastIndex = getLastTarget(nums, 0, nums.length-1, target);
        return lastIndex-firstIndex+1;
    }
    // 找到第一个target出现的位置
    public int getFirstTarget(int[] nums, int left, int right, int target) {
        while(left <= right) { 
            int mid = left + (right - left)/2;
            if(nums[mid] >= target) 
                right = mid - 1;
            else
                left = mid + 1;          
        }
        //如果存在target，那么退出循环时，right一定指向最左边 target的前一个位置，left 则一定指向最左边 target的位置
        if(left < nums.length && left >=0 && nums[left] == target) return left;
        else return -1;
    }
    // 找到最后一个target出现的位置
    public int getLastTarget(int[] nums, int left, int right, int target) {
        while(left <= right) {
            int mid = left + (right - left)/2;
            if(nums[mid] <= target)
                left = mid + 1;
            else
                right = mid - 1;
        }
        //如果存在target，那么退出循环时，left一定指向最右边 target的后一个位置，right 则一定指向最右边 target的位置
        if(right < nums.length && right >=0 && nums[right] == target) return right;
        else return -1;
    }
}

时间复杂度：O(logN)，这里 N 为数组的长度；
空间复杂度：O(1)，记录第一次出现的位置和最后一次出现的位置还有临时变量的位置，只有常数个。