剑指offer面试题53题目一-在排序数组中查找数字I

最新推荐文章于 2023-05-14 20:11:32 发布

原创最新推荐文章于 2023-05-14 20:11:32 发布 · 217 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#剑指offer #数组 #java #二分查找 #递归

剑指offer 专栏收录该内容

16 篇文章

订阅专栏

这篇博客介绍了如何在排序数组中查找特定数字出现的次数。首先，暴力法通过遍历数组实现，但时间复杂度较高。接着，优化后的暴力法可以在找到目标值后提前终止循环。然后，利用二分查找法降低时间复杂度，但仍然为O(n)。最终，通过二分查找确定目标数字的第一个和最后一个位置，达到O(logn)的时间复杂度。博客详细讨论了递归和循环两种实现方式。

一.题目描述

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

示例 1:

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

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

限制：

0 <= 数组长度 <= 50000

二.解题思路

1.暴力法

public int search(int[] nums, int target) {
        /*时间复杂度O(n),空间复杂度O(1)
        * */
        if(nums == null || nums.length == 0){
            return 0;
        }
        int count = 0;
        for (int i = 0; i < nums.length; i++) {
            if(nums[i] == target){
                count++;
            }
        }
        return count;
    }

在这里插入图片描述
2.暴力法，可以提前终止循环

public int search1(int[] nums, int target) {
        /*时间复杂度O(n),空间复杂度O(1)
         * */
        if(nums == null || nums.length == 0){
            return 0;
        }
        int count = 0;
        boolean find = false;
        for (int i = 0; i < nums.length; i++) {
            if(nums[i] == target){
                find = true;
                count++;
            }
            if(find == true && nums[i] != target){
                break;
            }
        }
        return count;
    }

在这里插入图片描述
3.因为是排序数组，考虑采用二分法

public int search2(int[] nums, int target) {
        /*二分法
        时间复杂度O(n),空间复杂度O(1)
         * */
        if(nums == null || nums.length == 0){
            return 0;
        }

        int pre = 0;
        int last = nums.length - 1;
        int mid = (pre + last) / 2;
        int count = 0;
        //注意这里包含等号的情况，最后指向的一个元素也可能是target
        while (pre <= last){
            if(nums[mid] < target){
                pre = mid + 1;
                mid = (pre + last) / 2;
                continue;
            }
            if(nums[mid] > target){
                last = mid - 1;
                mid = (pre + last) / 2;
                continue;
            }
            //找到了，mid左右两边可能还有元素值等于target，所以顺序扫描,
            //最坏的情况是扫描n次，此时复杂度是O(n)
            int p1 = mid - 1;
            int p2 = mid + 1;
            while (p1 >= 0 && nums[p1] == target){
                count++;
                p1--;
            }
            while (p2 <= nums.length - 1 && nums[p2] == target){
                count++;
                p2++;
            }
            return count + 1;
        }
        return count;
    }

在这里插入图片描述
这个时间复杂度还是O（n）,和暴力法无太大差别，通过分析发现时间主要消耗在了确定target出现的第一个位置和最后一个位置上面

所以3的二分法还可以优化一下

4.二分法用来查找target出现的第一个位置和最后一个位置，而非一个“不确定”的位置

