二分查找

/**
 * 二分查找(折半查找)
 *
 * 时间复杂度：O(logN)
 *
 * 注意：二分查找的前提是 查找的序列是有序的！
 *
 * 二分查找的应用：
 *      统计数字K在排序数组中出现的次数
 */
public class BinarySearch {

    /**
     * 二分查找 - 非递归
     *
     * 时间复杂度：O(logn)
     *
     * @param array
     * @param left
     * @param right
     * @param key
     * @return
     */
    public static int sortByNonRecursion(int[] array, int left, int right, int key) {

        if (array == null || left < 0 || right > array.length - 1) {
            return -1;
        }

        while (left <= right) {

            int mid = (left + right) >> 1;

            if (array[mid] == key) {
                return mid;
            } else if (array[mid] < key) {
                left = mid + 1;
            } else {
                right = mid - 1;
            }
        }
        return -1;
    }

    /**
     * 二分查找 - 递归
     *
     * 时间复杂度：O(logn)
     *
     * 缺点：若递归的层次太深，则容易导致栈溢出。
     *
     * @param array
     * @param left
     * @param right
     * @param key
     * @return
     */
    public static int sortByRecursion(int[] array, int left, int right, int key) {

        if (left > right) {
            return -1;
        }
        int mid = (left + right) >> 1;
        if (array[mid] == key) {
            return mid;
        } else if (array[mid] < key) {
            return sortByRecursion(array, mid + 1, right, key);
        } else {
            return sortByRecursion(array, left, mid - 1, key);
        }
    }


    /**
     * 统计数字K在排序数组中出现的次数
     *
     * 思路：
     *  1)因为数组是排序的，故我们使用二分法来查找K。
     *  2)数组中可能包含多个K，且多个K在数组中是连续的，故我们只需要找到数组中第一个K和最后一个K的位置就可以求出K的个数。
     *  3)若某个元素等于K 且 这个元素前面的元素不等于K，则这个元素就是数组中第一个K。
     *  4)若某个元素等于K 且 这个元素后面的元素不等于K，则这个元素就是数组中最后一个K。
     *
     * 时间复杂度：O(logn)
     *
     * @param array
     * @param K
     * @return
     */
    public static int getNumberOfK(int[] array, int K) {

        if (array == null || array.length == 0) {
            return 0;
        }

        int left = 0;
        int right = array.length - 1;

        while (left <= right) {
            int mid = (left + right)/2;
            if (array[mid] == K) {
                int i=mid; // 定义向左走的指针i，指针i最终指向第一个k
                while (i-1>= left && array[i-1]==K) {
                    i--;
                }

                int j = mid; // 定义向右走的指针j，指针j最终指向最后一个k
                while (j+1 <= right && array[j+1]==K ) {
                    j++;
                }
                return j-i > 0 ? j-i+1 : 1;
            } else if (array[mid] < K) {
                left = mid + 1;
            } else {
                right = mid - 1;
            }
        }
        return 0; // 没有找到k返回0
    }


    public static void main(String[] args) {

        int[] array = {1, 2, 4, 6, 7, 9, 10, 11, 13, 15, 17, 18, 25, 26, 34, 37};
        int i = sortByNonRecursion(array, 0, array.length - 1, 17);
        int ii = sortByRecursion(array, 0, array.length - 1, 18);
        System.out.println(i);
        System.out.println(ii);

        int[] array2 = {1,2,3,3,3,3,3,3,4,5};
        int numberOfK = getNumberOfK(array2,3);
        System.out.println("numberOfK " + numberOfK);
    }

}