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

题目描述：

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

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

示例：

• 示例1：

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

• 示例2：

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

• 提示：

     0 <= nums.length <= 105
	-109 <= nums[i] <= 109
	nums 是一个非递减数组
	-109 <= target <= 109

解析思路1：遍历+计数

• 直接遍历元素成员，进行累加计数，返回 target 对应的数值

代码（python3）

class Solution:
    def search(self, nums: List[int], target: int) -> int:
        count = 0;
        for i in range (0,len(nums)):
            if nums[i] == target:
                count += 1;
        return count;

代码（cpp）

class Solution {
public:
    int search(vector<int>& nums, int target) {
        int counts = 0;
            if (nums.size() == 0 ) // vector 为空
                return 0;
            for(int i= 0;  i < nums.size(); i++){  // 遍历vector成员 
                if (nums[i] == target)
                counts += 1;
            }
            return counts;
    }
};

复杂度分析：

• 时间复杂度为 O(n)，其中 n 为数组的长度。
• 空间复杂度 O(1)，程序需要常数空间存放若干变量。

解析思路2：二分法查找

• 直接遍历元素，计数返回数值，没有利用到数组升序排列的条件。
• 由于数组已经排序，因此整个数组是单调递增的，我们可以利用二分法来加速查找的过程。
• 参考k神解析.
• 统计数字 targettarget 的出现次数为 right - left - 1。
  
• 算法流程示意图：

• 优化：

• 过程演示：

代码（python3）

class Solution:
    def search(self, nums: [int], target: int) -> int:
        # 搜索右边界 right
        i, j = 0, len(nums) - 1
        while i <= j:
            m = (i + j) // 2
            if nums[m] <= target: i = m + 1
            else: j = m - 1
        right = i
        # 若数组中无 target ，则提前返回
        if j >= 0 and nums[j] != target: return 0
        # 搜索左边界 left
        i = 0
        while i <= j:
            m = (i + j) // 2
            if nums[m] < target: i = m + 1
            else: j = m - 1
        left = j
        return right - left - 1
        

• 函数封装优化：

class Solution:
    def search(self, nums: [int], target: int) -> int:
        def helper(tar):
            i, j = 0, len(nums) - 1
            while i <= j:
                m = (i + j) // 2
                if nums[m] <= tar: i = m + 1
                else: j = m - 1
            return i
        return helper(target) - helper(target - 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/

• helper() 函数是查找数字 tar 在数组 nums 中的 插入点 ，且若数组中存在值相同的元素，则插入到这些元素的右边。

代码（cpp）

class Solution {
public:
    int search(vector<int>& nums, int target) {
        int i = 0;
        int j = nums.size() - 1;
        while(i <= j) {
            int m = (i + j) / 2;
            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.size() - 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;

    }
};

• 函数封装：

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

复杂度分析：

• 时间复杂度 O(logN) ： 二分查找算法的时间复杂度为O(logN) 。
  空间复杂度 O(1) ： 程序需要几个变量，使用常数大小的额外空间。