剑指Offer面试题53查找数字

题目I——在排序数组种查找数字

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

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

示例 2:

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

限制：0 <= 数组长度 <= 50000

思路一

利用双指针解决该题，分别找到重复数字起始位置left和终止位置right,则重复次数为：ret = right - left + 1>

class Solution {
    public int search(int[] nums, int target) {
        //Step1:定义结果变量
        int ret = 0;
        //Step2:双指针
        int left = 0, right = nums.length - 1;
        while(left <= right){
            if(nums[left] == target && nums[right] == target){
                ret = right - left + 1;
                break;
            }else{
                if(nums[left] < target)left++;
                if(nums[right] > target) right--;
            }
        }
        //Step3:返回结果
        return ret;
    }
}

思路二

暴力解答，顺序遍历，采用增强for循环

class Solution {
    public int search(int[] nums, int target) {
        //Step1:定义结果变量
        int ret = 0;
        //Step2：增强for循环
        for(int num : nums){
            if(target == num) ret++;
        }
        //Step3:返回结果变量
        return ret;
    }
}

思路三——二分法

利用二分法先找到target出现的起始位置，然后从起始位置开始统计target出现的次数。

class Solution {
    public int search(int[] nums, int target) {
        //Step1:定义结果变量
        int ret = 0;
        //Step2:二分法---1.找到target出现的起始位置left
        int left = 0, right = nums.length - 1;
        while(left <= right){
            int mid = (left + right) / 2;
            if(nums[mid] >= target){
                right = mid - 1;
            }else{
                left = mid + 1;
            }
        }
        //Step3:从起始位置left开始，统计target出现的次数
        while(left < nums.length && nums[left++] == target){
            ret++;
        }
        return ret;
    }
}

题目II——0~n-1种缺失的数字

一个长度为n-1的递增排序数组中的所有数字都是唯一的，并且每个数字都在范围0～n-1之内。在范围0～n-1内的n个数字中有且只有一个数字不在该数组中，请找出这个数字。
示例 1:

输入: [0,1,3]
输出: 2

示例 2:

输入: [0,1,2,3,4,5,6,7,9]
输出: 8

限制：1 <= 数组长度 <= 10000

思路一

顺序遍历：由于原数组是递增排序，如果nums[i] != i,说明缺少i,返回该值；如果0~n-1都存在，则返回n。

class Solution {
    public int missingNumber(int[] nums) {
        //Step1:定义结果变量
        int ret = -1;
        //Step2:遍历
        int i = 0;
        for(i = 0; i < nums.length; i++){
            if(nums[i] != i){
                ret = i;
                break;
            }
        }
        //排除异常：0~n-1都存在，则返回n
        if(i == nums.length) ret = i;
        //Step3:返回结果
        return ret;
    }
}

简化代码：

class Solution {
    public int missingNumber(int[] nums) {
        for(int i = 0; i < nums.length; i++){
            if(nums[i] != i){
                return i;
            }
        }
        return nums.length;
    }
}

思路二——二分法

二分查找：

1. 当nums[m] > m时，缺失的数字一定比m小，则right = m - 1;
2. 当nums[m] = m， 缺失的数字一定比m大，则left = m + 1;
3. 当nums[m] < m，由于时递增数组，不存在这种情况

class Solution {
    public int missingNumber(int[] nums) {
        //Step1：定义辅助变量
        int left = 0, right = nums.length - 1;
        //Step2:二分查找
        while(left <= right){
            int m = (left + right) / 2;
            if(nums[m] > m){
                right = m - 1;
            }else{
                left = m + 1;
            }
        }
        //Step3:返回结果
        return left;
    }
}