題目描述

統計一個數字在排序數組中出現的次數

思路

思路一：暴力，簡單粗暴，但是並不可取

思路二：因為題中說是排序數組，因此我們要先想到二分查找，因此我們先用二分查找找出某個k出現的位置，然後再分別向前和向後查找總的個數。

思路三：還是二分查找的思想，先找到第一個k和最後一個k的位置相減

代碼實現

package Array;

/**
 * 數字在排序數組中出現的次數
 * 統計一個數字在排序數組中出現的次數。
 */
public class Solution33 {
    public static void main(String[] args) {
        Solution33 solution33 = new
 
 Solution33();
        int[] array = {1, 3, 4, 5, 5, 6, 7, 8, 9, 10};
        System.out.println(solution33.GetNumberOfK_3(array, 5));
    }

    /**
     * 二分查找 找到第一個k和最後一個k二者位置相減
     *
     * @param array
     * @param k
     * @return
     */
    public int GetNumberOfK_3(int[] array, int k) {
        if
 
 (array == null || array.length == 0)
            return 0;
        int number = 0;
        int first = GetFirstIndex(array, k, 0, array.length - 1);
        int last = GetLastIndex(array, k, 0, array.length - 1);
        if (first > -1 && last > -1)
            number = last - first + 1;
        return
 
 number;
    }

    /**
     * 找到最後一個k的位置
     *
     * @param array
     * @param k
     * @param left
     * @param right
     * @return
     */
    private int GetLastIndex(int[] array, int k, int left, int right) {
        if (left > right)
            return -1;
        int mid = left + ((right - left) >> 1);
        if (array[mid] == k) {
            if (mid == right || (array[mid + 1] != k)) {
                return mid;
            } else {
                left = mid + 1;
            }
        } else if (array[mid] > k) {
            right = mid - 1;
        } else {
            left = mid + 1;
        }
        return GetLastIndex(array, k, left, right);
    }

    /**
     * 找到第一個k的位置
     *
     * @param array
     * @param k
     * @param left
     * @param right
     * @return
     */
    private int GetFirstIndex(int[] array, int k, int left, int right) {
        if (left > right)
            return -1;
        int mid = left + ((right - left) >> 1);
        if (array[mid] == k) {
            if (mid == left || (array[mid - 1] != k)) {
                return mid;
            } else {
                right = mid - 1;
            }
        } else if (array[mid] > k) {
            right = mid - 1;
        } else {
            left = mid + 1;
        }
        return GetFirstIndex(array, k, left, right);
    }

    /**
     * 先用二分查找找出某個k出現的位置，然後再分別向前和向後查找總的個數
     *
     * @param array
     * @param k
     * @return
     */
    public int GetNumberOfK(int[] array, int k) {
        if (array.length == 0 || array == null)
            return 0;
        int left = 0;
        int right = array.length - 1;
        int count = 0;
        while (left <= right) {
            int mid = left + (right - left) / 2;//若數組過大，防止溢出
            if (array[mid] == k) {
                count++;
                //判斷前面是否還有等於k的元素
                if (mid > left) {
                    if (array[mid - 1] == k) {
                        for (int i = mid - 1; i >= 0; i--) {
                            if (array[i] == k) {
                                count++;
                            } else break;
                        }
                    }
                }
                //判斷後面是否還有等於k的元素
                if (mid < right) {
                    if (array[mid + 1] == k) {
                        for (int i = mid + 1; i <= right; i++) {
                            if (array[i] == k) {
                                count++;
                            } else break;
                        }
                    }
                }
                return count;
            } else if (array[mid] < k) {
                left = mid + 1;
            } else {
                right = mid - 1;
            }
        }
        return 0;
    }


    /**
     * 暴力
     *
     * @param array
     * @param k
     * @return
     */
    public int GetNumberOfK_2(int[] array, int k) {
        if (array.length == 0 || array == null)
            return 0;
        int count = 0;
        for (int i = 0; i < array.length; i++) {
            if (array[i] == k) {
                count++;
            }
        }
        return count;
    }

}

劍指Offer-數字在排序數組中出現的次數