【done】【重点】【二分查找】剑指offer——面试题38：数字在排序数组中出现的次数

直接转链接：https://blog.csdn.net/Allenlzcoder/article/details/134531148
20180906整理
##Solution1:
【注意】先利用二分查找扎到一个值然后再顺序遍历的做法时间复杂度也是$O(n)$，代码也在下面进行展示。
复杂度为$O(n)$的破算法。

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

二分查找+顺序遍历
时间复杂度$O(n)$

class Solution { //二分查找 + 遍历
public:
    int GetNumberOfK(vector<int> data, int k) {
        if (!data.size()) return 0;
        else if (data.size() == 1) {
            if (data[0] == k) return 1;
            else return 0;
        }
        int pos = binary_search(data, 0, data.size() - 1, k);
        if (pos == -1) return 0;
        int res = seq_search(data, pos);
        return res;
    }
    
    int binary_search(vector<int> &data, int start, int end, int k) {
        while (start <= end) {
            int mid = (start + end) >> 1;
            if (data[mid] == k)
                return mid;
            if (data[mid] < k)
                start = mid + 1;
            else 
                end = mid - 1;
        }
        return -1;
    }
    
    int seq_search(vector<int> &data, int pos) {
        int i = pos - 1, j = pos + 1, res = 1;
        while (i >= 0 && data[i] == data[pos]) {
            i--;
            res++;
        }
        while (j < data.size() && data[j] == data[pos]) {
            j++;
            res++;
        }
        return res;
    }
};

##Solution2:
复杂度为$O(logn)$的二分查找算法。。
还顺手复习了下二分查找，挺好的。。。
递归版二分查找如下：

class Solution {
public:
    int GetNumberOfK(vector<int> data ,int k) {
        int n = data.size();
        if(n == 0) 
            return 0;
        else {
            int lastnum = GetLastOfK(data, k, 0, n - 1), firstnum = GetFirstOfK(data, k, 0, n - 1);
            if(firstnum > -1 && lastnum > -1)
                return lastnum - firstnum + 1;
            else 
                return 0;
        }
    }
    
    int GetFirstOfK(vector<int> &data, int k, int begin, int end){
        if(begin > end)
            return -1;
        int middleindex = (begin + end) / 2;
        if(data[middleindex] == k) {
            if(middleindex > 0 && data[middleindex - 1] != k || middleindex == 0)
                return middleindex;
            else 
                end = middleindex - 1;
        }
         else if(data[middleindex] < k) {
            begin = middleindex + 1;
        }
        else if(data[middleindex] > k) {
            end = middleindex - 1;
        }
        return GetFirstOfK(data, k, begin, end);
    }
    
    int GetLastOfK(vector<int> &data, int k, int begin, int end){
        if(begin > end)
            return -1;
        int middleindex = (begin + end) / 2;
        if(data[middleindex] == k) {
            if(middleindex < data.size() - 1 && data[middleindex + 1] != k || middleindex == data.size() - 1)
                return middleindex;
            else 
                begin = middleindex + 1;
        }
         else if(data[middleindex] < k) {
            begin = middleindex + 1;
        }
        else if(data[middleindex] > k) {
            end = middleindex - 1;
        }
        return GetLastOfK(data, k, begin, end);
    }
};

##Solution3:
迭代版二分查找完整代码
参考网址：https://www.nowcoder.com/profile/7221411/codeBookDetail?submissionId=14533282

class Solution {
public:
    int GetNumberOfK(vector<int> data ,int k) {
        int n = data.size();
        if (n == 0)
            return 0;
        else {
            int lastnum = getLastK(data, k, 0, n - 1), 
                firstnum = getFirstK(data, k, 0, n - 1);
            if (firstnum > -1 && lastnum > -1)
                return lastnum - firstnum + 1;
            else 
                return 0;
        }
    }

    int getFirstK(vector<int> &array, int k, int start, int end) {
        while (start <= end) {
            int mid = (start + end) / 2;
            if (array[mid] == k) {
                if (mid > 0 && array[mid - 1] != k || 
                    mid == 0)
                    return mid;
                else end = mid - 1;
            } else if (array[mid] > k) {
                end = mid - 1;
            } else if (array[mid] < k) {
                start = mid + 1;
            }
        }
        return -1;
    }

    int getLastK(vector<int> &array, int k, int start, int end) {
        while (start <= end) {
            int mid = (start + end) >> 1;
            if (array[mid] == k) {
                if (mid < array.size() - 1 && array[mid + 1] != k || 
                    mid == array.size() - 1)
                    return mid;
                else start = mid + 1;
            } else if (array[mid] > k) {
                end = mid - 1;
            } else if (array[mid] < k) {
                start = mid + 1;
            }
        }
        return -1;
    }
};