剑指offer：数字在排序数组中出现的次数

题目描述

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

解法一：直接遍历，时间复杂度O(n)

class Solution {
public:
    int GetNumberOfK(vector<int> data ,int k) {
        int len = 0;
        for(int i=0; i<data.size(); i++)
            if(data[i] == k)
                len++;
        return len;
    }
};

解法二：

二分查找查找k的位置，然后统计K前后与K相等的个数。最坏情况下是数组data中的数字都是相同的，那么时间复杂度仍然是O(n)

class Solution {
public:
    int GetNumberOfK(vector<int> data ,int k) {
        int cnt = 0;
        if(data.size()<=0 )
            return cnt;
        int j = BinarySearch(data, k);
        if(j == -1)
            return cnt;
        cnt = 1;
        for(int i= j+1; i<data.size(); i++)
        {
            if(data[i] == k)
                cnt++;
            else
                break;
        }
        for(int i = j-1; j>=0; i--)
        {
            if(data[i] == k)
                cnt++;
            else
                break;
        }
        return  cnt;
    }
    
    int BinarySearch(vector<int>& data, int k)
    {
        int left = 0;
        int right = data.size()-1;
        while(left <= right)
        {
            int mid = ((right - left) >> 1) + left;
            if( k < data[mid] )
                right = mid - 1;
            else if(k > data[mid])
                left = mid +1;
            else
                return mid;
        }
        return -1;
    }
};

解法二的优化版：时间复杂度O(logn)

1. 使用二分查找：找到第一个和K相等的下标位置 i
2. 使用二分查找：找到最后一个和K相等的下标位置 j
3. 如果找到，则返回 j-i+1。否则返回0；

class Solution {
public:
    int GetNumberOfK(vector<int> data ,int k) {
        int cnt = 0;
        if(data.size()<=0 )
            return cnt;
        int first = BinarySearchFirst(data, k);
        int second = BinarySearchSecond(data, k);
        if(first == -1 && second == -1)
            return 0;
        else
            return second - first+1;
    }
    
    int BinarySearchFirst(vector<int>& data, int k)
    {
        int left = 0;
        int right = data.size()-1;
        while(left <= right)
        {
            int mid = ((right - left) >> 1) + left;
            if( k < data[mid] )
                right = mid - 1;
            else if(k > data[mid])
                left = mid +1;
            else
            {
                if(mid>0 && data[mid-1]==k)
                    right = mid - 1;
                else
                    return mid;
            }
        }
        return -1;
    }
    
    int BinarySearchSecond(vector<int>& data, int k)
    {
        int left = 0;
        int right = data.size()-1;
        while(left <= right)
        {
            int mid = ((right - left) >> 1) + left;
            if( k < data[mid] )
                right = mid - 1;
            else if(k > data[mid])
                left = mid +1;
            else
            {
                if(mid<data.size()-1 && data[mid+1]==k)
                    left = mid + 1;
                else
                    return mid;
            }
        }
        return -1;
    }
};