剑指offer-37、数字在升序数组中出现的次数

本篇文章分享剑指offer-37、数字在升序数组中出现的次数，对你有帮助的话记得收藏一下，看Java资料网收获更多编程知识

题目描述

统计⼀个数字在升序数组中出现的次数。

示例1
输⼊：[1,2,3,3,3,3,4,5],3
返回值：4

思路及解答

线性遍历

顺序遍历数组，遇到目标值就计数

public class Solution {

    public int GetNumberOfK(int[] array, int k) {
        if (array == null || array.length == 0) {
            return 0;
        }
        
        int count = 0;
        for (int i = 0; i < array.length; i++) {
            if (array[i] == k) {
                count++;
            }
            // 由于数组有序，如果当前元素已大于k，可提前结束
            else if (array[i] > k) {
                break;
            }
        }
        return count;
    }
}

• 时间复杂度​：O(n)，最坏情况下需要遍历整个数组
• ​空间复杂度​：O(1)，只使用常数级别额外空间

二分查找+左右扫描法

先使用二分查找定位到目标值，然后向两边扩展统计。

由于数组是有序的，可以明显看到是二分法。

第1步是找出数值为 k 的数的索引：
假设数组为 nums[] ，⼀开始的左边索引为 left = 0 ，右边界索引为 right = nums.length-1

1. 将数组分成两部分，中间的数为 nums[mid] 。第1部分为 [left,mid] ,第2部分为[mid+1,right]。
2. 如果 nums[mid]>k ,则说明 k 只可能存在前半部分中，对前半部分执⾏操作1。
3. 如果 nums[mid]<k ,则说明 k 只可能存在后半部分中，对后半部分执⾏操作1。
4. 如果 nums[mid]=k ,直接返回当前索引 mid 。
5. 如果 left > right ,说明 k 不存在，则返回 -1 。

找到索引之后，往两边扩展，同时统计k的个数，直到元素不等于 k 的时候停⽌。

public class Solution {

    public int GetNumberOfK(int[] array, int k) {
        if (array == null || array.length == 0) return 0;
        
        int left = 0, right = array.length - 1;
        int count = 0;
        
        // 二分查找
        while (left <= right) {
            int mid = left + (right - left) / 2;
            
            if (array[mid] < k) {
                left = mid + 1;
            } else if (array[mid] > k) {
                right = mid - 1;
            } else {
                // 找到目标值，向左右扩展统计
                count = 1;
                int temp = mid;
                
                // 向左统计
                while (--temp >= left && array[temp] == k) {
                    count++;
                }
                
                // 向右统计
                temp = mid;
                while (++temp <= right && array[temp] == k) {
                    count++;
                }
                break;
            }
        }
        return count;
    }
}

• ​时间复杂度​：O(log n + k)，其中k是目标值出现次数。当目标值出现次数较少时效率接近O(log n)，但最坏情况（全部是目标值）退化为O(n)
• ​空间复杂度​：O(1)

双二分查找法（推荐）

分别使用二分查找找到目标值的起始和结束位置，计算区间长度，这是最优解法。

public class Solution {

    public int GetNumberOfK(int[] array, int k) {
        if (array == null || array.length == 0) return 0;
        
        // 找到第一个k的位置
        int firstIndex = findFirstPosition(array, k);
        // 找到最后一个k的位置
        int lastIndex = findLastPosition(array, k);
        
        if (firstIndex == -1 || lastIndex == -1) {
            return 0; // 目标值不存在
        }
        
        return lastIndex - firstIndex + 1;
    }
    
    /**
     * 查找目标值的第一个出现位置
     */
    private int findFirstPosition(int[] array, int k) {
        int left = 0, right = array.length - 1;
        
        while (left <= right) {
            int mid = left + (right - left) / 2;
            
            if (array[mid] < k) {
                left = mid + 1;
            } else if (array[mid] > k) {
                right = mid - 1;
            } else {
                // 关键：检查是否为第一个出现位置
                if (mid == 0 || array[mid - 1] != k) {
                    return mid;
                } else {
                    right = mid - 1; // 继续在左半部分查找
                }
            }
        }
        return -1; // 未找到
    }
    
    /**
     * 查找目标值的最后一个出现位置
     */
    private int findLastPosition(int[] array, int k) {
        int left = 0, right = array.length - 1;
        
        while (left <= right) {
            int mid = left + (right - left) / 2;
            
            if (array[mid] < k) {
                left = mid + 1;
            } else if (array[mid] > k) {
                right = mid - 1;
            } else {
                // 关键：检查是否为最后一个出现位置
                if (mid == array.length - 1 || array[mid + 1] != k) {
                    return mid;
                } else {
                    left = mid + 1; // 继续在右半部分查找
                }
            }
        }
        return -1; // 未找到
    }
}

• ​时间复杂度​：O(log n)，执行两次二分查找
• ​空间复杂度​：O(1)，只使用常数空间

k±0.5边界查找法

一种巧妙的解法，通过查找目标值边界的插入位置来计算出现次数。

由于数组元素都是整数，k-0.5和k+0.5正好是目标值范围的边界，它们的插入位置差值就是目标值出现次数

public class Solution {

    public int GetNumberOfK(int[] array, int k) {
        if (array == null || array.length == 0) return 0;
        
        // 查找k+0.5的插入位置（第一个大于k的位置）
        int upperBound = findInsertPosition(array, k + 0.5);
        // 查找k-0.5的插入位置（第一个大于等于k的位置）
        int lowerBound = findInsertPosition(array, k - 0.5);
        
        return upperBound - lowerBound;
    }
    
    /**
     * 在有序数组中查找目标值的插入位置
     */
    private int findInsertPosition(int[] array, double target) {
        int left = 0, right = array.length - 1;
        
        while (left <= right) {
            int mid = left + (right - left) / 2;
            
            if (array[mid] < target) {
                left = mid + 1;
            } else {
                right = mid - 1;
            }
        }
        return left; // 返回插入位置
    }
}

• ​时间复杂度​：O(log n)，两次二分查找
• ​空间复杂度​：O(1)

文章来源:https://www.cnblogs.com/sevencoding/p/19204019
本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若内容造成侵权/违法违规/事实不符，请联系邮箱：jacktools123@163.com进行投诉反馈，一经查实，立即删除！