public int search3(int[] nums, int target) {
        /*二分查找确定target的第一个位置和最后一个位置（递归法实现）
        因为searchFirst和searchLast时间复杂度都是O(logn)
        所以总的时间复杂度O(logn),空间复杂度O(1)
         **/
        if(nums == null || nums.length == 0){
            return 0;
        }
        int initialRes = 0;
        int firstIndex = searchFirst(nums, nums.length, target, 0, nums.length - 1);
        int lastIndex = searchLast(nums,nums.length,target,0,nums.length-1);
        //考虑如果不存在这个数字的话，不能直接return lastIndex - firstIndex + 1;
        if(firstIndex > -1 && lastIndex > -1){
            return lastIndex - firstIndex + 1;
        }
        return initialRes;
    }

    private int searchFirst(int[] nums, int length, int target, int start, int end) {
        /*寻找target出现的第一个位置*/
        if(nums == null || nums.length == 0){
            return 0;
        }
        int index = 0;
        int mid = (start + end) / 2;
        if(start <= end){
            //缩小一半范围，在后半段找即可
            if(nums[mid] < target){
                return searchFirst(nums,length,target,mid+1,end);
            }
            //缩小一半范围，在前半段找即可
            if(nums[mid] > target){
                return searchFirst(nums,length,target,start,mid-1);
            }
            if(nums[mid] == target){
                //因为要找的是第一个出现的位置，当找到了后就判断前面一个
                if(((mid - 1 > -1) && nums[mid - 1] != target) || (mid - 1 == -1)){
                    return mid;
                }
                if((mid - 1 > -1) && nums[mid - 1] == target){
                    return searchFirst(nums,length,target,start,mid-1);
                }
            }
        }
        return -1;
    }
    private int searchLast(int[] nums, int length, int target, int start, int end) {
        /*寻找target出现的最后一个位置*/
        if(nums == null || nums.length == 0){
            return 0;
        }
        int index = 0;
        int mid = (start + end) / 2;
        if(start <= end){
            //缩小一半范围，在后半段找即可
            if(nums[mid] < target){
                return searchLast(nums,length,target,mid+1,end);
            }
            //缩小一半范围，在前半段找即可
            if(nums[mid] > target){
                return searchLast(nums,length,target,start,mid-1);
            }
            //因为要找的是最后一个出现的位置，当找到了后就判断其后面一个元素
            if(nums[mid] == target){
                if(((mid + 1 <= end) && nums[mid + 1] != target) || (mid + 1 == end + 1)){
                    return mid;
                }
                if((mid + 1 <= end) && nums[mid + 1] == target){
                    return searchLast(nums,length,target,mid+1,end);
                }
            }
        }
        return -1;
    }

在这里插入图片描述
5.4的循环法实现

public int search3(int[] nums, int target) {
        /*二分查找确定target的第一个位置和最后一个位置（递归法实现）
        因为searchFirst和searchLast时间复杂度都是O(logn)
        所以总的时间复杂度O(logn),空间复杂度O(1)
         **/
        if(nums == null || nums.length == 0){
            return 0;
        }
        int initialRes = 0;
        int firstIndex = searchFirst(nums, nums.length, target, 0, nums.length - 1);
        int lastIndex = searchLast(nums,nums.length,target,0,nums.length-1);
        //考虑如果不存在这个数字的话，不能直接return lastIndex - firstIndex + 1;
        if(firstIndex > -1 && lastIndex > -1){
            return lastIndex - firstIndex + 1;
        }
        return initialRes;
    }

    private int searchFirst(int[] nums, int length, int target, int start, int end) {
        /*寻找target出现的第一个位置*/
        if(nums == null || nums.length == 0){
            return 0;
        }
        int index = 0;
        int mid = (start + end) / 2;
        while(start <= end){
            mid = (start + end) / 2;
            //缩小一半范围，在后半段找即可
            if(nums[mid] < target){
                start = mid + 1;
            }
            //缩小一半范围，在前半段找即可
            if(nums[mid] > target){
                end = mid - 1;
            }
            if(nums[mid] == target){
                //因为要找的是第一个出现的位置，当找到了后就判断前面一个
                if(((mid - 1 > -1) && nums[mid - 1] != target) || (mid - 1 == -1)){
                    return mid;
                }
                if((mid - 1 > -1) && nums[mid - 1] == target){
                    end = mid - 1;
                }
            }
        }
        return -1;
    }
    private int searchLast(int[] nums, int length, int target, int start, int end) {
        /*寻找target出现的最后一个位置*/
        if(nums == null || nums.length == 0){
            return 0;
        }
        int index = 0;
        int mid = (start + end) / 2;
        while(start <= end){
            mid = (start + end) / 2;
            //缩小一半范围，在后半段找即可
            if(nums[mid] < target){
                start = mid + 1;
            }
            //缩小一半范围，在前半段找即可
            if(nums[mid] > target){
                end = mid - 1;
            }
            //因为要找的是最后一个出现的位置，当找到了后就判断其后面一个元素
            if(nums[mid] == target){
                if(((mid + 1 <= end) && nums[mid + 1] != target) || (mid + 1 == end + 1)){
                    return mid;
                }
                if((mid + 1 <= end) && nums[mid + 1] == target){
                    start = mid + 1;
                }
            }
        }
        return -1;
    }

在这里插入图片描述