数字在排序数组中出现的次数

时间限制：C/C++ 1秒，其他语言2秒 空间限制：C/C++ 32M，其他语言64M

题目描述

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

思路：
1、暴力搜索，遍历数组中的元素，相同则计数加1

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

2、由于该数组为排序数组（但未指明是升序还是降序，这里姑且认为他是升序的），对其进行二分搜索，找到这个元素后，停止搜索，以该元素为基准，向前向后搜索，相等计数加1

class Solution {
public:
    int GetNumberOfK(vector<int> data ,int k) {
        int low = 0;
        int high = data.size()-1;
        int middle = 0;
        while(low < high)
        {
            middle = low + (high - low)/2;
            if(data[middle] == k)
            {
                break;
            }
            else if(data[middle] > k)
            {
                high = middle -1;
            }
            else
            {
                low = middle + 1;
            }
        }
        int count = 0;
        //向前向后寻找
        if(low <= high)
        {
            for(int i= middle;i >= 0;i--)
                if(data[i] == k)
                    count++;
                else
                    break;
            for(int i = middle+1;i<data.size();i++)
                if(data[i] == k)
                    count++;
                else
                    break;
        }
        return count;
    }
};

3、也可以采用二分搜索，找到该元素第一个出现的位置，以及最后出现的位置，最后相减得到出现的次数

public class Solution {
    public int GetNumberOfK(int [] array , int k) {
        if(array == null || array.length == 0)
            return 0;
        int first = getFirstK(array,k,0,array.length - 1);
        int last = getLastK(array,k,0,array.length - 1);
        if(first == -1 || last == -1)
            return 0;
        else
            return last - first + 1;
    }
    private int getFirstK(int [] array, int k, int low, int high){
        int mid = 0;
        while(low <= high){
            mid = low + (high -low) / 2;
            if(array[mid] == k){
                if(mid > 0 && array[mid - 1] != k || mid == 0)
                    return mid;
                else
                    high = mid - 1;
            }
            else if(array[mid] > k)
                high = mid - 1;
            else
                low = mid + 1;
        }
        return -1;
    }
    private int getLastK(int [] array, int k, int low, int high){
        int mid = 0;
        while(low <= high){
            mid = low + (high -low) / 2;
            if(array[mid] == k){
                if(mid < array.length - 1 && array[mid + 1] != k || mid == array.length - 1)
                    return mid;
                else
                    low = mid + 1;
            }
            else if(array[mid] > k)
                high = mid - 1;
            else
                low = mid + 1;
        }
        return -1;
    }
}

4、这个方法思路很奇特，虽同样采用二分，但特点在于既然目的找int 类型的k值，那找k-0.5，k+0.5两个浮点数的位置（大于k+0.5的位置和小于k-0.5的位置），然后相减，即为所得

class Solution {
public:
    int GetNumberOfK(vector<int> data ,int k) {
        return binSearch(data,k+0.5) - binSearch(data,k-0.5);
    }
    int binSearch(vector<int> &data,double num)
    {
        int low = 0;
        int high = data.size()-1;
        while(low <= high)
        {
            int mid = low + (high-low)/2;
            if(data[mid] < num)
                low = mid+1;
            else
                high = mid-1;
        }
        return high;
    }
};